diff --git a/core/account-id/fuzz/fuzz_targets/borsh.rs b/core/account-id/fuzz/fuzz_targets/borsh.rs index 22b9baa0d3e..168e9cfe18b 100644 --- a/core/account-id/fuzz/fuzz_targets/borsh.rs +++ b/core/account-id/fuzz/fuzz_targets/borsh.rs @@ -5,9 +5,6 @@ use libfuzzer_sys::fuzz_target; use near_account_id::AccountId; fuzz_target!(|bytes: &[u8]| { - if bytes.len() >= 4 && bytes[0] == 0x12 && bytes[1] == 0x34 && bytes[2] == 0x56 && bytes[3] == 0x78 { - panic!("crash time for clusterfuzz test"); - } if let Ok(account_id) = AccountId::try_from_slice(bytes) { assert_eq!( account_id, diff --git a/runtime/near-vm-runner/Cargo.toml b/runtime/near-vm-runner/Cargo.toml index e339f2df932..c233033c2cd 100644 --- a/runtime/near-vm-runner/Cargo.toml +++ b/runtime/near-vm-runner/Cargo.toml @@ -53,12 +53,12 @@ wasmer-vm = { package = "wasmer-vm-near", version = "=2.4.0", optional = true } finite-wasm = "0.3.0" prefix-sum-vec = "0.1.2" -near-vm-compiler = { package = "wasmer-compiler-near", path = "../../../wasmer/lib/compiler", optional = true } -near-vm-compiler-singlepass = { package = "wasmer-compiler-singlepass-near", path = "../../../wasmer/lib/compiler-singlepass", optional = true, default-features = false, features = ["std"] } # Available features: std, rayon -near-vm-engine = { package = "wasmer-engine-near", path = "../../../wasmer/lib/engine", optional = true } -near-vm-engine-universal = { package = "wasmer-engine-universal-near", path = "../../../wasmer/lib/engine-universal", features = ["compiler"], optional = true } -near-vm-types = { package = "wasmer-types-near", path = "../../../wasmer/lib/types", optional = true } -near-vm-vm = { package = "wasmer-vm-near", path = "../../../wasmer/lib/vm", optional = true } +near-vm-compiler = { package = "wasmer-compiler-near", path = "../near-vm/lib/compiler", optional = true } +near-vm-compiler-singlepass = { package = "wasmer-compiler-singlepass-near", path = "../near-vm/lib/compiler-singlepass", optional = true } +near-vm-engine = { package = "wasmer-engine-near", path = "../near-vm/lib/engine", optional = true } +near-vm-engine-universal = { package = "wasmer-engine-universal-near", path = "../near-vm/lib/engine-universal", features = ["compiler"], optional = true } +near-vm-types = { package = "wasmer-types-near", path = "../near-vm/lib/types", optional = true } +near-vm-vm = { package = "wasmer-vm-near", path = "../near-vm/lib/vm", optional = true } [dev-dependencies] arbitrary.workspace = true diff --git a/runtime/near-vm/.cargo/config.toml b/runtime/near-vm/.cargo/config.toml new file mode 100644 index 00000000000..f9b89e8f713 --- /dev/null +++ b/runtime/near-vm/.cargo/config.toml @@ -0,0 +1,5 @@ +[target.'cfg(all(target_os = "linux", target_env = "gnu"))'] +rustflags = [ + # Put the VM functions in the dynamic symbol table. + "-C", "link-arg=-Wl,-E", +] diff --git a/runtime/near-vm/.gitattributes b/runtime/near-vm/.gitattributes new file mode 100644 index 00000000000..6486387fd29 --- /dev/null +++ b/runtime/near-vm/.gitattributes @@ -0,0 +1,4 @@ +CHANGELOG.md merge=union +*.wast linguist-vendored +*.wat linguist-vendored +scene*.txt -text diff --git a/runtime/near-vm/.github/CODEOWNERS b/runtime/near-vm/.github/CODEOWNERS new file mode 100644 index 00000000000..1508856eb42 --- /dev/null +++ b/runtime/near-vm/.github/CODEOWNERS @@ -0,0 +1,23 @@ +benches @syrusakbary +examples +fuzz @syrusakbary +lib/api @syrusakbary +lib/c-api +lib/cache @syrusakbary +lib/cli @syrusakbary +lib/compiler @syrusakbary +lib/compiler-cranelift @syrusakbary +lib/compiler-llvm +lib/compiler-singlepass @syrusakbary +lib/deprecated +lib/emscripten +lib/engine @syrusakbary +lib/engine-jit @syrusakbary +lib/engine-native @syrusakbary +lib/engine-object-file @syrusakbary +lib/object @syrusakbary +lib/vm @syrusakbary +lib/wasi +lib/wasmer-types @syrusakbary +scripts @syrusakbary +tests diff --git a/runtime/near-vm/.github/ISSUE_TEMPLATE/---bug-report.md b/runtime/near-vm/.github/ISSUE_TEMPLATE/---bug-report.md new file mode 100644 index 00000000000..470f5ea9b73 --- /dev/null +++ b/runtime/near-vm/.github/ISSUE_TEMPLATE/---bug-report.md @@ -0,0 +1,50 @@ +--- +name: "\U0001F41E Bug report" +about: Create a report to help us improve +title: '' +labels: "\U0001F41E bug" +assignees: '' + +--- + + + +### Describe the bug + + + +```sh +echo "`wasmer -V` | `rustc -V` | `uname -m`" +``` + + +### Steps to reproduce + + +### Expected behavior + + +### Actual behavior + + + +### Additional context + diff --git a/runtime/near-vm/.github/ISSUE_TEMPLATE/---feature-request.md b/runtime/near-vm/.github/ISSUE_TEMPLATE/---feature-request.md new file mode 100644 index 00000000000..be5746331f2 --- /dev/null +++ b/runtime/near-vm/.github/ISSUE_TEMPLATE/---feature-request.md @@ -0,0 +1,26 @@ +--- +name: "\U0001F389 Feature request" +about: Suggest an idea for this project +title: '' +labels: "\U0001F389 enhancement" +assignees: '' + +--- + +Thanks for proposing a new feature! + +### Motivation + +A clear and concise description of what the motivation for the new feature is, and what problem it is solving. + +### Proposed solution + +A clear and concise description of the feature you would like to add, and how it solves the motivating problem. + +### Alternatives + +A clear and concise description of any alternative solutions or features you've considered, and why you're proposed solution is better. + +### Additional context + +Add any other context or screenshots about the feature request here. diff --git a/runtime/near-vm/.github/ISSUE_TEMPLATE/--question.md b/runtime/near-vm/.github/ISSUE_TEMPLATE/--question.md new file mode 100644 index 00000000000..ad79ab2f5bf --- /dev/null +++ b/runtime/near-vm/.github/ISSUE_TEMPLATE/--question.md @@ -0,0 +1,16 @@ +--- +name: "❓ Question" +about: Ask a question about this project +title: '' +labels: "❓ question" +assignees: '' + +--- + +### Summary + +A clear and concise summary of your question. + +### Additional details + +Provide any additional details here. diff --git a/runtime/near-vm/.github/codecov.yml b/runtime/near-vm/.github/codecov.yml new file mode 100644 index 00000000000..af427cff68e --- /dev/null +++ b/runtime/near-vm/.github/codecov.yml @@ -0,0 +1,11 @@ +coverage: + status: + project: + default: + target: auto + threshold: 1% + patch: + default: + target: auto + threshold: 5% + base: auto diff --git a/runtime/near-vm/.github/pull_request_template.md b/runtime/near-vm/.github/pull_request_template.md new file mode 100644 index 00000000000..60e912fdb4f --- /dev/null +++ b/runtime/near-vm/.github/pull_request_template.md @@ -0,0 +1,15 @@ + + +# Description + + +# Review + +- [ ] Add a short description of the change to the CHANGELOG.md file diff --git a/runtime/near-vm/.github/stale.yml b/runtime/near-vm/.github/stale.yml new file mode 100644 index 00000000000..f992c78e168 --- /dev/null +++ b/runtime/near-vm/.github/stale.yml @@ -0,0 +1,17 @@ +# Number of days of inactivity before an issue becomes stale +daysUntilStale: 365 +# Number of days of inactivity before a stale issue is closed +daysUntilClose: 30 +# Issues with these labels will never be considered stale +exemptLabels: + - "🐞 bug" +# Label to use when marking an issue as stale +staleLabel: "🏚 stale" +# Comment to post when marking an issue as stale. Set to `false` to disable +markComment: > + This issue has been automatically marked as stale because it has not had + recent activity. It will be closed if no further activity occurs. Thank you + for your contributions. +# Comment to post when closing a stale issue. Set to `false` to disable +closeComment: > + Feel free to reopen the issue if it has been closed by mistake. diff --git a/runtime/near-vm/.github/workflows/cargo-deny.yaml b/runtime/near-vm/.github/workflows/cargo-deny.yaml new file mode 100644 index 00000000000..abf5a8eeae2 --- /dev/null +++ b/runtime/near-vm/.github/workflows/cargo-deny.yaml @@ -0,0 +1,14 @@ +on: + push: + branches: + - master + +name: cargo-deny + +jobs: + deny-check: + name: cargo-deny + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v2 + - uses: EmbarkStudios/cargo-deny-action@v1 diff --git a/runtime/near-vm/.github/workflows/test-sys.yaml b/runtime/near-vm/.github/workflows/test-sys.yaml new file mode 100644 index 00000000000..a54d109e363 --- /dev/null +++ b/runtime/near-vm/.github/workflows/test-sys.yaml @@ -0,0 +1,100 @@ +name: Runtime tests + +env: + RUST_BACKTRACE: 1 + ENABLE_SINGLEPASS: 1 + ENABLE_LLVM: 0 + ENABLE_CRANELIFT: 0 + +on: + push: + branches: + - 'near-main' + - 'staging' + - 'trying' + pull_request: + branches: [ 'near-main' ] + +jobs: + test: + name: Test on ${{ matrix.build }} + runs-on: ${{ matrix.os }} + strategy: + fail-fast: false + matrix: + include: + - build: linux-x64 + os: ubuntu-latest + - build: macos-x64 + os: macos-latest + run_ios_tests: true + # Singlepass does not support windows... + # - build: windows-x64 + # os: windows-latest + # Tests SIGSEGV due to probably signal wonkyness... + # - build: linux-musl-x64 + # os: ubuntu-latest + # container: alpine:latest + container: ${{ matrix.container }} + steps: + - uses: actions/checkout@v2 + - name: Set up base deps on musl + if: matrix.build == 'linux-musl-x64' + run: apk add build-base musl-dev wget curl make libtool libffi-dev gcc automake autoconf git openssl-dev g++ + - name: Set up dependencies for Mac OS + if: matrix.os == 'macos-latest' + run: | + brew install automake + # using gnu-tar is a workaround for https://github.com/actions/cache/issues/403 + brew install gnu-tar + echo PATH="/usr/local/opt/gnu-tar/libexec/gnubin:$PATH" >> $GITHUB_ENV + - name: Install Rust + uses: actions-rs/toolchain@v1 + with: + profile: minimal + default: true + - name: Test + run: make test + env: + RUSTFLAGS: -Cdebuginfo=0 + + audit: + name: Audit + env: + CARGO_AUDIT_VERSION: 0.16.0 + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v2 + - uses: actions/cache@master + with: + path: ${{ runner.tool_cache }}/cargo-audit + key: cargo-audit-bin-${{ env.CARGO_AUDIT_VERSION }} + - run: | + echo "'${{ runner.tool_cache }}/cargo-audit/bin'" >> $GITHUB_PATH + - run: | + cargo install cargo-audit --version ${{ env.CARGO_AUDIT_VERSION }} --root '${{ runner.tool_cache }}/cargo-audit' + # No fixed dependencies available for the first two and the emscripten is not fixed for + # the last one... + cargo audit --ignore RUSTSEC-2021-0119 --ignore RUSTSEC-2020-0095 --ignore RUSTSEC-2020-0071 + + lint: + name: Code lint + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v2 + - name: Install Rust + uses: actions-rs/toolchain@v1 + with: + profile: minimal + override: true + components: rustfmt, clippy + - run: cargo fmt --all -- --check + - run: cargo fmt --manifest-path fuzz/Cargo.toml -- --check + - run: make lint + env: + RUSTFLAGS: -Cdebuginfo=0 + + - name: Assert no files have changed + run: | + git status + ! [[ $(git status -s) ]] diff --git a/runtime/near-vm/.gitignore b/runtime/near-vm/.gitignore new file mode 100644 index 00000000000..b1166e461a8 --- /dev/null +++ b/runtime/near-vm/.gitignore @@ -0,0 +1,17 @@ +**/target +**/*.rs.bk +.DS_Store +.idea +.gdb_history +**/.vscode +api-docs-repo/ +/.cargo_home/ +/package/ +/dist/ +/wapm-cli/ +/src/windows-installer/WasmerInstaller.exe +/lib/c-api/wasmer.h + +# Generated by tests on Android +/avd +/core diff --git a/runtime/near-vm/.tarpaulin.toml b/runtime/near-vm/.tarpaulin.toml new file mode 100644 index 00000000000..08fe94c34ee --- /dev/null +++ b/runtime/near-vm/.tarpaulin.toml @@ -0,0 +1,17 @@ +[cranelift_coverage] +features = "cranelift,singlepass,llvm,coverage,test-cranelift,test-jit" +examples = ["early-exit", "engine-jit", "engine-native", "engine-headless", "cross-compilation", "compiler-cranelift", "exported-function", "wasi"] +release = true + +[llvm_coverage] +features = "cranelift,singlepass,llvm,coverage,test-llvm,test-jit" +examples = ["compiler-llvm"] +release = true + +[singlepass_coverage] +features = "cranelift,singlepass,llvm,coverage,test-singlepass,test-jit" +examples = ["compiler-singlepass"] +release = true + +[report] +out = ["Xml"] diff --git a/runtime/near-vm/ATTRIBUTIONS.md b/runtime/near-vm/ATTRIBUTIONS.md new file mode 100644 index 00000000000..1f1cca7ce18 --- /dev/null +++ b/runtime/near-vm/ATTRIBUTIONS.md @@ -0,0 +1,605 @@ +# Wasmer Attributions + +Wasmer is a community effort and makes use of code from various other +projects ❤️. +Listed below are notable sections of code that are licensed +from other projects and the relevant license of those projects. + +These are the projects that were used as inspiration and/or that we are using code from. +Each of the subcrates we have have an `Aknowledgements` section with more details. + +Projects: + +- [Emscripten](https://github.com/kripken/emscripten): for emtests test sources to ensure compatibility - [LICENSE](#emscripten) +- [Nebulet](https://github.com/nebulet/nebulet): as the base for creating a great Rust WebAssembly runtime - [LICENSE](#nebulet) +- [WAVM](https://github.com/wavm/wavm): for their great integration and testing framework - [LICENSE](#wavm) +- [wasmtime](https://github.com/CraneStation/wasmtime): for their API and internal documentation, as well as some internal implementations - [LICENSE](#wasmtime) +- [WebAssembly spec](https://github.com/WebAssembly/spec/tree/master/test): for the spectests implementation + +🙏 Please let us know if you believe there is an error or omission in +this list and we will correct. + +## Licenses + +### Nebulet + +```text +MIT License + +Copyright (c) 2018 + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +``` + +### WAVM + +```text +Copyright (c) 2018, Andrew Scheidecker +All rights reserved. + +Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: +* Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. +* Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. +* Neither the name of WAVM nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +The contents of [Test/spec](Test/spec) is covered by the license in [Test/spec/LICENSE](Test/spec/LICENSE). + +[Source/ThirdParty/dtoa/dtoa.c](Source/ThirdParty/dtoa/dtoa.c) is covered by the license in that file. + +[Source/ThirdParty/libunwind](Source/ThirdParty/libunwind) is covered by the license in [Source/ThirdParty/libunwind/LICENSE.TXT](Source/ThirdParty/libunwind/LICENSE.TXT). + +[Source/ThirdParty/xxhash](Source/ThirdParty/xxhash) is covered by the license in [Source/ThirdParty/xxhash/LICENSE](Source/ThirdParty/xxhash/LICENSE). +``` + +### Greenwasm + +```text + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + +TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + +1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + +2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + +3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + +4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + +5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + +6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + +7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + +8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + +9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + +END OF TERMS AND CONDITIONS + +APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + +Copyright [yyyy] [name of copyright owner] + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +``` + +### Wasmtime + +```text + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + +--- LLVM Exceptions to the Apache 2.0 License ---- + +As an exception, if, as a result of your compiling your source code, portions +of this Software are embedded into an Object form of such source code, you +may redistribute such embedded portions in such Object form without complying +with the conditions of Sections 4(a), 4(b) and 4(d) of the License. + +In addition, if you combine or link compiled forms of this Software with +software that is licensed under the GPLv2 ("Combined Software") and if a +court of competent jurisdiction determines that the patent provision (Section +3), the indemnity provision (Section 9) or other Section of the License +conflicts with the conditions of the GPLv2, you may retroactively and +prospectively choose to deem waived or otherwise exclude such Section(s) of +the License, but only in their entirety and only with respect to the Combined +Software. +``` + +### Emscripten +```text +Emscripten is available under 2 licenses, the MIT license and the +University of Illinois/NCSA Open Source License. + +Both are permissive open source licenses, with little if any +practical difference between them. + +The reason for offering both is that (1) the MIT license is +well-known, while (2) the University of Illinois/NCSA Open Source +License allows Emscripten's code to be integrated upstream into +LLVM, which uses that license, should the opportunity arise. + +The full text of both licenses follows. + +============================================================================== + +Copyright (c) 2010-2014 Emscripten authors, see AUTHORS file. + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. + +============================================================================== + +Copyright (c) 2010-2014 Emscripten authors, see AUTHORS file. +All rights reserved. + +Permission is hereby granted, free of charge, to any person obtaining a +copy of this software and associated documentation files (the +"Software"), to deal with the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + + Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimers. + + Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following disclaimers + in the documentation and/or other materials provided with the + distribution. + + Neither the names of Mozilla, + nor the names of its contributors may be used to endorse + or promote products derived from this Software without specific prior + written permission. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS +OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +IN NO EVENT SHALL THE CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR +ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, +TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE +SOFTWARE OR THE USE OR OTHER DEALINGS WITH THE SOFTWARE. + +============================================================================== + +This program uses portions of Node.js source code located in src/library_path.js, +in accordance with the terms of the MIT license. Node's license follows: + + """ + Copyright Joyent, Inc. and other Node contributors. All rights reserved. + Permission is hereby granted, free of charge, to any person obtaining a copy + of this software and associated documentation files (the "Software"), to + deal in the Software without restriction, including without limitation the + rights to use, copy, modify, merge, publish, distribute, sublicense, and/or + sell copies of the Software, and to permit persons to whom the Software is + furnished to do so, subject to the following conditions: + + The above copyright notice and this permission notice shall be included in + all copies or substantial portions of the Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS + IN THE SOFTWARE. + """ + +The musl libc project is bundled in this repo, and it has the MIT license, see +system/lib/libc/musl/COPYRIGHT + +The third_party/ subdirectory contains code with other licenses. None of it is +used by default, but certain options use it (e.g., the optional closure compiler +flag will run closure compiler from third_party/). + +``` diff --git a/runtime/near-vm/CHANGELOG.md b/runtime/near-vm/CHANGELOG.md new file mode 100644 index 00000000000..38e7d390f23 --- /dev/null +++ b/runtime/near-vm/CHANGELOG.md @@ -0,0 +1,729 @@ +# Changelog + +*The format is based on [Keep a Changelog].* + +[Keep a Changelog]: http://keepachangelog.com/en/1.0.0/ + +Looking for changes that affect our C API? See the [C API Changelog](lib/c-api/CHANGELOG.md). + +## **[Unreleased]** + +## 2.1.0 - 2021/11/30 + +### Added +- [#2574](https://github.com/wasmerio/wasmer/pull/2574) Added Windows support to Singlepass. +- [#2535](https://github.com/wasmerio/wasmer/pull/2435) Added iOS support for Wasmer. This relies on the `dylib-engine`. +- [#2460](https://github.com/wasmerio/wasmer/pull/2460) Wasmer can now compile to Javascript via `wasm-bindgen`. Use the `js-default` (and no default features) feature to try it!. +- [#2491](https://github.com/wasmerio/wasmer/pull/2491) Added support for WASI to Wasmer-js. +- [#2436](https://github.com/wasmerio/wasmer/pull/2436) Added the x86-32 bit variant support to LLVM compiler. +- [#2499](https://github.com/wasmerio/wasmer/pull/2499) Added a subcommand to linux wasmer-cli to register wasmer with binfmt_misc +- [#2511](https://github.com/wasmerio/wasmer/pull/2511) Added support for calling dynamic functions defined on the host +- [#2491](https://github.com/wasmerio/wasmer/pull/2491) Added support for WASI in Wasmer-js +- [#2592](https://github.com/wasmerio/wasmer/pull/2592) Added `ImportObject::get_namespace_exports` to allow modifying the contents of an existing namespace in an `ImportObject`. +- [#2694](https://github.com/wasmerio/wasmer/pull/2694) wasmer-js: Allow an `ImportObject` to be extended with a JS object. +- [#2698](https://github.com/wasmerio/wasmer/pull/2698) Provide WASI imports when invoking an explicit export from the CLI. +- [#2701](https://github.com/wasmerio/wasmer/pull/2701) Improved VFS API for usage from JS + +### Changed +- [#2460](https://github.com/wasmerio/wasmer/pull/2460) **breaking change** `wasmer` API usage with `no-default-features` requires now the `sys` feature to preserve old behavior. +- [#2476](https://github.com/wasmerio/wasmer/pull/2476) Removed unncessary abstraction `ModuleInfoTranslate` from `wasmer-compiler`. +- [#2442](https://github.com/wasmerio/wasmer/pull/2442) Improved `WasmPtr`, added `WasmCell` for host/guest interaction. +- [#2427](https://github.com/wasmerio/wasmer/pull/2427) Update `loupe` to 0.1.3. +- [#2685](https://github.com/wasmerio/wasmer/pull/2685) The minimum LLVM version for the LLVM compiler is now 12. LLVM 13 is used by default. +- [#2569](https://github.com/wasmerio/wasmer/pull/2569) Add `Send` and `Sync` to uses of the `LikeNamespace` trait object. +- [#2692](https://github.com/wasmerio/wasmer/pull/2692) Made module serialization deterministic. +- [#2693](https://github.com/wasmerio/wasmer/pull/2693) Validate CPU features when loading a deserialized module. + +### Fixed +- [#2599](https://github.com/wasmerio/wasmer/pull/2599) Fixed Universal engine for Linux/Aarch64 target. +- [#2587](https://github.com/wasmerio/wasmer/pull/2587) Fixed deriving `WasmerEnv` when aliasing `Result`. +- [#2518](https://github.com/wasmerio/wasmer/pull/2518) Remove temporary file used to creating an artifact when creating a Dylib engine artifact. +- [#2494](https://github.com/wasmerio/wasmer/pull/2494) Fixed `WasmerEnv` access when using `call_indirect` with the Singlepass compiler. +- [#2479](https://github.com/wasmerio/wasmer/pull/2479) Improved `wasmer validate` error message on non-wasm inputs. +- [#2454](https://github.com/wasmerio/wasmer/issues/2454) Won't set `WASMER_CACHE_DIR` for Windows. +- [#2426](https://github.com/wasmerio/wasmer/pull/2426) Fix the `wax` script generation. +- [#2635](https://github.com/wasmerio/wasmer/pull/2635) Fix cross-compilation for singlepass. +- [#2672](https://github.com/wasmerio/wasmer/pull/2672) Use `ENOENT` instead of `EINVAL` in some WASI syscalls for a non-existent file +- [#2547](https://github.com/wasmerio/wasmer/pull/2547) Delete temporary files created by the dylib engine. +- [#2548](https://github.com/wasmerio/wasmer/pull/2548) Fix stack probing on x86_64 linux with the cranelift compiler. +- [#2557](https://github.com/wasmerio/wasmer/pull/2557) [#2559](https://github.com/wasmerio/wasmer/pull/2559) Fix WASI dir path renaming. +- [#2560](https://github.com/wasmerio/wasmer/pull/2560) Fix signal handling on M1 MacOS. +- [#2474](https://github.com/wasmerio/wasmer/pull/2474) Fix permissions on `WASMER_CACHE_DIR` on Windows. +- [#2528](https://github.com/wasmerio/wasmer/pull/2528) [#2525](https://github.com/wasmerio/wasmer/pull/2525) [#2523](https://github.com/wasmerio/wasmer/pull/2523) [#2522](https://github.com/wasmerio/wasmer/pull/2522) [#2545](https://github.com/wasmerio/wasmer/pull/2545) [#2550](https://github.com/wasmerio/wasmer/pull/2550) [#2551](https://github.com/wasmerio/wasmer/pull/2551) Fix various bugs in the new VFS implementation. +- [#2552](https://github.com/wasmerio/wasmer/pull/2552) Fix stack guard handling on Windows. +- [#2585](https://github.com/wasmerio/wasmer/pull/2585) Fix build with 64-bit MinGW toolchain. +- [#2587](https://github.com/wasmerio/wasmer/pull/2587) Fix absolute import of `Result` in derive. +- [#2599](https://github.com/wasmerio/wasmer/pull/2599) Fix AArch64 support in the LLVM compiler. +- [#2655](https://github.com/wasmerio/wasmer/pull/2655) Fix argument parsing of `--dir` and `--mapdir`. +- [#2666](https://github.com/wasmerio/wasmer/pull/2666) Fix performance on Windows by using static memories by default. +- [#2667](https://github.com/wasmerio/wasmer/pull/2667) Fix error code for path_rename of a non-existant file +- [#2672](https://github.com/wasmerio/wasmer/pull/2672) Fix error code returned by some wasi fs syscalls for a non-existent file +- [#2673](https://github.com/wasmerio/wasmer/pull/2673) Fix BrTable codegen on the LLVM compiler +- [#2674](https://github.com/wasmerio/wasmer/pull/2674) Add missing `__WASI_RIGHT_FD_DATASYNC` for preopened directories +- [#2677](https://github.com/wasmerio/wasmer/pull/2677) Support 32-bit memories with 65536 pages +- [#2681](https://github.com/wasmerio/wasmer/pull/2681) Fix slow compilation in singlepass by using dynasm's `VecAssembler`. +- [#2690](https://github.com/wasmerio/wasmer/pull/2690) Fix memory leak when obtaining the stack bounds of a thread +- [#2699](https://github.com/wasmerio/wasmer/pull/2699) Partially fix unbounded memory leak from the FuncDataRegistry + +## 2.0.0 - 2021/06/16 + +### Added +- [#2411](https://github.com/wasmerio/wasmer/pull/2411) Extract types from `wasi` to a new `wasi-types` crate. +- [#2390](https://github.com/wasmerio/wasmer/pull/2390) Make `wasmer-vm` to compile on Windows 32bits. +- [#2402](https://github.com/wasmerio/wasmer/pull/2402) Add more examples and more doctests for `wasmer-middlewares`. + +### Changed +- [#2399](https://github.com/wasmerio/wasmer/pull/2399) Add the Dart integration in the `README.md`. + +### Fixed +- [#2386](https://github.com/wasmerio/wasmer/pull/2386) Handle properly when a module has no exported functions in the CLI. + +## 2.0.0-rc2 - 2021/06/03 + +### Fixed +- [#2383](https://github.com/wasmerio/wasmer/pull/2383) Fix bugs in the Wasmer CLI tool with the way `--version` and the name of the CLI tool itself were printed. + +## 2.0.0-rc1 - 2021/06/02 + +### Added +- [#2348](https://github.com/wasmerio/wasmer/pull/2348) Make Wasmer available on `aarch64-linux-android`. +- [#2315](https://github.com/wasmerio/wasmer/pull/2315) Make the Cranelift compiler working with the Native engine. +- [#2306](https://github.com/wasmerio/wasmer/pull/2306) Add support for the latest version of the Wasm SIMD proposal to compiler LLVM. +- [#2296](https://github.com/wasmerio/wasmer/pull/2296) Add support for the bulk memory proposal in compiler Singlepass and compiler LLVM. +- [#2291](https://github.com/wasmerio/wasmer/pull/2291) Type check tables when importing. +- [#2262](https://github.com/wasmerio/wasmer/pull/2262) Make parallelism optional for the Singlepass compiler. +- [#2249](https://github.com/wasmerio/wasmer/pull/2249) Make Cranelift unwind feature optional. +- [#2208](https://github.com/wasmerio/wasmer/pull/2208) Add a new CHANGELOG.md specific to our C API to make it easier for users primarily consuming our C API to keep up to date with changes that affect them. +- [#2154](https://github.com/wasmerio/wasmer/pull/2154) Implement Reference Types in the LLVM compiler. +- [#2003](https://github.com/wasmerio/wasmer/pull/2003) Wasmer works with musl, and is built, tested and packaged for musl. +- [#2250](https://github.com/wasmerio/wasmer/pull/2250) Use `rkyv` for the JIT/Universal engine. +- [#2190](https://github.com/wasmerio/wasmer/pull/2190) Use `rkyv` to read native `Module` artifact. +- [#2186](https://github.com/wasmerio/wasmer/pull/2186) Update and improve the Fuzz Testing infrastructure. +- [#2161](https://github.com/wasmerio/wasmer/pull/2161) Make NaN canonicalization configurable. +- [#2116](https://github.com/wasmerio/wasmer/pull/2116) Add a package for Windows that is not an installer, but all the `lib` and `include` files as for macOS and Linux. +- [#2123](https://github.com/wasmerio/wasmer/pull/2123) Use `ENABLE_{{compiler_name}}=(0|1)` to resp. force to disable or enable a compiler when running the `Makefile`, e.g. `ENABLE_LLVM=1 make build-wasmer`. +- [#2123](https://github.com/wasmerio/wasmer/pull/2123) `libwasmer` comes with all available compilers per target instead of Cranelift only. +- [#2135](https://github.com/wasmerio/wasmer/pull/2135) [Documentation](./PACKAGING.md) for Linux distribution maintainers +- [#2104](https://github.com/wasmerio/wasmer/pull/2104) Update WAsm core spectests and wasmparser. + +### Changed +- [#2369](https://github.com/wasmerio/wasmer/pull/2369) Remove the deprecated `--backend` option in the CLI. +- [#2368](https://github.com/wasmerio/wasmer/pull/2368) Remove the deprecated code in the `wasmer-wasi` crate. +- [#2367](https://github.com/wasmerio/wasmer/pull/2367) Remove the `deprecated` features and associated code in the `wasmer` crate. +- [#2366](https://github.com/wasmerio/wasmer/pull/2366) Remove the deprecated crates. +- [#2364](https://github.com/wasmerio/wasmer/pull/2364) Rename `wasmer-engine-object-file` to `wasmer-engine-staticlib`. +- [#2356](https://github.com/wasmerio/wasmer/pull/2356) Rename `wasmer-engine-native` to `wasmer-engine-dylib`. +- [#2340](https://github.com/wasmerio/wasmer/pull/2340) Rename `wasmer-engine-jit` to `wasmer-engine-universal`. +- [#2307](https://github.com/wasmerio/wasmer/pull/2307) Update Cranelift, implement low hanging fruit SIMD opcodes. +- [#2305](https://github.com/wasmerio/wasmer/pull/2305) Clean up and improve the trap API, more deterministic errors etc. +- [#2299](https://github.com/wasmerio/wasmer/pull/2299) Unused trap codes (due to Wasm spec changes), `HeapSetterOutOfBounds` and `TableSetterOutOfBounds` were removed from `wasmer_vm::TrapCode` and the numbering of the remaining variants has been adjusted. +- [#2293](https://github.com/wasmerio/wasmer/pull/2293) The `Memory::ty` trait method now returns `MemoryType` by value. `wasmer_vm::LinearMemory` now recomputes `MemoryType`'s `minimum` field when accessing its type. This behavior is what's expected by the latest spectests. `wasmer::Memory::ty` has also been updated to follow suit, it now returns `MemoryType` by value. +- [#2286](https://github.com/wasmerio/wasmer/pull/2286) Replace the `goblin` crate by the `object` crate. +- [#2281](https://github.com/wasmerio/wasmer/pull/2281) Refactor the `wasmer_vm` crate to remove unnecessary structs, reuse data when available etc. +- [#2251](https://github.com/wasmerio/wasmer/pull/2251) Wasmer CLI will now execute WASI modules with multiple WASI namespaces in them by default. Use `--allow-multiple-wasi-versions` to suppress the warning and use `--deny-multiple-wasi-versions` to make it an error. +- [#2201](https://github.com/wasmerio/wasmer/pull/2201) Implement `loupe::MemoryUsage` for `wasmer::Instance`. +- [#2200](https://github.com/wasmerio/wasmer/pull/2200) Implement `loupe::MemoryUsage` for `wasmer::Module`. +- [#2199](https://github.com/wasmerio/wasmer/pull/2199) Implement `loupe::MemoryUsage` for `wasmer::Store`. +- [#2195](https://github.com/wasmerio/wasmer/pull/2195) Remove dependency to `cranelift-entity`. +- [#2140](https://github.com/wasmerio/wasmer/pull/2140) Reduce the number of dependencies in the `wasmer.dll` shared library by statically compiling CRT. +- [#2113](https://github.com/wasmerio/wasmer/pull/2113) Bump minimum supported Rust version to 1.49 +- [#2144](https://github.com/wasmerio/wasmer/pull/2144) Bump cranelift version to 0.70 +- [#2149](https://github.com/wasmerio/wasmer/pull/2144) `wasmer-engine-native` looks for clang-11 instead of clang-10. +- [#2157](https://github.com/wasmerio/wasmer/pull/2157) Simplify the code behind `WasmPtr` + +### Fixed +- [#2397](https://github.com/wasmerio/wasmer/pull/2397) Fix WASI rename temporary file issue. +- [#2391](https://github.com/wasmerio/wasmer/pull/2391) Fix Singlepass emit bug, [#2347](https://github.com/wasmerio/wasmer/issues/2347) and [#2159](https://github.com/wasmerio/wasmer/issues/2159) +- [#2327](https://github.com/wasmerio/wasmer/pull/2327) Fix memory leak preventing internal instance memory from being freed when a WasmerEnv contained an exported extern (e.g. Memory, etc.). +- [#2247](https://github.com/wasmerio/wasmer/pull/2247) Internal WasiFS logic updated to be closer to what WASI libc does when finding a preopened fd for a path. +- [#2241](https://github.com/wasmerio/wasmer/pull/2241) Fix Undefined Behavior in setting memory in emscripten `EmEnv`. +- [#2224](https://github.com/wasmerio/wasmer/pull/2224) Enable SIMD based on actual Wasm features in the Cranelift compiler. +- [#2217](https://github.com/wasmerio/wasmer/pull/2217) Fix bug in `i64.rotr X 0` in the LLVM compiler. +- [#2290](https://github.com/wasmerio/wasmer/pull/2290) Handle Wasm modules with no imports in the CLI. +- [#2108](https://github.com/wasmerio/wasmer/pull/2108) The Object Native Engine generates code that now compiles correctly with C++. +- [#2125](https://github.com/wasmerio/wasmer/pull/2125) Fix RUSTSEC-2021-0023. +- [#2155](https://github.com/wasmerio/wasmer/pull/2155) Fix the implementation of shift and rotate in the LLVM compiler. +- [#2101](https://github.com/wasmerio/wasmer/pull/2101) cflags emitted by `wasmer config --pkg-config` are now correct. + +## 1.0.2 - 2021-02-04 + +### Added +- [#2053](https://github.com/wasmerio/wasmer/pull/2053) Implement the non-standard `wasi_get_unordered_imports` function in the C API. +- [#2072](https://github.com/wasmerio/wasmer/pull/2072) Add `wasm_config_set_target`, along with `wasm_target_t`, `wasm_triple_t` and `wasm_cpu_features_t` in the unstable C API. +- [#2059](https://github.com/wasmerio/wasmer/pull/2059) Ability to capture `stdout` and `stderr` with WASI in the C API. +- [#2040](https://github.com/wasmerio/wasmer/pull/2040) Add `InstanceHandle::vmoffsets` to expose the offsets of the `vmctx` region. +- [#2026](https://github.com/wasmerio/wasmer/pull/2026) Expose trap code of a `RuntimeError`, if it's a `Trap`. +- [#2054](https://github.com/wasmerio/wasmer/pull/2054) Add `wasm_config_delete` to the Wasm C API. +- [#2072](https://github.com/wasmerio/wasmer/pull/2072) Added cross-compilation to Wasm C API. + +### Changed +- [#2085](https://github.com/wasmerio/wasmer/pull/2085) Update to latest inkwell and LLVM 11. +- [#2037](https://github.com/wasmerio/wasmer/pull/2037) Improved parallelism of LLVM with the Native/Object engine +- [#2012](https://github.com/wasmerio/wasmer/pull/2012) Refactor Singlepass init stack assembly (more performant now) +- [#2036](https://github.com/wasmerio/wasmer/pull/2036) Optimize memory allocated for Function type definitions +- [#2083](https://github.com/wasmerio/wasmer/pull/2083) Mark `wasi_env_set_instance` and `wasi_env_set_memory` as deprecated. You may simply remove the calls with no side-effect. +- [#2056](https://github.com/wasmerio/wasmer/pull/2056) Change back to depend on the `enumset` crate instead of `wasmer_enumset` + +### Fixed +- [#2066](https://github.com/wasmerio/wasmer/pull/2066) Include 'extern "C"' in our C headers when included by C++ code. +- [#2090](https://github.com/wasmerio/wasmer/pull/2090) `wasi_env_t` needs to be freed with `wasi_env_delete` in the C API. +- [#2084](https://github.com/wasmerio/wasmer/pull/2084) Avoid calling the function environment finalizer more than once when the environment has been cloned in the C API. +- [#2069](https://github.com/wasmerio/wasmer/pull/2069) Use the new documentation for `include/README.md` in the Wasmer package. +- [#2042](https://github.com/wasmerio/wasmer/pull/2042) Parse more exotic environment variables in `wasmer run`. +- [#2041](https://github.com/wasmerio/wasmer/pull/2041) Documentation diagrams now have a solid white background rather than a transparent background. +- [#2070](https://github.com/wasmerio/wasmer/pull/2070) Do not drain the entire captured stream at first read with `wasi_env_read_stdout` or `_stderr` in the C API. +- [#2058](https://github.com/wasmerio/wasmer/pull/2058) Expose WASI versions to C correctly. +- [#2044](https://github.com/wasmerio/wasmer/pull/2044) Do not build C headers on docs.rs. + +## 1.0.1 - 2021-01-12 + +This release includes a breaking change in the API (changing the trait `enumset::EnumsetType` to `wasmer_enumset::EnumSetType` and changing `enumset::EnumSet` in signatures to `wasmer_enumset::EnumSet` to work around a breaking change introduced by `syn`) but is being released as a minor version because `1.0.0` is also in a broken state due to a breaking change introduced by `syn` which affects `enumset` and thus `wasmer`. + +This change is unlikely to affect any users of `wasmer`, but if it does please change uses of the `enumset` crate to the `wasmer_enumset` crate where possible. + +### Added +- [#2010](https://github.com/wasmerio/wasmer/pull/2010) A new, experimental, minified build of `wasmer` called `wasmer-headless` will now be included with releases. `wasmer-headless` is the `wasmer` VM without any compilers attached, so it can only run precompiled Wasm modules. +- [#2005](https://github.com/wasmerio/wasmer/pull/2005) Added the arguments `alias` and `optional` to `WasmerEnv` derive's `export` attribute. + +### Changed +- [#2006](https://github.com/wasmerio/wasmer/pull/2006) Use `wasmer_enumset`, a fork of the `enumset` crate to work around a breaking change in `syn` +- [#1985](https://github.com/wasmerio/wasmer/pull/1985) Bump minimum supported Rust version to 1.48 + +### Fixed +- [#2007](https://github.com/wasmerio/wasmer/pull/2007) Fix packaging of wapm on Windows +- [#2005](https://github.com/wasmerio/wasmer/pull/2005) Emscripten is now working again. + +## 1.0.0 - 2021-01-05 + +### Added + +- [#1969](https://github.com/wasmerio/wasmer/pull/1969) Added D integration to the README + +### Changed +- [#1979](https://github.com/wasmerio/wasmer/pull/1979) `WasmPtr::get_utf8_string` was renamed to `WasmPtr::get_utf8_str` and made `unsafe`. + +### Fixed +- [#1979](https://github.com/wasmerio/wasmer/pull/1979) `WasmPtr::get_utf8_string` now returns a `String`, fixing a soundness issue in certain circumstances. The old functionality is available under a new `unsafe` function, `WasmPtr::get_utf8_str`. + +## 1.0.0-rc1 - 2020-12-23 + +### Added + +* [#1894](https://github.com/wasmerio/wasmer/pull/1894) Added exports `wasmer::{CraneliftOptLevel, LLVMOptLevel}` to allow using `Cranelift::opt_level` and `LLVM::opt_level` directly via the `wasmer` crate + +### Changed + +* [#1941](https://github.com/wasmerio/wasmer/pull/1941) Turn `get_remaining_points`/`set_remaining_points` of the `Metering` middleware into free functions to allow using them in an ahead-of-time compilation setup +* [#1955](https://github.com/wasmerio/wasmer/pull/1955) Set `jit` as a default feature of the `wasmer-wasm-c-api` crate +* [#1944](https://github.com/wasmerio/wasmer/pull/1944) Require `WasmerEnv` to be `Send + Sync` even in dynamic functions. +* [#1963](https://github.com/wasmerio/wasmer/pull/1963) Removed `to_wasm_error` in favour of `impl From for WasmError` +* [#1962](https://github.com/wasmerio/wasmer/pull/1962) Replace `wasmparser::Result<()>` with `Result<(), MiddlewareError>` in middleware, allowing implementors to return errors in `FunctionMiddleware::feed` + +### Fixed + +- [#1949](https://github.com/wasmerio/wasmer/pull/1949) `wasm__vec_delete` functions no longer crash when the given vector is uninitialized, in the Wasmer C API +- [#1949](https://github.com/wasmerio/wasmer/pull/1949) The `wasm_frame_vec_t`, `wasm_functype_vec_t`, `wasm_globaltype_vec_t`, `wasm_memorytype_vec_t`, and `wasm_tabletype_vec_t` are now boxed vectors in the Wasmer C API + +## 1.0.0-beta2 - 2020-12-16 + +### Added + +* [#1916](https://github.com/wasmerio/wasmer/pull/1916) Add the `WASMER_VERSION*` constants with the `wasmer_version*` functions in the Wasmer C API +* [#1867](https://github.com/wasmerio/wasmer/pull/1867) Added `Metering::get_remaining_points` and `Metering::set_remaining_points` +* [#1881](https://github.com/wasmerio/wasmer/pull/1881) Added `UnsupportedTarget` error to `CompileError` +* [#1908](https://github.com/wasmerio/wasmer/pull/1908) Implemented `TryFrom>` for `i32`/`u32`/`i64`/`u64`/`f32`/`f64` +* [#1927](https://github.com/wasmerio/wasmer/pull/1927) Added mmap support in `Engine::deserialize_from_file` to speed up artifact loading +* [#1911](https://github.com/wasmerio/wasmer/pull/1911) Generalized signature type in `Function::new` and `Function::new_with_env` to accept owned and reference `FunctionType` as well as array pairs. This allows users to define signatures as constants. Implemented `From<([Type; $N], [Type; $M])>` for `FunctionType` to support this. + +### Changed + +- [#1865](https://github.com/wasmerio/wasmer/pull/1865) Require that implementors of `WasmerEnv` also implement `Send`, `Sync`, and `Clone`. +- [#1851](https://github.com/wasmerio/wasmer/pull/1851) Improve test suite and documentation of the Wasmer C API +- [#1874](https://github.com/wasmerio/wasmer/pull/1874) Set `CompilerConfig` to be owned (following wasm-c-api) +- [#1880](https://github.com/wasmerio/wasmer/pull/1880) Remove cmake dependency for tests +- [#1924](https://github.com/wasmerio/wasmer/pull/1924) Rename reference implementation `wasmer::Tunables` to `wasmer::BaseTunables`. Export trait `wasmer_engine::Tunables` as `wasmer::Tunables`. + +### Fixed + +- [#1865](https://github.com/wasmerio/wasmer/pull/1865) Fix memory leaks with host function environments. +- [#1870](https://github.com/wasmerio/wasmer/pull/1870) Fixed Trap instruction address maps in Singlepass +* [#1914](https://github.com/wasmerio/wasmer/pull/1914) Implemented `TryFrom for Pages` instead of `From for Pages` to properly handle overflow errors + +## 1.0.0-beta1 - 2020-12-01 + +### Added + +- [#1839](https://github.com/wasmerio/wasmer/pull/1839) Added support for Metering Middleware +- [#1837](https://github.com/wasmerio/wasmer/pull/1837) It is now possible to use exports of an `Instance` even after the `Instance` has been freed +- [#1831](https://github.com/wasmerio/wasmer/pull/1831) Added support for Apple Silicon chips (`arm64-apple-darwin`) +- [#1739](https://github.com/wasmerio/wasmer/pull/1739) Improved function environment setup via `WasmerEnv` proc macro. +- [#1649](https://github.com/wasmerio/wasmer/pull/1649) Add outline of migration to 1.0.0 docs. + +### Changed + +- [#1739](https://github.com/wasmerio/wasmer/pull/1739) Environments passed to host function- must now implement the `WasmerEnv` trait. You can implement it on your existing type with `#[derive(WasmerEnv)]`. +- [#1838](https://github.com/wasmerio/wasmer/pull/1838) Deprecate `WasiEnv::state_mut`: prefer `WasiEnv::state` instead. +- [#1663](https://github.com/wasmerio/wasmer/pull/1663) Function environments passed to host functions now must be passed by `&` instead of `&mut`. This is a breaking change. This change fixes a race condition when a host function is called from multiple threads. If you need mutability in your environment, consider using `std::sync::Mutex` or other synchronization primitives. +- [#1830](https://github.com/wasmerio/wasmer/pull/1830) Minimum supported Rust version bumped to 1.47.0 +- [#1810](https://github.com/wasmerio/wasmer/pull/1810) Make the `state` field of `WasiEnv` public + +### Fixed + +- [#1857](https://github.com/wasmerio/wasmer/pull/1857) Fix dynamic function with new Environment API +- [#1855](https://github.com/wasmerio/wasmer/pull/1855) Fix memory leak when using `wat2wasm` in the C API, the function now takes its output parameter by pointer rather than returning an allocated `wasm_byte_vec_t`. +- [#1841](https://github.com/wasmerio/wasmer/pull/1841) We will now panic when attempting to use a native function with a captured env as a host function. Previously this would silently do the wrong thing. See [#1840](https://github.com/wasmerio/wasmer/pull/1840) for info about Wasmer's support of closures as host functions. +- [#1764](https://github.com/wasmerio/wasmer/pull/1764) Fix bug in WASI `path_rename` allowing renamed files to be 1 directory below a preopened directory. + +## 1.0.0-alpha5 - 2020-11-06 + +### Added + +- [#1761](https://github.com/wasmerio/wasmer/pull/1761) Implement the `wasm_trap_t**` argument of `wasm_instance_new` in the Wasm C API. +- [#1687](https://github.com/wasmerio/wasmer/pull/1687) Add basic table example; fix ownership of local memory and local table metadata in the VM. +- [#1751](https://github.com/wasmerio/wasmer/pull/1751) Implement `wasm_trap_t` inside a function declared with `wasm_func_new_with_env` in the Wasm C API. +- [#1741](https://github.com/wasmerio/wasmer/pull/1741) Implement `wasm_memory_type` in the Wasm C API. +- [#1736](https://github.com/wasmerio/wasmer/pull/1736) Implement `wasm_global_type` in the Wasm C API. +- [#1699](https://github.com/wasmerio/wasmer/pull/1699) Update `wasm.h` to its latest version. +- [#1685](https://github.com/wasmerio/wasmer/pull/1685) Implement `wasm_exporttype_delete` in the Wasm C API. +- [#1725](https://github.com/wasmerio/wasmer/pull/1725) Implement `wasm_func_type` in the Wasm C API. +- [#1715](https://github.com/wasmerio/wasmer/pull/1715) Register errors from `wasm_module_serialize` in the Wasm C API. +- [#1709](https://github.com/wasmerio/wasmer/pull/1709) Implement `wasm_module_name` and `wasm_module_set_name` in the Wasm(er) C API. +- [#1700](https://github.com/wasmerio/wasmer/pull/1700) Implement `wasm_externtype_copy` in the Wasm C API. +- [#1785](https://github.com/wasmerio/wasmer/pull/1785) Add more examples on the Rust API. +- [#1783](https://github.com/wasmerio/wasmer/pull/1783) Handle initialized but empty results in `wasm_func_call` in the Wasm C API. +- [#1780](https://github.com/wasmerio/wasmer/pull/1780) Implement new SIMD zero-extend loads in compiler-llvm. +- [#1754](https://github.com/wasmerio/wasmer/pull/1754) Implement aarch64 ABI for compiler-llvm. +- [#1693](https://github.com/wasmerio/wasmer/pull/1693) Add `wasmer create-exe` subcommand. + +### Changed + +- [#1772](https://github.com/wasmerio/wasmer/pull/1772) Remove lifetime parameter from `NativeFunc`. +- [#1762](https://github.com/wasmerio/wasmer/pull/1762) Allow the `=` sign in a WASI environment variable value. +- [#1710](https://github.com/wasmerio/wasmer/pull/1710) Memory for function call trampolines is now owned by the Artifact. +- [#1781](https://github.com/wasmerio/wasmer/pull/1781) Cranelift upgrade to 0.67. +- [#1777](https://github.com/wasmerio/wasmer/pull/1777) Wasmparser update to 0.65. +- [#1775](https://github.com/wasmerio/wasmer/pull/1775) Improve LimitingTunables implementation. +- [#1720](https://github.com/wasmerio/wasmer/pull/1720) Autodetect llvm regardless of architecture. + +### Fixed + +- [#1718](https://github.com/wasmerio/wasmer/pull/1718) Fix panic in the API in some situations when the memory's min bound was greater than the memory's max bound. +- [#1731](https://github.com/wasmerio/wasmer/pull/1731) In compiler-llvm always load before store, to trigger any traps before any bytes are written. + +## 1.0.0-alpha4 - 2020-10-08 + +### Added +- [#1635](https://github.com/wasmerio/wasmer/pull/1635) Implement `wat2wasm` in the Wasm C API. +- [#1636](https://github.com/wasmerio/wasmer/pull/1636) Implement `wasm_module_validate` in the Wasm C API. +- [#1657](https://github.com/wasmerio/wasmer/pull/1657) Implement `wasm_trap_t` and `wasm_frame_t` for Wasm C API; add examples in Rust and C of exiting early with a host function. + +### Fixed +- [#1690](https://github.com/wasmerio/wasmer/pull/1690) Fix `wasm_memorytype_limits` where `min` and `max` represents pages, not bytes. Additionally, fixes the max limit sentinel value. +- [#1671](https://github.com/wasmerio/wasmer/pull/1671) Fix probestack firing inappropriately, and sometimes over/under allocating stack. +- [#1660](https://github.com/wasmerio/wasmer/pull/1660) Fix issue preventing map-dir aliases starting with `/` from working properly. +- [#1624](https://github.com/wasmerio/wasmer/pull/1624) Add Value::I32/Value::I64 converters from unsigned ints. + +### Changed +- [#1682](https://github.com/wasmerio/wasmer/pull/1682) Improve error reporting when making a memory with invalid settings. +- [#1691](https://github.com/wasmerio/wasmer/pull/1691) Bump minimum supported Rust version to 1.46.0 +- [#1645](https://github.com/wasmerio/wasmer/pull/1645) Move the install script to https://github.com/wasmerio/wasmer-install + +## 1.0.0-alpha3 - 2020-09-14 + +### Fixed + +- [#1620](https://github.com/wasmerio/wasmer/pull/1620) Fix bug causing the Wapm binary to not be packaged with the release +- [#1619](https://github.com/wasmerio/wasmer/pull/1619) Improve error message in engine-native when C compiler is missing + +## 1.0.0-alpha02.0 - 2020-09-11 + +### Added + +- [#1566](https://github.com/wasmerio/wasmer/pull/1566) Add support for opening special Unix files to the WASI FS + +### Fixed + +- [#1602](https://github.com/wasmerio/wasmer/pull/1602) Fix panic when calling host functions with negative numbers in certain situations +- [#1590](https://github.com/wasmerio/wasmer/pull/1590) Fix soundness issue in API of vm::Global + +## TODO: 1.0.0-alpha01.0 + +- Wasmer refactor lands + +## 0.17.1 - 2020-06-24 + +### Changed +- [#1439](https://github.com/wasmerio/wasmer/pull/1439) Move `wasmer-interface-types` into its own repository + +### Fixed + +- [#1554](https://github.com/wasmerio/wasmer/pull/1554) Update supported stable Rust version to 1.45.2. +- [#1552](https://github.com/wasmerio/wasmer/pull/1552) Disable `sigint` handler by default. + +## 0.17.0 - 2020-05-11 + +### Added +- [#1331](https://github.com/wasmerio/wasmer/pull/1331) Implement the `record` type and instrutions for WIT +- [#1345](https://github.com/wasmerio/wasmer/pull/1345) Adding ARM testing in Azure Pipelines +- [#1329](https://github.com/wasmerio/wasmer/pull/1329) New numbers and strings instructions for WIT +- [#1285](https://github.com/wasmerio/wasmer/pull/1285) Greatly improve errors in `wasmer-interface-types` +- [#1303](https://github.com/wasmerio/wasmer/pull/1303) NaN canonicalization for singlepass backend. +- [#1313](https://github.com/wasmerio/wasmer/pull/1313) Add new high-level public API through `wasmer` crate. Includes many updates including: + - Minor improvement: `imports!` macro now handles no trailing comma as well as a trailing comma in namespaces and between namespaces. + - New methods on `Module`: `exports`, `imports`, and `custom_sections`. + - New way to get exports from an instance with `let func_name: Func = instance.exports.get("func_name");`. + - Improved `Table` APIs including `set` which now allows setting functions directly. TODO: update this more if `Table::get` gets made public in this PR + - TODO: finish the list of changes here +- [#1305](https://github.com/wasmerio/wasmer/pull/1305) Handle panics from DynamicFunc. +- [#1300](https://github.com/wasmerio/wasmer/pull/1300) Add support for multiple versions of WASI tests: wasitests now test all versions of WASI. +- [#1292](https://github.com/wasmerio/wasmer/pull/1292) Experimental Support for Android (x86_64 and AArch64) + +### Fixed +- [#1283](https://github.com/wasmerio/wasmer/pull/1283) Workaround for floating point arguments and return values in `DynamicFunc`s. + +### Changed +- [#1401](https://github.com/wasmerio/wasmer/pull/1401) Make breaking change to `RuntimeError`: `RuntimeError` is now more explicit about its possible error values allowing for better insight into why a call into Wasm failed. +- [#1382](https://github.com/wasmerio/wasmer/pull/1382) Refactored test infranstructure (part 2) +- [#1380](https://github.com/wasmerio/wasmer/pull/1380) Refactored test infranstructure (part 1) +- [#1357](https://github.com/wasmerio/wasmer/pull/1357) Refactored bin commands into separate files +- [#1335](https://github.com/wasmerio/wasmer/pull/1335) Change mutability of `memory` to `const` in `wasmer_memory_data_length` in the C API +- [#1332](https://github.com/wasmerio/wasmer/pull/1332) Add option to `CompilerConfig` to force compiler IR verification off even when `debug_assertions` are enabled. This can be used to make debug builds faster, which may be important if you're creating a library that wraps Wasmer and depend on the speed of debug builds. +- [#1320](https://github.com/wasmerio/wasmer/pull/1320) Change `custom_sections` field in `ModuleInfo` to be more standards compliant by allowing multiple custom sections with the same name. To get the old behavior with the new API, you can add `.last().unwrap()` to accesses. For example, `module_info.custom_sections["custom_section_name"].last().unwrap()`. +- [#1301](https://github.com/wasmerio/wasmer/pull/1301) Update supported stable Rust version to 1.41.1. + +## 0.16.2 - 2020-03-11 + +### Fixed + +- [#1294](https://github.com/wasmerio/wasmer/pull/1294) Fix bug related to system calls in WASI that rely on reading from WasmPtrs as arrays of length 0. `WasmPtr` will now succeed on length 0 arrays again. + +## 0.16.1 - 2020-03-11 + +### Fixed + +- [#1291](https://github.com/wasmerio/wasmer/pull/1291) Fix installation packaging script to package the `wax` command. + +## 0.16.0 - 2020-03-11 + +### Added +- [#1286](https://github.com/wasmerio/wasmer/pull/1286) Updated Windows Wasmer icons. Add wax +- [#1284](https://github.com/wasmerio/wasmer/pull/1284) Implement string and memory instructions in `wasmer-interface-types` + +### Fixed +- [#1272](https://github.com/wasmerio/wasmer/pull/1272) Fix off-by-one error bug when accessing memory with a `WasmPtr` that contains the last valid byte of memory. Also changes the behavior of `WasmPtr` with a length of 0 and `WasmPtr` where `std::mem::size_of::()` is 0 to always return `None` + +## 0.15.0 - 2020-03-04 + +- [#1263](https://github.com/wasmerio/wasmer/pull/1263) Changed the behavior of some WASI syscalls to now handle preopened directories more properly. Changed default `--debug` logging to only show Wasmer-related messages. +- [#1217](https://github.com/wasmerio/wasmer/pull/1217) Polymorphic host functions based on dynamic trampoline generation. +- [#1252](https://github.com/wasmerio/wasmer/pull/1252) Allow `/` in wasi `--mapdir` wasm path. +- [#1212](https://github.com/wasmerio/wasmer/pull/1212) Add support for GDB JIT debugging: + - Add `--generate-debug-info` and `-g` flags to `wasmer run` to generate debug information during compilation. The debug info is passed via the GDB JIT interface to a debugger to allow source-level debugging of Wasm files. Currently only available on clif-backend. + - Break public middleware APIs: there is now a `source_loc` parameter that should be passed through if applicable. + - Break compiler trait methods such as `feed_local`, `feed_event` as well as `ModuleCodeGenerator::finalize`. + +## 0.14.1 - 2020-02-24 + +- [#1245](https://github.com/wasmerio/wasmer/pull/1245) Use Ubuntu 16.04 in CI so that we use an earlier version of GLIBC. +- [#1234](https://github.com/wasmerio/wasmer/pull/1234) Check for unused excluded spectest failures. +- [#1232](https://github.com/wasmerio/wasmer/pull/1232) `wasmer-interface-types` has a WAT decoder. + +## 0.14.0 - 2020-02-20 + +- [#1233](https://github.com/wasmerio/wasmer/pull/1233) Improved Wasmer C API release artifacts. +- [#1216](https://github.com/wasmerio/wasmer/pull/1216) `wasmer-interface-types` receives a binary encoder. +- [#1228](https://github.com/wasmerio/wasmer/pull/1228) Singlepass cleanup: Resolve several FIXMEs and remove protect_unix. +- [#1218](https://github.com/wasmerio/wasmer/pull/1218) Enable Cranelift verifier in debug mode. Fix bug with table indices being the wrong type. +- [#787](https://github.com/wasmerio/wasmer/pull/787) New crate `wasmer-interface-types` to implement WebAssembly Interface Types. +- [#1213](https://github.com/wasmerio/wasmer/pull/1213) Fixed WASI `fdstat` to detect `isatty` properly. +- [#1192](https://github.com/wasmerio/wasmer/pull/1192) Use `ExceptionCode` for error representation. +- [#1191](https://github.com/wasmerio/wasmer/pull/1191) Fix singlepass miscompilation on `Operator::CallIndirect`. +- [#1180](https://github.com/wasmerio/wasmer/pull/1180) Fix compilation for target `x86_64-unknown-linux-musl`. +- [#1170](https://github.com/wasmerio/wasmer/pull/1170) Improve the WasiFs builder API with convenience methods for overriding stdin, stdout, and stderr as well as a new sub-builder for controlling the permissions and properties of preopened directories. Also breaks that implementations of `WasiFile` must be `Send` -- please file an issue if this change causes you any issues. +- [#1161](https://github.com/wasmerio/wasmer/pull/1161) Require imported functions to be `Send`. This is a breaking change that fixes a soundness issue in the API. +- [#1140](https://github.com/wasmerio/wasmer/pull/1140) Use [`blake3`](https://github.com/BLAKE3-team/BLAKE3) as default hashing algorithm for caching. +- [#1129](https://github.com/wasmerio/wasmer/pull/1129) Standard exception types for singlepass backend. + +## 0.13.1 - 2020-01-16 +- Fix bug in wapm related to the `package.wasmer_extra_flags` entry in the manifest + +## 0.13.0 - 2020-01-15 + +Special thanks to [@repi](https://github.com/repi) and [@srenatus](https://github.com/srenatus) for their contributions! + +- [#1153](https://github.com/wasmerio/wasmer/pull/1153) Added Wasmex, an Elixir language integration, to the README +- [#1133](https://github.com/wasmerio/wasmer/pull/1133) New `wasmer_trap` function in the C API, to properly error from within a host function +- [#1147](https://github.com/wasmerio/wasmer/pull/1147) Remove `log` and `trace` macros from `wasmer-runtime-core`, remove `debug` and `trace` features from `wasmer-*` crates, use the `log` crate for logging and use `fern` in the Wasmer CLI binary to output log messages. Colorized output will be enabled automatically if printing to a terminal, to force colorization on or off, set the `WASMER_COLOR` environment variable to `true` or `false`. +- [#1128](https://github.com/wasmerio/wasmer/pull/1128) Fix a crash when a host function is missing and the `allow_missing_functions` flag is enabled +- [#1099](https://github.com/wasmerio/wasmer/pull/1099) Remove `backend::Backend` from `wasmer_runtime_core` +- [#1097](https://github.com/wasmerio/wasmer/pull/1097) Move inline breakpoint outside of runtime backend +- [#1095](https://github.com/wasmerio/wasmer/pull/1095) Update to cranelift 0.52. +- [#1092](https://github.com/wasmerio/wasmer/pull/1092) Add `get_utf8_string_with_nul` to `WasmPtr` to read nul-terminated strings from memory. +- [#1071](https://github.com/wasmerio/wasmer/pull/1071) Add support for non-trapping float-to-int conversions, enabled by default. + +## 0.12.0 - 2019-12-18 + +Special thanks to [@ethanfrey](https://github.com/ethanfrey), [@AdamSLevy](https://github.com/AdamSLevy), [@Jasper-Bekkers](https://github.com/Jasper-Bekkers), [@srenatus](https://github.com/srenatus) for their contributions! + +- [#1078](https://github.com/wasmerio/wasmer/pull/1078) Increase the maximum number of parameters `Func` can take +- [#1062](https://github.com/wasmerio/wasmer/pull/1062) Expose some opt-in Emscripten functions to the C API +- [#1032](https://github.com/wasmerio/wasmer/pull/1032) Change the signature of the Emscripten `abort` function to work with Emscripten 1.38.30 +- [#1060](https://github.com/wasmerio/wasmer/pull/1060) Test the capi with all the backends +- [#1069](https://github.com/wasmerio/wasmer/pull/1069) Add function `get_memory_and_data` to `Ctx` to help prevent undefined behavior and mutable aliasing. It allows accessing memory while borrowing data mutably for the `Ctx` lifetime. This new function is now being used in `wasmer-wasi`. +- [#1058](https://github.com/wasmerio/wasmer/pull/1058) Fix minor panic issue when `wasmer::compile_with` called with llvm backend. +- [#858](https://github.com/wasmerio/wasmer/pull/858) Minor panic fix when wasmer binary with `loader` option run a module without exported `_start` function. +- [#1056](https://github.com/wasmerio/wasmer/pull/1056) Improved `--invoke` args parsing (supporting `i32`, `i64`, `f32` and `f32`) in Wasmer CLI +- [#1054](https://github.com/wasmerio/wasmer/pull/1054) Improve `--invoke` output in Wasmer CLI +- [#1053](https://github.com/wasmerio/wasmer/pull/1053) For RuntimeError and breakpoints, use Box instead of Box. +- [#1052](https://github.com/wasmerio/wasmer/pull/1052) Fix minor panic and improve Error handling in singlepass backend. +- [#1050](https://github.com/wasmerio/wasmer/pull/1050) Attach C & C++ headers to releases. +- [#1033](https://github.com/wasmerio/wasmer/pull/1033) Set cranelift backend as default compiler backend again, require at least one backend to be enabled for Wasmer CLI +- [#1044](https://github.com/wasmerio/wasmer/pull/1044) Enable AArch64 support in the LLVM backend. +- [#1030](https://github.com/wasmerio/wasmer/pull/1030) Ability to generate `ImportObject` for a specific version WASI version with the C API. +- [#1028](https://github.com/wasmerio/wasmer/pull/1028) Introduce strict/non-strict modes for `get_wasi_version` +- [#1029](https://github.com/wasmerio/wasmer/pull/1029) Add the “floating” `WasiVersion::Latest` version. +- [#1006](https://github.com/wasmerio/wasmer/pull/1006) Fix minor panic issue when `wasmer::compile_with` called with llvm backend +- [#1009](https://github.com/wasmerio/wasmer/pull/1009) Enable LLVM verifier for all tests, add new llvm-backend-tests crate. +- [#1022](https://github.com/wasmerio/wasmer/pull/1022) Add caching support for Singlepass backend. +- [#1004](https://github.com/wasmerio/wasmer/pull/1004) Add the Auto backend to enable to adapt backend usage depending on wasm file executed. +- [#1068](https://github.com/wasmerio/wasmer/pull/1068) Various cleanups for the singlepass backend on AArch64. + +## 0.11.0 - 2019-11-22 + +- [#713](https://github.com/wasmerio/wasmer/pull/713) Add AArch64 support for singlepass. +- [#995](https://github.com/wasmerio/wasmer/pull/995) Detect when a global is read without being initialized (emit a proper error instead of panicking) +- [#996](https://github.com/wasmerio/wasmer/pull/997) Refactored spectests, emtests and wasitests to use default compiler logic +- [#992](https://github.com/wasmerio/wasmer/pull/992) Updates WAPM version to 0.4.1, fix arguments issue introduced in #990 +- [#990](https://github.com/wasmerio/wasmer/pull/990) Default wasmer CLI to `run`. Wasmer will now attempt to parse unrecognized command line options as if they were applied to the run command: `wasmer mywasm.wasm --dir=.` now works! +- [#987](https://github.com/wasmerio/wasmer/pull/987) Fix `runtime-c-api` header files when compiled by gnuc. +- [#957](https://github.com/wasmerio/wasmer/pull/957) Change the meaning of `wasmer_wasi::is_wasi_module` to detect any type of WASI module, add support for new wasi snapshot_preview1 +- [#934](https://github.com/wasmerio/wasmer/pull/934) Simplify float expressions in the LLVM backend. + +## 0.10.2 - 2019-11-18 + +- [#968](https://github.com/wasmerio/wasmer/pull/968) Added `--invoke` option to the command +- [#964](https://github.com/wasmerio/wasmer/pull/964) Enable cross-compilation for specific target +- [#971](https://github.com/wasmerio/wasmer/pull/971) In LLVM backend, use unaligned loads and stores for non-atomic accesses to wasmer memory. +- [#960](https://github.com/wasmerio/wasmer/pull/960) Fix `runtime-c-api` header files when compiled by clang. +- [#925](https://github.com/wasmerio/wasmer/pull/925) Host functions can be closures with a captured environment. +- [#917](https://github.com/wasmerio/wasmer/pull/917) Host functions (aka imported functions) may not have `&mut vm::Ctx` as first argument, i.e. the presence of the `&mut vm::Ctx` argument is optional. +- [#915](https://github.com/wasmerio/wasmer/pull/915) All backends share the same definition of `Trampoline` (defined in `wasmer-runtime-core`). + +## 0.10.1 - 2019-11-11 + +- [#952](https://github.com/wasmerio/wasmer/pull/952) Use C preprocessor to properly hide trampoline functions on Windows and non-x86_64 targets. + +## 0.10.0 - 2019-11-11 + +Special thanks to [@newpavlov](https://github.com/newpavlov) and [@Maxgy](https://github.com/Maxgy) for their contributions! + +- [#942](https://github.com/wasmerio/wasmer/pull/942) Deny missing docs in runtime core and add missing docs +- [#939](https://github.com/wasmerio/wasmer/pull/939) Fix bug causing attempts to append to files with WASI to delete the contents of the file +- [#940](https://github.com/wasmerio/wasmer/pull/940) Update supported Rust version to 1.38+ +- [#923](https://github.com/wasmerio/wasmer/pull/923) Fix memory leak in the C API caused by an incorrect cast in `wasmer_trampoline_buffer_destroy` +- [#921](https://github.com/wasmerio/wasmer/pull/921) In LLVM backend, annotate all memory accesses with TBAA metadata. +- [#883](https://github.com/wasmerio/wasmer/pull/883) Allow floating point operations to have arbitrary inputs, even including SNaNs. +- [#856](https://github.com/wasmerio/wasmer/pull/856) Expose methods in the runtime C API to get a WASI import object + +## 0.9.0 - 2019-10-23 + +Special thanks to @alocquet for their contributions! + +- [#898](https://github.com/wasmerio/wasmer/pull/898) State tracking is now disabled by default in the LLVM backend. It can be enabled with `--track-state`. +- [#861](https://github.com/wasmerio/wasmer/pull/861) Add descriptions to `unimplemented!` macro in various places +- [#897](https://github.com/wasmerio/wasmer/pull/897) Removes special casing of stdin, stdout, and stderr in WASI. Closing these files now works. Removes `stdin`, `stdout`, and `stderr` from `WasiFS`, replaced by the methods `stdout`, `stdout_mut`, and so on. +- [#863](https://github.com/wasmerio/wasmer/pull/863) Fix min and max for cases involving NaN and negative zero when using the LLVM backend. + +## 0.8.0 - 2019-10-02 + +Special thanks to @jdanford for their contributions! + +- [#850](https://github.com/wasmerio/wasmer/pull/850) New `WasiStateBuilder` API. small, add misc. breaking changes to existing API (for example, changing the preopen dirs arg on `wasi::generate_import_object` from `Vec` to `Vec`) +- [#852](https://github.com/wasmerio/wasmer/pull/852) Make minor grammar/capitalization fixes to README.md +- [#841](https://github.com/wasmerio/wasmer/pull/841) Slightly improve rustdoc documentation and small updates to outdated info in readme files +- [#836](https://github.com/wasmerio/wasmer/pull/836) Update Cranelift fork version to `0.44.0` +- [#839](https://github.com/wasmerio/wasmer/pull/839) Change supported version to stable Rust 1.37+ +- [#834](https://github.com/wasmerio/wasmer/pull/834) Fix panic when unwraping `wasmer` arguments +- [#835](https://github.com/wasmerio/wasmer/pull/835) Add parallel execution example (independent instances created from the same `ImportObject` and `Module` run with rayon) +- [#834](https://github.com/wasmerio/wasmer/pull/834) Fix panic when parsing numerical arguments for no-ABI targets run with the wasmer binary +- [#833](https://github.com/wasmerio/wasmer/pull/833) Add doc example of using ImportObject's new `maybe_with_namespace` method +- [#832](https://github.com/wasmerio/wasmer/pull/832) Delete unused runtime ABI +- [#809](https://github.com/wasmerio/wasmer/pull/809) Fix bugs leading to panics in `LocalBacking`. +- [#831](https://github.com/wasmerio/wasmer/pull/831) Add support for atomic operations, excluding wait and notify, to singlepass. +- [#822](https://github.com/wasmerio/wasmer/pull/822) Update Cranelift fork version to `0.43.1` +- [#829](https://github.com/wasmerio/wasmer/pull/829) Fix deps on `make bench-*` commands; benchmarks don't compile other backends now +- [#807](https://github.com/wasmerio/wasmer/pull/807) Implement Send for `Instance`, breaking change on `ImportObject`, remove method `get_namespace` replaced with `with_namespace` and `maybe_with_namespace` +- [#817](https://github.com/wasmerio/wasmer/pull/817) Add document for tracking features across backends and language integrations, [docs/feature_matrix.md] +- [#823](https://github.com/wasmerio/wasmer/issues/823) Improved Emscripten / WASI integration +- [#821](https://github.com/wasmerio/wasmer/issues/821) Remove patch version on most deps Cargo manifests. This gives Wasmer library users more control over which versions of the deps they use. +- [#820](https://github.com/wasmerio/wasmer/issues/820) Remove null-pointer checks in `WasmPtr` from runtime-core, re-add them in Emscripten +- [#803](https://github.com/wasmerio/wasmer/issues/803) Add method to `Ctx` to invoke functions by their `TableIndex` +- [#790](https://github.com/wasmerio/wasmer/pull/790) Fix flaky test failure with LLVM, switch to large code model. +- [#788](https://github.com/wasmerio/wasmer/pull/788) Use union merge on the changelog file. +- [#785](https://github.com/wasmerio/wasmer/pull/785) Include Apache license file for spectests. +- [#786](https://github.com/wasmerio/wasmer/pull/786) In the LLVM backend, lower atomic wasm operations to atomic machine instructions. +- [#784](https://github.com/wasmerio/wasmer/pull/784) Fix help string for wasmer run. + +## 0.7.0 - 2019-09-12 + +Special thanks to @YaronWittenstein @penberg for their contributions. + +- [#776](https://github.com/wasmerio/wasmer/issues/776) Allow WASI preopened fds to be closed +- [#774](https://github.com/wasmerio/wasmer/issues/774) Add more methods to the `WasiFile` trait +- [#772](https://github.com/wasmerio/wasmer/issues/772) [#770](https://github.com/wasmerio/wasmer/issues/770) Handle more internal failures by passing back errors +- [#756](https://github.com/wasmerio/wasmer/issues/756) Allow NULL parameter and 0 arity in `wasmer_export_func_call` C API +- [#747](https://github.com/wasmerio/wasmer/issues/747) Return error instead of panicking on traps when using the Wasmer binary +- [#741](https://github.com/wasmerio/wasmer/issues/741) Add validate Wasm fuzz target +- [#733](https://github.com/wasmerio/wasmer/issues/733) Remove dependency on compiler backends for `middleware-common` +- [#732](https://github.com/wasmerio/wasmer/issues/732) [#731](https://github.com/wasmerio/wasmer/issues/731) WASI bug fixes and improvements +- [#726](https://github.com/wasmerio/wasmer/issues/726) Add serialization and deserialization for Wasi State +- [#716](https://github.com/wasmerio/wasmer/issues/716) Improve portability of install script +- [#714](https://github.com/wasmerio/wasmer/issues/714) Add Code of Conduct +- [#708](https://github.com/wasmerio/wasmer/issues/708) Remove unconditional dependency on Cranelift in the C API +- [#703](https://github.com/wasmerio/wasmer/issues/703) Fix compilation on AArch64 Linux +- [#702](https://github.com/wasmerio/wasmer/issues/702) Add SharedMemory to Wasmer. Add `--enable-threads` flag, add partial implementation of atomics to LLVM backend. +- [#698](https://github.com/wasmerio/wasmer/issues/698) [#690](https://github.com/wasmerio/wasmer/issues/690) [#687](https://github.com/wasmerio/wasmer/issues/690) Fix panics in Emscripten +- [#689](https://github.com/wasmerio/wasmer/issues/689) Replace `wasmer_runtime_code::memory::Atomic` with `std::sync::atomic` atomics, changing its interface +- [#680](https://github.com/wasmerio/wasmer/issues/680) [#673](https://github.com/wasmerio/wasmer/issues/673) [#669](https://github.com/wasmerio/wasmer/issues/669) [#660](https://github.com/wasmerio/wasmer/issues/660) [#659](https://github.com/wasmerio/wasmer/issues/659) Misc. runtime and singlepass fixes +- [#677](https://github.com/wasmerio/wasmer/issues/677) [#675](https://github.com/wasmerio/wasmer/issues/675) [#674](https://github.com/wasmerio/wasmer/issues/674) LLVM backend fixes and improvements +- [#671](https://github.com/wasmerio/wasmer/issues/671) Implement fs polling in `wasi::poll_oneoff` for Unix-like platforms +- [#656](https://github.com/wasmerio/wasmer/issues/656) Move CI to Azure Pipelines +- [#650](https://github.com/wasmerio/wasmer/issues/650) Implement `wasi::path_rename`, improve WASI FS public api, and allow open files to exist even when the underlying file is deleted +- [#643](https://github.com/wasmerio/wasmer/issues/643) Implement `wasi::path_symlink` and improve WASI FS public api IO error reporting +- [#608](https://github.com/wasmerio/wasmer/issues/608) Implement wasi syscalls `fd_allocate`, `fd_sync`, `fd_pread`, `path_link`, `path_filestat_set_times`; update WASI fs API in a WIP way; reduce coupling of WASI code to host filesystem; make debug messages from WASI more readable; improve rights-checking when calling syscalls; implement reference counting on inodes; misc bug fixes and improvements +- [#616](https://github.com/wasmerio/wasmer/issues/616) Create the import object separately from instance instantiation in `runtime-c-api` +- [#620](https://github.com/wasmerio/wasmer/issues/620) Replace one `throw()` with `noexcept` in llvm backend +- [#618](https://github.com/wasmerio/wasmer/issues/618) Implement `InternalEvent::Breakpoint` in the llvm backend to allow metering in llvm +- [#615](https://github.com/wasmerio/wasmer/issues/615) Eliminate `FunctionEnvironment` construction in `feed_event()` speeding up to 70% of compilation in clif +- [#609](https://github.com/wasmerio/wasmer/issues/609) Update dependencies +- [#602](https://github.com/wasmerio/wasmer/issues/602) C api extract instance context from instance +- [#590](https://github.com/wasmerio/wasmer/issues/590) Error visibility changes in wasmer-c-api +- [#589](https://github.com/wasmerio/wasmer/issues/589) Make `wasmer_byte_array` fields `public` in wasmer-c-api + +## 0.6.0 - 2019-07-31 +- [#603](https://github.com/wasmerio/wasmer/pull/603) Update Wapm-cli, bump version numbers +- [#595](https://github.com/wasmerio/wasmer/pull/595) Add unstable public API for interfacing with the WASI file system in plugin-like usecases +- [#598](https://github.com/wasmerio/wasmer/pull/598) LLVM Backend is now supported in Windows +- [#599](https://github.com/wasmerio/wasmer/pull/599) Fix llvm backend failures in fat spec tests and simd_binaryen spec test. +- [#579](https://github.com/wasmerio/wasmer/pull/579) Fix bug in caching with LLVM and Singlepass backends. + Add `default-backend-singlepass`, `default-backend-llvm`, and `default-backend-cranelift` features to `wasmer-runtime` + to control the `default_compiler()` function (this is a breaking change). Add `compiler_for_backend` function in `wasmer-runtime` +- [#561](https://github.com/wasmerio/wasmer/pull/561) Call the `data_finalizer` field on the `Ctx` +- [#576](https://github.com/wasmerio/wasmer/pull/576) fix `Drop` of uninit `Ctx` +- [#542](https://github.com/wasmerio/wasmer/pull/542) Add SIMD support to Wasmer (LLVM backend only) + - Updates LLVM to version 8.0 + +## 0.5.7 - 2019-07-23 +- [#575](https://github.com/wasmerio/wasmer/pull/575) Prepare for release; update wapm to 0.3.6 +- [#555](https://github.com/wasmerio/wasmer/pull/555) WASI filesystem rewrite. Major improvements + - adds virtual root showing all preopened directories + - improved sandboxing and code-reuse + - symlinks work in a lot more situations + - many misc. improvements to most syscalls touching the filesystem + +## 0.5.6 - 2019-07-16 +- [#565](https://github.com/wasmerio/wasmer/pull/565) Update wapm and bump version to 0.5.6 +- [#563](https://github.com/wasmerio/wasmer/pull/563) Improve wasi testing infrastructure + - fixes arg parsing from comments & fixes the mapdir test to have the native code doing the same thing as the WASI code + - makes wasitests-generate output stdout/stderr by default & adds function to print stdout and stderr for a command if it fails + - compiles wasm with size optimizations & strips generated wasm with wasm-strip +- [#554](https://github.com/wasmerio/wasmer/pull/554) Finish implementation of `wasi::fd_seek`, fix bug in filestat +- [#550](https://github.com/wasmerio/wasmer/pull/550) Fix singlepass compilation error with `imul` instruction + + +## 0.5.5 - 2019-07-10 +- [#541](https://github.com/wasmerio/wasmer/pull/541) Fix dependency graph by making separate test crates; ABI implementations should not depend on compilers. Add Cranelift fork as git submodule of clif-backend +- [#537](https://github.com/wasmerio/wasmer/pull/537) Add hidden flag (`--cache-key`) to use prehashed key into the compiled wasm cache and change compiler backend-specific caching to use directories +- [#536](https://github.com/wasmerio/wasmer/pull/536) ~Update cache to use compiler backend name in cache key~ + +## 0.5.4 - 2019-07-06 +- [#529](https://github.com/wasmerio/wasmer/pull/529) Updates the Wasm Interface library, which is used by wapm, with bug fixes and error message improvements + +## 0.5.3 - 2019-07-03 +- [#523](https://github.com/wasmerio/wasmer/pull/523) Update wapm version to fix bug related to signed packages in the global namespace and locally-stored public keys + +## 0.5.2 - 2019-07-02 +- [#516](https://github.com/wasmerio/wasmer/pull/516) Add workaround for singlepass miscompilation on GetLocal +- [#521](https://github.com/wasmerio/wasmer/pull/521) Update Wapm-cli, bump version numbers +- [#518](https://github.com/wasmerio/wasmer/pull/518) Update Cranelift and WasmParser +- [#514](https://github.com/wasmerio/wasmer/pull/514) [#519](https://github.com/wasmerio/wasmer/pull/519) Improved Emscripten network related calls, added a null check to `WasmPtr` +- [#515](https://github.com/wasmerio/wasmer/pull/515) Improved Emscripten dyncalls +- [#513](https://github.com/wasmerio/wasmer/pull/513) Fix emscripten lseek implementation. +- [#510](https://github.com/wasmerio/wasmer/pull/510) Simplify construction of floating point constants in LLVM backend. Fix LLVM assertion failure due to definition of %ctx. + +## 0.5.1 - 2019-06-24 +- [#508](https://github.com/wasmerio/wasmer/pull/508) Update wapm version, includes bug fixes + +## 0.5.0 - 2019-06-17 + +- [#471](https://github.com/wasmerio/wasmer/pull/471) Added missing functions to run Python. Improved Emscripten bindings +- [#494](https://github.com/wasmerio/wasmer/pull/494) Remove deprecated type aliases from libc in the runtime C API +- [#493](https://github.com/wasmerio/wasmer/pull/493) `wasmer_module_instantiate` has better error messages in the runtime C API +- [#474](https://github.com/wasmerio/wasmer/pull/474) Set the install name of the dylib to `@rpath` +- [#490](https://github.com/wasmerio/wasmer/pull/490) Add MiddlewareChain and StreamingCompiler to runtime +- [#487](https://github.com/wasmerio/wasmer/pull/487) Fix stack offset check in singlepass backend +- [#450](https://github.com/wasmerio/wasmer/pull/450) Added Metering +- [#481](https://github.com/wasmerio/wasmer/pull/481) Added context trampoline into runtime +- [#484](https://github.com/wasmerio/wasmer/pull/484) Fix bugs in emscripten socket syscalls +- [#476](https://github.com/wasmerio/wasmer/pull/476) Fix bug with wasi::environ_get, fix off by one error in wasi::environ_sizes_get +- [#470](https://github.com/wasmerio/wasmer/pull/470) Add mapdir support to Emscripten, implement getdents for Unix +- [#467](https://github.com/wasmerio/wasmer/pull/467) `wasmer_instantiate` returns better error messages in the runtime C API +- [#463](https://github.com/wasmerio/wasmer/pull/463) Fix bug in WASI path_open allowing one level above preopened dir to be accessed +- [#461](https://github.com/wasmerio/wasmer/pull/461) Prevent passing negative lengths in various places in the runtime C API +- [#459](https://github.com/wasmerio/wasmer/pull/459) Add monotonic and real time clocks for wasi on windows +- [#447](https://github.com/wasmerio/wasmer/pull/447) Add trace macro (`--features trace`) for more verbose debug statements +- [#451](https://github.com/wasmerio/wasmer/pull/451) Add `--mapdir=src:dest` flag to rename host directories in the guest context +- [#457](https://github.com/wasmerio/wasmer/pull/457) Implement file metadata for WASI, fix bugs in WASI clock code for Unix platforms + +## 0.4.2 - 2019-05-16 + +- [#416](https://github.com/wasmerio/wasmer/pull/416) Remote code loading framework +- [#449](https://github.com/wasmerio/wasmer/pull/449) Fix bugs: opening host files in filestat and opening with write permissions unconditionally in path_open +- [#442](https://github.com/wasmerio/wasmer/pull/442) Misc. WASI FS fixes and implement readdir +- [#440](https://github.com/wasmerio/wasmer/pull/440) Fix type mismatch between `wasmer_instance_call` and `wasmer_export_func_*_arity` functions in the runtime C API. +- [#269](https://github.com/wasmerio/wasmer/pull/269) Add better runtime docs +- [#432](https://github.com/wasmerio/wasmer/pull/432) Fix returned value of `wasmer_last_error_message` in the runtime C API +- [#429](https://github.com/wasmerio/wasmer/pull/429) Get wasi::path_filestat_get working for some programs; misc. minor WASI FS improvements +- [#413](https://github.com/wasmerio/wasmer/pull/413) Update LLVM backend to use new parser codegen traits + +## 0.4.1 - 2019-05-06 + +- [#426](https://github.com/wasmerio/wasmer/pull/426) Update wapm-cli submodule, bump version to 0.4.1 +- [#422](https://github.com/wasmerio/wasmer/pull/422) Improved Emscripten functions to run optipng and pngquant compiled to wasm +- [#409](https://github.com/wasmerio/wasmer/pull/409) Improved Emscripten functions to run JavascriptCore compiled to wasm +- [#399](https://github.com/wasmerio/wasmer/pull/399) Add example of using a plugin extended from WASI +- [#397](https://github.com/wasmerio/wasmer/pull/397) Fix WASI fs abstraction to work on Windows +- [#390](https://github.com/wasmerio/wasmer/pull/390) Pin released wapm version and add it as a git submodule +- [#408](https://github.com/wasmerio/wasmer/pull/408) Add images to windows installer and update installer to add wapm bin directory to path + +## 0.4.0 - 2019-04-23 + +- [#383](https://github.com/wasmerio/wasmer/pull/383) Hook up wasi exit code to wasmer cli. +- [#382](https://github.com/wasmerio/wasmer/pull/382) Improve error message on `--backend` flag to only suggest currently enabled backends +- [#381](https://github.com/wasmerio/wasmer/pull/381) Allow retrieving propagated user errors. +- [#379](https://github.com/wasmerio/wasmer/pull/379) Fix small return types from imported functions. +- [#371](https://github.com/wasmerio/wasmer/pull/371) Add more Debug impl for WASI types +- [#368](https://github.com/wasmerio/wasmer/pull/368) Fix issue with write buffering +- [#343](https://github.com/wasmerio/wasmer/pull/343) Implement preopened files for WASI and fix aligment issue when accessing WASI memory +- [#367](https://github.com/wasmerio/wasmer/pull/367) Add caching support to the LLVM backend. +- [#366](https://github.com/wasmerio/wasmer/pull/366) Remove `UserTrapper` trait to fix [#365](https://github.com/wasmerio/wasmer/issues/365). +- [#348](https://github.com/wasmerio/wasmer/pull/348) Refactor internal runtime ↔️ backend abstraction. +- [#355](https://github.com/wasmerio/wasmer/pull/355) Misc changes to `Cargo.toml`s for publishing +- [#352](https://github.com/wasmerio/wasmer/pull/352) Bump version numbers to 0.3.0 +- [#351](https://github.com/wasmerio/wasmer/pull/351) Add hidden option to specify wasm program name (can be used to improve error messages) +- [#350](https://github.com/wasmerio/wasmer/pull/350) Enforce that CHANGELOG.md is updated through CI. +- [#349](https://github.com/wasmerio/wasmer/pull/349) Add [CHANGELOG.md](https://github.com/wasmerio/wasmer/blob/master/CHANGELOG.md). + +## 0.3.0 - 2019-04-12 + +- [#276](https://github.com/wasmerio/wasmer/pull/276) [#288](https://github.com/wasmerio/wasmer/pull/288) [#344](https://github.com/wasmerio/wasmer/pull/344) Use new singlepass backend (with the `--backend=singlepass` when running Wasmer) +- [#338](https://github.com/wasmerio/wasmer/pull/338) Actually catch traps/panics/etc when using a typed func. +- [#325](https://github.com/wasmerio/wasmer/pull/325) Fixed func_index in debug mode +- [#323](https://github.com/wasmerio/wasmer/pull/323) Add validate subcommand to validate Wasm files +- [#321](https://github.com/wasmerio/wasmer/pull/321) Upgrade to Cranelift 0.3.0 +- [#319](https://github.com/wasmerio/wasmer/pull/319) Add Export and GlobalDescriptor to Runtime API +- [#310](https://github.com/wasmerio/wasmer/pull/310) Cleanup warnings +- [#299](https://github.com/wasmerio/wasmer/pull/299) [#300](https://github.com/wasmerio/wasmer/pull/300) [#301](https://github.com/wasmerio/wasmer/pull/301) [#303](https://github.com/wasmerio/wasmer/pull/303) [#304](https://github.com/wasmerio/wasmer/pull/304) [#305](https://github.com/wasmerio/wasmer/pull/305) [#306](https://github.com/wasmerio/wasmer/pull/306) [#307](https://github.com/wasmerio/wasmer/pull/307) Add support for WASI 🎉 +- [#286](https://github.com/wasmerio/wasmer/pull/286) Add extend to imports +- [#278](https://github.com/wasmerio/wasmer/pull/278) Add versioning to cache +- [#250](https://github.com/wasmerio/wasmer/pull/250) Setup bors diff --git a/runtime/near-vm/CODE_OF_CONDUCT.md b/runtime/near-vm/CODE_OF_CONDUCT.md new file mode 100644 index 00000000000..d9965c509ce --- /dev/null +++ b/runtime/near-vm/CODE_OF_CONDUCT.md @@ -0,0 +1,76 @@ +# Contributor Covenant Code of Conduct + +## Our Pledge + +In the interest of fostering an open and welcoming environment, we as +contributors and maintainers pledge to making participation in our project and +our community a harassment-free experience for everyone, regardless of age, body +size, disability, ethnicity, sex characteristics, gender identity and expression, +level of experience, education, socio-economic status, nationality, personal +appearance, race, religion, or sexual identity and orientation. + +## Our Standards + +Examples of behavior that contributes to creating a positive environment +include: + +* Using welcoming and inclusive language +* Being respectful of differing viewpoints and experiences +* Gracefully accepting constructive criticism +* Focusing on what is best for the community +* Showing empathy towards other community members + +Examples of unacceptable behavior by participants include: + +* The use of sexualized language or imagery and unwelcome sexual attention or + advances +* Trolling, insulting/derogatory comments, and personal or political attacks +* Public or private harassment +* Publishing others' private information, such as a physical or electronic + address, without explicit permission +* Other conduct which could reasonably be considered inappropriate in a + professional setting + +## Our Responsibilities + +Project maintainers are responsible for clarifying the standards of acceptable +behavior and are expected to take appropriate and fair corrective action in +response to any instances of unacceptable behavior. + +Project maintainers have the right and responsibility to remove, edit, or +reject comments, commits, code, wiki edits, issues, and other contributions +that are not aligned to this Code of Conduct, or to ban temporarily or +permanently any contributor for other behaviors that they deem inappropriate, +threatening, offensive, or harmful. + +## Scope + +This Code of Conduct applies both within project spaces and in public spaces +when an individual is representing the project or its community. Examples of +representing a project or community include using an official project e-mail +address, posting via an official social media account, or acting as an appointed +representative at an online or offline event. Representation of a project may be +further defined and clarified by project maintainers. + +## Enforcement + +Instances of abusive, harassing, or otherwise unacceptable behavior may be +reported by contacting the project team at contact@wasmer.io. All +complaints will be reviewed and investigated and will result in a response that +is deemed necessary and appropriate to the circumstances. The project team is +obligated to maintain confidentiality with regard to the reporter of an incident. +Further details of specific enforcement policies may be posted separately. + +Project maintainers who do not follow or enforce the Code of Conduct in good +faith may face temporary or permanent repercussions as determined by other +members of the project's leadership. + +## Attribution + +This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4, +available at https://www.contributor-covenant.org/version/1/4/code-of-conduct.html + +[homepage]: https://www.contributor-covenant.org + +For answers to common questions about this code of conduct, see +https://www.contributor-covenant.org/faq diff --git a/runtime/near-vm/CONTRIBUTING.md b/runtime/near-vm/CONTRIBUTING.md new file mode 100644 index 00000000000..5665f393dbc --- /dev/null +++ b/runtime/near-vm/CONTRIBUTING.md @@ -0,0 +1,27 @@ +# How to Contribute to Wasmer + +Thank you for your interest in contributing to Wasmer. This document outlines some recommendations on how to contribute. + +## Issues & Feature Requests + +Please use the issue template and provide a failing example if possible to help us recreate the issue. + +## Pull Requests + +For large changes, please try reaching communicating with the Wasmer maintainers via GitHub Issues or Spectrum Chat to ensure we can accept the change once it is ready. + +We recommend trying the following commands before sending a pull request to ensure code quality: + +- `cargo fmt --all` Ensures all code is correctly formatted. +- Run `cargo test` in the crates that you are modifying. +- Run `cargo build --all`. + +A comprehensive CI test suite will be run by a Wasmer team member after the PR has been created. + +### Common Build Issues + +#### LLVM Dependency + +`Didn't find usable system-wide LLVM` + +Building Wasmer with the LLVM backend requires LLVM to be installed diff --git a/runtime/near-vm/Cargo.lock b/runtime/near-vm/Cargo.lock new file mode 100644 index 00000000000..0f285457598 --- /dev/null +++ b/runtime/near-vm/Cargo.lock @@ -0,0 +1,2205 @@ +# This file is automatically @generated by Cargo. +# It is not intended for manual editing. +version = 3 + +[[package]] +name = "addr2line" +version = "0.19.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a76fd60b23679b7d19bd066031410fb7e458ccc5e958eb5c325888ce4baedc97" +dependencies = [ + "gimli", +] + +[[package]] +name = "adler" +version = "1.0.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f26201604c87b1e01bd3d98f8d5d9a8fcbb815e8cedb41ffccbeb4bf593a35fe" + +[[package]] +name = "ahash" +version = "0.7.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fcb51a0695d8f838b1ee009b3fbf66bda078cd64590202a864a8f3e8c4315c47" +dependencies = [ + "getrandom", + "once_cell", + "version_check", +] + +[[package]] +name = "ansi_term" +version = "0.12.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d52a9bb7ec0cf484c551830a7ce27bd20d67eac647e1befb56b0be4ee39a55d2" +dependencies = [ + "winapi", +] + +[[package]] +name = "anyhow" +version = "1.0.68" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2cb2f989d18dd141ab8ae82f64d1a8cdd37e0840f73a406896cf5e99502fab61" + +[[package]] +name = "arbitrary" +version = "1.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b0224938f92e7aef515fac2ff2d18bd1115c1394ddf4a092e0c87e8be9499ee5" +dependencies = [ + "derive_arbitrary", +] + +[[package]] +name = "atty" +version = "0.2.14" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d9b39be18770d11421cdb1b9947a45dd3f37e93092cbf377614828a319d5fee8" +dependencies = [ + "hermit-abi 0.1.19", + "libc", + "winapi", +] + +[[package]] +name = "autocfg" +version = "1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d468802bab17cbc0cc575e9b053f41e72aa36bfa6b7f55e3529ffa43161b97fa" + +[[package]] +name = "backtrace" +version = "0.3.67" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "233d376d6d185f2a3093e58f283f60f880315b6c60075b01f36b3b85154564ca" +dependencies = [ + "addr2line", + "cc", + "cfg-if 1.0.0", + "libc", + "miniz_oxide", + "object", + "rustc-demangle", +] + +[[package]] +name = "bitflags" +version = "1.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a" + +[[package]] +name = "bitvec" +version = "1.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1bc2832c24239b0141d5674bb9174f9d68a8b5b3f2753311927c172ca46f7e9c" +dependencies = [ + "funty", + "radium", + "tap", + "wyz", +] + +[[package]] +name = "bolero" +version = "0.6.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "256a795047239482fdc98374c3a050d51ca8921427c842e089b3bd7267659427" +dependencies = [ + "bolero-afl", + "bolero-engine", + "bolero-generator", + "bolero-honggfuzz", + "bolero-libfuzzer", + "cfg-if 1.0.0", + "libtest-mimic", + "rand", +] + +[[package]] +name = "bolero-afl" +version = "0.6.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bd0c2595f3cc558c84e285318f8d29d3552140ecd106dbf3a356094898dc5619" +dependencies = [ + "bolero-engine", + "cc", +] + +[[package]] +name = "bolero-engine" +version = "0.6.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "839667421d443c03ca5746ec1c1b8db10d305fdb062f6f20c62b3f4cfcd431b5" +dependencies = [ + "anyhow", + "backtrace", + "bolero-generator", + "lazy_static", + "pretty-hex", + "rand", +] + +[[package]] +name = "bolero-generator" +version = "0.6.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ce5ff9a4b0a1f80c09e3a35c4dc47a3bed344e5a431f2b96ca74952beb6c0767" +dependencies = [ + "bolero-generator-derive", + "byteorder", + "either", + "rand_core", +] + +[[package]] +name = "bolero-generator-derive" +version = "0.6.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3a2ef03f5627ff547424f470cdf527bc5c7551ec48bd560f3a0e794d0082c6f9" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "bolero-honggfuzz" +version = "0.6.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7dc187a50ea23588958b0160113a742181b09ba4dba8412072c5e311a062bb4b" +dependencies = [ + "bolero-engine", +] + +[[package]] +name = "bolero-libfuzzer" +version = "0.6.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6d7734f24b16e80871f6a54e636e0db8338c22eea957685b4751e29b1dce1a5b" +dependencies = [ + "bolero-engine", + "cc", +] + +[[package]] +name = "bstr" +version = "0.2.17" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ba3569f383e8f1598449f1a423e72e99569137b47740b1da11ef19af3d5c3223" +dependencies = [ + "lazy_static", + "memchr", + "regex-automata", + "serde", +] + +[[package]] +name = "build-deps" +version = "0.1.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "64f14468960818ce4f3e3553c32d524446687884f8e7af5d3e252331d8a87e43" +dependencies = [ + "glob", +] + +[[package]] +name = "bumpalo" +version = "3.11.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "572f695136211188308f16ad2ca5c851a712c464060ae6974944458eb83880ba" + +[[package]] +name = "bytecheck" +version = "0.6.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d11cac2c12b5adc6570dad2ee1b87eff4955dac476fe12d81e5fdd352e52406f" +dependencies = [ + "bytecheck_derive", + "ptr_meta", +] + +[[package]] +name = "bytecheck_derive" +version = "0.6.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "13e576ebe98e605500b3c8041bb888e966653577172df6dd97398714eb30b9bf" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "byteorder" +version = "1.4.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "14c189c53d098945499cdfa7ecc63567cf3886b3332b312a5b4585d8d3a6a610" + +[[package]] +name = "cast" +version = "0.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "37b2a672a2cb129a2e41c10b1224bb368f9f37a2b16b612598138befd7b37eb5" + +[[package]] +name = "cc" +version = "1.0.78" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a20104e2335ce8a659d6dd92a51a767a0c062599c73b343fd152cb401e828c3d" +dependencies = [ + "jobserver", +] + +[[package]] +name = "cfg-if" +version = "0.1.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4785bdd1c96b2a846b2bd7cc02e86b6b3dbf14e7e53446c4f54c92a361040822" + +[[package]] +name = "cfg-if" +version = "1.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd" + +[[package]] +name = "clap" +version = "2.34.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a0610544180c38b88101fecf2dd634b174a62eef6946f84dfc6a7127512b381c" +dependencies = [ + "ansi_term", + "atty", + "bitflags", + "strsim", + "textwrap", + "unicode-width", + "vec_map", +] + +[[package]] +name = "compiler-test-derive" +version = "0.0.1" +dependencies = [ + "pretty_assertions", + "proc-macro2", + "quote", + "syn", + "trybuild", +] + +[[package]] +name = "criterion" +version = "0.3.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b01d6de93b2b6c65e17c634a26653a29d107b3c98c607c765bf38d041531cd8f" +dependencies = [ + "atty", + "cast", + "clap", + "criterion-plot", + "csv", + "itertools", + "lazy_static", + "num-traits", + "oorandom", + "plotters", + "rayon", + "regex", + "serde", + "serde_cbor", + "serde_derive", + "serde_json", + "tinytemplate", + "walkdir", +] + +[[package]] +name = "criterion-plot" +version = "0.4.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2673cc8207403546f45f5fd319a974b1e6983ad1a3ee7e6041650013be041876" +dependencies = [ + "cast", + "itertools", +] + +[[package]] +name = "crossbeam-channel" +version = "0.4.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b153fe7cbef478c567df0f972e02e6d736db11affe43dfc9c56a9374d1adfb87" +dependencies = [ + "crossbeam-utils 0.7.2", + "maybe-uninit", +] + +[[package]] +name = "crossbeam-channel" +version = "0.5.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c2dd04ddaf88237dc3b8d8f9a3c1004b506b54b3313403944054d23c0870c521" +dependencies = [ + "cfg-if 1.0.0", + "crossbeam-utils 0.8.14", +] + +[[package]] +name = "crossbeam-deque" +version = "0.8.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "715e8152b692bba2d374b53d4875445368fdf21a94751410af607a5ac677d1fc" +dependencies = [ + "cfg-if 1.0.0", + "crossbeam-epoch", + "crossbeam-utils 0.8.14", +] + +[[package]] +name = "crossbeam-epoch" +version = "0.9.13" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "01a9af1f4c2ef74bb8aa1f7e19706bc72d03598c8a570bb5de72243c7a9d9d5a" +dependencies = [ + "autocfg", + "cfg-if 1.0.0", + "crossbeam-utils 0.8.14", + "memoffset 0.7.1", + "scopeguard", +] + +[[package]] +name = "crossbeam-utils" +version = "0.7.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c3c7c73a2d1e9fc0886a08b93e98eb643461230d5f1925e4036204d5f2e261a8" +dependencies = [ + "autocfg", + "cfg-if 0.1.10", + "lazy_static", +] + +[[package]] +name = "crossbeam-utils" +version = "0.8.14" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4fb766fa798726286dbbb842f174001dab8abc7b627a1dd86e0b7222a95d929f" +dependencies = [ + "cfg-if 1.0.0", +] + +[[package]] +name = "csv" +version = "1.1.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "22813a6dc45b335f9bade10bf7271dc477e81113e89eb251a0bc2a8a81c536e1" +dependencies = [ + "bstr", + "csv-core", + "itoa 0.4.8", + "ryu", + "serde", +] + +[[package]] +name = "csv-core" +version = "0.1.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2b2466559f260f48ad25fe6317b3c8dac77b5bdb5763ac7d9d6103530663bc90" +dependencies = [ + "memchr", +] + +[[package]] +name = "ctor" +version = "0.1.26" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6d2301688392eb071b0bf1a37be05c469d3cc4dbbd95df672fe28ab021e6a096" +dependencies = [ + "quote", + "syn", +] + +[[package]] +name = "darling" +version = "0.14.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b0dd3cd20dc6b5a876612a6e5accfe7f3dd883db6d07acfbf14c128f61550dfa" +dependencies = [ + "darling_core", + "darling_macro", +] + +[[package]] +name = "darling_core" +version = "0.14.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a784d2ccaf7c98501746bf0be29b2022ba41fd62a2e622af997a03e9f972859f" +dependencies = [ + "fnv", + "ident_case", + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "darling_macro" +version = "0.14.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7618812407e9402654622dd402b0a89dff9ba93badd6540781526117b92aab7e" +dependencies = [ + "darling_core", + "quote", + "syn", +] + +[[package]] +name = "derive_arbitrary" +version = "1.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cf460bbff5f571bfc762da5102729f59f338be7db17a21fade44c5c4f5005350" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "diff" +version = "0.1.13" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "56254986775e3233ffa9c4d7d3faaf6d36a2c09d30b20687e9f88bc8bafc16c8" + +[[package]] +name = "dissimilar" +version = "1.0.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bd5f0c7e4bd266b8ab2550e6238d2e74977c23c15536ac7be45e9c95e2e3fbbb" + +[[package]] +name = "dynasm" +version = "1.2.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "add9a102807b524ec050363f09e06f1504214b0e1c7797f64261c891022dce8b" +dependencies = [ + "bitflags", + "byteorder", + "lazy_static", + "proc-macro-error", + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "dynasmrt" +version = "1.2.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "64fba5a42bd76a17cad4bfa00de168ee1cbfa06a5e8ce992ae880218c05641a9" +dependencies = [ + "byteorder", + "dynasm", + "memmap2", +] + +[[package]] +name = "either" +version = "1.8.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "90e5c1c8368803113bf0c9584fc495a58b86dc8a29edbf8fe877d21d9507e797" + +[[package]] +name = "enumset" +version = "1.0.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "19be8061a06ab6f3a6cf21106c873578bf01bd42ad15e0311a9c76161cb1c753" +dependencies = [ + "enumset_derive", +] + +[[package]] +name = "enumset_derive" +version = "0.6.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "03e7b551eba279bf0fa88b83a46330168c1560a52a94f5126f892f0b364ab3e0" +dependencies = [ + "darling", + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "fastrand" +version = "1.8.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a7a407cfaa3385c4ae6b23e84623d48c2798d06e3e6a1878f7f59f17b3f86499" +dependencies = [ + "instant", +] + +[[package]] +name = "finite-wasm" +version = "0.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c6b821e04f9b8562f75e2c3a1806d629084a78e7f154aadac9e8230ab9efd1d7" +dependencies = [ + "bitvec", + "dissimilar", + "num-traits", + "prefix-sum-vec", + "thiserror", + "wasmparser", + "wasmprinter", +] + +[[package]] +name = "fnv" +version = "1.0.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1" + +[[package]] +name = "form_urlencoded" +version = "1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a9c384f161156f5260c24a097c56119f9be8c798586aecc13afbcbe7b7e26bf8" +dependencies = [ + "percent-encoding", +] + +[[package]] +name = "funty" +version = "2.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e6d5a32815ae3f33302d95fdcb2ce17862f8c65363dcfd29360480ba1001fc9c" + +[[package]] +name = "generator" +version = "0.7.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d266041a359dfa931b370ef684cceb84b166beb14f7f0421f4a6a3d0c446d12e" +dependencies = [ + "cc", + "libc", + "log", + "rustversion", + "windows", +] + +[[package]] +name = "getrandom" +version = "0.2.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c05aeb6a22b8f62540c194aac980f2115af067bfe15a0734d7277a768d396b31" +dependencies = [ + "cfg-if 1.0.0", + "libc", + "wasi", +] + +[[package]] +name = "gimli" +version = "0.27.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "dec7af912d60cdbd3677c1af9352ebae6fb8394d165568a2234df0fa00f87793" + +[[package]] +name = "glob" +version = "0.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9b919933a397b79c37e33b77bb2aa3dc8eb6e165ad809e58ff75bc7db2e34574" + +[[package]] +name = "half" +version = "1.8.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "eabb4a44450da02c90444cf74558da904edde8fb4e9035a9a6a4e15445af0bd7" + +[[package]] +name = "hashbrown" +version = "0.11.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ab5ef0d4909ef3724cc8cce6ccc8572c5c817592e9285f5464f8e86f8bd3726e" +dependencies = [ + "ahash", +] + +[[package]] +name = "hashbrown" +version = "0.12.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8a9ee70c43aaf417c914396645a0fa852624801b24ebb7ae78fe8272889ac888" +dependencies = [ + "ahash", +] + +[[package]] +name = "heck" +version = "0.3.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6d621efb26863f0e9924c6ac577e8275e5e6b77455db64ffa6c65c904e9e132c" +dependencies = [ + "unicode-segmentation", +] + +[[package]] +name = "heck" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2540771e65fc8cb83cd6e8a237f70c319bd5c29f78ed1084ba5d50eeac86f7f9" + +[[package]] +name = "hermit-abi" +version = "0.1.19" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "62b467343b94ba476dcb2500d242dadbb39557df889310ac77c5d99100aaac33" +dependencies = [ + "libc", +] + +[[package]] +name = "hermit-abi" +version = "0.2.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ee512640fe35acbfb4bb779db6f0d80704c2cacfa2e39b601ef3e3f47d1ae4c7" +dependencies = [ + "libc", +] + +[[package]] +name = "ident_case" +version = "1.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b9e0384b61958566e926dc50660321d12159025e767c18e043daf26b70104c39" + +[[package]] +name = "idna" +version = "0.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e14ddfc70884202db2244c223200c204c2bda1bc6e0998d11b5e024d657209e6" +dependencies = [ + "unicode-bidi", + "unicode-normalization", +] + +[[package]] +name = "indexmap" +version = "1.9.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1885e79c1fc4b10f0e172c475f458b7f7b93061064d98c3293e98c5ba0c8b399" +dependencies = [ + "autocfg", + "hashbrown 0.12.3", +] + +[[package]] +name = "instant" +version = "0.1.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7a5bbe824c507c5da5956355e86a746d82e0e1464f65d862cc5e71da70e94b2c" +dependencies = [ + "cfg-if 1.0.0", +] + +[[package]] +name = "itertools" +version = "0.10.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b0fd2260e829bddf4cb6ea802289de2f86d6a7a690192fbe91b3f46e0f2c8473" +dependencies = [ + "either", +] + +[[package]] +name = "itoa" +version = "0.4.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b71991ff56294aa922b450139ee08b3bfc70982c6b2c7562771375cf73542dd4" + +[[package]] +name = "itoa" +version = "1.0.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fad582f4b9e86b6caa621cabeb0963332d92eea04729ab12892c2533951e6440" + +[[package]] +name = "jobserver" +version = "0.1.25" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "068b1ee6743e4d11fb9c6a1e6064b3693a1b600e7f5f5988047d98b3dc9fb90b" +dependencies = [ + "libc", +] + +[[package]] +name = "js-sys" +version = "0.3.60" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "49409df3e3bf0856b916e2ceaca09ee28e6871cf7d9ce97a692cacfdb2a25a47" +dependencies = [ + "wasm-bindgen", +] + +[[package]] +name = "lazy_static" +version = "1.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646" + +[[package]] +name = "leb128" +version = "0.2.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "884e2677b40cc8c339eaefcb701c32ef1fd2493d71118dc0ca4b6a736c93bd67" + +[[package]] +name = "libc" +version = "0.2.139" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "201de327520df007757c1f0adce6e827fe8562fbc28bfd9c15571c66ca1f5f79" + +[[package]] +name = "libfuzzer-sys" +version = "0.4.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c8fff891139ee62800da71b7fd5b508d570b9ad95e614a53c6f453ca08366038" +dependencies = [ + "arbitrary", + "cc", + "once_cell", +] + +[[package]] +name = "libtest-mimic" +version = "0.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "08a7b8ac1f53f7be8d895ce6f7f534e49581c85c499b47429634b2cb2995e2ae" +dependencies = [ + "crossbeam-channel 0.4.4", + "rayon", + "structopt", + "termcolor", +] + +[[package]] +name = "lock_api" +version = "0.4.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "435011366fe56583b16cf956f9df0095b405b82d76425bc8981c0e22e60ec4df" +dependencies = [ + "autocfg", + "scopeguard", +] + +[[package]] +name = "log" +version = "0.4.17" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "abb12e687cfb44aa40f41fc3978ef76448f9b6038cad6aef4259d3c095a2382e" +dependencies = [ + "cfg-if 1.0.0", +] + +[[package]] +name = "loom" +version = "0.5.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ff50ecb28bb86013e935fb6683ab1f6d3a20016f123c76fd4c27470076ac30f5" +dependencies = [ + "cfg-if 1.0.0", + "generator", + "scoped-tls", + "tracing", + "tracing-subscriber", +] + +[[package]] +name = "mach" +version = "0.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b823e83b2affd8f40a9ee8c29dbc56404c1e34cd2710921f2801e2cf29527afa" +dependencies = [ + "libc", +] + +[[package]] +name = "matchers" +version = "0.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8263075bb86c5a1b1427b5ae862e8889656f126e9f77c484496e8b47cf5c5558" +dependencies = [ + "regex-automata", +] + +[[package]] +name = "maybe-uninit" +version = "2.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "60302e4db3a61da70c0cb7991976248362f30319e88850c487b9b95bbf059e00" + +[[package]] +name = "memchr" +version = "2.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2dffe52ecf27772e601905b7522cb4ef790d2cc203488bbd0e2fe85fcb74566d" + +[[package]] +name = "memmap2" +version = "0.5.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4b182332558b18d807c4ce1ca8ca983b34c3ee32765e47b3f0f69b90355cc1dc" +dependencies = [ + "libc", +] + +[[package]] +name = "memoffset" +version = "0.6.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5aa361d4faea93603064a027415f07bd8e1d5c88c9fbf68bf56a285428fd79ce" +dependencies = [ + "autocfg", +] + +[[package]] +name = "memoffset" +version = "0.7.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5de893c32cde5f383baa4c04c5d6dbdd735cfd4a794b0debdb2bb1b421da5ff4" +dependencies = [ + "autocfg", +] + +[[package]] +name = "miniz_oxide" +version = "0.6.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b275950c28b37e794e8c55d88aeb5e139d0ce23fdbbeda68f8d7174abdf9e8fa" +dependencies = [ + "adler", +] + +[[package]] +name = "more-asserts" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7843ec2de400bcbc6a6328c958dc38e5359da6e93e72e37bc5246bf1ae776389" + +[[package]] +name = "nu-ansi-term" +version = "0.46.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "77a8165726e8236064dbb45459242600304b42a5ea24ee2948e18e023bf7ba84" +dependencies = [ + "overload", + "winapi", +] + +[[package]] +name = "num-traits" +version = "0.2.15" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "578ede34cf02f8924ab9447f50c28075b4d3e5b269972345e7e0372b38c6cdcd" +dependencies = [ + "autocfg", +] + +[[package]] +name = "num_cpus" +version = "1.15.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0fac9e2da13b5eb447a6ce3d392f23a29d8694bff781bf03a16cd9ac8697593b" +dependencies = [ + "hermit-abi 0.2.6", + "libc", +] + +[[package]] +name = "object" +version = "0.30.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8d864c91689fdc196779b98dba0aceac6118594c2df6ee5d943eb6a8df4d107a" +dependencies = [ + "memchr", +] + +[[package]] +name = "once_cell" +version = "1.17.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6f61fba1741ea2b3d6a1e3178721804bb716a68a6aeba1149b5d52e3d464ea66" + +[[package]] +name = "oorandom" +version = "11.1.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0ab1bc2a289d34bd04a330323ac98a1b4bc82c9d9fcb1e66b63caa84da26b575" + +[[package]] +name = "output_vt100" +version = "0.1.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "628223faebab4e3e40667ee0b2336d34a5b960ff60ea743ddfdbcf7770bcfb66" +dependencies = [ + "winapi", +] + +[[package]] +name = "overload" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b15813163c1d831bf4a13c3610c05c0d03b39feb07f7e09fa234dac9b15aaf39" + +[[package]] +name = "parking_lot" +version = "0.11.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7d17b78036a60663b797adeaee46f5c9dfebb86948d1255007a1d6be0271ff99" +dependencies = [ + "instant", + "lock_api", + "parking_lot_core", +] + +[[package]] +name = "parking_lot_core" +version = "0.8.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "60a2cfe6f0ad2bfc16aefa463b497d5c7a5ecd44a23efa72aa342d90177356dc" +dependencies = [ + "cfg-if 1.0.0", + "instant", + "libc", + "redox_syscall", + "smallvec", + "winapi", +] + +[[package]] +name = "percent-encoding" +version = "2.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "478c572c3d73181ff3c2539045f6eb99e5491218eae919370993b890cdbdd98e" + +[[package]] +name = "pin-project-lite" +version = "0.2.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e0a7ae3ac2f1173085d398531c705756c94a4c56843785df85a60c1a0afac116" + +[[package]] +name = "plotters" +version = "0.3.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2538b639e642295546c50fcd545198c9d64ee2a38620a628724a3b266d5fbf97" +dependencies = [ + "num-traits", + "plotters-backend", + "plotters-svg", + "wasm-bindgen", + "web-sys", +] + +[[package]] +name = "plotters-backend" +version = "0.3.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "193228616381fecdc1224c62e96946dfbc73ff4384fba576e052ff8c1bea8142" + +[[package]] +name = "plotters-svg" +version = "0.3.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f9a81d2759aae1dae668f783c308bc5c8ebd191ff4184aaa1b37f65a6ae5a56f" +dependencies = [ + "plotters-backend", +] + +[[package]] +name = "ppv-lite86" +version = "0.2.17" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5b40af805b3121feab8a3c29f04d8ad262fa8e0561883e7653e024ae4479e6de" + +[[package]] +name = "prefix-sum-vec" +version = "0.1.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "aa06bd51638b6e76ac9ba9b6afb4164fa647bd2916d722f2623fbb6d1ed8bdba" + +[[package]] +name = "pretty-hex" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bc5c99d529f0d30937f6f4b8a86d988047327bb88d04d2c4afc356de74722131" + +[[package]] +name = "pretty_assertions" +version = "1.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a25e9bcb20aa780fd0bb16b72403a9064d6b3f22f026946029acb941a50af755" +dependencies = [ + "ctor", + "diff", + "output_vt100", + "yansi", +] + +[[package]] +name = "proc-macro-error" +version = "1.0.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "da25490ff9892aab3fcf7c36f08cfb902dd3e71ca0f9f9517bea02a73a5ce38c" +dependencies = [ + "proc-macro-error-attr", + "proc-macro2", + "quote", + "syn", + "version_check", +] + +[[package]] +name = "proc-macro-error-attr" +version = "1.0.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a1be40180e52ecc98ad80b184934baf3d0d29f979574e439af5a55274b35f869" +dependencies = [ + "proc-macro2", + "quote", + "version_check", +] + +[[package]] +name = "proc-macro2" +version = "1.0.49" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "57a8eca9f9c4ffde41714334dee777596264c7825420f521abc92b5b5deb63a5" +dependencies = [ + "unicode-ident", +] + +[[package]] +name = "ptr_meta" +version = "0.1.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0738ccf7ea06b608c10564b31debd4f5bc5e197fc8bfe088f68ae5ce81e7a4f1" +dependencies = [ + "ptr_meta_derive", +] + +[[package]] +name = "ptr_meta_derive" +version = "0.1.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "16b845dbfca988fa33db069c0e230574d15a3088f147a87b64c7589eb662c9ac" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "quote" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8856d8364d252a14d474036ea1358d63c9e6965c8e5c1885c18f73d70bff9c7b" +dependencies = [ + "proc-macro2", +] + +[[package]] +name = "radium" +version = "0.7.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "dc33ff2d4973d518d823d61aa239014831e521c75da58e3df4840d3f47749d09" + +[[package]] +name = "rand" +version = "0.8.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "34af8d1a0e25924bc5b7c43c079c942339d8f0a8b57c39049bef581b46327404" +dependencies = [ + "libc", + "rand_chacha", + "rand_core", +] + +[[package]] +name = "rand_chacha" +version = "0.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88" +dependencies = [ + "ppv-lite86", + "rand_core", +] + +[[package]] +name = "rand_core" +version = "0.6.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c" +dependencies = [ + "getrandom", +] + +[[package]] +name = "rayon" +version = "1.6.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6db3a213adf02b3bcfd2d3846bb41cb22857d131789e01df434fb7e7bc0759b7" +dependencies = [ + "either", + "rayon-core", +] + +[[package]] +name = "rayon-core" +version = "1.10.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cac410af5d00ab6884528b4ab69d1e8e146e8d471201800fa1b4524126de6ad3" +dependencies = [ + "crossbeam-channel 0.5.6", + "crossbeam-deque", + "crossbeam-utils 0.8.14", + "num_cpus", +] + +[[package]] +name = "redox_syscall" +version = "0.2.16" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fb5a58c1855b4b6819d59012155603f0b22ad30cad752600aadfcb695265519a" +dependencies = [ + "bitflags", +] + +[[package]] +name = "regex" +version = "1.7.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e076559ef8e241f2ae3479e36f97bd5741c0330689e217ad51ce2c76808b868a" +dependencies = [ + "regex-syntax", +] + +[[package]] +name = "regex-automata" +version = "0.1.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6c230d73fb8d8c1b9c0b3135c5142a8acee3a0558fb8db5cf1cb65f8d7862132" +dependencies = [ + "regex-syntax", +] + +[[package]] +name = "regex-syntax" +version = "0.6.28" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "456c603be3e8d448b072f410900c09faf164fbce2d480456f50eea6e25f9c848" + +[[package]] +name = "region" +version = "3.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "76e189c2369884dce920945e2ddf79b3dff49e071a167dd1817fa9c4c00d512e" +dependencies = [ + "bitflags", + "libc", + "mach", + "winapi", +] + +[[package]] +name = "remove_dir_all" +version = "0.5.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3acd125665422973a33ac9d3dd2df85edad0f4ae9b00dafb1a05e43a9f5ef8e7" +dependencies = [ + "winapi", +] + +[[package]] +name = "rend" +version = "0.3.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "79af64b4b6362ffba04eef3a4e10829718a4896dac19daa741851c86781edf95" +dependencies = [ + "bytecheck", +] + +[[package]] +name = "rkyv" +version = "0.7.39" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cec2b3485b07d96ddfd3134767b8a447b45ea4eb91448d0a35180ec0ffd5ed15" +dependencies = [ + "bytecheck", + "hashbrown 0.12.3", + "ptr_meta", + "rend", + "rkyv_derive", + "seahash", +] + +[[package]] +name = "rkyv_derive" +version = "0.7.39" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6eaedadc88b53e36dd32d940ed21ae4d850d5916f2581526921f553a72ac34c4" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "rustc-demangle" +version = "0.1.21" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7ef03e0a2b150c7a90d01faf6254c9c48a41e95fb2a8c2ac1c6f0d2b9aefc342" + +[[package]] +name = "rustc_version" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bfa0f585226d2e68097d4f95d113b15b83a82e819ab25717ec0590d9584ef366" +dependencies = [ + "semver", +] + +[[package]] +name = "rustversion" +version = "1.0.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5583e89e108996506031660fe09baa5011b9dd0341b89029313006d1fb508d70" + +[[package]] +name = "ryu" +version = "1.0.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7b4b9743ed687d4b4bcedf9ff5eaa7398495ae14e61cba0a295704edbc7decde" + +[[package]] +name = "same-file" +version = "1.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "93fc1dc3aaa9bfed95e02e6eadabb4baf7e3078b0bd1b4d7b6b0b68378900502" +dependencies = [ + "winapi-util", +] + +[[package]] +name = "scoped-tls" +version = "1.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e1cf6437eb19a8f4a6cc0f7dca544973b0b78843adbfeb3683d1a94a0024a294" + +[[package]] +name = "scopeguard" +version = "1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d29ab0c6d3fc0ee92fe66e2d99f700eab17a8d57d1c1d3b748380fb20baa78cd" + +[[package]] +name = "seahash" +version = "4.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1c107b6f4780854c8b126e228ea8869f4d7b71260f962fefb57b996b8959ba6b" + +[[package]] +name = "semver" +version = "1.0.16" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "58bc9567378fc7690d6b2addae4e60ac2eeea07becb2c64b9f218b53865cba2a" + +[[package]] +name = "serde" +version = "1.0.152" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bb7d1f0d3021d347a83e556fc4683dea2ea09d87bccdf88ff5c12545d89d5efb" + +[[package]] +name = "serde_cbor" +version = "0.11.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2bef2ebfde456fb76bbcf9f59315333decc4fda0b2b44b420243c11e0f5ec1f5" +dependencies = [ + "half", + "serde", +] + +[[package]] +name = "serde_derive" +version = "1.0.152" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "af487d118eecd09402d70a5d72551860e788df87b464af30e5ea6a38c75c541e" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "serde_json" +version = "1.0.91" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "877c235533714907a8c2464236f5c4b2a17262ef1bd71f38f35ea592c8da6883" +dependencies = [ + "itoa 1.0.5", + "ryu", + "serde", +] + +[[package]] +name = "serial_test" +version = "0.5.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e0bccbcf40c8938196944a3da0e133e031a33f4d6b72db3bda3cc556e361905d" +dependencies = [ + "lazy_static", + "parking_lot", + "serial_test_derive", +] + +[[package]] +name = "serial_test_derive" +version = "0.5.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b2acd6defeddb41eb60bb468f8825d0cfd0c2a76bc03bfd235b6a1dc4f6a1ad5" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "sharded-slab" +version = "0.1.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "900fba806f70c630b0a382d0d825e17a0f19fcd059a2ade1ff237bcddf446b31" +dependencies = [ + "lazy_static", +] + +[[package]] +name = "smallvec" +version = "1.10.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a507befe795404456341dfab10cef66ead4c041f62b8b11bbb92bffe5d0953e0" + +[[package]] +name = "strsim" +version = "0.8.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8ea5119cdb4c55b55d432abb513a0429384878c15dde60cc77b1c99de1a95a6a" + +[[package]] +name = "structopt" +version = "0.3.26" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0c6b5c64445ba8094a6ab0c3cd2ad323e07171012d9c98b0b15651daf1787a10" +dependencies = [ + "clap", + "lazy_static", + "structopt-derive", +] + +[[package]] +name = "structopt-derive" +version = "0.4.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "dcb5ae327f9cc13b68763b5749770cb9e048a99bd9dfdfa58d0cf05d5f64afe0" +dependencies = [ + "heck 0.3.3", + "proc-macro-error", + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "strum" +version = "0.24.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "063e6045c0e62079840579a7e47a355ae92f60eb74daaf156fb1e84ba164e63f" +dependencies = [ + "strum_macros", +] + +[[package]] +name = "strum_macros" +version = "0.24.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1e385be0d24f186b4ce2f9982191e7101bb737312ad61c1f2f984f34bcf85d59" +dependencies = [ + "heck 0.4.0", + "proc-macro2", + "quote", + "rustversion", + "syn", +] + +[[package]] +name = "syn" +version = "1.0.107" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1f4064b5b16e03ae50984a5a8ed5d4f8803e6bc1fd170a3cda91a1be4b18e3f5" +dependencies = [ + "proc-macro2", + "quote", + "unicode-ident", +] + +[[package]] +name = "tap" +version = "1.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "55937e1799185b12863d447f42597ed69d9928686b8d88a1df17376a097d8369" + +[[package]] +name = "target-lexicon" +version = "0.12.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9410d0f6853b1d94f0e519fb95df60f29d2c1eff2d921ffdf01a4c8a3b54f12d" + +[[package]] +name = "tempfile" +version = "3.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5cdb1ef4eaeeaddc8fbd371e5017057064af0911902ef36b39801f67cc6d79e4" +dependencies = [ + "cfg-if 1.0.0", + "fastrand", + "libc", + "redox_syscall", + "remove_dir_all", + "winapi", +] + +[[package]] +name = "termcolor" +version = "1.1.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bab24d30b911b2376f3a13cc2cd443142f0c81dda04c118693e35b3835757755" +dependencies = [ + "winapi-util", +] + +[[package]] +name = "test-generator" +version = "0.1.0" +dependencies = [ + "anyhow", + "target-lexicon", +] + +[[package]] +name = "test-log" +version = "0.2.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "38f0c854faeb68a048f0f2dc410c5ddae3bf83854ef0e4977d58306a5edef50e" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "textwrap" +version = "0.11.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d326610f408c7a4eb6f51c37c330e496b08506c9457c9d34287ecc38809fb060" +dependencies = [ + "unicode-width", +] + +[[package]] +name = "thiserror" +version = "1.0.38" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6a9cd18aa97d5c45c6603caea1da6628790b37f7a34b6ca89522331c5180fed0" +dependencies = [ + "thiserror-impl", +] + +[[package]] +name = "thiserror-impl" +version = "1.0.38" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1fb327af4685e4d03fa8cbcf1716380da910eeb2bb8be417e7f9fd3fb164f36f" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "thread_local" +version = "1.1.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5516c27b78311c50bf42c071425c560ac799b11c30b31f87e3081965fe5e0180" +dependencies = [ + "once_cell", +] + +[[package]] +name = "tinytemplate" +version = "1.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "be4d6b5f19ff7664e8c98d03e2139cb510db9b0a60b55f8e8709b689d939b6bc" +dependencies = [ + "serde", + "serde_json", +] + +[[package]] +name = "tinyvec" +version = "1.6.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "87cc5ceb3875bb20c2890005a4e226a4651264a5c75edb2421b52861a0a0cb50" +dependencies = [ + "tinyvec_macros", +] + +[[package]] +name = "tinyvec_macros" +version = "0.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cda74da7e1a664f795bb1f8a87ec406fb89a02522cf6e50620d016add6dbbf5c" + +[[package]] +name = "toml" +version = "0.5.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1333c76748e868a4d9d1017b5ab53171dfd095f70c712fdb4653a406547f598f" +dependencies = [ + "serde", +] + +[[package]] +name = "tracing" +version = "0.1.37" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8ce8c33a8d48bd45d624a6e523445fd21ec13d3653cd51f681abf67418f54eb8" +dependencies = [ + "cfg-if 1.0.0", + "log", + "pin-project-lite", + "tracing-attributes", + "tracing-core", +] + +[[package]] +name = "tracing-attributes" +version = "0.1.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4017f8f45139870ca7e672686113917c71c7a6e02d4924eda67186083c03081a" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "tracing-core" +version = "0.1.30" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "24eb03ba0eab1fd845050058ce5e616558e8f8d8fca633e6b163fe25c797213a" +dependencies = [ + "once_cell", + "valuable", +] + +[[package]] +name = "tracing-log" +version = "0.1.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "78ddad33d2d10b1ed7eb9d1f518a5674713876e97e5bb9b7345a7984fbb4f922" +dependencies = [ + "lazy_static", + "log", + "tracing-core", +] + +[[package]] +name = "tracing-subscriber" +version = "0.3.16" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a6176eae26dd70d0c919749377897b54a9276bd7061339665dd68777926b5a70" +dependencies = [ + "matchers", + "nu-ansi-term", + "once_cell", + "regex", + "sharded-slab", + "smallvec", + "thread_local", + "tracing", + "tracing-core", + "tracing-log", +] + +[[package]] +name = "tracing-tracy" +version = "0.9.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "23a42311a35ed976d72f359de43e9fe028ec9d9f1051c4c52bd05a4f66ff3cbf" +dependencies = [ + "tracing-core", + "tracing-subscriber", + "tracy-client", +] + +[[package]] +name = "tracy-client" +version = "0.13.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "42ebfe7a24c18b5ba86d8920c124b41b942352f863fbe0c84d3d63428fa1860f" +dependencies = [ + "loom", + "once_cell", + "tracy-client-sys", +] + +[[package]] +name = "tracy-client-sys" +version = "0.17.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "178d021455e83078bb38c00b70046b95117ef0a0312cbef925f426d833d11c79" +dependencies = [ + "cc", +] + +[[package]] +name = "trybuild" +version = "1.0.73" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ed01de3de062db82c0920b5cabe804f88d599a3f217932292597c678c903754d" +dependencies = [ + "glob", + "once_cell", + "serde", + "serde_derive", + "serde_json", + "termcolor", + "toml", +] + +[[package]] +name = "unicode-bidi" +version = "0.3.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "099b7128301d285f79ddd55b9a83d5e6b9e97c92e0ea0daebee7263e932de992" + +[[package]] +name = "unicode-ident" +version = "1.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "84a22b9f218b40614adcb3f4ff08b703773ad44fa9423e4e0d346d5db86e4ebc" + +[[package]] +name = "unicode-normalization" +version = "0.1.22" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5c5713f0fc4b5db668a2ac63cdb7bb4469d8c9fed047b1d0292cc7b0ce2ba921" +dependencies = [ + "tinyvec", +] + +[[package]] +name = "unicode-segmentation" +version = "1.10.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0fdbf052a0783de01e944a6ce7a8cb939e295b1e7be835a1112c3b9a7f047a5a" + +[[package]] +name = "unicode-width" +version = "0.1.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c0edd1e5b14653f783770bce4a4dabb4a5108a5370a5f5d8cfe8710c361f6c8b" + +[[package]] +name = "url" +version = "2.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0d68c799ae75762b8c3fe375feb6600ef5602c883c5d21eb51c09f22b83c4643" +dependencies = [ + "form_urlencoded", + "idna", + "percent-encoding", +] + +[[package]] +name = "valuable" +version = "0.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "830b7e5d4d90034032940e4ace0d9a9a057e7a45cd94e6c007832e39edb82f6d" + +[[package]] +name = "vec_map" +version = "0.8.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f1bddf1187be692e79c5ffeab891132dfb0f236ed36a43c7ed39f1165ee20191" + +[[package]] +name = "version_check" +version = "0.9.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "49874b5167b65d7193b8aba1567f5c7d93d001cafc34600cee003eda787e483f" + +[[package]] +name = "walkdir" +version = "2.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "808cf2735cd4b6866113f648b791c6adc5714537bc222d9347bb203386ffda56" +dependencies = [ + "same-file", + "winapi", + "winapi-util", +] + +[[package]] +name = "wasi" +version = "0.11.0+wasi-snapshot-preview1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423" + +[[package]] +name = "wasm-bindgen" +version = "0.2.83" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "eaf9f5aceeec8be17c128b2e93e031fb8a4d469bb9c4ae2d7dc1888b26887268" +dependencies = [ + "cfg-if 1.0.0", + "wasm-bindgen-macro", +] + +[[package]] +name = "wasm-bindgen-backend" +version = "0.2.83" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4c8ffb332579b0557b52d268b91feab8df3615f265d5270fec2a8c95b17c1142" +dependencies = [ + "bumpalo", + "log", + "once_cell", + "proc-macro2", + "quote", + "syn", + "wasm-bindgen-shared", +] + +[[package]] +name = "wasm-bindgen-macro" +version = "0.2.83" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "052be0f94026e6cbc75cdefc9bae13fd6052cdcaf532fa6c45e7ae33a1e6c810" +dependencies = [ + "quote", + "wasm-bindgen-macro-support", +] + +[[package]] +name = "wasm-bindgen-macro-support" +version = "0.2.83" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "07bc0c051dc5f23e307b13285f9d75df86bfdf816c5721e573dec1f9b8aa193c" +dependencies = [ + "proc-macro2", + "quote", + "syn", + "wasm-bindgen-backend", + "wasm-bindgen-shared", +] + +[[package]] +name = "wasm-bindgen-shared" +version = "0.2.83" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1c38c045535d93ec4f0b4defec448e4291638ee608530863b1e2ba115d4fff7f" + +[[package]] +name = "wasm-encoder" +version = "0.4.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "51b4949d4f2b25a4b208317dcf86aacef9e7a5884e48dfc45d4aeb91808d6f86" +dependencies = [ + "leb128", +] + +[[package]] +name = "wasm-encoder" +version = "0.12.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2b47b995b096a689358ca9de6c727b94351b95b390dbbf6b7021c22797d36caa" +dependencies = [ + "leb128", +] + +[[package]] +name = "wasm-encoder" +version = "0.20.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "05632e0a66a6ed8cca593c24223aabd6262f256c3693ad9822c315285f010614" +dependencies = [ + "leb128", +] + +[[package]] +name = "wasm-smith" +version = "0.4.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f7e95fdeed16adeffed44efdc7ccf27d4f57ff2e99de417c75bcee7dee09049b" +dependencies = [ + "arbitrary", + "indexmap", + "leb128", + "wasm-encoder 0.4.1", +] + +[[package]] +name = "wasmer-bin-fuzz" +version = "0.0.0" +dependencies = [ + "anyhow", + "libfuzzer-sys", + "wasm-smith", + "wasmer-compiler-singlepass-near", + "wasmer-engine-universal-near", + "wasmer-near", + "wasmprinter", +] + +[[package]] +name = "wasmer-compiler-near" +version = "2.4.0" +dependencies = [ + "enumset", + "finite-wasm", + "hashbrown 0.11.2", + "rkyv", + "smallvec", + "target-lexicon", + "thiserror", + "tracing", + "wasmer-types-near", + "wasmer-vm-near", + "wasmparser", +] + +[[package]] +name = "wasmer-compiler-singlepass-near" +version = "2.4.0" +dependencies = [ + "byteorder", + "dynasm", + "dynasmrt", + "enumset", + "finite-wasm", + "hashbrown 0.11.2", + "lazy_static", + "memoffset 0.6.5", + "more-asserts", + "rayon", + "smallvec", + "strum", + "target-lexicon", + "tracing", + "wasmer-compiler-near", + "wasmer-types-near", + "wasmer-vm-near", +] + +[[package]] +name = "wasmer-engine-near" +version = "2.4.0" +dependencies = [ + "backtrace", + "enumset", + "finite-wasm", + "lazy_static", + "memmap2", + "more-asserts", + "rustc-demangle", + "target-lexicon", + "thiserror", + "wasmer-compiler-near", + "wasmer-types-near", + "wasmer-vm-near", +] + +[[package]] +name = "wasmer-engine-universal-near" +version = "2.4.0" +dependencies = [ + "cfg-if 1.0.0", + "enumset", + "finite-wasm", + "leb128", + "prefix-sum-vec", + "region", + "rkyv", + "thiserror", + "tracing", + "wasmer-compiler-near", + "wasmer-engine-near", + "wasmer-types-near", + "wasmer-vm-near", + "wasmparser", + "winapi", +] + +[[package]] +name = "wasmer-near" +version = "2.4.0" +dependencies = [ + "anyhow", + "cfg-if 1.0.0", + "finite-wasm", + "indexmap", + "more-asserts", + "prefix-sum-vec", + "target-lexicon", + "tempfile", + "thiserror", + "tracing", + "wasmer-compiler-near", + "wasmer-compiler-singlepass-near", + "wasmer-engine-near", + "wasmer-engine-universal-near", + "wasmer-types-near", + "wasmer-vm-near", + "wat", + "winapi", +] + +[[package]] +name = "wasmer-types-near" +version = "2.4.0" +dependencies = [ + "bolero", + "indexmap", + "num-traits", + "rkyv", + "thiserror", +] + +[[package]] +name = "wasmer-vm-near" +version = "2.4.0" +dependencies = [ + "backtrace", + "cc", + "cfg-if 1.0.0", + "finite-wasm", + "indexmap", + "libc", + "memoffset 0.6.5", + "more-asserts", + "region", + "rkyv", + "thiserror", + "tracing", + "wasmer-types-near", + "wasmparser", + "winapi", +] + +[[package]] +name = "wasmer-wast" +version = "2.1.0" +dependencies = [ + "anyhow", + "tempfile", + "thiserror", + "wasmer-near", + "wast 38.0.1", +] + +[[package]] +name = "wasmer-workspace" +version = "2.4.0" +dependencies = [ + "anyhow", + "build-deps", + "cfg-if 1.0.0", + "compiler-test-derive", + "criterion", + "glob", + "lazy_static", + "rayon", + "rustc_version", + "serial_test", + "tempfile", + "test-generator", + "test-log", + "tracing", + "tracing-subscriber", + "tracing-tracy", + "tracy-client", + "wasm-encoder 0.12.0", + "wasmer-compiler-near", + "wasmer-compiler-singlepass-near", + "wasmer-engine-near", + "wasmer-engine-universal-near", + "wasmer-near", + "wasmer-types-near", + "wasmer-vm-near", + "wasmer-wast", + "wat", +] + +[[package]] +name = "wasmparser" +version = "0.99.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9ef3b717afc67f848f412d4f02c127dd3e35a0eecd58c684580414df4fde01d3" +dependencies = [ + "indexmap", + "url", +] + +[[package]] +name = "wasmprinter" +version = "0.2.49" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "27c13dff901f9354fa9a6a877152d9c5642513645985635c9b83bcca99e40ea1" +dependencies = [ + "anyhow", + "wasmparser", +] + +[[package]] +name = "wast" +version = "38.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ae0d7b256bef26c898fa7344a2d627e8499f5a749432ce0a05eae1a64ff0c271" +dependencies = [ + "leb128", +] + +[[package]] +name = "wast" +version = "50.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a2cbb59d4ac799842791fe7e806fa5dbbf6b5554d538e51cc8e176db6ff0ae34" +dependencies = [ + "leb128", + "memchr", + "unicode-width", + "wasm-encoder 0.20.0", +] + +[[package]] +name = "wat" +version = "1.0.52" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "584aaf7a1ecf4d383bbe1a25eeab0cbb8ff96acc6796707ff65cde48f4632f15" +dependencies = [ + "wast 50.0.0", +] + +[[package]] +name = "web-sys" +version = "0.3.60" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bcda906d8be16e728fd5adc5b729afad4e444e106ab28cd1c7256e54fa61510f" +dependencies = [ + "js-sys", + "wasm-bindgen", +] + +[[package]] +name = "winapi" +version = "0.3.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419" +dependencies = [ + "winapi-i686-pc-windows-gnu", + "winapi-x86_64-pc-windows-gnu", +] + +[[package]] +name = "winapi-i686-pc-windows-gnu" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6" + +[[package]] +name = "winapi-util" +version = "0.1.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "70ec6ce85bb158151cae5e5c87f95a8e97d2c0c4b001223f33a334e3ce5de178" +dependencies = [ + "winapi", +] + +[[package]] +name = "winapi-x86_64-pc-windows-gnu" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f" + +[[package]] +name = "windows" +version = "0.39.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f1c4bd0a50ac6020f65184721f758dba47bb9fbc2133df715ec74a237b26794a" +dependencies = [ + "windows_aarch64_msvc", + "windows_i686_gnu", + "windows_i686_msvc", + "windows_x86_64_gnu", + "windows_x86_64_msvc", +] + +[[package]] +name = "windows_aarch64_msvc" +version = "0.39.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ec7711666096bd4096ffa835238905bb33fb87267910e154b18b44eaabb340f2" + +[[package]] +name = "windows_i686_gnu" +version = "0.39.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "763fc57100a5f7042e3057e7e8d9bdd7860d330070251a73d003563a3bb49e1b" + +[[package]] +name = "windows_i686_msvc" +version = "0.39.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7bc7cbfe58828921e10a9f446fcaaf649204dcfe6c1ddd712c5eebae6bda1106" + +[[package]] +name = "windows_x86_64_gnu" +version = "0.39.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6868c165637d653ae1e8dc4d82c25d4f97dd6605eaa8d784b5c6e0ab2a252b65" + +[[package]] +name = "windows_x86_64_msvc" +version = "0.39.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5e4d40883ae9cae962787ca76ba76390ffa29214667a111db9e0a1ad8377e809" + +[[package]] +name = "wyz" +version = "0.5.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "05f360fc0b24296329c78fda852a1e9ae82de9cf7b27dae4b7f62f118f77b9ed" +dependencies = [ + "tap", +] + +[[package]] +name = "yansi" +version = "0.5.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "09041cd90cf85f7f8b2df60c646f853b7f535ce68f85244eb6731cf89fa498ec" diff --git a/runtime/near-vm/Cargo.toml b/runtime/near-vm/Cargo.toml new file mode 100644 index 00000000000..f962671ae48 --- /dev/null +++ b/runtime/near-vm/Cargo.toml @@ -0,0 +1,192 @@ +[package] +name = "wasmer-workspace" +version = "2.4.0" +description = "Wasmer workspace" +authors = ["Wasmer Engineering Team "] +repository = "https://github.com/wasmerio/wasmer" +license = "MIT" +edition = "2018" +publish = false +autoexamples = false + +[dependencies] +wasmer = { version = "=2.4.0", path = "lib/api", package = "wasmer-near" } +wasmer-compiler = { version = "=2.4.0", path = "lib/compiler", package = "wasmer-compiler-near" } +wasmer-compiler-singlepass = { version = "=2.4.0", path = "lib/compiler-singlepass", optional = true, package = "wasmer-compiler-singlepass-near" } +wasmer-engine = { version = "=2.4.0", path = "lib/engine", package = "wasmer-engine-near" } +wasmer-engine-universal = { version = "=2.4.0", path = "lib/engine-universal", optional = true, package = "wasmer-engine-universal-near" } +wasmer-wast = { version = "2.0.0", path = "tests/lib/wast", optional = true } +wasmer-types = { version = "=2.4.0", path = "lib/types", package = "wasmer-types-near" } +wasmer-vm = { version = "=2.4.0", path = "lib/vm", package = "wasmer-vm-near" } + +cfg-if = "1.0" +tracing = "0.1" + +[workspace] +members = [ + "lib/api", + "lib/compiler", + "lib/compiler-singlepass", + "lib/engine", + "lib/engine-universal", + "lib/vm", + "lib/types", + "tests/lib/wast", + "tests/lib/compiler-test-derive", + "fuzz", +] +resolver = "2" + +[build-dependencies] +test-generator = { path = "tests/lib/test-generator" } +build-deps = "0.1.4" +anyhow = "1.0" +glob = "0.3" +rustc_version = "0.4" + +[dev-dependencies] +anyhow = "1.0" +criterion = "0.3" +lazy_static = "1.4" +serial_test = "0.5" +compiler-test-derive = { path = "tests/lib/compiler-test-derive" } +rayon = "1.5" +tempfile = "3.1" +# For logging tests using the `RUST_LOG=debug` when testing +test-log = { version = "0.2", default-features = false, features = ["trace"] } +tracing = { version = "0.1", default-features = false, features = ["log"] } +tracing-subscriber = { version = "0.3", default-features = false, features = ["env-filter", "fmt"] } +tracing-tracy = "0.9" +tracy-client = "0.13" +wat = "1.0" +wasm-encoder = "0.12" + +[features] +# Don't add the compiler features in default, please add them on the Makefile +# since we might want to autoconfigure them depending on the availability on the host. +default = [ + "wasmer/wat", + "wast", + "universal", + "singlepass", +] +engine = [] +universal = [ + "wasmer-engine-universal", + "engine", +] +wast = ["wasmer-wast"] +compiler = [ + "wasmer/compiler", + "wasmer-compiler/translator", + "wasmer-engine-universal/compiler", +] +singlepass = [ + "wasmer-compiler-singlepass", + "compiler", +] + +# Specifies that we're running in coverage testing mode. This disables tests +# that raise signals because that interferes with tarpaulin. +coverage = [] + +[profile.dev] +split-debuginfo = "unpacked" + +[[bench]] +name = "static_and_dynamic_functions" +harness = false + +[[bench]] +name = "limits" +harness = false + +[[example]] +name = "tracy-exec" +path = "examples/tracy_exec.rs" +required-features = ["singlepass"] + +[[example]] +name = "early-exit" +path = "examples/early_exit.rs" +required-features = ["singlepass"] + +[[example]] +name = "engine-universal" +path = "examples/engine_universal.rs" +required-features = ["singlepass"] + +[[example]] +name = "compiler-singlepass" +path = "examples/compiler_singlepass.rs" +required-features = ["singlepass"] + +[[example]] +name = "exported-function" +path = "examples/exports_function.rs" +required-features = ["singlepass"] + +[[example]] +name = "exported-global" +path = "examples/exports_global.rs" +required-features = ["singlepass"] + +[[example]] +name = "exported-memory" +path = "examples/exports_memory.rs" +required-features = ["singlepass"] + +[[example]] +name = "imported-function" +path = "examples/imports_function.rs" +required-features = ["singlepass"] + +[[example]] +name = "imported-global" +path = "examples/imports_global.rs" +required-features = ["singlepass"] + +[[example]] +name = "table" +path = "examples/table.rs" +required-features = ["singlepass"] + +[[example]] +name = "memory" +path = "examples/memory.rs" +required-features = ["singlepass"] + +[[example]] +name = "instance" +path = "examples/instance.rs" +required-features = ["singlepass"] + +[[example]] +name = "errors" +path = "examples/errors.rs" +required-features = ["singlepass"] + +[[example]] +name = "imported-function-env" +path = "examples/imports_function_env.rs" +required-features = ["singlepass"] + +[[example]] +name = "hello-world" +path = "examples/hello_world.rs" +required-features = ["singlepass"] + +[[example]] +name = "imports-exports" +path = "examples/imports_exports.rs" +required-features = ["singlepass"] + +[[example]] +name = "features" +path = "examples/features.rs" +required-features = ["singlepass"] + +[[example]] +name = "coremark" +path = "examples/coremark.rs" +required-features = ["singlepass"] diff --git a/runtime/near-vm/LICENSE b/runtime/near-vm/LICENSE new file mode 100644 index 00000000000..62bb543eb9e --- /dev/null +++ b/runtime/near-vm/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2019-present Wasmer, Inc. and its affiliates. + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/runtime/near-vm/Makefile b/runtime/near-vm/Makefile new file mode 100644 index 00000000000..8c95c79447f --- /dev/null +++ b/runtime/near-vm/Makefile @@ -0,0 +1,345 @@ +SHELL=/usr/bin/env bash + + +##### +# +# The Matrix +# +##### + +# The matrix is the product of the following columns: +# +# |------------|-----------|----------|--------------|-------| +# | Compiler ⨯ Engine ⨯ Platform ⨯ Architecture ⨯ libc | +# |------------|-----------|----------|--------------|-------| +# | Singlepass | Universal | Linux | amd64 | glibc | +# | | | Darwin | aarch64 | musl | +# | | | Windows | | | +# |------------|-----------|----------|--------------|-------| +# +# Here is what works and what doesn't: +# +# * Singlepass with the Universal engine works on Linux+Darwin/`amd64`, but +# it doesn't work on */`aarch64` or Windows/*. +# +# * Singlepass with the Dylib engine doesn't work because it doesn't +# know how to output object files for the moment. +# +# * Windows isn't tested on `aarch64`, that's why we consider it's not +# working, but it might possibly be. + + +##### +# +# Define the “Platform” and “Architecture” columns of the matrix. +# +##### + + +IS_DARWIN := 0 +IS_LINUX := 0 +IS_WINDOWS := 0 +IS_AMD64 := 0 +IS_AARCH64 := 0 + +# Test Windows apart because it doesn't support `uname -s`. +ifeq ($(OS), Windows_NT) + # We can assume it will likely be in amd64. + IS_AMD64 := 1 + IS_WINDOWS := 1 +else + # Platform + uname := $(shell uname -s) + + ifeq ($(uname), Darwin) + IS_DARWIN := 1 + else ifeq ($(uname), Linux) + IS_LINUX := 1 + else + # We use spaces instead of tabs to indent `$(error)` + # otherwise it's considered as a command outside a + # target and it will fail. + $(error Unrecognized platform, expect `Darwin`, `Linux` or `Windows_NT`) + endif + + # Architecture + uname := $(shell uname -m) + + ifeq ($(uname), x86_64) + IS_AMD64 := 1 + else ifneq (, $(filter $(uname), aarch64 arm64)) + IS_AARCH64 := 1 + else + # We use spaces instead of tabs to indent `$(error)` + # otherwise it's considered as a command outside a + # target and it will fail. + $(error Unrecognized architecture, expect `x86_64`, `aarch64` or `arm64`) + endif + + # Libc + LIBC ?= $(shell ldd 2>&1 | grep -o musl | head -n1) +endif + + +##### +# +# Define the “Compiler” column of the matrix. +# +##### + + +# Variables that can be overriden by the users to force to enable or +# to disable a specific compiler. +ENABLE_SINGLEPASS ?= + +# Which compilers we build. These have dependencies that may not be on the system. +compilers := +exclude_tests := + +## +# Singlepass +## + +# If the user didn't disable the Singlepass compiler… +ifneq ($(ENABLE_SINGLEPASS), 0) + # … then maybe the user forced to enable the Singlepass compiler. + ifeq ($(ENABLE_SINGLEPASS), 1) + compilers += singlepass + # … otherwise, we try to check whether Singlepass works on this host. + else ifneq (, $(filter 1, $(IS_DARWIN) $(IS_LINUX) $(IS_WINDOWS))) + ifeq ($(IS_AMD64), 1) + compilers += singlepass + endif + endif +endif + +ifneq (, $(findstring singlepass,$(compilers))) + ENABLE_SINGLEPASS := 1 +endif + +## +# Clean the `compilers` variable. +## + +compilers := $(strip $(compilers)) + + +##### +# +# Define the “Engine” column of the matrix. +# +##### + + +# The engine is part of a pair of kind (compiler, engine). All the +# pairs are stored in the `compilers_engines` variable. +compilers_engines := + +## +# The Singlepass case. +## + +ifeq ($(ENABLE_SINGLEPASS), 1) + ifneq (, $(filter 1, $(IS_DARWIN) $(IS_LINUX))) + ifeq ($(IS_AMD64), 1) + compilers_engines += singlepass-universal + endif + endif +endif + +# Clean the `compilers_engines` variable. +compilers_engines := $(strip $(compilers_engines)) + + +##### +# +# Cargo features. +# +##### + +# Small trick to define a space and a comma. +space := $() $() +comma := , + +# Define the compiler Cargo features for all crates. +compiler_features := --features $(subst $(space),$(comma),$(compilers)) + +##### +# +# Display information. +# +##### + +ifneq (, $(filter 1, $(IS_DARWIN) $(IS_LINUX))) + bold := $(shell tput bold 2>/dev/null || echo -n '') + green := $(shell tput setaf 2 2>/dev/null || echo -n '') + yellow := $(shell tput setaf 3 2>/dev/null || echo -n '') + reset := $(shell tput sgr0 2>/dev/null || echo -n '') +endif + +HOST_TARGET=$(shell rustup show | grep 'Default host: ' | cut -d':' -f2 | tr -d ' ') + +TARGET_DIR := target/release + +ifneq (, $(TARGET)) + TARGET_DIR := target/$(TARGET)/release +endif + +$(info -----------) +$(info $(bold)$(green)INFORMATION$(reset)) +$(info -----------) +$(info ) +$(info Host Target: `$(bold)$(green)$(HOST_TARGET)$(reset)`.) +ifneq (, $(TARGET)) + # We use spaces instead of tabs to indent `$(info)` + # otherwise it's considered as a command outside a + # target and it will fail. + $(info Build Target: $(bold)$(green)$(TARGET)$(reset) $(yellow)($(TARGET_DIR))$(reset)) +endif +ifneq (, $(LIBC)) + # We use spaces instead of tabs to indent `$(info)` + # otherwise it's considered as a command outside a + # target and it will fail. + $(info C standard library: $(bold)$(green)$(LIBC)$(reset)) +endif +$(info Enabled Compilers: $(bold)$(green)$(subst $(space),$(reset)$(comma)$(space)$(bold)$(green),$(compilers))$(reset).) +$(info Testing the following compilers & engines:) +$(info   * API: $(bold)$(green)${compilers_engines}$(reset),) +$(info Cargo features:) +$(info   * Compilers: `$(bold)$(green)${compiler_features}$(reset)`.) +$(info Rust version: $(bold)$(green)$(shell rustc --version)$(reset).) +$(info NodeJS version: $(bold)$(green)$(shell node --version)$(reset).) +$(info ) +$(info ) +$(info --------------) +$(info $(bold)$(green)RULE EXECUTION$(reset)) +$(info --------------) +$(info ) +$(info ) + +##### +# +# Configure `sed -i` for a cross-platform usage. +# +##### + +SEDI ?= + +ifeq ($(IS_DARWIN), 1) + SEDI := "-i ''" +else ifeq ($(IS_LINUX), 1) + SEDI := "-i" +endif + +##### +# +# Building. +# +##### + +bench: + cargo bench $(compiler_features) + +# For best results ensure the release profile looks like the following +# in Cargo.toml: +# [profile.release] +# opt-level = 'z' +# debug = false +# debug-assertions = false +# overflow-checks = false +# lto = true +# panic = 'abort' +# incremental = false +# codegen-units = 1 +# rpath = false +ifeq ($(IS_DARWIN), 1) + strip -u target/$(HOST_TARGET)/release/wasmer-headless +else ifeq ($(IS_WINDOWS), 1) + strip --strip-unneeded target/$(HOST_TARGET)/release/wasmer-headless.exe +else + strip --strip-unneeded target/$(HOST_TARGET)/release/wasmer-headless +endif + +##### +# +# Testing. +# +##### + +test: + cargo test --release --all $(compiler_features) + +##### +# +# Packaging. +# +##### + +package-docs: build-docs + mkdir -p "package/docs/crates" + cp -R target/doc/ package/docs/crates + echo '' > package/docs/index.html + echo '' > package/docs/crates/index.html + +distribution: package + cp LICENSE package/LICENSE + cp ATTRIBUTIONS.md package/ATTRIBUTIONS + mkdir -p dist +ifeq ($(IS_WINDOWS), 1) + iscc scripts/windows-installer/wasmer.iss + cp scripts/windows-installer/WasmerInstaller.exe dist/ +endif + tar -C package -zcvf wasmer.tar.gz bin lib include LICENSE ATTRIBUTIONS + mv wasmer.tar.gz dist/ + +##### +# +# Installating (for Distros). +# +##### + +DESTDIR ?= /usr/local + +install: install-wasmer install-pkgconfig install-misc + +install-wasmer: + install -Dm755 target/release/wasmer $(DESTDIR)/bin/wasmer + +install-misc: + install -Dm644 LICENSE "$(DESTDIR)"/share/licenses/wasmer/LICENSE + +install-pkgconfig: + # Make sure WASMER_INSTALL_PREFIX is set during build + unset WASMER_DIR; \ + if pc="$$(target/release/wasmer config --pkg-config 1>/dev/null 2>/dev/null)"; then \ + echo "$$pc" | install -Dm644 /dev/stdin "$(DESTDIR)"/lib/pkgconfig/wasmer.pc; \ + else \ + echo 1>&2 "WASMER_INSTALL_PREFIX was not set during build, not installing wasmer.pc"; \ + fi + +install-wasmer-headless-minimal: + install -Dm755 target/release/wasmer-headless $(DESTDIR)/bin/wasmer-headless + +##### +# +# Miscellaneous. +# +##### + +# Updates the spectests from the repo +update-testsuite: + git subtree pull --prefix tests/wast/spec https://github.com/WebAssembly/testsuite.git master --squash + +lint-packages: RUSTFLAGS += -D dead-code -D nonstandard-style -D unused-imports -D unused-mut -D unused-variables -D unused-unsafe -D unreachable-patterns -D bad-style -D improper-ctypes -D unused-allocation -D unused-comparisons -D while-true -D unconditional-recursion -D bare-trait-objects # TODO: add `-D missing-docs` # TODO: add `-D function_item_references` (not available on Rust 1.47, try when upgrading) +lint-packages: + RUSTFLAGS="${RUSTFLAGS}" cargo clippy --all $(exclude_tests) + RUSTFLAGS="${RUSTFLAGS}" cargo clippy --manifest-path fuzz/Cargo.toml $(compiler_features) + +lint-formatting: + cargo fmt --all -- --check + cargo fmt --manifest-path fuzz/Cargo.toml -- --check + +lint: lint-formatting lint-packages + +install-local: package + tar -C ~/.wasmer -zxvf wasmer.tar.gz diff --git a/runtime/near-vm/PACKAGING.md b/runtime/near-vm/PACKAGING.md new file mode 100644 index 00000000000..7b392fff50f --- /dev/null +++ b/runtime/near-vm/PACKAGING.md @@ -0,0 +1,54 @@ +# Wasmer OS distro packaging notes + +* Wasmer is written in Rust. To build Wasmer, where possible, do not + directly invoke `cargo`, but use the supplied `Makefile` + +* Wasmer provides several compilers and the `Makefile` autodetects + when compilers can be compiled and/or installed. Set the environment + variables `ENABLE_SINGLEPASS=1` to force compiler + to be build or to fail trying, e.g: + + ```sh + $ ENABLE_LLVM=1 make build-wasmer + ``` + +* `make install` respects `DESTDIR`, but `prefix` must be configured + with `WASMER_INSTALL_PREFIX`, e.g.: + + ```sh + export WASMER_INSTALL_PREFIX=/usr + make + DESTDIR=.../usr make install + ``` + +* In case you must build/install directly with `cargo`, make sure to + enable at least one compiler feature, like e.g. `--features + singlepass`, + + * Beware that compiling with `cargo build --workspace --features …` + will not enable features on the subcrates in the workspace and + result in a headless Wasmer binary that can not compile Wasm files + directly. + +* If you split the package into several subpackages, beware that the + `create-exe` command of the `wasmer` CLI requires `libwasmer.a` to + be installed at `$WASMER_INSTALL_PREFIX/lib/libwasmer.a`. Suggestions for splitting: + + * The `wasmer-headless` CLI contains a subset of the `wasmer`'s functionalities + and should only be packaged when splitting — it must be built + explicitly with: + + ```sh + $ make build-wasmer-headless-minimal install-wasmer-headless-minimal + ``` + * `libwasmer`, containing `libwasmer.so*`, + * `libwasmer-dev`, containing the header files and a `.pc` file, + * `libwasmer-static`, containing `libwasmer.a`. + +The Wasmer distro packaging story is still in its infancy, so feedback is very welcome. + +## Miscellaneous: binfmt_misc + +Wasmer can be registered as a binfmt interpreter for wasm binaries. +An example systemd [.service](./scripts/wasmer-binfmt.service.example) is included here. +Please consider statically linking the wasmer binary so that this capability is also available in mount namespaces. diff --git a/runtime/near-vm/README.md b/runtime/near-vm/README.md new file mode 100644 index 00000000000..22c8b43f1fd --- /dev/null +++ b/runtime/near-vm/README.md @@ -0,0 +1,237 @@ + + +
+ +Wasmer is a _fast_ and _secure_ [**WebAssembly**](https://webassembly.org) runtime that enables super +_lightweight containers_ to run anywhere: from *Desktop* to the *Cloud*, *Edge* and *IoT* devices. + +> _This document is also available in: +[🇨🇳 中 文 -Chinese](https://github.com/wasmerio/wasmer/blob/master/docs/cn/README.md) • +[🇩🇪 Deutsch-German](https://github.com/wasmerio/wasmer/blob/master/docs/de/README.md) • +[🇪🇸 Español-Spanish](https://github.com/wasmerio/wasmer/blob/master/docs/es/README.md) • +[🇫🇷 Français-French](https://github.com/wasmerio/wasmer/blob/master/docs/fr/README.md) • +[🇯🇵 日本 語 -Japanese](https://github.com/wasmerio/wasmer/blob/master/docs/ja/README.md) • +[🇰🇷 한국인 -Korean](https://github.com/wasmerio/wasmer/blob/master/docs/ko/README.md)_. + +### Features + +* Secure by default. No file, network, or environment access, unless explicitly enabled. +* Supports [WASI](https://github.com/WebAssembly/WASI) and [Emscripten](https://emscripten.org/) out of the box. +* Fast. Run WebAssembly at near-native speeds. +* Embeddable in [multiple programming languages](https://github.com/wasmerio/wasmer/#-language-integrations) +* Compliant with latest WebAssembly Proposals (SIMD, Reference Types, Threads, ...) + +### Install + +Wasmer CLI ships as a single executable with no dependencies. + +```sh +curl https://get.wasmer.io -sSfL | sh +``` + + +
+ Other installation options (Powershell, Brew, Cargo, ...) + + _Wasmer can be installed from various package managers. Choose the one that fits best for your environment:_ + + * Powershell (Windows) + ```powershell + iwr https://win.wasmer.io -useb | iex + ``` + + * Homebrew (macOS, Linux) + + ```sh + brew install wasmer + ``` + + * Scoop (Windows) + + ```sh + scoop install wasmer + ``` + + * Chocolatey (Windows) + + ```sh + choco install wasmer + ``` + + * Cargo + + _Note: All the available + features are described in the [`wasmer-cli` + crate docs](https://github.com/wasmerio/wasmer/tree/master/lib/cli/README.md)_ + + ```sh + cargo install wasmer-cli + ``` + + > Looking for more installation options? See [the `wasmer-install` + repository](https://github.com/wasmerio/wasmer-install) to learn + more! +
+ +### Quickstart + +You can start by running +[QuickJS](https://github.com/bellard/quickjs/), a small and +embeddable Javascript engine compiled as a WebAssembly module ([`qjs.wasm`](https://registry-cdn.wapm.io/contents/_/quickjs/0.0.3/build/qjs.wasm)): + +```bash +$ wasmer qjs.wasm +QuickJS - Type "\h" for help +qjs > const i = 1 + 2; +qjs > console.log("hello " + i); +hello 3 +``` + +#### Here is what you can do next: + +- [Use Wasmer from your Rust application](https://docs.wasmer.io/integrations/rust) +- [Publish a Wasm package on WAPM](https://docs.wasmer.io/ecosystem/wapm/publishing-your-package) +- [Read more about Wasmer](https://medium.com/wasmer/) + +## 📦 Language Integrations + +The Wasmer runtime can be used as a library **embedded in different +languages**, so you can use WebAssembly _anywhere_. + +| | Language | Package | Documentation | +|-|-|-|-| +| ![Rust logo] | [**Rust**][Rust integration] | [`wasmer` Rust crate] | [Learn][rust docs] +| ![C logo] | [**C/C++**][C integration] | [`wasmer.h` header] | [Learn][c docs] | +| ![C# logo] | [**C#**][C# integration] | [`WasmerSharp` NuGet package] | [Learn][c# docs] | +| ![D logo] | [**D**][D integration] | [`wasmer` Dub package] | [Learn][d docs] | +| ![Python logo] | [**Python**][Python integration] | [`wasmer` PyPI package] | [Learn][python docs] | +| ![JS logo] | [**Javascript**][JS integration] | [`@wasmerio` NPM packages] | [Learn][js docs] | +| ![Go logo] | [**Go**][Go integration] | [`wasmer` Go package] | [Learn][go docs] | +| ![PHP logo] | [**PHP**][PHP integration] | [`wasm` PECL package] | [Learn][php docs] | +| ![Ruby logo] | [**Ruby**][Ruby integration] | [`wasmer` Ruby Gem] | [Learn][ruby docs] | +| ![Java logo] | [**Java**][Java integration] | [`wasmer/wasmer-jni` Bintray package] | [Learn][java docs] | +| ![Elixir logo] | [**Elixir**][Elixir integration] | [`wasmex` hex package] | [Learn][elixir docs] | +| ![R logo] | [**R**][R integration] | *no published package* | [Learn][r docs] | +| ![Postgres logo] | [**Postgres**][Postgres integration] | *no published package* | [Learn][postgres docs] | +| ![Swift logo] | [**Swift**][Swift integration] | *no published package* | | +| ![Zig logo] | [**Zig**][Zig integration] | *no published package* | | +| ![Dart logo] | [**Dart**][Dart integration] | [`wasm` pub package] | | +| ![Crystal logo] | [**Crystal**][Crystal integration] | *no published package* | [Learn][crystal docs] | +| ![Lisp logo] | [**Lisp**][Lisp integration] | *under heavy development - no published package* | | + +[👋  Missing a language?](https://github.com/wasmerio/wasmer/issues/new?assignees=&labels=%F0%9F%8E%89+enhancement&template=---feature-request.md&title=) + +[rust logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/rust.svg +[rust integration]: https://github.com/wasmerio/wasmer/tree/master/lib/api +[`wasmer` rust crate]: https://crates.io/crates/wasmer/ +[rust docs]: https://docs.rs/wasmer/ + +[c logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/c.svg +[c integration]: https://github.com/wasmerio/wasmer/tree/master/lib/c-api +[`wasmer.h` header]: https://github.com/wasmerio/wasmer/blob/master/lib/c-api/wasmer.h +[c docs]: https://docs.rs/wasmer-c-api/*/wasmer_c_api/wasm_c_api/index.html + +[c# logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/csharp.svg +[c# integration]: https://github.com/migueldeicaza/WasmerSharp +[`wasmersharp` nuget package]: https://www.nuget.org/packages/WasmerSharp/ +[c# docs]: https://migueldeicaza.github.io/WasmerSharp/ + +[d logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/d.svg +[d integration]: https://github.com/chances/wasmer-d +[`wasmer` Dub package]: https://code.dlang.org/packages/wasmer +[d docs]: https://chances.github.io/wasmer-d + +[python logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/python.svg +[python integration]: https://github.com/wasmerio/wasmer-python +[`wasmer` pypi package]: https://pypi.org/project/wasmer/ +[python docs]: https://wasmerio.github.io/wasmer-python/api/wasmer/ + +[go logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/go.svg +[go integration]: https://github.com/wasmerio/wasmer-go +[`wasmer` go package]: https://pkg.go.dev/github.com/wasmerio/wasmer-go/wasmer +[go docs]: https://pkg.go.dev/github.com/wasmerio/wasmer-go/wasmer?tab=doc + +[php logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/php.svg +[php integration]: https://github.com/wasmerio/wasmer-php +[`wasm` pecl package]: https://pecl.php.net/package/wasm +[php docs]: https://wasmerio.github.io/wasmer-php/ + +[js logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/js.svg +[js integration]: https://github.com/wasmerio/wasmer-js +[`@wasmerio` npm packages]: https://www.npmjs.com/org/wasmer +[js docs]: https://docs.wasmer.io/integrations/js/reference-api + +[ruby logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/ruby.svg +[ruby integration]: https://github.com/wasmerio/wasmer-ruby +[`wasmer` ruby gem]: https://rubygems.org/gems/wasmer +[ruby docs]: https://wasmerio.github.io/wasmer-ruby/wasmer_ruby/index.html + +[java logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/java.svg +[java integration]: https://github.com/wasmerio/wasmer-java +[`wasmer/wasmer-jni` bintray package]: https://bintray.com/wasmer/wasmer-jni/wasmer-jni +[java docs]: https://github.com/wasmerio/wasmer-java/#api-of-the-wasmer-library + +[elixir logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/elixir.svg +[elixir integration]: https://github.com/tessi/wasmex +[elixir docs]: https://hexdocs.pm/wasmex/api-reference.html +[`wasmex` hex package]: https://hex.pm/packages/wasmex + +[r logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/r.svg +[r integration]: https://github.com/dirkschumacher/wasmr +[r docs]: https://github.com/dirkschumacher/wasmr#example + +[postgres logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/postgres.svg +[postgres integration]: https://github.com/wasmerio/wasmer-postgres +[postgres docs]: https://github.com/wasmerio/wasmer-postgres#usage--documentation + +[swift logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/swift.svg +[swift integration]: https://github.com/AlwaysRightInstitute/SwiftyWasmer + +[zig logo]: https://raw.githubusercontent.com/ziglang/logo/master/zig-favicon.png +[zig integration]: https://github.com/zigwasm/wasmer-zig + +[dart logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/dart.svg +[dart integration]: https://github.com/dart-lang/wasm +[`wasm` pub package]: https://pub.dev/packages/wasm + +[lisp logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/lisp.svg +[lisp integration]: https://github.com/helmutkian/cl-wasm-runtime + +[crystal logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/crystal.svg +[crystal integration]: https://github.com/naqvis/wasmer-crystal +[crystal docs]: https://naqvis.github.io/wasmer-crystal/ + +## Contribute + +We appreciate your help! 💜 + +Check our docs on how to [build Wasmer from +source](https://docs.wasmer.io/ecosystem/wasmer/building-from-source) or [test your changes](https://docs.wasmer.io/ecosystem/wasmer/building-from-source/testing). + +## Community + +Wasmer has an amazing community of developers and contributors. Welcome, please join us! 👋 + +- [Wasmer Community Slack](https://slack.wasmer.io/) +- [Wasmer on Twitter](https://twitter.com/wasmerio) +- [Wasmer on Facebook](https://www.facebook.com/wasmerio) +- [Email](mailto:hello@wasmer.io) diff --git a/runtime/near-vm/SECURITY.md b/runtime/near-vm/SECURITY.md new file mode 100644 index 00000000000..6a1254a5867 --- /dev/null +++ b/runtime/near-vm/SECURITY.md @@ -0,0 +1,21 @@ +# Security Policy + +## Supported Versions + +The table below summarizes which versions are still supported, and which aren't. + +| Version | Supported | +|-|-| +| 0.x | ❌ | +| 1.x | ✅ | + +## Reporting a Vulnerability + +The Wasmer team and community take security bugs in Wasmer seriously. +We appreciate your efforts to responsibly disclose your findings, and will make every effort to acknowledge your contributions. + +To report a security issue, email security@wasmer.io or +hello@wasmer.io and include the word "SECURITY" in the subject line. + +The Wasmer team will send a response indicating the next steps in handling your report. +After the initial reply to your report, the security team will keep you informed of the progress towards a fix and full announcement, and may ask for additional information or guidance. diff --git a/runtime/near-vm/Xargo.toml b/runtime/near-vm/Xargo.toml new file mode 100644 index 00000000000..2b87983bcad --- /dev/null +++ b/runtime/near-vm/Xargo.toml @@ -0,0 +1,2 @@ +[dependencies] +std = {} diff --git a/runtime/near-vm/assets/README.md b/runtime/near-vm/assets/README.md new file mode 100644 index 00000000000..b32a94349e9 --- /dev/null +++ b/runtime/near-vm/assets/README.md @@ -0,0 +1,3 @@ +# Wasmer Documentation Assets + +This directory contains documentation assets. diff --git a/runtime/near-vm/assets/diagrams/Diagram_module_compilation.png b/runtime/near-vm/assets/diagrams/Diagram_module_compilation.png new file mode 100644 index 00000000000..5ed33a70dc1 Binary files /dev/null and b/runtime/near-vm/assets/diagrams/Diagram_module_compilation.png differ diff --git a/runtime/near-vm/assets/diagrams/Diagram_module_compilation.svg b/runtime/near-vm/assets/diagrams/Diagram_module_compilation.svg new file mode 100644 index 00000000000..f930d2063c5 --- /dev/null +++ b/runtime/near-vm/assets/diagrams/Diagram_module_compilation.svg @@ -0,0 +1 @@ +
wasmer::Module::new
wasmer::Module::new
Wasm bytes
Wasm bytes
wasmer::Module::compile
wasmer::Module::compile
wasmer_engine::Engine::compile
wasmer_engine::Engine::compile
wasmer::Module::validate
wasmer::Module::validate
wasmer_compiler::ModuleEnvironment::translate
wasmer_compiler::ModuleEnvironment::translate
wasmer_compiler::Compiler::compile_module
wasmer_compiler::Compiler::compile_module diff --git a/runtime/near-vm/assets/diagrams/Diagram_module_instantiation.png b/runtime/near-vm/assets/diagrams/Diagram_module_instantiation.png new file mode 100644 index 00000000000..69e01edd5d9 Binary files /dev/null and b/runtime/near-vm/assets/diagrams/Diagram_module_instantiation.png differ diff --git a/runtime/near-vm/assets/diagrams/Diagram_module_instantiation.svg b/runtime/near-vm/assets/diagrams/Diagram_module_instantiation.svg new file mode 100644 index 00000000000..a3d049d2d0e --- /dev/null +++ b/runtime/near-vm/assets/diagrams/Diagram_module_instantiation.svg @@ -0,0 +1 @@ +
wasmer::Instance::new
wasmer::Instance::new
wasmer::Module::instantiate
wasmer::Module::instantiate
wasmer_engine::Artifact::instantiate
wasmer_engine::Artifact::instantiate
wasmer_engine::resolver::resolve_imports
wasmer_engine::resolver::resolve_imports
wasmer_engine::Tunables::create_memories
wasmer_engine::Tunables::create_memories
wasmer_engine::Tunables::create_tables
wasmer_engine::Tunables::create_tables
wasmer_engine::Tunables::create_globals
wasmer_engine::Tunables::create_globals
wasmer_engine::Artifact::finish_instantiation
wasmer_engine::Artifact::finish_instantiation diff --git a/runtime/near-vm/assets/diagrams/Diagram_module_serialization.png b/runtime/near-vm/assets/diagrams/Diagram_module_serialization.png new file mode 100644 index 00000000000..cc83a827117 Binary files /dev/null and b/runtime/near-vm/assets/diagrams/Diagram_module_serialization.png differ diff --git a/runtime/near-vm/assets/diagrams/Diagram_module_serialization.svg b/runtime/near-vm/assets/diagrams/Diagram_module_serialization.svg new file mode 100644 index 00000000000..1ce98d3263f --- /dev/null +++ b/runtime/near-vm/assets/diagrams/Diagram_module_serialization.svg @@ -0,0 +1 @@ +
wasmer::Module::serialize
wasmer::Module::serialize
wasmer::Module::deserialize
wasmer::Module::deserialize
use a headless engine
for example
use a headless engine...
wasmer_engine::Artifact::serialize
wasmer_engine::Artifact::serialize
wasmer_engine::Artifact::deserialize
wasmer_engine::Artifact::deserialize diff --git a/runtime/near-vm/assets/languages/c.svg b/runtime/near-vm/assets/languages/c.svg new file mode 100644 index 00000000000..3d37c89c63e --- /dev/null +++ b/runtime/near-vm/assets/languages/c.svg @@ -0,0 +1 @@ + \ No newline at end of file diff --git a/runtime/near-vm/assets/languages/cpp.svg b/runtime/near-vm/assets/languages/cpp.svg new file mode 100644 index 00000000000..db14db4d98e --- /dev/null +++ b/runtime/near-vm/assets/languages/cpp.svg @@ -0,0 +1 @@ + \ No newline at end of file diff --git a/runtime/near-vm/assets/languages/crystal.svg b/runtime/near-vm/assets/languages/crystal.svg new file mode 100644 index 00000000000..29931929d3b --- /dev/null +++ b/runtime/near-vm/assets/languages/crystal.svg @@ -0,0 +1,16 @@ + + + + + + + + + + + diff --git a/runtime/near-vm/assets/languages/csharp.svg b/runtime/near-vm/assets/languages/csharp.svg new file mode 100644 index 00000000000..aeba5f7bb0f --- /dev/null +++ b/runtime/near-vm/assets/languages/csharp.svg @@ -0,0 +1 @@ + \ No newline at end of file diff --git a/runtime/near-vm/assets/languages/d.svg b/runtime/near-vm/assets/languages/d.svg new file mode 100644 index 00000000000..f19e305ae19 --- /dev/null +++ b/runtime/near-vm/assets/languages/d.svg @@ -0,0 +1 @@ + \ No newline at end of file diff --git a/runtime/near-vm/assets/languages/dart.svg b/runtime/near-vm/assets/languages/dart.svg new file mode 100644 index 00000000000..ab1636ff1fe --- /dev/null +++ b/runtime/near-vm/assets/languages/dart.svg @@ -0,0 +1 @@ + \ No newline at end of file diff --git a/runtime/near-vm/assets/languages/elixir.svg b/runtime/near-vm/assets/languages/elixir.svg new file mode 100644 index 00000000000..1976dfbc41c --- /dev/null +++ b/runtime/near-vm/assets/languages/elixir.svg @@ -0,0 +1 @@ + \ No newline at end of file diff --git a/runtime/near-vm/assets/languages/go.svg b/runtime/near-vm/assets/languages/go.svg new file mode 100644 index 00000000000..76f70ad36aa --- /dev/null +++ b/runtime/near-vm/assets/languages/go.svg @@ -0,0 +1 @@ + \ No newline at end of file diff --git a/runtime/near-vm/assets/languages/java.svg b/runtime/near-vm/assets/languages/java.svg new file mode 100644 index 00000000000..15083c7c7c4 --- /dev/null +++ b/runtime/near-vm/assets/languages/java.svg @@ -0,0 +1 @@ + \ No newline at end of file diff --git a/runtime/near-vm/assets/languages/js.svg b/runtime/near-vm/assets/languages/js.svg new file mode 100644 index 00000000000..39e20b39182 --- /dev/null +++ b/runtime/near-vm/assets/languages/js.svg @@ -0,0 +1 @@ + \ No newline at end of file diff --git a/runtime/near-vm/assets/languages/lisp.svg b/runtime/near-vm/assets/languages/lisp.svg new file mode 100644 index 00000000000..0d5875391b3 --- /dev/null +++ b/runtime/near-vm/assets/languages/lisp.svg @@ -0,0 +1,6 @@ + + + + + + diff --git a/runtime/near-vm/assets/languages/php.svg b/runtime/near-vm/assets/languages/php.svg new file mode 100644 index 00000000000..f88c8acad09 --- /dev/null +++ b/runtime/near-vm/assets/languages/php.svg @@ -0,0 +1 @@ + \ No newline at end of file diff --git a/runtime/near-vm/assets/languages/postgres.svg b/runtime/near-vm/assets/languages/postgres.svg new file mode 100644 index 00000000000..e7b5622414a --- /dev/null +++ b/runtime/near-vm/assets/languages/postgres.svg @@ -0,0 +1 @@ + \ No newline at end of file diff --git a/runtime/near-vm/assets/languages/python.svg b/runtime/near-vm/assets/languages/python.svg new file mode 100644 index 00000000000..3a223e73491 --- /dev/null +++ b/runtime/near-vm/assets/languages/python.svg @@ -0,0 +1 @@ + \ No newline at end of file diff --git a/runtime/near-vm/assets/languages/r.svg b/runtime/near-vm/assets/languages/r.svg new file mode 100644 index 00000000000..73ef6586b77 --- /dev/null +++ b/runtime/near-vm/assets/languages/r.svg @@ -0,0 +1 @@ + \ No newline at end of file diff --git a/runtime/near-vm/assets/languages/ruby.svg b/runtime/near-vm/assets/languages/ruby.svg new file mode 100644 index 00000000000..aad08a2ff3f --- /dev/null +++ b/runtime/near-vm/assets/languages/ruby.svg @@ -0,0 +1 @@ + \ No newline at end of file diff --git a/runtime/near-vm/assets/languages/rust.svg b/runtime/near-vm/assets/languages/rust.svg new file mode 100644 index 00000000000..c88b70bce24 --- /dev/null +++ b/runtime/near-vm/assets/languages/rust.svg @@ -0,0 +1 @@ + \ No newline at end of file diff --git a/runtime/near-vm/assets/languages/swift.svg b/runtime/near-vm/assets/languages/swift.svg new file mode 100644 index 00000000000..667824822bf --- /dev/null +++ b/runtime/near-vm/assets/languages/swift.svg @@ -0,0 +1 @@ + \ No newline at end of file diff --git a/runtime/near-vm/assets/logo.png b/runtime/near-vm/assets/logo.png new file mode 100644 index 00000000000..7537a2f7f2f Binary files /dev/null and b/runtime/near-vm/assets/logo.png differ diff --git a/runtime/near-vm/benches/README.md b/runtime/near-vm/benches/README.md new file mode 100644 index 00000000000..cb81186a4e7 --- /dev/null +++ b/runtime/near-vm/benches/README.md @@ -0,0 +1,4 @@ +# Wasmer Benches + +This directory contains small, punctual benches. Other benchmarks are +landing somewhere else. We will update this section soon. diff --git a/runtime/near-vm/benches/limits.rs b/runtime/near-vm/benches/limits.rs new file mode 100644 index 00000000000..a8d5d3099a9 --- /dev/null +++ b/runtime/near-vm/benches/limits.rs @@ -0,0 +1,173 @@ +use criterion::{black_box, criterion_group, criterion_main, BenchmarkId, Criterion}; +use wasmer::*; +use wasmer_engine_universal::UniversalExecutableRef; + +pub struct LargeContract { + pub functions: u32, + pub locals_per_function: u32, + pub panic_imports: u32, // How many times to import `env.panic` +} + +impl Default for LargeContract { + fn default() -> Self { + Self { + functions: 1, + locals_per_function: 0, + panic_imports: 0, + } + } +} + +impl LargeContract { + /// Construct a contract with many entitites. + /// + /// Currently supports constructing contracts that contain a specified number of functions with the + /// specified number of locals each. + /// + /// Exports a function called `main` that does nothing. + pub fn make(&self) -> Vec { + use wasm_encoder::{ + CodeSection, EntityType, Export, ExportSection, Function, FunctionSection, + ImportSection, Instruction, Module, TypeSection, ValType, + }; + + // Won't generate a valid WASM without functions. + assert!( + self.functions >= 1, + "must specify at least 1 function to be generated" + ); + let mut module = Module::new(); + let mut type_section = TypeSection::new(); + type_section.function([], []); + module.section(&type_section); + + if self.panic_imports != 0 { + let mut import_section = ImportSection::new(); + for _ in 0..self.panic_imports { + import_section.import("env", "panic", EntityType::Function(0)); + } + module.section(&import_section); + } + + let mut functions_section = FunctionSection::new(); + for _ in 0..self.functions { + functions_section.function(0); + } + module.section(&functions_section); + + let mut exports_section = ExportSection::new(); + exports_section.export("main", Export::Function(0)); + module.section(&exports_section); + + let mut code_section = CodeSection::new(); + for _ in 0..self.functions { + let mut f = Function::new([(self.locals_per_function, ValType::I64)]); + f.instruction(&Instruction::End); + code_section.function(&f); + } + module.section(&code_section); + + module.finish() + } +} + +fn many_functions(c: &mut Criterion) { + let mut group = c.benchmark_group("many_functions"); + for functions in [1, 10, 100, 1000, 10000] { + let wasm = LargeContract { + functions, + ..Default::default() + } + .make(); + let store = Store::new(&Universal::new(Singlepass::new()).engine()); + group.bench_function(BenchmarkId::new("compile+instantiate", functions), |b| { + b.iter(|| { + let module = Module::new(&store, &wasm).unwrap(); + let imports = imports! {}; + let _ = Instance::new(&module, &imports).unwrap(); + }) + }); + + let module = Module::new(&store, &wasm).unwrap(); + let imports = imports! {}; + let instance = Instance::new(&module, &imports).unwrap(); + group.bench_function(BenchmarkId::new("lookup_main", functions), |b| { + b.iter(|| { + let _: Function = instance.lookup_function("main").unwrap(); + }) + }); + + let main: Function = instance.lookup_function("main").unwrap(); + group.bench_function(BenchmarkId::new("call_main", functions), |b| { + b.iter(|| { + black_box(main.call(&[]).unwrap()); + }) + }); + + let wasm = wat::parse_bytes(wasm.as_ref()).unwrap(); + let executable = store.engine().compile(&wasm, store.tunables()).unwrap(); + group.bench_function(BenchmarkId::new("serialize", functions), |b| { + b.iter(|| { + black_box(executable.serialize().unwrap()); + }) + }); + + let serialized = executable.serialize().unwrap(); + group.bench_function(BenchmarkId::new("load", functions), |b| { + b.iter(|| unsafe { + let deserialized = UniversalExecutableRef::deserialize(&serialized).unwrap(); + black_box(store.engine().load(&deserialized).unwrap()); + }) + }); + } +} + +fn many_locals(c: &mut Criterion) { + let mut group = c.benchmark_group("many_locals"); + for (functions, locals_per_function) in [(10, 100), (100, 1000), (1000, 10000)] { + let wasm = LargeContract { + functions, + locals_per_function, + ..Default::default() + } + .make(); + let size = functions * locals_per_function; + let store = Store::new(&Universal::new(Singlepass::new()).engine()); + group.bench_function(BenchmarkId::new("compile+instantiate", size), |b| { + b.iter(|| { + let module = Module::new(&store, &wasm).unwrap(); + let imports = imports! {}; + let _ = Instance::new(&module, &imports).unwrap(); + }) + }); + + let wasm = wat::parse_bytes(wasm.as_ref()).unwrap(); + let executable = store.engine().compile(&wasm, store.tunables()).unwrap(); + group.bench_function(BenchmarkId::new("serialize", size), |b| { + b.iter(|| { + black_box(executable.serialize().unwrap()); + }) + }); + + let serialized = executable.serialize().unwrap(); + group.bench_function(BenchmarkId::new("load", size), |b| { + b.iter(|| unsafe { + let deserialized = UniversalExecutableRef::deserialize(&serialized).unwrap(); + black_box(store.engine().load(&deserialized).unwrap()); + }) + }); + } +} + +criterion_group! { + name = functions; + config = Criterion::default(); + targets = many_functions +} +criterion_group! { + name = locals; + config = Criterion::default(); + targets = many_locals +} + +criterion_main!(functions, locals); diff --git a/runtime/near-vm/benches/static_and_dynamic_functions.rs b/runtime/near-vm/benches/static_and_dynamic_functions.rs new file mode 100644 index 00000000000..0db18069d67 --- /dev/null +++ b/runtime/near-vm/benches/static_and_dynamic_functions.rs @@ -0,0 +1,169 @@ +use criterion::{black_box, criterion_group, criterion_main, Criterion}; + +use wasmer::*; + +static BASIC_WAT: &str = r#"(module + (func $multiply (import "env" "multiply") (param i32 i32) (result i32)) + (func (export "add") (param i32 i32) (result i32) + (i32.add (local.get 0) + (local.get 1))) + (func (export "add20") (param i32 i32 i32 i32 i32 + i32 i32 i32 i32 i32 + i32 i32 i32 i32 i32 + i32 i32 i32 i32 i32) (result i32) + (i32.add + (i32.add + (i32.add (i32.add (i32.add (local.get 0) (local.get 1)) + (i32.add (local.get 2) (local.get 3))) + (i32.add (i32.add (local.get 4) (local.get 5)) + (i32.add (local.get 6) (local.get 7)))) + (i32.add + (i32.add (i32.add (local.get 8) (local.get 9)) + (i32.add (local.get 10) (local.get 11))) + (i32.add (i32.add (local.get 12) (local.get 13)) + (i32.add (local.get 14) (local.get 15))))) + + (i32.add (i32.add (local.get 16) (local.get 17)) + (i32.add (local.get 18) (local.get 19)))) +) + (func (export "double_then_add") (param i32 i32) (result i32) + (i32.add (call $multiply (local.get 0) (i32.const 2)) + (call $multiply (local.get 1) (i32.const 2)))) +)"#; + +pub fn run_basic_static_function(store: &Store, compiler_name: &str, c: &mut Criterion) { + let module = Module::new(&store, BASIC_WAT).unwrap(); + let import_object = imports! { + "env" => { + "multiply" => Function::new_native(&store, |a: i32, b: i32| a * b), + }, + }; + let instance = Instance::new(&module, &import_object).unwrap(); + let dyn_f = instance.lookup_function("add").unwrap(); + let f: NativeFunc<(i32, i32), i32> = dyn_f.native().unwrap(); + + c.bench_function(&format!("basic static func {}", compiler_name), |b| { + b.iter(|| { + let result = black_box(f.call(4, 6).unwrap()); + assert_eq!(result, 10); + }) + }); + + let dyn_f_many = instance.lookup_function("add20").unwrap(); + let f_many: NativeFunc< + ( + i32, + i32, + i32, + i32, + i32, + i32, + i32, + i32, + i32, + i32, + i32, + i32, + i32, + i32, + i32, + i32, + i32, + i32, + i32, + i32, + ), + i32, + > = dyn_f_many.native().unwrap(); + c.bench_function( + &format!("basic static func with many args {}", compiler_name), + |b| { + b.iter(|| { + let result = black_box( + f_many + .call( + 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, + ) + .unwrap(), + ); + assert_eq!(result, 210); + }) + }, + ); +} + +pub fn run_basic_dynamic_function(store: &Store, compiler_name: &str, c: &mut Criterion) { + let module = Module::new(&store, BASIC_WAT).unwrap(); + let import_object = imports! { + "env" => { + "multiply" => Function::new_native(&store, |a: i32, b: i32| a * b), + }, + }; + let instance = Instance::new(&module, &import_object).unwrap(); + + let dyn_f = instance.lookup_function("add").unwrap(); + c.bench_function(&format!("basic dynfunc {}", compiler_name), |b| { + b.iter(|| { + let dyn_result = black_box(dyn_f.call(&[Val::I32(4), Val::I32(6)]).unwrap()); + assert_eq!(dyn_result[0], Val::I32(10)); + }) + }); + + let dyn_f_many = instance.lookup_function("add20").unwrap(); + c.bench_function( + &format!("basic dynfunc with many args {}", compiler_name), + |b| { + b.iter(|| { + let dyn_result = black_box( + dyn_f_many + .call(&[ + Val::I32(1), + Val::I32(2), + Val::I32(3), + Val::I32(4), + Val::I32(5), + Val::I32(6), + Val::I32(7), + Val::I32(8), + Val::I32(9), + Val::I32(10), + Val::I32(11), + Val::I32(12), + Val::I32(13), + Val::I32(14), + Val::I32(15), + Val::I32(16), + Val::I32(17), + Val::I32(18), + Val::I32(19), + Val::I32(20), + ]) + .unwrap(), + ); + assert_eq!(dyn_result[0], Val::I32(210)); + }) + }, + ); +} + +fn run_static_benchmarks(_c: &mut Criterion) { + #[cfg(feature = "singlepass")] + { + let store = + Store::new(&Universal::new(wasmer_compiler_singlepass::Singlepass::new()).engine()); + run_basic_static_function(&store, "singlepass", _c); + } +} + +fn run_dynamic_benchmarks(_c: &mut Criterion) { + #[cfg(feature = "singlepass")] + { + let store = + Store::new(&Universal::new(wasmer_compiler_singlepass::Singlepass::new()).engine()); + run_basic_dynamic_function(&store, "singlepass", _c); + } +} + +criterion_group!(benches, run_static_benchmarks, run_dynamic_benchmarks); + +criterion_main!(benches); diff --git a/runtime/near-vm/bors.toml b/runtime/near-vm/bors.toml new file mode 100644 index 00000000000..3a3413de37f --- /dev/null +++ b/runtime/near-vm/bors.toml @@ -0,0 +1,14 @@ +status = [ + "Audit", + "Code lint", + "Test on linux-x64", + # "Test on linux-musl-x64", + # "Test on linux-aarch64", + "Test on macos-x64", + "Test on windows-x64", + "Test cross-compile on linux", + "Test cross-compile on macos", +] +required_approvals = 1 +timeout_sec = 7200 +delete_merged_branches = true diff --git a/runtime/near-vm/build.rs b/runtime/near-vm/build.rs new file mode 100644 index 00000000000..66c272b2cad --- /dev/null +++ b/runtime/near-vm/build.rs @@ -0,0 +1,57 @@ +//! The logic that gets executed before building the binary and tests. +//! We use it to auto-generate the Wasm spectests for each of the +//! available compilers. +//! +//! Please try to keep this file as clean as possible. + +use std::env; +use std::fs; +use std::path::PathBuf; +use std::process::Command; +use test_generator::{ + test_directory, test_directory_module, wast_processor, with_test_module, Testsuite, +}; + +fn main() -> anyhow::Result<()> { + // As rerun-if-changed doesn't support globs, we use another crate + // to check changes in directories. + + let out_dir = PathBuf::from( + env::var_os("OUT_DIR").expect("The OUT_DIR environment variable must be set"), + ); + + // Spectests test generation + { + let mut spectests = Testsuite { + buffer: String::new(), + path: vec![], + }; + + with_test_module(&mut spectests, "spec", |spectests| { + let _spec_tests = test_directory(spectests, "tests/wast/spec", wast_processor)?; + test_directory_module( + spectests, + "tests/wast/spec/proposals/multi-value", + wast_processor, + )?; + test_directory_module(spectests, "tests/wast/spec/proposals/simd", wast_processor)?; + // test_directory_module(spectests, "tests/wast/spec/proposals/bulk-memory-operations", wast_processor)?; + Ok(()) + })?; + with_test_module(&mut spectests, "wasmer", |spectests| { + let _spec_tests = test_directory(spectests, "tests/wast/wasmer", wast_processor)?; + Ok(()) + })?; + + let spectests_output = out_dir.join("generated_spectests.rs"); + fs::write(&spectests_output, spectests.buffer)?; + + // Write out our auto-generated tests and opportunistically format them with + // `rustfmt` if it's installed. + // Note: We need drop because we don't want to run `unwrap` or `expect` as + // the command might fail, but we don't care about it's result. + drop(Command::new("rustfmt").arg(&spectests_output).status()); + } + + Ok(()) +} diff --git a/runtime/near-vm/deny.toml b/runtime/near-vm/deny.toml new file mode 100644 index 00000000000..d03aaabff3f --- /dev/null +++ b/runtime/near-vm/deny.toml @@ -0,0 +1,43 @@ +targets = [] + +[advisories] +db-path = "~/.cargo/advisory-db" +db-urls = ["https://github.com/rustsec/advisory-db"] +vulnerability = "deny" +unmaintained = "warn" +yanked = "deny" +notice = "warn" +ignore = [] + +[licenses] +unlicensed = "deny" +allow = ["MIT", "Apache-2.0", "Apache-2.0 WITH LLVM-exception"] +deny = ["AGPL-1.0", "AGPL-3.0",] +copyleft = "warn" +allow-osi-fsf-free = "either" +default = "deny" +confidence-threshold = 0.8 +exceptions = [] + +[licenses.private] +ignore = false +registries = [] + +[bans] +multiple-versions = "deny" +wildcards = "allow" +highlight = "all" +allow = [] +deny = [] +skip = [ + { name = "ahash", version = "=0.4.7" }, + { name = "hashbrown", version = "=0.9.1" }, + { name = "gimli", version = "=0.25.0" }, + { name = "semver", version = "=0.11.0" }, +] + +[sources] +unknown-registry = "deny" +unknown-git = "deny" +allow-registry = ["https://github.com/rust-lang/crates.io-index"] +allow-git = [] diff --git a/runtime/near-vm/docs/README.md b/runtime/near-vm/docs/README.md new file mode 100644 index 00000000000..7d397daffcb --- /dev/null +++ b/runtime/near-vm/docs/README.md @@ -0,0 +1,24 @@ +# Wasmer Documentation + +Wasmer provides multiple documentations. Here are some pointers: + +* [The Wasmer runtime + `README.md`](https://github.com/wasmerio/wasmer/blob/master/README.md) + is a good start for the first steps, like installations, first runs etc., +* [The public documentation](https://docs.wasmer.io/) contains all the + documentation you need to learn about Wasmer and WebAssembly, +* [The Rust crates documentations](https://wasmerio.github.io/wasmer/) + contain all the documentations to use the `wasmer-*` Rust crates, + with many examples, +* [The collection of + examples](https://github.com/wasmerio/wasmer/blob/master/examples/README.md) + illustrates how to use Wasmer and its numerous features through very + commented examples, +* [Documentations for all embeddings/language + integrations](https://github.com/wasmerio/wasmer/blob/master/README.md): + the Wasmer runtime can be embeddeded in various languages or + environments, each embedding provides its own documentation, book + etc., +* [OS distro packaging + notes](https://github.com/wasmerio/wasmer/blob/master/PACKAGING.md) + contains notes about how to package Wasmer for OS distributions. diff --git a/runtime/near-vm/docs/cn/README.md b/runtime/near-vm/docs/cn/README.md new file mode 100644 index 00000000000..f26114a9ee6 --- /dev/null +++ b/runtime/near-vm/docs/cn/README.md @@ -0,0 +1,195 @@ +
+ + Wasmer logo + + +

+ + Build Status + + + License + + + Slack channel + +

+ +

+ 网站 + • + 文档 + • + 聊天 +

+ +
+ +
+ +[Wasmer](https://wasmer.io/) 提供基于 [WebAssembly](https://webassembly.org/) 的超轻量级容器，其可以在任何地方运行：从桌面到云、以及 IoT 设备，并且能也嵌入在 [*任何编程语言*](https://github.com/wasmerio/wasmer#language-integrations). + +> 其他语言的 Readme: [🇩🇪 Deutsch-德語](https://github.com/wasmerio/wasmer/blob/master/docs/de/README.md) • [🇬🇧 English-英文](https://github.com/wasmerio/wasmer/blob/master/README.md) • [🇪🇸 Español-西班牙语](https://github.com/wasmerio/wasmer/blob/master/docs/es/README.md) • [🇫🇷 Français-法语](https://github.com/wasmerio/wasmer/blob/master/docs/fr/README.md) • [🇯🇵 日本語-日文](https://github.com/wasmerio/wasmer/blob/master/docs/ja/README.md). + +## 特性 + +* **快速又安全**. Wasmer在完全沙盒化的环境中以“接近本机”的速度运行 WebAssembly。 + +* **可插拔**. Wasmer 可以根据你的需求支持不同的编译框架 (LLVM，Cranelift ...). + +* **通用的**. 你可以在**任何平台**(macOS, Linux and Windows) 和芯片组运行 Wasmer. + +* **符合标准**. 运行时通过了[官方WebAssembly测试集](https://github.com/WebAssembly/testsuite) 支持[WASI](https://github.com/WebAssembly/WASI) 和[Emscripten](https://emscripten.org/). + +## 快速开始 + +Wasmer 不需要安装其他依赖. 你可以使用以下安装程序进行安装: + +```sh +curl https://get.wasmer.io -sSfL | sh +``` + +
+ 使用Powershell (Windows) +

+ +```powershell +iwr https://win.wasmer.io -useb | iex +``` + +

+
+ +> 有关更多安装选项，请参见 [wasmer-install](https://github.com/wasmerio/wasmer-install): Homebrew, Scoop, Cargo... + + +#### 执行WebAssembly文件 + +安装Wasmer之后，你已经准备好执行第一个WebAssemby文件了! 🎉 + +您可以通过运行 QuickJS 开始: [qjs.wasm](https://registry-cdn.wapm.io/contents/_/quickjs/0.0.3/build/qjs.wasm) + +```bash +$ wasmer qjs.wasm +QuickJS - Type "\h" for help +qjs > +``` + +#### 接下来是你可以做的: + +- [在你的Rust应用程序中使用Wasmer](https://docs.wasmer.io/integrations/rust) +- [在WAPM上发布Wasm程序包](https://docs.wasmer.io/ecosystem/wapm/publishing-your-package) +- [阅读有关Wasmer的更多信息](https://medium.com/wasmer/) + +## 语言整合 + +📦 Wasmer 运行时能以库的形式**嵌入到不同的语言**，因此你可以在任何地方使用WebAssembly. + +|   | 语言 | 程序包 | 文档 | +|-|-|-|-| +| ![Rust logo] | [**Rust**][Rust integration] | [`wasmer` Rust crate] | [文档][rust docs] +| ![C logo] | [**C/C++**][C integration] | [`wasmer.h` headers] | [文档][c docs] | +| ![C# logo] | [**C#**][C# integration] | [`WasmerSharp` NuGet package] | [文档][c# docs] | +| ![D logo] | [**D**][D integration] | [`wasmer` Dub package] | [文档][d docs] | +| ![Python logo] | [**Python**][Python integration] | [`wasmer` PyPI package] | [文档][python docs] | +| ![JS logo] | [**Javascript**][JS integration] | [`@wasmerio` NPM packages] | [文档][js docs] | +| ![Go logo] | [**Go**][Go integration] | [`wasmer` Go package] | [文档][go docs] | +| ![PHP logo] | [**PHP**][PHP integration] | [`wasm` PECL package] | [文档][php docs] | +| ![Ruby logo] | [**Ruby**][Ruby integration] | [`wasmer` Ruby Gem] | [文档][ruby docs] | +| ![Java logo] | [**Java**][Java integration] | [`wasmer/wasmer-jni` Bintray package] | [文档][java docs] | +| ![Elixir logo] | [**Elixir**][Elixir integration] | [`wasmex` hex package] | [文档][elixir docs] | +| ![R logo] | [**R**][R integration] | *没有已发布的软件包* | [文档][r docs] | +| ![Postgres logo] | [**Postgres**][Postgres integration] | *没有已发布的软件包* | [文档][postgres docs] | +| | [**Swift**][Swift integration] | *没有已发布的软件包* | | +| ![Zig logo] | [**Zig**][Zig integration] | *no published package* | | + +[👋 缺少语言？](https://github.com/wasmerio/wasmer/issues/new?assignees=&labels=%F0%9F%8E%89+enhancement&template=---feature-request.md&title=) + +[rust logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/rust.svg +[rust integration]: https://github.com/wasmerio/wasmer/tree/master/lib/api +[`wasmer` rust crate]: https://crates.io/crates/wasmer/ +[rust docs]: https://wasmerio.github.io/wasmer/crates/wasmer + +[c logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/c.svg +[c integration]: https://github.com/wasmerio/wasmer/tree/master/lib/c-api +[`wasmer.h` headers]: https://wasmerio.github.io/wasmer/c/ +[c docs]: https://wasmerio.github.io/wasmer/c/ + +[c# logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/csharp.svg +[c# integration]: https://github.com/migueldeicaza/WasmerSharp +[`wasmersharp` nuget package]: https://www.nuget.org/packages/WasmerSharp/ +[c# docs]: https://migueldeicaza.github.io/WasmerSharp/ + +[d logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/d.svg +[d integration]: https://github.com/chances/wasmer-d +[`wasmer` Dub package]: https://code.dlang.org/packages/wasmer +[d docs]: https://chances.github.io/wasmer-d + +[python logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/python.svg +[python integration]: https://github.com/wasmerio/wasmer-python +[`wasmer` pypi package]: https://pypi.org/project/wasmer/ +[python docs]: https://github.com/wasmerio/wasmer-python#api-of-the-wasmer-extensionmodule + +[go logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/go.svg +[go integration]: https://github.com/wasmerio/wasmer-go +[`wasmer` go package]: https://pkg.go.dev/github.com/wasmerio/wasmer-go/wasmer +[go docs]: https://pkg.go.dev/github.com/wasmerio/wasmer-go/wasmer?tab=doc + +[php logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/php.svg +[php integration]: https://github.com/wasmerio/wasmer-php +[`wasm` pecl package]: https://pecl.php.net/package/wasm +[php docs]: https://wasmerio.github.io/wasmer-php/wasm/ + +[js logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/js.svg +[js integration]: https://github.com/wasmerio/wasmer-js +[`@wasmerio` npm packages]: https://www.npmjs.com/org/wasmer +[js docs]: https://docs.wasmer.io/integrations/js/reference-api + +[ruby logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/ruby.svg +[ruby integration]: https://github.com/wasmerio/wasmer-ruby +[`wasmer` ruby gem]: https://rubygems.org/gems/wasmer +[ruby docs]: https://www.rubydoc.info/gems/wasmer/ + +[java logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/java.svg +[java integration]: https://github.com/wasmerio/wasmer-java +[`wasmer/wasmer-jni` bintray package]: https://bintray.com/wasmer/wasmer-jni/wasmer-jni +[java docs]: https://github.com/wasmerio/wasmer-java/#api-of-the-wasmer-library + +[elixir logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/elixir.svg +[elixir integration]: https://github.com/tessi/wasmex +[elixir docs]: https://hexdocs.pm/wasmex/api-reference.html +[`wasmex` hex package]: https://hex.pm/packages/wasmex + +[r logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/r.svg +[r integration]: https://github.com/dirkschumacher/wasmr +[r docs]: https://github.com/dirkschumacher/wasmr#example + +[postgres logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/postgres.svg +[postgres integration]: https://github.com/wasmerio/wasmer-postgres +[postgres docs]: https://github.com/wasmerio/wasmer-postgres#usage--documentation + +[swift integration]: https://github.com/AlwaysRightInstitute/SwiftyWasmer + +[zig logo]: https://raw.githubusercontent.com/ziglang/logo/master/zig-favicon.png +[zig integration]: https://github.com/zigwasm/wasmer-zig + +## 贡献 + +**我们欢迎任何形式的贡献，尤其是来自社区新成员的贡献** 💜 + +你可以在[我们的出色文档](https://docs.wasmer.io/ecosystem/wasmer/building-from-source) 中学习如何构建 Wasmer 运行时! + +### 测试 + +想要测试吗? [参考 Wasmer 文档](https://docs.wasmer.io/ecosystem/wasmer/building-from-source/testing). + +## 社区 + +Wasmer 拥有一个由出色的开发人员和贡献者组成的社区。 欢迎你，请加入我们! 👋 + +### 频道 + +- [Slack](https://slack.wasmer.io/) +- [Twitter](https://twitter.com/wasmerio) +- [Facebook](https://www.facebook.com/wasmerio) +- [Email](mailto:hello@wasmer.io) diff --git a/runtime/near-vm/docs/de/README.md b/runtime/near-vm/docs/de/README.md new file mode 100644 index 00000000000..16d7ac4f65f --- /dev/null +++ b/runtime/near-vm/docs/de/README.md @@ -0,0 +1,225 @@ + + +
+ +Wasmer ist eine _schnelle_ und _sichere_ [**WebAssembly**](https://webassembly.org) Runtime, die das Ausführen von +_schlanken Containern_ überall ermöglicht: auf dem *Desktop* in der *Cloud*, so wie auf *Edge* und *IoT* Geräten. + +> _Die README ist auch in folgenden Sprachen verfügbar: +[🇨🇳 中文-Chinesisch](https://github.com/wasmerio/wasmer/blob/master/docs/cn/README.md) • +[🇬🇧 English-Englisch](https://github.com/wasmerio/wasmer/blob/master/README.md) • +[🇪🇸 Español-Spanisch](https://github.com/wasmerio/wasmer/blob/master/docs/es/README.md) • +[🇫🇷 Français-Französisch](https://github.com/wasmerio/wasmer/blob/master/docs/fr/README.md) • +[🇯🇵 日本語-Japanisch](https://github.com/wasmerio/wasmer/blob/master/docs/ja/README.md)_. + +### Leistungsmerkmale + +* Standardmäßig sicher. Kein Datei-, Netzwerk- oder Umgebungszugriff, sofern nicht explizit aktiviert. +* Unterstützt [WASI](https://github.com/WebAssembly/WASI) und [Emscripten](https://emscripten.org/) standardmäßig. +* Schnell. Führt WebAssembly in nahezu nativer Geschwindigkeit aus. +* Einbettbar in [mehrere Programmiersprachen](https://github.com/wasmerio/wasmer/#-language-integrations) +* Kompatibel mit den neuesten Empfehlungen für WebAssembly (SIMD, Referenztypen, Threads, ...) + +### Installation + +Wasmer CLI wird als eine einzige ausführbare Datei ohne Abhängigkeiten ausgeliefert. + +```sh +curl https://get.wasmer.io -sSfL | sh +``` + + +
+ Weitere Installationsmöglichkeiten (Powershell, Brew, Cargo, ...) + + _Wasmer kann über verschiedene Paketmanager installiert werden. Wählen Sie den für Ihre Umgebung am besten geeigneten aus:_ + + * Powershell (Windows) + ```powershell + iwr https://win.wasmer.io -useb | iex + ``` + + * Homebrew (macOS, Linux) + + ```sh + brew install wasmer + ``` + + * Scoop (Windows) + + ```sh + scoop install wasmer + ``` + + * Chocolatey (Windows) + + ```sh + choco install wasmer + ``` + + * Cargo + + _Note: All the available + features are described in the [`wasmer-cli` + crate docs](https://github.com/wasmerio/wasmer/tree/master/lib/cli/README.md)_ + + ```sh + cargo install wasmer-cli + ``` + + > Suchen Sie nach weiteren Installationsmöglichkeiten? Im [`wasmer-install` + Repository](https://github.com/wasmerio/wasmer-install) können Si mehr erfahren! +
+ +### Schnellstart + +Sie können beginnen, +[QuickJS](https://github.com/bellard/quickjs/) auszuführen, eine kleine und +einbettbare Javascript Engine, die als WebAssembly Modul kompiliert ist: ([`qjs.wasm`](https://registry-cdn.wapm.io/contents/_/quickjs/0.0.3/build/qjs.wasm)): + +```bash +$ wasmer qjs.wasm +QuickJS - Type "\h" for help +qjs > const i = 1 + 2; +qjs > console.log("hello " + i); +hello 3 +``` + +#### Folgendes können Sie als nächstes tun: + +- [Wasmer für eine Rust Anwendung nutzen](https://docs.wasmer.io/integrations/rust) +- [Ein asm Paket auf WAPM veröffentlichen](https://docs.wasmer.io/ecosystem/wapm/publishing-your-package) +- [Mehr zu Wasmer lesen](https://medium.com/wasmer/) + +## 📦 Unterstützte Sprachen + +Die Wasmer-Laufzeit kann als Bibliothek **eingebettet in verschiedenen +Sprachen** verwendet werden, so dass Sie WebAssembly _überall_ einsetzen können. + +| | Sprache | Paket | Dokumentation | +|-|-|-|-| +| ![Rust logo] | [**Rust**][Rust Integration] | [`wasmer` Rust crate] | [Lernen][rust docs] +| ![C logo] | [**C/C++**][C Integration] | [`wasmer.h` header] | [Lernen][c docs] | +| ![C# logo] | [**C#**][C# Integration] | [`WasmerSharp` NuGet Paket] | [Lernen][c# docs] | +| ![D logo] | [**D**][D Integration] | [`wasmer` Dub Paket] | [Lernen][d docs] | +| ![Python logo] | [**Python**][Python Integration] | [`wasmer` PyPI Paket] | [Lernen][python docs] | +| ![JS logo] | [**Javascript**][JS Integration] | [`@wasmerio` NPM Paket] | [Lernen][js docs] | +| ![Go logo] | [**Go**][Go Integration] | [`wasmer` Go Paket] | [Lernen][go docs] | +| ![PHP logo] | [**PHP**][PHP Integration] | [`wasm` PECL Paket] | [Lernen][php docs] | +| ![Ruby logo] | [**Ruby**][Ruby Integration] | [`wasmer` Ruby Gem] | [Lernen][ruby docs] | +| ![Java logo] | [**Java**][Java Integration] | [`wasmer/wasmer-jni` Bintray Paket] | [Lernen][java docs] | +| ![Elixir logo] | [**Elixir**][Elixir Integration] | [`wasmex` hex Paket] | [Lernen][elixir docs] | +| ![R logo] | [**R**][R Integration] | *kein Paket veröffentlicht* | [Lernen][r docs] | +| ![Postgres logo] | [**Postgres**][Postgres Integration] | *kein Paket veröffentlicht* | [Lernen][postgres docs] | +| | [**Swift**][Swift Integration] | *kein Paket veröffentlicht* | | +| ![Zig logo] | [**Zig**][Zig Integration] | *kein Paket veröffentlicht* | | +| ![Dart logo] | [**Dart**][Dart Integration] | [`wasm` pub Paket] | | + +[👋  Fehlt eine Sprache?](https://github.com/wasmerio/wasmer/issues/new?assignees=&labels=%F0%9F%8E%89+enhancement&template=---feature-request.md&title=) + +[rust logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/rust.svg +[rust integration]: https://github.com/wasmerio/wasmer/tree/master/lib/api +[`wasmer` rust crate]: https://crates.io/crates/wasmer/ +[rust docs]: https://wasmerio.github.io/wasmer/crates/wasmer + +[c logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/c.svg +[c integration]: https://github.com/wasmerio/wasmer/tree/master/lib/c-api +[`wasmer.h` header]: https://github.com/wasmerio/wasmer/blob/master/lib/c-api/wasmer.h +[c docs]: https://wasmerio.github.io/wasmer/crates/wasmer_c_api + +[c# logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/csharp.svg +[c# integration]: https://github.com/migueldeicaza/WasmerSharp +[`wasmersharp` nuget package]: https://www.nuget.org/packages/WasmerSharp/ +[c# docs]: https://migueldeicaza.github.io/WasmerSharp/ + +[d logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/d.svg +[d integration]: https://github.com/chances/wasmer-d +[`wasmer` Dub package]: https://code.dlang.org/packages/wasmer +[d docs]: https://chances.github.io/wasmer-d + +[python logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/python.svg +[python integration]: https://github.com/wasmerio/wasmer-python +[`wasmer` pypi package]: https://pypi.org/project/wasmer/ +[python docs]: https://wasmerio.github.io/wasmer-python/api/wasmer/ + +[go logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/go.svg +[go integration]: https://github.com/wasmerio/wasmer-go +[`wasmer` go package]: https://pkg.go.dev/github.com/wasmerio/wasmer-go/wasmer +[go docs]: https://pkg.go.dev/github.com/wasmerio/wasmer-go/wasmer?tab=doc + +[php logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/php.svg +[php integration]: https://github.com/wasmerio/wasmer-php +[`wasm` pecl package]: https://pecl.php.net/package/wasm +[php docs]: https://wasmerio.github.io/wasmer-php/wasm/ + +[js logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/js.svg +[js integration]: https://github.com/wasmerio/wasmer-js +[`@wasmerio` npm packages]: https://www.npmjs.com/org/wasmer +[js docs]: https://docs.wasmer.io/integrations/js/reference-api + +[ruby logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/ruby.svg +[ruby integration]: https://github.com/wasmerio/wasmer-ruby +[`wasmer` ruby gem]: https://rubygems.org/gems/wasmer +[ruby docs]: https://wasmerio.github.io/wasmer-ruby/wasmer_ruby/index.html + +[java logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/java.svg +[java integration]: https://github.com/wasmerio/wasmer-java +[`wasmer/wasmer-jni` bintray package]: https://bintray.com/wasmer/wasmer-jni/wasmer-jni +[java docs]: https://github.com/wasmerio/wasmer-java/#api-of-the-wasmer-library + +[elixir logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/elixir.svg +[elixir integration]: https://github.com/tessi/wasmex +[elixir docs]: https://hexdocs.pm/wasmex/api-reference.html +[`wasmex` hex package]: https://hex.pm/packages/wasmex + +[r logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/r.svg +[r integration]: https://github.com/dirkschumacher/wasmr +[r docs]: https://github.com/dirkschumacher/wasmr#example + +[postgres logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/postgres.svg +[postgres integration]: https://github.com/wasmerio/wasmer-postgres +[postgres docs]: https://github.com/wasmerio/wasmer-postgres#usage--documentation + +[swift integration]: https://github.com/AlwaysRightInstitute/SwiftyWasmer + +[zig logo]: https://raw.githubusercontent.com/ziglang/logo/master/zig-favicon.png +[zig integration]: https://github.com/zigwasm/wasmer-zig + +[dart logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/dart.svg +[dart integration]: https://github.com/dart-lang/wasm +[`wasm` pub package]: https://pub.dev/packages/wasm + +## Unterstützen + +Wir sind dankbar für Ihre Hilfe! 💜 + +Lesen Sie in unserer Dokumentation nach, wie man [Wasmer aus dem +Quellcode kompiliert](https://docs.wasmer.io/ecosystem/wasmer/building-from-source) oder [testen Sie Änderungen](https://docs.wasmer.io/ecosystem/wasmer/building-from-source/testing). + +## Community + +Wasmer hat eine wunderbare Community von Entwicklern und Mitwirkenden. Sie sind herzlich willkommen, bitte machen Sie mit! 👋 + +- [Wasmer Community auf Slack](https://slack.wasmer.io/) +- [Wasmer auf Twitter](https://twitter.com/wasmerio) +- [Wasmer auf Facebook](https://www.facebook.com/wasmerio) +- [Email](mailto:hello@wasmer.io) diff --git a/runtime/near-vm/docs/deps_dedup.dot b/runtime/near-vm/docs/deps_dedup.dot new file mode 100644 index 00000000000..c9d98a470e3 --- /dev/null +++ b/runtime/near-vm/docs/deps_dedup.dot @@ -0,0 +1,74 @@ +digraph dependencies { + newrank=true; + + n0 [label="wasmer", color=orange]; + n1 [label="wasmer-compiler", color=orange]; + n5 [label="wasmer-engine", color=orange]; + n6 [label="wasmer-engine-universal", color=orange]; + n7 [label="wasmer-engine-dylib", color=orange]; + n8 [label="wasmer-types", color=orange]; + n9 [label="wasmer-vm", color=orange]; + n10 [label="wasmer-c-api", color=orange]; + n11 [label="wasmer-emscripten", color=orange]; + n12 [label="wasmer-wasi", color=orange]; + n13 [label="wasmer-cache", color=orange]; + n14 [label="wasmer-cli", color=orange]; + + + subgraph cluster_compiler { + label="Compilers"; + color=brown; + + n2 [label="wasmer-compiler-cranelift", color=orange]; + n3 [label="wasmer-compiler-llvm", color=orange]; + n4 [label="wasmer-compiler-singlepass", color=orange]; + } + + subgraph cluster_engine { + label="Engines"; + color=brown; + + n6 [label="wasmer-engine-universal", color=orange]; + n7 [label="wasmer-engine-dylib", color=orange]; + } + + { + rank=same; + n2; + n3; + n4; + n6; + n7; + } + + + subgraph cluster_abi { + label="Provided ABIs"; + color=brown; + + n12 [label="wasmer-wasi", color=orange]; + n11 [label="wasmer-emscripten", color=orange]; + } + + n14 -> n13 [color=orange, style=dashed]; + n14 -> n12 [color=orange, style=dashed]; + n14 -> n11 [color=orange, style=dashed]; + n13 -> n0 [color=orange, style=dashed]; + n10 -> n11 [color=orange, style=dashed]; + n10 -> n12 [color=orange, style=dashed]; + n11 -> n0 [color=orange, style=dashed]; + n12 -> n0 [color=orange, style=dashed]; + n0 -> n2 [color=orange, style=dashed]; + n0 -> n3 [color=orange, style=dashed]; + n0 -> n4 [color=orange, style=dashed]; + n0 -> n6 [color=orange, style=dashed]; + n0 -> n7 [color=orange, style=dashed]; + n2 -> n1 [color=orange, style=dashed]; + n3 -> n1 [color=orange, style=dashed]; + n4 -> n1 [color=orange, style=dashed]; + n6 -> n5 [color=orange, style=dashed]; + n7 -> n5 [color=orange, style=dashed]; + n5 -> n1 [color=orange, style=dashed]; + n1 -> n9 [color=orange, style=dashed]; + n9 -> n8 [color=orange, style=dashed]; +} diff --git a/runtime/near-vm/docs/deps_dedup.svg b/runtime/near-vm/docs/deps_dedup.svg new file mode 100644 index 00000000000..1280e3d0faf --- /dev/null +++ b/runtime/near-vm/docs/deps_dedup.svg @@ -0,0 +1,244 @@ + + + + + + +dependencies + + +cluster_compiler + +Compilers + + +cluster_engine + +Engines + + +cluster_abi + +Provided ABIs + + + +n0 + +wasmer + + + +n6 + +wasmer-engine-universal + + + +n0->n6 + + + + + +n7 + +wasmer-engine-dylib + + + +n0->n7 + + + + + +n2 + +wasmer-compiler-cranelift + + + +n0->n2 + + + + + +n3 + +wasmer-compiler-llvm + + + +n0->n3 + + + + + +n4 + +wasmer-compiler-singlepass + + + +n0->n4 + + + + + +n1 + +wasmer-compiler + + + +n9 + +wasmer-vm + + + +n1->n9 + + + + + +n5 + +wasmer-engine + + + +n5->n1 + + + + + +n6->n5 + + + + + +n7->n5 + + + + + +n8 + +wasmer-types + + + +n9->n8 + + + + + +n10 + +wasmer-c-api + + + +n11 + +wasmer-emscripten + + + +n10->n11 + + + + + +n12 + +wasmer-wasi + + + +n10->n12 + + + + + +n11->n0 + + + + + +n12->n0 + + + + + +n13 + +wasmer-cache + + + +n13->n0 + + + + + +n14 + +wasmer-cli + + + +n14->n11 + + + + + +n14->n12 + + + + + +n14->n13 + + + + + +n2->n1 + + + + + +n3->n1 + + + + + +n4->n1 + + + + + diff --git a/runtime/near-vm/docs/es/README.md b/runtime/near-vm/docs/es/README.md new file mode 100644 index 00000000000..6d0b0b050dc --- /dev/null +++ b/runtime/near-vm/docs/es/README.md @@ -0,0 +1,195 @@ +
+ + Wasmer logo + + +

+ + Build Status + + + License + + + Slack channel + +

+ +

+ Web + • + Documentación + • + Chat +

+ +
+ +
+ +[Wasmer](https://wasmer.io/) hace posible tener contenedores ultraligeros basados en [WebAssembly](https://webassembly.org/) que pueden ser ejecutados en cualquier sitio: desde tu ordenador hasta la nube y dispositivos de IoT, además de poder ser ejecutados [*en cualquier lenguaje de programación*](https://github.com/wasmerio/wasmer#language-integrations). + +> This README is also available in: [🇩🇪 Deutsch-Alemán](https://github.com/wasmerio/wasmer/blob/master/docs/de/README.md) • [🇬🇧 English-Inglés](https://github.com/wasmerio/wasmer/blob/master/README.md) • [🇫🇷 Français-Francés](https://github.com/wasmerio/wasmer/blob/master/docs/fr/README.md) • [🇨🇳 中文-Chino](https://github.com/wasmerio/wasmer/blob/master/docs/cn/README.md) • [🇯🇵 日本語-japonés](https://github.com/wasmerio/wasmer/blob/master/docs/ja/README.md). + +## Funcionalidades + +* **Rápido y Seguro**. Wasmer ejecuta WebAssembly a velocidades *nativas* en un entorno completamente protegido. + +* **Extendible**. Wasmer soporta diferentes métodos de compilación dependiendo de tus necesidades (LLVM, Cranelift...). + +* **Universal**. Puedes ejecutar Wasmer en cualquier *platforma* (macOS, Linux y Windows) y *chip*. + +* **Respeta los estándares**. Wasmer pasa los [tests oficiales de WebAssembly](https://github.com/WebAssembly/testsuite) siendo compatible con [WASI](https://github.com/WebAssembly/WASI) y [Emscripten](https://emscripten.org/). + +## Empezamos? + +Wasmer no requiere ninguna dependencia. Puedes instalarlo con uno de éstos instaladores: + +```sh +curl https://get.wasmer.io -sSfL | sh +``` + +
+ Con PowerShell (Windows) +

+ +```powershell +iwr https://win.wasmer.io -useb | iex +``` + +

+
+ +> Visita [wasmer-install](https://github.com/wasmerio/wasmer-install) para más opciones de instalación: Homebrew, Scoop, Cargo... + + +#### Ejecuta un archivo WebAssembly + +¡Después de instalar Wasmer deberías estar listo para ejecutar tu primer módulo de WebAssembly! 🎉 + +Puedes empezar corriendo QuickJS: [qjs.wasm](https://registry-cdn.wapm.io/contents/_/quickjs/0.0.3/build/qjs.wasm) + +```bash +$ wasmer qjs.wasm +QuickJS - Type "\h" for help +qjs > +``` + +#### Esto es lo que puedes hacer: + +- [Usa Wasmer desde tu aplicación de Rust](https://docs.wasmer.io/integrations/rust) +- [Publica un paquete de Wasm en WAPM](https://docs.wasmer.io/ecosystem/wapm/publishing-your-package) +- [Lee más sobre Wasmer](https://medium.com/wasmer/) + +## Integraciones en diferentes Lenguajes + +📦 Wasmer puede ser usado como una librería **integrado en diferentes lenguajes de programación**, para que puedas ejecutar WebAssembly _en cualquier sitio_. + +|   | Lenguaje | Librería | Documentación | +|-|-|-|-| +| ![Rust logo] | [**Rust**][Rust integration] | [`wasmer` en crates.io] | [Documentación][rust docs] +| ![C logo] | [**C/C++**][C integration] | [cabecera `wasmer.h`] | [Documentación][c docs] | +| ![C# logo] | [**C#**][C# integration] | [`WasmerSharp` en NuGet] | [Documentación][c# docs] | +| ![D logo] | [**D**][D integration] | [`wasmer` en Dug] | [Documentación][d docs] | +| ![Python logo] | [**Python**][Python integration] | [`wasmer` en PyPI] | [Documentación][python docs] | +| ![JS logo] | [**Javascript**][JS integration] | [`@wasmerio` en NPM] | [Documentación][js docs] | +| ![Go logo] | [**Go**][Go integration] | [`wasmer` en Go] | [Documentación][go docs] | +| ![PHP logo] | [**PHP**][PHP integration] | [`wasm` en PECL] | [Documentación][php docs] | +| ![Ruby logo] | [**Ruby**][Ruby integration] | [`wasmer` en Ruby Gems] | [Documentación][ruby docs] | +| ![Java logo] | [**Java**][Java integration] | [`wasmer/wasmer-jni` en Bintray] | [Documentación][java docs] | +| ![Elixir logo] | [**Elixir**][Elixir integration] | [`wasmex` en hex] | [Documentación][elixir docs] | +| ![R logo] | [**R**][R integration] | *sin paquete publicado* | [Documentación][r docs] | +| ![Postgres logo] | [**Postgres**][Postgres integration] | *sin paquete publicado* | [Documentación][postgres docs] | +| | [**Swift**][Swift integration] | *sin paquete publicado* | | +| ![Zig logo] | [**Zig**][Zig integration] | *no published package* | | + +[👋 Falta algún lenguaje?](https://github.com/wasmerio/wasmer/issues/new?assignees=&labels=%F0%9F%8E%89+enhancement&template=---feature-request.md&title=) + +[rust logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/rust.svg +[rust integration]: https://github.com/wasmerio/wasmer/tree/master/lib/api +[`wasmer` en crates.io]: https://crates.io/crates/wasmer/ +[rust docs]: https://wasmerio.github.io/wasmer/crates/wasmer + +[c logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/c.svg +[c integration]: https://github.com/wasmerio/wasmer/tree/master/lib/c-api +[cabecera `wasmer.h`]: https://wasmerio.github.io/wasmer/c/ +[c docs]: https://wasmerio.github.io/wasmer/c/ + +[c# logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/csharp.svg +[c# integration]: https://github.com/migueldeicaza/WasmerSharp +[`wasmersharp` en NuGet]: https://www.nuget.org/packages/WasmerSharp/ +[c# docs]: https://migueldeicaza.github.io/WasmerSharp/ + +[d logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/d.svg +[d integration]: https://github.com/chances/wasmer-d +[`wasmer` en Dub]: https://code.dlang.org/packages/wasmer +[d docs]: https://chances.github.io/wasmer-d + +[python logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/python.svg +[python integration]: https://github.com/wasmerio/wasmer-python +[`wasmer` en pypi]: https://pypi.org/project/wasmer/ +[python docs]: https://github.com/wasmerio/wasmer-python#api-of-the-wasmer-extensionmodule + +[go logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/go.svg +[go integration]: https://github.com/wasmerio/wasmer-go +[`wasmer` en go]: https://pkg.go.dev/github.com/wasmerio/wasmer-go/wasmer +[go docs]: https://pkg.go.dev/github.com/wasmerio/wasmer-go/wasmer?tab=doc + +[php logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/php.svg +[php integration]: https://github.com/wasmerio/wasmer-php +[php docs]: https://wasmerio.github.io/wasmer-php/wasm/ +[`wasm` en pecl]: https://pecl.php.net/package/wasm + +[js logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/js.svg +[js integration]: https://github.com/wasmerio/wasmer-js +[`@wasmerio` en npm]: https://www.npmjs.com/org/wasmer +[js docs]: https://docs.wasmer.io/integrations/js/reference-api + +[ruby logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/ruby.svg +[ruby integration]: https://github.com/wasmerio/wasmer-ruby +[`wasmer` en ruby gems]: https://rubygems.org/gems/wasmer +[ruby docs]: https://www.rubydoc.info/gems/wasmer/ + +[java logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/java.svg +[java integration]: https://github.com/wasmerio/wasmer-java +[`wasmer/wasmer-jni` en bintray]: https://bintray.com/wasmer/wasmer-jni/wasmer-jni +[java docs]: https://github.com/wasmerio/wasmer-java/#api-of-the-wasmer-library + +[elixir logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/elixir.svg +[elixir integration]: https://github.com/tessi/wasmex +[elixir docs]: https://hexdocs.pm/wasmex/api-reference.html +[`wasmex` en hex]: https://hex.pm/packages/wasmex + +[r logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/r.svg +[r integration]: https://github.com/dirkschumacher/wasmr +[r docs]: https://github.com/dirkschumacher/wasmr#example + +[postgres logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/postgres.svg +[postgres integration]: https://github.com/wasmerio/wasmer-postgres +[postgres docs]: https://github.com/wasmerio/wasmer-postgres#usage--documentation + +[swift integration]: https://github.com/AlwaysRightInstitute/SwiftyWasmer + +[zig logo]: https://raw.githubusercontent.com/ziglang/logo/master/zig-favicon.png +[zig integration]: https://github.com/zigwasm/wasmer-zig + +## Contribuye + +**Damos la bienvenida a cualquier forma de contribución, especialmente a los nuevos miembros de la comunidad** 💜 + +¡Puedes ver cómo crear el binario de Wasmer con [nuestros increíbles documentos](https://docs.wasmer.io/ecosystem/wasmer/building-from-source)! + +### Tests + +Testear quieres? Los [documentos de Wasmer te enseñarán cómo](https://docs.wasmer.io/ecosystem/wasmer/building-from-source/testing). + +## Comunidad + +Wasmer tiene una comunidad increíble de desarrolladores y colaboradores ¡Bienvenido, únete a nosotros! 👋 + +### Medios + +- [Slack](https://slack.wasmer.io/) +- [Twitter](https://twitter.com/wasmerio) +- [Facebook](https://www.facebook.com/wasmerio) +- [Email](mailto:hello@wasmer.io) diff --git a/runtime/near-vm/docs/fr/README.md b/runtime/near-vm/docs/fr/README.md new file mode 100644 index 00000000000..de502fa7904 --- /dev/null +++ b/runtime/near-vm/docs/fr/README.md @@ -0,0 +1,195 @@ +
+ + Logo Wasmer + + +

+ + État des tests + + + Licence + + + Salon Slack + +

+ +

+ Web + • + Documentation + • + Chat +

+ +
+ +
+ +[Wasmer](https://wasmer.io/) permet l'utilisation de conteneurs super légers basés sur [WebAssembly](https://webassembly.org/) qui peuvent fonctionner n'importe où : du bureau au cloud en passant par les appareils IoT, et également intégrés dans [*une multitude de langages de programmation*](https://github.com/wasmerio/wasmer#language-integrations). + +> This readme is also available in: [🇩🇪 Deutsch-Allemand](https://github.com/wasmerio/wasmer/blob/master/docs/de/README.md) • [🇬🇧 English-Anglaise](https://github.com/wasmerio/wasmer/blob/master/README.md) • [🇪🇸 Español-Espagnol](https://github.com/wasmerio/wasmer/blob/master/docs/es/README.md) • [🇨🇳 中文-Chinoise](https://github.com/wasmerio/wasmer/blob/master/docs/cn/README.md) • [🇯🇵 日本語-japonais](https://github.com/wasmerio/wasmer/blob/master/docs/ja/README.md) + +## Fonctionnalités + +* **Rapide et sûr**. Wasmer exécute WebAssembly à une vitesse *quasi native* dans un environnement entièrement contrôlé (bac à sable, _sandbox_). + +* **Modulaire**. Wasmer prend en charge différents frameworks de compilation pour répondre au mieux à vos besoins (LLVM, Cranelift ...). + +* **Universel**. Vous pouvez exécuter Wasmer sur n'importe quelle *plate-forme* (macOS, Linux et Windows) et *processeur*. + +* **Conforme aux normes**. Wasmer passe [la suite de tests officielle de WebAssembly](https://github.com/WebAssembly/testsuite) prenant en charge [WASI](https://github.com/WebAssembly/WASI) et [Emscripten](https://emscripten.org/) + +## Quickstart + +Wasmer est livré sans aucune dépendance. Vous pouvez l'installer à l'aide des programmes d'installation ci-dessous : + +```sh +curl https://get.wasmer.io -sSfL | sh +``` + +
+ Avec PowerShell (Windows) +

+ +```powershell +iwr https://win.wasmer.io -useb | iex +``` + +

+
+ +> Voir [wasmer-install](https://github.com/wasmerio/wasmer-install) pour plus d'options d'installation: Homebrew, Scoop, Cargo... + + +#### Exécution d'un fichier WebAssembly + +Après avoir installé Wasmer, vous devriez être prêt à exécuter votre premier fichier WebAssemby ! 🎉 + +Vous pouvez commencer par exécuter QuickJS : [qjs.wasm](https://registry-cdn.wapm.io/contents/_/quickjs/0.0.3/build/qjs.wasm) + +```bash +$ wasmer qjs.wasm +QuickJS - Type "\h" for help +qjs > +``` + +#### Voici ce que vous pouvez faire ensuite + +- [Utilisez Wasmer depuis votre application Rust](https://docs.wasmer.io/integrations/rust) +- [Publier un paquet Wasm sur WAPM](https://docs.wasmer.io/ecosystem/wapm/publishing-your-package) +- [En savoir plus sur Wasmer](https://medium.com/wasmer/) + +## Intégrations + +📦 Wasmer peut être utilisé comme une bibliothèque **intégrée dans différents langages**, vous pouvez donc utiliser WebAssembly _n'import où_. + +|   | Langage de programmation | Package | Docs | +|-|-|-|-| +| ![Rust logo] | [**Rust**][Rust integration] | [`wasmer` Rust crate] | [Docs][rust docs] +| ![C logo] | [**C/C++**][C integration] | [`wasmer.h` headers] | [Docs][c docs] | +| ![C# logo] | [**C#**][C# integration] | [`WasmerSharp` NuGet package] | [Docs][c# docs] | +| ![D logo] | [**D**][D integration] | [`wasmer` Dub package] | [Docs][d docs] | +| ![Python logo] | [**Python**][Python integration] | [`wasmer` PyPI package] | [Docs][python docs] | +| ![JS logo] | [**Javascript**][JS integration] | [`@wasmerio` NPM packages] | [Docs][js docs] | +| ![Go logo] | [**Go**][Go integration] | [`wasmer` Go package] | [Docs][go docs] | +| ![PHP logo] | [**PHP**][PHP integration] | [`wasm` PECL package] | [Docs][php docs] | +| ![Ruby logo] | [**Ruby**][Ruby integration] | [`wasmer` Ruby Gem] | [Docs][ruby docs] | +| ![Java logo] | [**Java**][Java integration] | [`wasmer/wasmer-jni` Bintray package] | [Docs][java docs] | +| ![Elixir logo] | [**Elixir**][Elixir integration] | [`wasmex` hex package] | [Docs][elixir docs] | +| ![R logo] | [**R**][R integration] | *no published package* | [Docs][r docs] | +| ![Postgres logo] | [**Postgres**][Postgres integration] | *no published package* | [Docs][postgres docs] | +| | [**Swift**][Swift integration] | *no published package* | | +| ![Zig logo] | [**Zig**][Zig integration] | *no published package* | | + +[👋 Il manque un langage ?](https://github.com/wasmerio/wasmer/issues/new?assignees=&labels=%F0%9F%8E%89+enhancement&template=---feature-request.md&title=) + +[rust logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/rust.svg +[rust integration]: https://github.com/wasmerio/wasmer/tree/master/lib/api +[`wasmer` rust crate]: https://crates.io/crates/wasmer/ +[rust docs]: https://wasmerio.github.io/wasmer/crates/wasmer + +[c logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/c.svg +[c integration]: https://github.com/wasmerio/wasmer/tree/master/lib/c-api +[`wasmer.h` headers]: https://wasmerio.github.io/wasmer/c/ +[c docs]: https://wasmerio.github.io/wasmer/c/ + +[c# logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/csharp.svg +[c# integration]: https://github.com/migueldeicaza/WasmerSharp +[`wasmersharp` nuget package]: https://www.nuget.org/packages/WasmerSharp/ +[c# docs]: https://migueldeicaza.github.io/WasmerSharp/ + +[d logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/d.svg +[d integration]: https://github.com/chances/wasmer-d +[`wasmer` Dub package]: https://code.dlang.org/packages/wasmer +[d docs]: https://chances.github.io/wasmer-d + +[python logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/python.svg +[python integration]: https://github.com/wasmerio/wasmer-python +[`wasmer` pypi package]: https://pypi.org/project/wasmer/ +[python docs]: https://github.com/wasmerio/wasmer-python#api-of-the-wasmer-extensionmodule + +[go logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/go.svg +[go integration]: https://github.com/wasmerio/wasmer-go +[`wasmer` go package]: https://pkg.go.dev/github.com/wasmerio/wasmer-go/wasmer +[go docs]: https://pkg.go.dev/github.com/wasmerio/wasmer-go/wasmer?tab=doc + +[php logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/php.svg +[php integration]: https://github.com/wasmerio/wasmer-php +[`wasm` pecl package]: https://pecl.php.net/package/wasm +[php docs]: https://wasmerio.github.io/wasmer-php/wasm/ + +[js logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/js.svg +[js integration]: https://github.com/wasmerio/wasmer-js +[`@wasmerio` npm packages]: https://www.npmjs.com/org/wasmer +[js docs]: https://docs.wasmer.io/integrations/js/reference-api + +[ruby logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/ruby.svg +[ruby integration]: https://github.com/wasmerio/wasmer-ruby +[`wasmer` ruby gem]: https://rubygems.org/gems/wasmer +[ruby docs]: https://www.rubydoc.info/gems/wasmer/ + +[java logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/java.svg +[java integration]: https://github.com/wasmerio/wasmer-java +[`wasmer/wasmer-jni` bintray package]: https://bintray.com/wasmer/wasmer-jni/wasmer-jni +[java docs]: https://github.com/wasmerio/wasmer-java/#api-of-the-wasmer-library + +[elixir logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/elixir.svg +[elixir integration]: https://github.com/tessi/wasmex +[elixir docs]: https://hexdocs.pm/wasmex/api-reference.html +[`wasmex` hex package]: https://hex.pm/packages/wasmex + +[r logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/r.svg +[r integration]: https://github.com/dirkschumacher/wasmr +[r docs]: https://github.com/dirkschumacher/wasmr#example + +[postgres logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/postgres.svg +[postgres integration]: https://github.com/wasmerio/wasmer-postgres +[postgres docs]: https://github.com/wasmerio/wasmer-postgres#usage--documentation + +[swift integration]: https://github.com/AlwaysRightInstitute/SwiftyWasmer + +[zig logo]: https://raw.githubusercontent.com/ziglang/logo/master/zig-favicon.png +[zig integration]: https://github.com/zigwasm/wasmer-zig + +## Contribuer + +**Nous accueillons toutes formes de contributions, en particulier de la part des nouveaux membres de notre communauté**. 💜 + +Vous pouvez vérifier comment compiler Wasmer dans [notre documentation](https://docs.wasmer.io/ecosystem/wasmer/building-from-source)! + +### Test + +Vous voulez des tests ? La [documentation de Wasmer](https://docs.wasmer.io/ecosystem/wasmer/building-from-source/testing) vous montrera comment les exécuter. + +## Communauté + +Wasmer a une incroyable communauté de développeurs et de contributeurs. Bienvenue et rejoignez-nous ! 👋 + +### Canaux de communications + +- [Slack](https://slack.wasmer.io/) +- [Twitter](https://twitter.com/wasmerio) +- [Facebook](https://www.facebook.com/wasmerio) +- [Email](mailto:hello@wasmer.io) diff --git a/runtime/near-vm/docs/ja/README.md b/runtime/near-vm/docs/ja/README.md new file mode 100644 index 00000000000..96989c67cc8 --- /dev/null +++ b/runtime/near-vm/docs/ja/README.md @@ -0,0 +1,195 @@ +
+ + Wasmerロゴ + + +

+ + ビルドステータス + + + ライセンス + + + Slackチャンネル + +

+ +

+ Website + • + Docs + • + Chat +

+ +
+ +
+ +[Wasmer](https://wasmer.io/) は、[WebAssembly](https://webassembly.org/) をベースとした非常に軽量なコンテナを実現します。デスクトップからクラウドや IoT デバイス上まで、どんな環境でも実行でき、さらに[*任意のプログラミング言語*](#他の言語とのインテグレーション)に埋め込むこともできます。 + +> この readme は、次の言語でも利用可能です。[🇩🇪 Deutsch-ドイツ語](https://github.com/wasmerio/wasmer/blob/master/docs/de/README.md) • [🇨🇳 中文-Chinese](https://github.com/wasmerio/wasmer/blob/master/docs/cn/README.md) • [🇬🇧 English-英語](https://github.com/wasmerio/wasmer/blob/master/README.md) • [🇪🇸 Español-Spanish](https://github.com/wasmerio/wasmer/blob/master/docs/es/README.md) • [🇫🇷 Français-French](https://github.com/wasmerio/wasmer/blob/master/docs/fr/README.md) + +## 機能 + +* **高速かつ安全**。WebAssembly を完全なサンドボックス環境内で*ネイティブに近い*スピードで実行します。 + +* **プラガブル**。異なるコンパイルフレームワーク (LLVM、Cranelift など...) をサポートしているため、ニーズに合った最適なフレームワークを選択できます。 + +* **ユニバーサル**。どんなプラットフォーム上 (macOS、Linux、Windows) でも、どんな*チップセット*上でも実行できます。 + +* **標準に準拠**。ランタイムは[公式の WebAssembly テストスイート](https://github.com/WebAssembly/testsuite)に通っており、[WASI](https://github.com/WebAssembly/WASI) と [Emscripten](https://emscripten.org/) をサポートします。 + +## クイックスタート + +Wasmer は依存関係なしで動作します。以下のコマンドでインストーラーを使用してインストールできます。 + +```sh +curl https://get.wasmer.io -sSfL | sh +``` + +
+ PowerShell の場合 (Windows) +

+ +```powershell +iwr https://win.wasmer.io -useb | iex +``` + +

+
+ +> Homebrew、Scoop、Cargo など、他のインストール方法については、[wasmer-install](https://github.com/wasmerio/wasmer-install) を参照してください。 + + +#### WebAssembly ファイルの実行 + +Wasmer をインストールしたら、初めての WebAssembly ファイルの実行準備が完了です！ 🎉 + +QuickJS ([qjs.wasm](https://registry-cdn.wapm.io/contents/_/quickjs/0.0.3/build/qjs.wasm)) を実行することで、すぐに始められます。 + +```bash +$ wasmer qjs.wasm +QuickJS - Type "\h" for help +qjs > +``` + +#### 次にできること + +- [Rust アプリケーションから Wasmer を使用する](https://docs.wasmer.io/integrations/rust) +- [WAPM で Wasm パッケージを公開する](https://docs.wasmer.io/ecosystem/wapm/publishing-your-package) +- [Wasmer についてさらに学ぶ](https://medium.com/wasmer/) + +## 他の言語とのインテグレーション + +📦 Wasmer ランタイムは**他の言語に組み込んで**使用できるため、WebAssembly は_どんな場所でも_利用できます。 + +|   | Language | Package | Docs | +|-|-|-|-| +| ![Rust logo] | [**Rust**][Rust integration] | [`wasmer` Rust crate] | [Docs][rust docs] +| ![C logo] | [**C/C++**][C integration] | [`wasmer.h` headers] | [Docs][c docs] | +| ![C# logo] | [**C#**][C# integration] | [`WasmerSharp` NuGet package] | [Docs][c# docs] | +| ![D logo] | [**D**][D integration] | [`wasmer` Dub package] | [Docs][d docs] | +| ![Python logo] | [**Python**][Python integration] | [`wasmer` PyPI package] | [Docs][python docs] | +| ![JS logo] | [**Javascript**][JS integration] | [`@wasmerio` NPM packages] | [Docs][js docs] | +| ![Go logo] | [**Go**][Go integration] | [`wasmer` Go package] | [Docs][go docs] | +| ![PHP logo] | [**PHP**][PHP integration] | [`wasm` PECL package] | [Docs][php docs] | +| ![Ruby logo] | [**Ruby**][Ruby integration] | [`wasmer` Ruby Gem] | [Docs][ruby docs] | +| ![Java logo] | [**Java**][Java integration] | [`wasmer/wasmer-jni` Bintray package] | [Docs][java docs] | +| ![Elixir logo] | [**Elixir**][Elixir integration] | [`wasmex` hex package] | [Docs][elixir docs] | +| ![R logo] | [**R**][R integration] | *公開パッケージなし* | [Docs][r docs] | +| ![Postgres logo] | [**Postgres**][Postgres integration] | *公開パッケージなし* | [Docs][postgres docs] | +| | [**Swift**][Swift integration] | *公開パッケージなし* | | +| ![Zig logo] | [**Zig**][Zig integration] | *no published package* | | + +[👋 言語が見当たらない？](https://github.com/wasmerio/wasmer/issues/new?assignees=&labels=%F0%9F%8E%89+enhancement&template=---feature-request.md&title=) + +[rust logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/rust.svg +[rust integration]: https://github.com/wasmerio/wasmer/tree/master/lib/api +[`wasmer` rust crate]: https://crates.io/crates/wasmer/ +[rust docs]: https://wasmerio.github.io/wasmer/crates/wasmer + +[c logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/c.svg +[c integration]: https://github.com/wasmerio/wasmer/tree/master/lib/c-api +[`wasmer.h` headers]: https://wasmerio.github.io/wasmer/c/ +[c docs]: https://wasmerio.github.io/wasmer/c/ + +[c# logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/csharp.svg +[c# integration]: https://github.com/migueldeicaza/WasmerSharp +[`wasmersharp` nuget package]: https://www.nuget.org/packages/WasmerSharp/ +[c# docs]: https://migueldeicaza.github.io/WasmerSharp/ + +[d logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/d.svg +[d integration]: https://github.com/chances/wasmer-d +[`wasmer` Dub package]: https://code.dlang.org/packages/wasmer +[d docs]: https://chances.github.io/wasmer-d + +[python logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/python.svg +[python integration]: https://github.com/wasmerio/wasmer-python +[`wasmer` pypi package]: https://pypi.org/project/wasmer/ +[python docs]: https://github.com/wasmerio/wasmer-python#api-of-the-wasmer-extensionmodule + +[go logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/go.svg +[go integration]: https://github.com/wasmerio/wasmer-go +[`wasmer` go package]: https://pkg.go.dev/github.com/wasmerio/wasmer-go/wasmer +[go docs]: https://pkg.go.dev/github.com/wasmerio/wasmer-go/wasmer?tab=doc + +[php logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/php.svg +[php integration]: https://github.com/wasmerio/wasmer-php +[`wasm` pecl package]: https://pecl.php.net/package/wasm +[php docs]: https://wasmerio.github.io/wasmer-php/wasm/ + +[js logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/js.svg +[js integration]: https://github.com/wasmerio/wasmer-js +[`@wasmerio` npm packages]: https://www.npmjs.com/org/wasmer +[js docs]: https://docs.wasmer.io/integrations/js/reference-api + +[ruby logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/ruby.svg +[ruby integration]: https://github.com/wasmerio/wasmer-ruby +[`wasmer` ruby gem]: https://rubygems.org/gems/wasmer +[ruby docs]: https://www.rubydoc.info/gems/wasmer/ + +[java logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/java.svg +[java integration]: https://github.com/wasmerio/wasmer-java +[`wasmer/wasmer-jni` bintray package]: https://bintray.com/wasmer/wasmer-jni/wasmer-jni +[java docs]: https://github.com/wasmerio/wasmer-java/#api-of-the-wasmer-library + +[elixir logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/elixir.svg +[elixir integration]: https://github.com/tessi/wasmex +[elixir docs]: https://hexdocs.pm/wasmex/api-reference.html +[`wasmex` hex package]: https://hex.pm/packages/wasmex + +[r logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/r.svg +[r integration]: https://github.com/dirkschumacher/wasmr +[r docs]: https://github.com/dirkschumacher/wasmr#example + +[postgres logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/postgres.svg +[postgres integration]: https://github.com/wasmerio/wasmer-postgres +[postgres docs]: https://github.com/wasmerio/wasmer-postgres#usage--documentation + +[swift integration]: https://github.com/AlwaysRightInstitute/SwiftyWasmer + +[zig logo]: https://raw.githubusercontent.com/ziglang/logo/master/zig-favicon.png +[zig integration]: https://github.com/zigwasm/wasmer-zig + +## コントリビューション + +**どんな形での貢献も歓迎です。コミュニティの新しいメンバーからの貢献は特に歓迎します。** 💜 + +Wasmer ランタイムのビルド方法は、[素晴らしいドキュメント](https://docs.wasmer.io/ecosystem/wasmer/building-from-source)で確認できます！ + +### テスト + +テストを実行したいですか？ [Wasmer docs で方法を説明](https://docs.wasmer.io/ecosystem/wasmer/building-from-source/testing)しています。 + +## コミュニティ + +Wasmer には、開発者とコントリビューターの素晴らしいコミュニティがあります。ようこそ！ あなたも是非参加してください！ 👋 + +### チャンネル + +- [Slack](https://slack.wasmer.io/) +- [Twitter](https://twitter.com/wasmerio) +- [Facebook](https://www.facebook.com/wasmerio) +- [Email](mailto:hello@wasmer.io) diff --git a/runtime/near-vm/docs/ko/README.md b/runtime/near-vm/docs/ko/README.md new file mode 100644 index 00000000000..47a9674ed27 --- /dev/null +++ b/runtime/near-vm/docs/ko/README.md @@ -0,0 +1,223 @@ + + +
+ +Wasmer는 _초경량 컨테이너_ 를 *Desktop*에서부터 *Cloud*, *Edge*, *IoT* 기기들까지 어디에서나 실행할 수 있는 _빠르고 안전한_ [**WebAssembly**](https://webassembly.org) 런타임 입니다. + +> _이 문서는 아래와 같은 언어들을 지원합니다.: +[🇨🇳 中 文 -Chinese](https://github.com/wasmerio/wasmer/blob/master/docs/cn/README.md) • +[🇩🇪 Deutsch-German](https://github.com/wasmerio/wasmer/blob/master/docs/de/README.md) • +[🇪🇸 Español-Spanish](https://github.com/wasmerio/wasmer/blob/master/docs/es/README.md) • +[🇫🇷 Français-French](https://github.com/wasmerio/wasmer/blob/master/docs/fr/README.md) • +[🇯🇵 日本 語 -Japanese](https://github.com/wasmerio/wasmer/blob/master/docs/ja/README.md)_. +[🇰🇷 한국어 -Korean](https://github.com/wasmerio/wasmer/blob/master/docs/ko/README.md)_. + +### 특징 + +* 기본적으로 안전합니다. 파일, 네트워크, 환경 접근이 명시적으로 활성화 되지 않습니다. +* [WASI](https://github.com/WebAssembly/WASI)와 [Emscripten](https://emscripten.org/)을 즉시 지원합니다. +* 빠릅니다. native에 가까운 속도로 WebAssembly를 실행합니다. +* [여러 프로그래밍 언어](https://github.com/wasmerio/wasmer/#-language-integrations)에 임베디드 가능합니다. +* 최신 WebAssembly 제안(SIMD, Reference Types, Threads, ...)을 준수합니다. + +### 설치 + +Wasmer CLI는 종속성이 없는 단일 실행 파일로 제공됩니다. + +```sh +curl https://get.wasmer.io -sSfL | sh +``` + + +
+ 다른 설치 옵션 (Powershell, Brew, Cargo, ...) + + _Wasmer는 다양한 패키지 매니저를 통해 설치 할 수 있습니다. 환경에 가장 적합한 것을 선택하십시오.:_ + + * Powershell (Windows) + ```powershell + iwr https://win.wasmer.io -useb | iex + ``` + + * Homebrew (macOS, Linux) + + ```sh + brew install wasmer + ``` + + * Scoop (Windows) + + ```sh + scoop install wasmer + ``` + + * Chocolatey (Windows) + + ```sh + choco install wasmer + ``` + + * Cargo + + _Note: 사용 가능한 모든 기능은 [`wasmer-cli` + crate docs](https://github.com/wasmerio/wasmer/tree/master/lib/cli/README.md) 문서에 설명되어 있습니다._ + + ```sh + cargo install wasmer-cli + ``` + + > 더 많은 설치 옵션을 찾고 계십니까? 자세한 내용은 [the `wasmer-install` + repository](https://github.com/wasmerio/wasmer-install)를 참조하십시오! +
+ +### 빠른 시작 + +WebAssembly 모듈([`qjs.wasm`](https://registry-cdn.wapm.io/contents/_/quickjs/0.0.3/build/qjs.wasm))로 컴파일된 +작고 포함 가능한 Javascript 엔진인 [QuickJS](https://github.com/bellard/quickjs/)를 실행하여 시작할 수 있습니다.: + +```bash +$ wasmer qjs.wasm +QuickJS - Type "\h" for help +qjs > const i = 1 + 2; +qjs > console.log("hello " + i); +hello 3 +``` + +#### 다음에 할 수 있는 일 : + +- [어플리케이션에서 wasmer 사용](https://docs.wasmer.io/integrations/rust) +- [WAPM에 wasm 패키지 게시](https://docs.wasmer.io/ecosystem/wapm/publishing-your-package) +- [Wasmer에 대해 자세히 알아보기](https://medium.com/wasmer/) + +## 📦 다른 언어와의 통합 + +Wasmer 런타임은 **다른 언어에 내장된** 라이브러리로 사용할 수 있으므로 _어디에서나_ WebAssembly를 사용할 수 있습니다. + +| | Language | Package | Documentation | +|-|-|-|-| +| ![Rust logo] | [**Rust**][Rust integration] | [`wasmer` Rust crate] | [Learn][rust docs] +| ![C logo] | [**C/C++**][C integration] | [`wasmer.h` header] | [Learn][c docs] | +| ![C# logo] | [**C#**][C# integration] | [`WasmerSharp` NuGet package] | [Learn][c# docs] | +| ![D logo] | [**D**][D integration] | [`wasmer` Dub package] | [Learn][d docs] | +| ![Python logo] | [**Python**][Python integration] | [`wasmer` PyPI package] | [Learn][python docs] | +| ![JS logo] | [**Javascript**][JS integration] | [`@wasmerio` NPM packages] | [Learn][js docs] | +| ![Go logo] | [**Go**][Go integration] | [`wasmer` Go package] | [Learn][go docs] | +| ![PHP logo] | [**PHP**][PHP integration] | [`wasm` PECL package] | [Learn][php docs] | +| ![Ruby logo] | [**Ruby**][Ruby integration] | [`wasmer` Ruby Gem] | [Learn][ruby docs] | +| ![Java logo] | [**Java**][Java integration] | [`wasmer/wasmer-jni` Bintray package] | [Learn][java docs] | +| ![Elixir logo] | [**Elixir**][Elixir integration] | [`wasmex` hex package] | [Learn][elixir docs] | +| ![R logo] | [**R**][R integration] | *공개 패키지 없음* | [Learn][r docs] | +| ![Postgres logo] | [**Postgres**][Postgres integration] | *공개 패키지 없음* | [Learn][postgres docs] | +| | [**Swift**][Swift integration] | *공개 패키지 없음* | | +| ![Zig logo] | [**Zig**][Zig integration] | *공개 패키지 없음* | | +| ![Dart logo] | [**Dart**][Dart integration] | [`wasm` pub package] | | +| | [**Lisp**][Lisp integration] | *under heavy development - no published package* | | + +[👋  없는 언어가 있습니까?](https://github.com/wasmerio/wasmer/issues/new?assignees=&labels=%F0%9F%8E%89+enhancement&template=---feature-request.md&title=) + +[rust logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/rust.svg +[rust integration]: https://github.com/wasmerio/wasmer/tree/master/lib/api +[`wasmer` rust crate]: https://crates.io/crates/wasmer/ +[rust docs]: https://docs.rs/wasmer/ + +[c logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/c.svg +[c integration]: https://github.com/wasmerio/wasmer/tree/master/lib/c-api +[`wasmer.h` header]: https://github.com/wasmerio/wasmer/blob/master/lib/c-api/wasmer.h +[c docs]: https://docs.rs/wasmer-c-api/*/wasmer_c_api/wasm_c_api/index.html + +[c# logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/csharp.svg +[c# integration]: https://github.com/migueldeicaza/WasmerSharp +[`wasmersharp` nuget package]: https://www.nuget.org/packages/WasmerSharp/ +[c# docs]: https://migueldeicaza.github.io/WasmerSharp/ + +[d logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/d.svg +[d integration]: https://github.com/chances/wasmer-d +[`wasmer` Dub package]: https://code.dlang.org/packages/wasmer +[d docs]: https://chances.github.io/wasmer-d + +[python logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/python.svg +[python integration]: https://github.com/wasmerio/wasmer-python +[`wasmer` pypi package]: https://pypi.org/project/wasmer/ +[python docs]: https://wasmerio.github.io/wasmer-python/api/wasmer/ + +[go logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/go.svg +[go integration]: https://github.com/wasmerio/wasmer-go +[`wasmer` go package]: https://pkg.go.dev/github.com/wasmerio/wasmer-go/wasmer +[go docs]: https://pkg.go.dev/github.com/wasmerio/wasmer-go/wasmer?tab=doc + +[php logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/php.svg +[php integration]: https://github.com/wasmerio/wasmer-php +[`wasm` pecl package]: https://pecl.php.net/package/wasm +[php docs]: https://wasmerio.github.io/wasmer-php/ + +[js logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/js.svg +[js integration]: https://github.com/wasmerio/wasmer-js +[`@wasmerio` npm packages]: https://www.npmjs.com/org/wasmer +[js docs]: https://docs.wasmer.io/integrations/js/reference-api + +[ruby logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/ruby.svg +[ruby integration]: https://github.com/wasmerio/wasmer-ruby +[`wasmer` ruby gem]: https://rubygems.org/gems/wasmer +[ruby docs]: https://wasmerio.github.io/wasmer-ruby/wasmer_ruby/index.html + +[java logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/java.svg +[java integration]: https://github.com/wasmerio/wasmer-java +[`wasmer/wasmer-jni` bintray package]: https://bintray.com/wasmer/wasmer-jni/wasmer-jni +[java docs]: https://github.com/wasmerio/wasmer-java/#api-of-the-wasmer-library + +[elixir logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/elixir.svg +[elixir integration]: https://github.com/tessi/wasmex +[elixir docs]: https://hexdocs.pm/wasmex/api-reference.html +[`wasmex` hex package]: https://hex.pm/packages/wasmex + +[r logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/r.svg +[r integration]: https://github.com/dirkschumacher/wasmr +[r docs]: https://github.com/dirkschumacher/wasmr#example + +[postgres logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/postgres.svg +[postgres integration]: https://github.com/wasmerio/wasmer-postgres +[postgres docs]: https://github.com/wasmerio/wasmer-postgres#usage--documentation + +[swift integration]: https://github.com/AlwaysRightInstitute/SwiftyWasmer + +[zig logo]: https://raw.githubusercontent.com/ziglang/logo/master/zig-favicon.png +[zig integration]: https://github.com/zigwasm/wasmer-zig + +[dart logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/dart.svg +[dart integration]: https://github.com/dart-lang/wasm +[`wasm` pub package]: https://pub.dev/packages/wasm + +[lisp integration]: https://github.com/helmutkian/cl-wasm-runtime + +## 기여 + +도움을 주셔서 감사합니다! 💜 + +[Wasmer를 빌드](https://docs.wasmer.io/ecosystem/wasmer/building-from-source)하거나 [변경 사항을 테스트](https://docs.wasmer.io/ecosystem/wasmer/building-from-source/testing)하는 방법에 대한 문서를 확인하십시오. + +## 커뮤니티 +Wasmer에는 개발자의 기여가 있는 훌륭한 커뮤니티가 있습니다. 환영합니다! 꼭 참여해주세요! 👋 + +- [Wasmer Community Slack](https://slack.wasmer.io/) +- [Wasmer on Twitter](https://twitter.com/wasmerio) +- [Wasmer on Facebook](https://www.facebook.com/wasmerio) +- [Email](mailto:hello@wasmer.io) diff --git a/runtime/near-vm/docs/migration_to_1.0.0.md b/runtime/near-vm/docs/migration_to_1.0.0.md new file mode 100644 index 00000000000..5da6c35e645 --- /dev/null +++ b/runtime/near-vm/docs/migration_to_1.0.0.md @@ -0,0 +1,358 @@ +# Migrating from Wasmer 0.x to Wasmer 1.0.0 + +Wasmer 1.0.0 is getting ready for a full release and is our primary focus. This document will +describe the differences between Wasmer 0.x and Wasmer 1.0.0 and provide examples +to make migrating to the new API as simple as possible. + +## Table of Contents + +- [Rationale for changes in 1.0.0](#rationale-for-changes-in-100) +- [How to use Wasmer 1.0.0](#how-to-use-wasmer-100) + - [Installing Wasmer CLI](#installing-wamser-cli) + - [Using Wasmer 1.0.0](#using-wamser-100) +- [Project structure](#project-structure) +- [Differences](#differences) + - [Instantiating modules](#instantiating-modules) + - [Passing host functions](#passing-host-functions) + - [Accessing the environment as a host function](#accessing-the-environment-as-a-host-function) + - [Error handling](#error-handling) + - [Caching modules](#caching-modules) + +## Rationale for changes in 1.0.0 + +Wasmer 0.x was great but as the Wasm community and standards evolve we felt the need to make Wasmer also follow these +changes. + +Wasmer 1.x is what we think a necessary rewrite of a big part of the project to make it more future-proof. + +This version introduces many new features and makes using Wasmer more natural. We did a hard work making it as close +to the standard API as possible while always providing good performances, flexibility and stability. + +The rewrite of the Wasmer Runtime also comes with a rewrite of the languages integrations to achieve the same goals: +providing a clearer API and improving the feature set. + +In this document you will discover the major changes between Wasmer 0.x and Wasmer 1.x by highlighting how to use the +new Rust API. + +## How to use Wasmer 1.0.0 + +### Installing Wasmer CLI + +See [wasmer.io] for installation instructions. + +If you already have wasmer installed, run `wasmer self-update`. + +Install the latest versions of Wasmer with [wasmer-nightly] or by following the steps described in the +documentation: [Getting Started][getting-started]. + +### Using Wasmer 1.0.0 + +The CLI interface for Wasmer 1.0.0 is mostly the same as it was in Wasmer 0.x. + +One difference is that rather than specifying the compiler with `--backend=cranelift`, +in Wasmer 1.0.0 we prefer using the name of the backend as a flag directly, +for example: `--cranelift`. + +The top-level crates that users will usually interface with are: + +- [wasmer] - Wasmer's core runtime API +- [wasmer-wasi] - Wasmer's WASI implementation +- [wasmer-emscripten] - Wasmer's Emscripten implementation +- TODO: + +See the [examples] to find out how to do specific things in Wasmer 1.0.0. + +## Project Structure + +![Wasmer dependencies graph](./deps_dedup.svg) + +The figure above shows the core Wasmer crates and their dependencies with transitive dependencies deduplicated. + +Wasmer 1.0.0 has two core architectural abstractions: engines and compilers. + +An engine is a system that processes Wasm with a compiler and prepares it to be executed. + +A compiler is a system that translates Wasm into a format that can be understood +more directly by a real computer: machine code. + +For example, in the [examples] you'll see that we are using the JIT engine and the Cranelift compiler. The JIT engine +will generate machine code at runtime, using Cranelift, and then execute it. + +For most uses, users will primarily use the [wasmer] crate directly, perhaps with one of our +provided ABIs such as [wasmer-wasi]. However, for users that need finer grained control over +the behavior of wasmer, other crates such as [wasmer-compiler] and [wasmer-engine] may be used +to implement custom compilers and engines respectively. + +## Differences + +### Instantiating modules + +With Wasmer 0.x, instantiating a module was a matter of calling `wasmer::compiler::compile` and then calling +`instantiate` on the compiled module. + +While simple, this did not give you full-control over Wasmer's configuration. For example, choosing another compiler +was not straightforward. + +With Wasmer 1.x, we changed this part and made the API look more like how Wasmer works internally to give you more +control: + +```diff +- let module = compile(&wasm_bytes[..])?; ++ let engine = JIT::new(Cranelift::default()).engine(); ++ let store = Store::new(&engine); ++ let module = Module::new(&store, wasm_bytes)?; +- let instance = module.instantiate(&imports)?; ++ let instance = Instance::new(&module, &import_object)?; +``` + +Note that we did not cover how to create the import object here. This is because this part works the same as it used to +with Wasmer 0.x. + +To get more information on how instantiation now works, have a look at the [dedicated example][instance-example] + +### Passing host functions + +With Wasmer 0.x passing host functions to the guest was primarily done using the `func!` macro or by directly using +`Func::new` or `DynamicFunc::new`. + +In Wasmer 1.0 the equivalent of `Func::new` is `Function::new_native` / +`Function::new_native_with_env` and the equivalent of `DynamicFunc::new` +is `Function::new` / `Function::new_with_env`. + +Given we have a function like: + +```rust +fn sum(a: i32, b: i32) -> i32 { + a + b +} +``` + +We want to import this function in the guest module, let's have a look at how it differs between Wasmer 0.x and +Wasmer 1.x: + +```diff +let import_object = imports! { + "env" => { +- "sum" => func!(sum), ++ "sum" => Function::new_native(&store, sum), + } +} +``` + +The above example illustrates how to import what we call "native functions". There were already available in Wasmer +0.x through the `func!` macro or with `Func::new`. + +There is a second flavor for imported functions: dynamic functions. With Wasmer 0.x you would have created such a +function using `DynamicFunc::new`, here is how it's done with Wasmer 1.x: + +```rust +let sum_signature = FunctionType::new(vec![Type::I32, Type::I32], vec![Type::I32]); +let sum = Function::new(&store, &sum_signature, |args| { + let result = args[0].unwrap_I32() + args[1].unwrap_i32(); + + Ok(vec![Value::I32(result)]) +}); +``` + +Both examples address different needs and have their own pros and cons. We encourage you to have a look at the +dedicated example: [Exposing host functions][host-functions-example]. + +Note that having this API for functions now looks more like the other entities APIs: globals, memories, tables. Here is +a quick example introducing each of them: [Imports & Exports][imports-exports-example] + +### Accessing the environment as a host function + +With Wasmer 0.x each function had its own `vm::Ctx`. This was your entrypoint to the module internals and allowed +access to the context of the currently running instance. + +With Wasmer 1.0.0 this was changed to provide a simpler yet powerful API. + +Let's see an example where we want to have access to the module memory. Here is how that changed from 0.x to 1.0.0: + +```diff ++ #[derive(WasmerEnv, Clone, Default)] ++ struct MyEnv { ++ #[wasmer(export)] ++ memory: LazyInit, ++ } ++ let env = MyEnv::default(); ++ +- let get_at = |ctx: &mut vm::Ctx, ptr: WasmPtr, len: u32| { ++ let get_at = |env: &MyEnv, ptr: WasmPtr, len: u32| { +- let mem_desc = ctx.memory(0); +- let mem = mem_desc.deref(); ++ let mem = env.memory_ref().unwrap(); + + println!("Memory: {:?}", mem); + + let string = ptr.get_utf8_string(mem, len).unwrap(); + println!("string: {}", string); + }; + + let import_object = imports! { + "env" => { +- "get_at" => func!(get_at), ++ "get_at" => Function::new_native_with_env(&store, env.clone(), get_at), + } + }; + +- let instance = instantiate(wasm_bytes, &import_object)?; ++ let instance = Instance::new(&wasm_bytes, &import_object)?; +``` + +Here we have a module which provides one exported function: `get`. Each time we call this function it will in turn +call our imported function `get_at`. + +The `get_at` function is responsible for reading the guest module-s memory through the `vm::Ctx`. + +With Wasmer 1.0.0 (where the `vm::Ctx` does not exist anymore) we can achieve the same result with something more +natural: we only use imports and exports to read from the memory and write to it. + +However in order to provide an easy to use interface, we now have a trait +that can be implemented with a derive macro: `WasmerEnv`. We must make our +env types implement `WasmerEnv` and `Clone`. We mark an internal field +wrapped with `LazyInit` with `#[wasmer(export)]` to indicate that the type +should be found in the Wasm exports with the name of the field +(`"memory"`). The derive macro then generates helper functions such as +`memory_ref` on the type for easy access to these fields. + +See the [`WasmerEnv`](https://docs.rs/wasmer/*/wasmer/trait.WasmerEnv.html) +docs for more information. + +Take a look at the following examples to get more details: +* [Interacting with memory][memory] +* [Using memory pointers][memory-pointers] + +The other thing where `vm::Ctx` was useful was to pass data from and to host functions. This has also been made simpler +with Wasmer 1.x: + +```rust +let shared_counter: Arc> = Arc::new(RefCell::new(0)); + +#[derive(WasmerEnv, Clone)] +struct Env { + counter: Arc>, +} + +fn get_counter(env: &Env) -> i32 { + *env.counter.borrow() +} + +let get_counter_func = Function::new_native_with_env( + &store, + Env { counter: shared_counter.clone() }, + get_counter +); +``` + +A dedicated example describes how to use this feature: [Exposing host functions][host-functions]. + +### Error handling + +Handling errors with Wasmer 0.x was a bit hard, especially, the `wasmer_runtime::error::RuntimeError`. It was rather +complex: it had many variants that you had to handle when pattern matching results. This has been made way simpler with +Wasmer 1.0.0: + +```diff +// Retrieve the `get` function from module's exports and then call it +let result = get.call(0, 13); + +match result { +- Err(RuntimeError::InvokeError(InvokeError::TrapCode { .. })) => { +- // ... +- } +- Err(RuntimeError::InvokeError(InvokeError::FailedWithNoError)) => { +- // ... +- } +- Err(RuntimeError::InvokeError(InvokeError::UnknownTrap { .. })) => { +- // ... +- } +- Err(RuntimeError::InvokeError(InvokeError::UnknownTrapCode { .. })) => { +- // ... +- } +- Err(RuntimeError::InvokeError(InvokeError::EarlyTrap(_))) => { +- // ... +- } +- Err(RuntimeError::InvokeError(InvokeError::Breakpoint(_))) => { +- // ... +- } +- Err(RuntimeError::Metering(_)) => { +- // ... +- } +- Err(RuntimeError::InstanceImage(_)) => { +- // ... +- } +- Err(RuntimeError::User(_)) => { +- // ... +- } ++ Error(e) => { ++ println!("Error caught from `div_by_zero`: {}", e.message()); ++ ++ let frames = e.trace(); ++ let frames_len = frames.len(); ++ ++ // ... ++ } + Ok(_) => { + // ... + }, +} +``` + +As you can see here, handling errors is really easy now! You may find the following examples useful to get more familiar +with this topic: +* [Handling Errors][errors] +* [Interrupting Execution][exit-early] + +Note that with Wasmer 1.0.0, each function that is part of the API has its own kind of error. For example: +* Instantiating a module may return `InstantiationError`s; +* Getting exports from the guest module may return `ExportError`s; +* Calling an exported function may return `RuntimeError`s; +* ... + +### Caching modules + +You may be aware Wasmer, since 0.x, allows you to cache compiled module so that further executions of your program +will be faster. + +Because caching may bring a significant boost when running Wasm modules we wanted to make it easier to use with +Wasmer 1.0.0. + +With Wasmer 0.x you had to handle the whole caching process inside your program's code. With Wasmer 1.0.0 +you'll be able to delegate most of the work to Wasmer: + +```diff +- let artifact = module.cache().unwrap(); +- let bytes = artifact.serialize().unwrap(); +- +- let path = "module_cached.so"; +- fs::write(path, bytes).unwrap(); ++ module.serialize_to_file(path)?; + +- let mut file = File::open(path).unwrap(); +- let cached_bytes = &mut vec![]; +- file.read_to_end(cached_bytes); +- drop(file); +- +- let cached_artifact = Artifact::deserialize(&cached_bytes).unwrap(); +- let cached_module = unsafe { load_cache_with(cached_artifact, &default_compiler()) }.unwrap(); ++ let cached_module = unsafe { Module::deserialize_from_file(&store, path) }?; +``` + +[examples]: https://docs.wasmer.io/integrations/examples +[wasmer]: https://crates.io/crates/wasmer +[wasmer-wasi]: https://crates.io/crates/wasmer-wasi +[wasmer-emscripten]: https://crates.io/crates/wasmer-emscripten +[wasmer-engine]: https://crates.io/crates/wasmer-engine +[wasmer-compiler]: https://crates.io/crates/wasmer-compiler +[wasmer.io]: https://wasmer.io +[wasmer-nightly]: https://github.com/wasmerio/wasmer-nightly/ +[getting-started]: https://docs.wasmer.io/ecosystem/wasmer/getting-started +[instance-example]: https://docs.wasmer.io/integrations/examples/instance +[imports-exports-example]: https://docs.wasmer.io/integrations/examples/imports-and-exports +[host-functions-example]: https://docs.wasmer.io/integrations/examples/host-functions +[memory]: https://docs.wasmer.io/integrations/examples/memory +[memory-pointers]: https://docs.wasmer.io/integrations/examples/memory-pointers +[host-functions]: https://docs.wasmer.io/integrations/examples/host-functions +[errors]: https://docs.wasmer.io/integrations/examples/errors +[exit-early]: https://docs.wasmer.io/integrations/examples/exit-early diff --git a/runtime/near-vm/examples/README.md b/runtime/near-vm/examples/README.md new file mode 100644 index 00000000000..ac0d667779f --- /dev/null +++ b/runtime/near-vm/examples/README.md @@ -0,0 +1,370 @@ +# Wasmer Examples + +This directory contains a collection of examples. This isn't an +exhaustive collection though, if one example is missing, please ask, +we will be happy to fulfill your needs! + +## Handy Diagrams + +As a quick introduction to Wasmer's main workflows, here are three +diagrams. We hope it provides an overview of how the crates assemble +together. + +1. **Module compilation**, illustrates how WebAssembly bytes are + validated, parsed, and compiled, with the help of the + `wasmer::Module`, `wasmer_engine::Engine`, and + `wasmer_compiler::Compiler` API. + + ![Module compilation](../assets/diagrams/Diagram_module_compilation.png) + +2. **Module serialization**, illustrates how a module can be + serialized and deserialized, with the help of + `wasmer::Module::serialize` and `wasmer::Module::deserialize`. The + important part is that the engine can changed between those two + steps, and thus how a headless engine can be used for the + deserialization. + + ![Module serialization](../assets/diagrams/Diagram_module_serialization.png) + +3. **Module instantiation**, illustrates what happens when + `wasmer::Instance::new` is called. + + ![Module instantiation](../assets/diagrams/Diagram_module_instantiation.png) + +## Examples + +The examples are written in a difficulty/discovery order. Concepts that +are explained in an example is not necessarily re-explained in a next +example. + +### Basics + +1. [**Hello World**][hello-world], explains the core concepts of the Wasmer + API for compiling and executing WebAssembly. + + _Keywords_: introduction, instance, module. + +
+ Execute the example + + ```shell + $ cargo run --example hello-world --release --features "singlepass" + ``` + +
+ +2. [**Instantiating a module**][instance], explains the basics of using Wasmer + and how to create an instance out of a Wasm module. + + _Keywords_: instance, module. + +
+ Execute the example + + ```shell + $ cargo run --example instance --release --features "singlepass" + ``` + +
+ +3. [**Handling errors**][errors], explains the basics of interacting with + Wasm module memory. + + _Keywords_: instance, error. + +
+ Execute the example + + ```shell + $ cargo run --example errors --release --features "singlepass" + ``` + +
+ +4. [**Interacting with memory**][memory], explains the basics of interacting with + Wasm module memory. + + _Keywords_: memory, module. + +
+ Execute the example + + ```shell + $ cargo run --example memory --release --features "singlepass" + ``` + +
+ +### Exports + +1. [**Exported global**][exported-global], explains how to work with + exported globals: get/set their value, have information about their + type. + + _Keywords_: export, global. + +
+ Execute the example + + ```shell + $ cargo run --example exported-global --release --features "singlepass" + ``` + +
+ +2. [**Exported function**][exported-function], explains how to get and + how to call an exported function. They come in 2 flavors: dynamic, + and “static”/native. The pros and cons are discussed briefly. + + _Keywords_: export, function, dynamic, static, native. + +
+ Execute the example + + ```shell + $ cargo run --example exported-function --release --features "singlepass" + ``` + +
+ + +3. [**Exported memory**][exported-memory], explains how to read from + and write to exported memory. + + _Keywords_: export, memory. + +
+ Execute the example + + ```shell + $ cargo run --example exported-memory --release --features "singlepass" + ``` + +
+ +### Imports + +1. [**Imported global**][imported-global], explains how to work with + imported globals: create globals, import them, get/set their value. + + _Keywords_: import, global. + +
+ Execute the example + + ```shell + $ cargo run --example imported-global --release --features "singlepass" + ``` + +
+ +2. [**Imported function**][imported-function], explains how to define + an imported function. They come in 2 flavors: dynamic, + and “static”/native. + + _Keywords_: import, function, dynamic, static, native. + +
+ Execute the example + + ```shell + $ cargo run --example imported-function --release --features "singlepass" + ``` + +
+ +### Externs + +1. [**Table**][table], explains how to use Wasm Tables from the Wasmer API. + + _Keywords_: basic, table, call_indirect + +
+ Execute the example + + ```shell + $ cargo run --example table --release --features "singlepass" + ``` + +
+ +2. [**Memory**][memory], explains how to use Wasm Memories from + the Wasmer API. Memory example is a work in progress. + + _Keywords_: basic, memory + +
+ Execute the example + + ```shell + $ cargo run --example memory --release --features "singlepass" + ``` + +
+ +### Tunables + +1. [**Limit memory**][tunables-limit-memory], explains how to use Tunables to limit the + size of an exported Wasm memory + + _Keywords_: basic, tunables, memory + +
+ Execute the example + + ```shell + $ cargo run --example tunables-limit-memory --release --features "singlepass" + ``` + +
+ +### Engines + +1. [**Universal engine**][engine-universal], explains what an engine is, what the + Universal engine is, and how to set it up. The example completes itself + with the compilation of the Wasm module, its instantiation, and + finally, by calling an exported function. + + _Keywords_: Universal, engine, in-memory, executable code. + +
+ Execute the example + + ```shell + $ cargo run --example engine-universal --release --features "singlepass" + ``` + +
+ +2. [**Dylib engine**][engine-dylib], explains what a Dylib engine + is, and how to set it up. The example completes itself with the + compilation of the Wasm module, its instantiation, and finally, by + calling an exported function. + + _Keywords_: native, engine, shared library, dynamic library, + executable code. + +
+ Execute the example + + ```shell + $ cargo run --example engine-dylib --release --features "singlepass" + ``` + +
+ +3. [**Headless engines**][engine-headless], explains what a headless + engine is, what problem it does solve, and what are the benefits of + it. The example completes itself with the instantiation of a + pre-compiled Wasm module, and finally, by calling an exported + function. + + _Keywords_: native, engine, constrained environment, ahead-of-time + compilation, cross-compilation, executable code, serialization. + +
+ Execute the example + + ```shell + $ cargo run --example engine-headless --release --features "singlepass" + ``` + +
+ +4. [**Cross-compilation**][cross-compilation], illustrates the power + of the abstraction over the engines and the compilers, such as it + is possible to cross-compile a Wasm module for a custom target. + + _Keywords_: engine, compiler, cross-compilation. + +
+ Execute the example + + ```shell + $ cargo run --example cross-compilation --release --features "singlepass" + ``` + +
+ +5. [**Features**][features], illustrates how to enable WebAssembly + features that aren't yet stable. + + _Keywords_: engine, features. + +
+ Execute the example + + ```shell + $ cargo run --example features --release --features "singlepass" + ``` + +
+ +### Compilers + +1. [**Singlepass compiler**][compiler-singlepass], explains how to use + the [`wasmer-compiler-singlepass`] compiler. + + _Keywords_: compiler, singlepass. + +
+ Execute the example + + ```shell + $ cargo run --example compiler-singlepass --release --features "singlepass" + ``` + +
+ +### Integrations + +1. [**WASI**][wasi], explains how to use the [WebAssembly System + Interface][WASI] (WASI), i.e. the [`wasmer-wasi`] crate. + + _Keywords_: wasi, system, interface + +
+ Execute the example + + ```shell + $ cargo run --example wasi --release --features "singlepass,wasi" + ``` + +
+ +2. [**WASI Pipes**][wasi-pipes], builds on the WASI example to show off + stdio piping in Wasmer. + + _Keywords_: wasi, system, interface + +
+ Execute the example + + ```shell + $ cargo run --example wasi-pipes --release --features "singlepass,wasi" + ``` + +
+ +[hello-world]: ./hello_world.rs +[engine-universal]: ./engine_universal.rs +[engine-dylib]: ./engine_dylib.rs +[engine-headless]: ./engine_headless.rs +[compiler-singlepass]: ./compiler_singlepass.rs +[cross-compilation]: ./engine_cross_compilation.rs +[exported-global]: ./exports_global.rs +[exported-function]: ./exports_function.rs +[exported-memory]: ./exports_memory.rs +[imported-global]: ./imports_global.rs +[imported-function]: ./imports_function.rs +[instance]: ./instance.rs +[wasi]: ./wasi.rs +[wasi-pipes]: ./wasi_pipes.rs +[table]: ./table.rs +[memory]: ./memory.rs +[errors]: ./errors.rs +[tunables-limit-memory]: ./tunables_limit_memory.rs +[features]: ./features.rs +[`wasmer-compiler-singlepass`]: https://github.com/wasmerio/wasmer/tree/master/lib/compiler-singlepass +[`wasmer-wasi`]: https://github.com/wasmerio/wasmer/tree/master/lib/wasi +[WASI]: https://github.com/WebAssembly/WASI diff --git a/runtime/near-vm/examples/compiler_singlepass.rs b/runtime/near-vm/examples/compiler_singlepass.rs new file mode 100644 index 00000000000..a8f087dc198 --- /dev/null +++ b/runtime/near-vm/examples/compiler_singlepass.rs @@ -0,0 +1,66 @@ +//! A Wasm module can be compiled with multiple compilers. +//! +//! This example illustrates how to use the Singlepass compiler. +//! +//! You can run the example directly by executing in Wasmer root: +//! +//! ```shell +//! cargo run --example compiler-singlepass --release --features "singlepass" +//! ``` +//! +//! Ready? + +use wasmer::{imports, wat2wasm, Instance, Module, Store, Value}; +use wasmer_compiler_singlepass::Singlepass; +use wasmer_engine_universal::Universal; + +fn main() -> Result<(), Box> { + // Let's declare the Wasm module with the text representation. + let wasm_bytes = wat2wasm( + r#" +(module + (type $sum_t (func (param i32 i32) (result i32))) + (func $sum_f (type $sum_t) (param $x i32) (param $y i32) (result i32) + local.get $x + local.get $y + i32.add) + (export "sum" (func $sum_f))) +"# + .as_bytes(), + )?; + + // Use Singlepass compiler with the default settings + let compiler = Singlepass::default(); + + // Create the store + let store = Store::new(&Universal::new(compiler).engine()); + + println!("Compiling module..."); + // Let's compile the Wasm module. + let module = Module::new(&store, wasm_bytes)?; + + // Create an empty import object. + let import_object = imports! {}; + + println!("Instantiating module..."); + // Let's instantiate the Wasm module. + let instance = Instance::new(&module, &import_object)?; + + let sum = instance.lookup_function("sum").expect("function lookup"); + + println!("Calling `sum` function..."); + // Let's call the `sum` exported function. The parameters are a + // slice of `Value`s. The results are a boxed slice of `Value`s. + let results = sum.call(&[Value::I32(1), Value::I32(2)])?; + + println!("Results: {:?}", results); + assert_eq!(results.to_vec(), vec![Value::I32(3)]); + + Ok(()) +} + +#[test] +#[cfg(feature = "singlepass")] +fn test_compiler_singlepass() -> Result<(), Box> { + main() +} diff --git a/runtime/near-vm/examples/coremark.rs b/runtime/near-vm/examples/coremark.rs new file mode 100644 index 00000000000..c71067aae9a --- /dev/null +++ b/runtime/near-vm/examples/coremark.rs @@ -0,0 +1,39 @@ +//! Benchmark the codegen quality with a compute benchmark. +//! +//! ```shell +//! cargo run --example coremark --release --features "singlepass" +//! ``` + +use wasmer::{imports, Function, FunctionType, Instance, Module, Store, Type, Value}; +use wasmer_compiler_singlepass::Singlepass; +use wasmer_engine_universal::Universal; + +fn main() -> Result<(), Box> { + let wasm_bytes = include_bytes!("coremark.wasm"); + let compiler = Singlepass::default(); + let store = Store::new(&Universal::new(compiler).engine()); + println!("Compiling module..."); + let module = Module::new(&store, wasm_bytes)?; + let clock_ms_sig = FunctionType::new(vec![], vec![Type::I64]); + let start = std::time::Instant::now(); + let import_object = imports! { + "env" => { + "clock_ms" => Function::new(&store, clock_ms_sig, move |_| { + Ok(vec![Value::I64(start.elapsed().as_millis() as u64 as i64)]) + }) + } + }; + println!("Instantiating module..."); + let instance = Instance::new(&module, &import_object)?; + let run = instance.lookup_function("run").expect("function lookup"); + println!("Calling CoreMark 1.0. Should take 12~20 seconds..."); + let results = run.call(&[])?; + println!("Score: {:?}", results); + Ok(()) +} + +#[test] +#[cfg(feature = "singlepass")] +fn test_compiler_singlepass() -> Result<(), Box> { + main() +} diff --git a/runtime/near-vm/examples/coremark.wasm b/runtime/near-vm/examples/coremark.wasm new file mode 100644 index 00000000000..c5d6b878d53 Binary files /dev/null and b/runtime/near-vm/examples/coremark.wasm differ diff --git a/runtime/near-vm/examples/early_exit.rs b/runtime/near-vm/examples/early_exit.rs new file mode 100644 index 00000000000..345836e4178 --- /dev/null +++ b/runtime/near-vm/examples/early_exit.rs @@ -0,0 +1,112 @@ +//! There are cases where you may want to interrupt this synchronous execution of the Wasm module +//! while the it is calling a host function. This can be useful for saving resources, and not +//! returning back to the guest Wasm for execution, when you already know the Wasm execution will +//! fail, or no longer be needed. +//! +//! In this example, we will run a Wasm module that calls the imported host function +//! interrupt_execution. This host function will immediately stop executing the WebAssembly module. +//! +//! You can run the example directly by executing in Wasmer root: +//! +//! ```shell +//! cargo run --example early-exit --release --features "singlepass" +//! ``` +//! +//! Ready? + +use anyhow::bail; +use std::fmt; +use wasmer::{imports, wat2wasm, Function, Instance, Module, NativeFunc, RuntimeError, Store}; +use wasmer_compiler_singlepass::Singlepass; +use wasmer_engine_universal::Universal; + +// First we need to create an error type that we'll use to signal the end of execution. +#[derive(Debug, Clone, Copy)] +struct ExitCode(u32); + +// This type must implement `std::error::Error` so we must also implement `std::fmt::Display` for it. +impl fmt::Display for ExitCode { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + write!(f, "{}", self.0) + } +} + +// And then we implement `std::error::Error`. +impl std::error::Error for ExitCode {} + +fn main() -> anyhow::Result<()> { + // Let's declare the Wasm module with the text representation. + let wasm_bytes = wat2wasm( + br#" +(module + (type $run_t (func (param i32 i32) (result i32))) + (type $early_exit_t (func (param) (result))) + (import "env" "early_exit" (func $early_exit (type $early_exit_t))) + (func $run (type $run_t) (param $x i32) (param $y i32) (result i32) + (call $early_exit) + (i32.add + local.get $x + local.get $y)) + (export "run" (func $run))) +"#, + )?; + + // Create a Store. + // Note that we don't need to specify the engine/compiler if we want to use + // the default provided by Wasmer. + // You can use `Store::default()` for that. + let store = Store::new(&Universal::new(Singlepass::default()).engine()); + + println!("Compiling module..."); + // Let's compile the Wasm module. + let module = Module::new(&store, wasm_bytes)?; + + // We declare the host function that we'll use to terminate execution. + fn early_exit() { + // This is where it happens. + RuntimeError::raise(Box::new(ExitCode(1))); + } + + // Create an import object. + let import_object = imports! { + "env" => { + "early_exit" => Function::new_native(&store, early_exit), + } + }; + + println!("Instantiating module..."); + // Let's instantiate the Wasm module. + let instance = Instance::new(&module, &import_object)?; + + // Here we go. + // + // Get the `run` function which we'll use as our entrypoint. + println!("Calling `run` function..."); + let run_func: NativeFunc<(i32, i32), i32> = instance + .lookup_function("run") + .ok_or(anyhow::anyhow!("could not find `run` export"))? + .native()?; + + // When we call a function it can either succeed or fail. We expect it to fail. + match run_func.call(1, 7) { + Ok(result) => { + bail!( + "Expected early termination with `ExitCode`, found: {}", + result + ); + } + // In case of a failure, which we expect, we attempt to downcast the error into the error + // type that we were expecting. + Err(e) => match e.downcast::() { + // We found the exit code used to terminate execution. + Ok(exit_code) => { + println!("Exited early with exit code: {}", exit_code); + + Ok(()) + } + Err(e) => { + bail!("Unknown error `{}` found. expected `ErrorCode`", e); + } + }, + } +} diff --git a/runtime/near-vm/examples/engine_universal.rs b/runtime/near-vm/examples/engine_universal.rs new file mode 100644 index 00000000000..c9c88d8c35f --- /dev/null +++ b/runtime/near-vm/examples/engine_universal.rs @@ -0,0 +1,93 @@ +//! Defining an engine in Wasmer is one of the fundamental steps. +//! +//! This example illustrates how to use the `wasmer_engine_universal`, +//! aka the Universal engine. An engine applies roughly 2 steps: +//! +//! 1. It compiles the Wasm module bytes to executable code, through +//! the intervention of a compiler, +//! 2. It stores the executable code somewhere. +//! +//! In the particular context of the Universal engine, the executable +//! code is stored in memory. +//! +//! You can run the example directly by executing in Wasmer root: +//! +//! ```shell +//! cargo run --example engine-universal --release --features "singlepass" +//! ``` +//! +//! Ready? + +use wasmer::{imports, wat2wasm, Instance, Module, Store, Value}; +use wasmer_compiler_singlepass::Singlepass; +use wasmer_engine_universal::Universal; + +fn main() -> Result<(), Box> { + // Let's declare the Wasm module with the text representation. + let wasm_bytes = wat2wasm( + r#" +(module + (type $sum_t (func (param i32 i32) (result i32))) + (func $sum_f (type $sum_t) (param $x i32) (param $y i32) (result i32) + local.get $x + local.get $y + i32.add) + (export "sum" (func $sum_f))) +"# + .as_bytes(), + )?; + + // Define a compiler configuration. + // + // In this situation, the compiler is + // `wasmer_compiler_singlepass`. The compiler is responsible to + // compile the Wasm module into executable code. + let compiler_config = Singlepass::default(); + + println!("Creating Universal engine..."); + // Define the engine that will drive everything. + // + // In this case, the engine is `wasmer_engine_universal` which roughly + // means that the executable code will live in memory. + let engine = Universal::new(compiler_config).engine(); + + // Create a store, that holds the engine. + let store = Store::new(&engine); + + println!("Compiling module..."); + // Here we go. + // + // Let's compile the Wasm module. It is at this step that the Wasm + // text is transformed into Wasm bytes (if necessary), and then + // compiled to executable code by the compiler, which is then + // stored in memory by the engine. + let module = Module::new(&store, wasm_bytes)?; + + // Congrats, the Wasm module is compiled! Now let's execute it for + // the sake of having a complete example. + + // Create an import object. Since our Wasm module didn't declare + // any imports, it's an empty object. + let import_object = imports! {}; + + println!("Instantiating module..."); + // And here we go again. Let's instantiate the Wasm module. + let instance = Instance::new(&module, &import_object)?; + + println!("Calling `sum` function..."); + // The Wasm module exports a function called `sum`. + let sum = instance + .lookup_function("sum") + .ok_or("could not find `sum` export")?; + let results = sum.call(&[Value::I32(1), Value::I32(2)])?; + + println!("Results: {:?}", results); + assert_eq!(results.to_vec(), vec![Value::I32(3)]); + + Ok(()) +} + +#[test] +fn test_engine_universal() -> Result<(), Box> { + main() +} diff --git a/runtime/near-vm/examples/errors.rs b/runtime/near-vm/examples/errors.rs new file mode 100644 index 00000000000..4bbac7eb6bc --- /dev/null +++ b/runtime/near-vm/examples/errors.rs @@ -0,0 +1,103 @@ +//! A Wasm module can sometimes be invalid or trigger traps, and in those case we will get +//! an error back from the API. +//! +//! In this example we'll see how to handle such errors in the most +//! basic way. To do that we'll use a Wasm module that we know will +//! produce an error. +//! +//! You can run the example directly by executing in Wasmer root: +//! +//! ```shell +//! cargo run --example errors --release --features "singlepass" +//! ``` +//! +//! Ready? + +use wasmer::{imports, wat2wasm, Instance, Module, Store}; +use wasmer_compiler_singlepass::Singlepass; +use wasmer_engine_universal::Universal; + +fn main() -> Result<(), Box> { + // Let's declare the Wasm module with the text representation. + let wasm_bytes = wat2wasm( + br#" +(module + (type $do_div_by_zero_t (func (result i32))) + (func $do_div_by_zero_f (type $do_div_by_zero_t) (result i32) + i32.const 4 + i32.const 0 + i32.div_s) + + (type $div_by_zero_t (func (result i32))) + (func $div_by_zero_f (type $div_by_zero_t) (result i32) + call $do_div_by_zero_f) + (export "div_by_zero" (func $div_by_zero_f))) +"#, + )?; + + // Create a Store. + // Note that we don't need to specify the engine/compiler if we want to use + // the default provided by Wasmer. + // You can use `Store::default()` for that. + let store = Store::new(&Universal::new(Singlepass::default()).engine()); + + println!("Compiling module..."); + // Let's compile the Wasm module. + let module = Module::new(&store, wasm_bytes)?; + + // Create an import object. + let import_object = imports! {}; + + println!("Instantiating module..."); + // Let's instantiate the Wasm module. + let instance = Instance::new(&module, &import_object)?; + + // Here we go. + // + // The Wasm module exports a function called `div_by_zero`. As its name + // implies, this function will try to do a division by zero and thus + // produce an error. + // + // Let's get it. + let div_by_zero = instance + .lookup_function("div_by_zero") + .ok_or("could not find `div_by_zero` export")? + .native::<(), i32>()?; + + println!("Calling `div_by_zero` function..."); + // Let's call the `div_by_zero` exported function. + let result = div_by_zero.call(); + + // When we call a function it can either succeed or fail. We expect it to fail. + match result { + Ok(_) => { + // This should have thrown an error, return an error + panic!("div_by_zero did not error"); + } + Err(e) => { + // Log the error + println!("Error caught from `div_by_zero`: {}", e.message()); + + // Errors come with a trace we can inspect to get more + // information on the execution flow. + let frames = e.trace(); + let frames_len = frames.len(); + + for i in 0..frames_len { + println!( + " Frame #{}: {:?}::{:?}", + frames_len - i, + frames[i].module_name(), + frames[i].function_name().or(Some("")).unwrap() + ); + } + } + } + + Ok(()) +} + +#[test] +fn test_exported_function() -> Result<(), Box> { + main() +} diff --git a/runtime/near-vm/examples/exports_function.rs b/runtime/near-vm/examples/exports_function.rs new file mode 100644 index 00000000000..cc8b0d5e142 --- /dev/null +++ b/runtime/near-vm/examples/exports_function.rs @@ -0,0 +1,114 @@ +//! A Wasm module can export entities, like functions, memories, +//! globals and tables. +//! +//! This example illustrates how to use exported functions. They come +//! in 2 flavors: +//! +//! 1. Dynamic functions, where parameters and results are of a +//! slice of `Value`, +//! 2. Native function, where parameters and results are statically +//! typed Rust values. +//! +//! You can run the example directly by executing in Wasmer root: +//! +//! ```shell +//! cargo run --example exported-function --release --features "singlepass" +//! ``` +//! +//! Ready? + +use wasmer::{imports, wat2wasm, Instance, Module, Store, Value}; +use wasmer_compiler_singlepass::Singlepass; +use wasmer_engine_universal::Universal; + +fn main() -> Result<(), Box> { + // Let's declare the Wasm module with the text representation. + let wasm_bytes = wat2wasm( + r#" +(module + (type $sum_t (func (param i32 i32) (result i32))) + (func $sum_f (type $sum_t) (param $x i32) (param $y i32) (result i32) + local.get $x + local.get $y + i32.add) + (export "sum" (func $sum_f))) +"# + .as_bytes(), + )?; + + // Create a Store. + // Note that we don't need to specify the engine/compiler if we want to use + // the default provided by Wasmer. + // You can use `Store::default()` for that. + let store = Store::new(&Universal::new(Singlepass::default()).engine()); + + println!("Compiling module..."); + // Let's compile the Wasm module. + let module = Module::new(&store, wasm_bytes)?; + + // Create an empty import object. + let import_object = imports! {}; + + println!("Instantiating module..."); + // Let's instantiate the Wasm module. + let instance = Instance::new(&module, &import_object)?; + + // Here we go. + // + // The Wasm module exports a function called `sum`. Let's get + // it. Note that + // + // ``` + // get_function(name) + // ``` + // + // is just an alias to + // + // ``` + // get::(name)`. + // ``` + let sum = instance + .lookup_function("sum") + .ok_or("could not find `sum` export")?; + + println!("Calling `sum` function..."); + // Let's call the `sum` exported function. The parameters are a + // slice of `Value`s. The results are a boxed slice of `Value`s. + let args = [Value::I32(1), Value::I32(2)]; + let result = sum.call(&args)?; + + println!("Results: {:?}", result); + assert_eq!(result.to_vec(), vec![Value::I32(3)]); + + // That was fun. But what if we can get rid of the `Value`s? Well, + // that's possible with the `NativeFunction` API. The function + // will use native Rust values. + // + // Note that `native` takes 2 generic parameters: `Args` and + // `Rets`, respectively for the parameters and the results. If + // those values don't match the exported function signature, an + // error will be raised. + let sum_native = sum.native::<(i32, i32), i32>()?; + + println!("Calling `sum` function (natively)..."); + // Let's call the `sum` exported function. The parameters are + // statically typed Rust values of type `i32` and `i32`. The + // result, in this case particular case, in a unit of type `i32`. + let result = sum_native.call(3, 4)?; + + println!("Results: {:?}", result); + assert_eq!(result, 7); + + // Much nicer, isn't it? + // + // Those two API exist because they address different needs. The + // former has a more dynamic approach, while the second has a more + // static approach. + + Ok(()) +} + +#[test] +fn test_exported_function() -> Result<(), Box> { + main() +} diff --git a/runtime/near-vm/examples/exports_global.rs b/runtime/near-vm/examples/exports_global.rs new file mode 100644 index 00000000000..44900d398ca --- /dev/null +++ b/runtime/near-vm/examples/exports_global.rs @@ -0,0 +1,151 @@ +//! A Wasm module can export entities, like functions, memories, +//! globals and tables. +//! +//! This example illustrates how to use exported globals. They come +//! in 2 flavors: +//! +//! 1. Immutable globals (const), +//! 2. Mutable globals. +//! +//! You can run the example directly by executing in Wasmer root: +//! +//! ```shell +//! cargo run --example exported-global --release --features "singlepass" +//! ``` +//! +//! Ready? + +use wasmer::{imports, wat2wasm, Instance, Module, Mutability, Store, Type, Value}; +use wasmer_compiler_singlepass::Singlepass; +use wasmer_engine_universal::Universal; + +fn main() -> Result<(), Box> { + // Let's declare the Wasm module with the text representation. + let wasm_bytes = wat2wasm( + br#" +(module + (global $one (export "one") f32 (f32.const 1)) + (global $some (export "some") (mut f32) (f32.const 0)) + + (func (export "get_one") (result f32) (global.get $one)) + (func (export "get_some") (result f32) (global.get $some)) + + (func (export "set_some") (param f32) (global.set $some (local.get 0)))) +"#, + )?; + + // Create a Store. + // Note that we don't need to specify the engine/compiler if we want to use + // the default provided by Wasmer. + // You can use `Store::default()` for that. + let store = Store::new(&Universal::new(Singlepass::default()).engine()); + + println!("Compiling module..."); + // Let's compile the Wasm module. + let module = Module::new(&store, wasm_bytes)?; + + // Create an empty import object. + let import_object = imports! {}; + + println!("Instantiating module..."); + // Let's instantiate the Wasm module. + let instance = Instance::new(&module, &import_object)?; + + // Here we go. + // + // The Wasm module exports some globals. Let's get them. + // Note that + // + // ``` + // get_global(name) + // ``` + // + // is just an alias to + // + // ``` + // get::(name)`. + // ``` + let one = match instance.lookup("one") { + Some(wasmer::Export::Global(g)) => g, + _ => return Err("could not find `one` export as a global".into()), + }; + let some = match instance.lookup("some") { + Some(wasmer::Export::Global(g)) => g, + _ => return Err("could not find `some` export as a global".into()), + }; + + println!("Getting globals types information..."); + // Let's get the globals types. The results are `GlobalType`s. + let one_type = one.from.ty(); + let some_type = some.from.ty(); + + println!("`one` type: {:?} {:?}", one_type.mutability, one_type.ty); + assert_eq!(one_type.mutability, Mutability::Const); + assert_eq!(one_type.ty, Type::F32); + + println!("`some` type: {:?} {:?}", some_type.mutability, some_type.ty); + assert_eq!(some_type.mutability, Mutability::Var); + assert_eq!(some_type.ty, Type::F32); + + println!("Getting global values..."); + // Getting the values of globals can be done in two ways: + // 1. Through an exported function, + // 2. Using the Global API directly. + // + // We will use an exported function for the `one` global + // and the Global API for `some`. + let get_one = instance + .lookup_function("get_one") + .ok_or("could not find `get_one` export")? + .native::<(), f32>()?; + + let one_value = get_one.call()?; + let some_value = some.from.get(&store); + + println!("`one` value: {:?}", one_value); + assert_eq!(one_value, 1.0); + + println!("`some` value: {:?}", some_value); + assert_eq!(some_value, Value::F32(0.0)); + + println!("Setting global values..."); + // Trying to set the value of a immutable global (`const`) + // will result in a `RuntimeError`. + let result = unsafe { one.from.set(Value::F32(42.0)) }; + assert_eq!( + result.expect_err("Expected an error").to_string(), + "Attempted to set an immutable global" + ); + + let one_result = one.from.get(&store); + println!("`one` value after `set`: {:?}", one_result); + assert_eq!(one_result, Value::F32(1.0)); + + // Setting the values of globals can be done in two ways: + // 1. Through an exported function, + // 2. Using the Global API directly. + // + // We will use both for the `some` global. + let set_some = instance + .lookup_function("set_some") + .ok_or("could not find `set_some` export")? + .native::()?; + set_some.call(21.0)?; + let some_result = some.from.get(&store); + println!("`some` value after `set_some`: {:?}", some_result); + assert_eq!(some_result, Value::F32(21.0)); + + unsafe { + some.from.set(Value::F32(42.0))?; + } + let some_result = some.from.get(&store); + println!("`some` value after `set`: {:?}", some_result); + assert_eq!(some_result, Value::F32(42.0)); + + Ok(()) +} + +#[test] +fn test_exported_global() -> Result<(), Box> { + main() +} diff --git a/runtime/near-vm/examples/exports_memory.rs b/runtime/near-vm/examples/exports_memory.rs new file mode 100644 index 00000000000..5ec21ffb354 --- /dev/null +++ b/runtime/near-vm/examples/exports_memory.rs @@ -0,0 +1,131 @@ +//! A Wasm module can export entities, like functions, memories, +//! globals and tables. +//! +//! This example illustrates how to use exported memories +//! +//! You can run the example directly by executing in Wasmer root: +//! +//! ```shell +//! cargo run --example exported-memory --release --features "singlepass" +//! ``` +//! +//! Ready? + +use wasmer::{imports, wat2wasm, Array, Instance, Module, Store, WasmPtr}; +use wasmer_compiler_singlepass::Singlepass; +use wasmer_engine_universal::Universal; + +fn main() -> Result<(), Box> { + // Let's declare the Wasm module with the text representation. + let wasm_bytes = wat2wasm( + br#" +(module + (memory (export "mem") 1) + + (global $offset i32 (i32.const 42)) + (global $length (mut i32) (i32.const 13)) + + (func (export "load_offset") (result i32) + global.get $offset) + (func (export "load_length") (result i32) + global.get $length) + + (data (global.get $offset) "Hello, World!")) +"#, + )?; + + // Create a Store. + // Note that we don't need to specify the engine/compiler if we want to use + // the default provided by Wasmer. + // You can use `Store::default()` for that. + let store = Store::new(&Universal::new(Singlepass::default()).engine()); + + println!("Compiling module..."); + // Let's compile the Wasm module. + let module = Module::new(&store, wasm_bytes)?; + + // Create an empty import object. + let import_object = imports! {}; + + println!("Instantiating module..."); + // Let's instantiate the Wasm module. + let instance = Instance::new(&module, &import_object)?; + + let load_offset = instance + .lookup_function("load_offset") + .ok_or("could not find `load_offset` export")? + .native::<(), WasmPtr>()?; + let load_length = instance + .lookup_function("load_length") + .ok_or("could not find `load_length` export")? + .native::<(), i32>()?; + + // Here we go. + // + // The Wasm module exports a memory under "mem". Let's get it. + let memory = match instance.lookup("mem") { + Some(wasmer::Export::Memory(m)) => m, + _ => return Err("could not find `mem` as an exported memory".into()), + }; + let memory = wasmer::Memory::from_vmmemory(&store, memory); + + // Now that we have the exported memory, let's get some + // information about it. + // + // The first thing we might be intersted in is the size of the memory. + // Let's get it! + println!("Memory size (pages) {:?}", memory.size()); + println!("Memory size (bytes) {:?}", memory.data_size()); + + // Next, we'll want to read the contents of the memory. + // + // To do so, we have to get a `View` of the memory. + //let view = memory.view::(); + + // Oh! Wait, before reading the contents, we need to know + // where to find what we are looking for. + // + // Fortunately, the Wasm module exports a `load` function + // which will tell us the offset and length of the string. + let ptr = load_offset.call()?; + println!("String offset: {:?}", ptr.offset()); + let length = load_length.call()?; + println!("String length: {:?}", length); + + // We now know where to fin our string, let's read it. + // + // We will get bytes out of the memory so we need to + // decode them into a string. + let str = ptr.get_utf8_string(&memory, length as u32).unwrap(); + println!("Memory contents: {:?}", str); + + // What about changing the contents of the memory with a more + // appropriate string? + // + // To do that, we'll dereference our pointer and change the content + // of each `Cell` + let new_str = b"Hello, Wasmer!"; + let values = ptr.deref(&memory, 0, new_str.len() as u32).unwrap(); + for i in 0..new_str.len() { + values[i].set(new_str[i]); + } + + // And now, let's see the result. + // + // Since the new strings is bigger than the older one, we + // query the length again. The offset remains the same as + // before. + println!("New string length: {:?}", new_str.len()); + + let str = ptr.get_utf8_string(&memory, new_str.len() as u32).unwrap(); + println!("New memory contents: {:?}", str); + + // Much better, don't you think? + + Ok(()) +} + +#[test] +fn test_exported_memory() -> Result<(), Box> { + main() +} diff --git a/runtime/near-vm/examples/features.rs b/runtime/near-vm/examples/features.rs new file mode 100644 index 00000000000..209436f9623 --- /dev/null +++ b/runtime/near-vm/examples/features.rs @@ -0,0 +1,58 @@ +//! WebAssembly is a living standard. Wasmer integrates some +//! WebAssembly features that aren't yet stable but can still be +//! turned on. This example explains how. +//! +//! You can run the example directly by executing in Wasmer root: +//! +//! ```shell +//! cargo run --example features --release --features "singlepass" +//! ``` +//! +//! Ready? + +use wasmer::{imports, wat2wasm, Features, Instance, Module, Store, Value}; +use wasmer_compiler_singlepass::Singlepass; +use wasmer_engine_universal::Universal; + +fn main() -> anyhow::Result<()> { + // Let's declare the Wasm module with the text representation. + let wasm_bytes = wat2wasm( + br#" +(module + (type $swap_t (func (param i32 i64) (result i64 i32))) + (func $swap (type $swap_t) (param $x i32) (param $y i64) (result i64 i32) + (local.get $y) + (local.get $x)) + (export "swap" (func $swap))) +"#, + )?; + + // Set up the compiler. + let compiler = Singlepass::default(); + + // Let's declare the features. + let mut features = Features::new(); + // Enable the multi-value feature. + features.multi_value(true); + + // Set up the engine. That's where we define the features! + let engine = Universal::new(compiler).features(features); + + // Now, let's define the store, and compile the module. + let store = Store::new(&engine.engine()); + let module = Module::new(&store, wasm_bytes)?; + + // Finally, let's instantiate the module, and execute something + // :-). + let import_object = imports! {}; + let instance = Instance::new(&module, &import_object)?; + let swap = instance + .lookup_function("swap") + .ok_or(anyhow::anyhow!("could not find `swap` export"))?; + + let results = swap.call(&[Value::I32(1), Value::I64(2)])?; + + assert_eq!(results.to_vec(), vec![Value::I64(2), Value::I32(1)]); + + Ok(()) +} diff --git a/runtime/near-vm/examples/hello_world.rs b/runtime/near-vm/examples/hello_world.rs new file mode 100644 index 00000000000..b8f9845c855 --- /dev/null +++ b/runtime/near-vm/examples/hello_world.rs @@ -0,0 +1,90 @@ +//! This is a simple example introducing the core concepts of the Wasmer API. +//! +//! You can run the example directly by executing the following in the Wasmer root: +//! +//! ```shell +//! cargo run --example hello-world --release --features "singlepass" +//! ``` + +use wasmer::{imports, wat2wasm, Function, Instance, Module, NativeFunc, Store}; +use wasmer_compiler_singlepass::Singlepass; +use wasmer_engine_universal::Universal; + +fn main() -> anyhow::Result<()> { + // First we create a simple Wasm program to use with Wasmer. + // We use the WebAssembly text format and use `wasmer::wat2wasm` to compile + // it into a WebAssembly binary. + // + // Most WebAssembly programs come from compiling source code in a high level + // language and will already be in the binary format. + let wasm_bytes = wat2wasm( + br#" +(module + ;; First we define a type with no parameters and no results. + (type $no_args_no_rets_t (func (param) (result))) + + ;; Then we declare that we want to import a function named "env" "say_hello" with + ;; that type signature. + (import "env" "say_hello" (func $say_hello (type $no_args_no_rets_t))) + + ;; Finally we create an entrypoint that calls our imported function. + (func $run (type $no_args_no_rets_t) + (call $say_hello)) + ;; And mark it as an exported function named "run". + (export "run" (func $run))) +"#, + )?; + + // Next we create the `Store`, the top level type in the Wasmer API. + // + // Note that we don't need to specify the engine/compiler if we want to use + // the default provided by Wasmer. + // You can use `Store::default()` for that. + // + // However for the purposes of showing what's happening, we create a compiler + // (`Singlepass`) and pass it to an engine (`Universal`). We then pass the engine to + // the store and are now ready to compile and run WebAssembly! + let store = Store::new(&Universal::new(Singlepass::default()).engine()); + + // We then use our store and Wasm bytes to compile a `Module`. + // A `Module` is a compiled WebAssembly module that isn't ready to execute yet. + let module = Module::new(&store, wasm_bytes)?; + + // Next we'll set up our `Module` so that we can execute it. + + // We define a function to act as our "env" "say_hello" function imported in the + // Wasm program above. + fn say_hello_world() { + println!("Hello, world!") + } + + // We then create an import object so that the `Module`'s imports can be satisfied. + let import_object = imports! { + // We use the default namespace "env". + "env" => { + // And call our function "say_hello". + "say_hello" => Function::new_native(&store, say_hello_world), + } + }; + + // We then use the `Module` and the import object to create an `Instance`. + // + // An `Instance` is a compiled WebAssembly module that has been set up + // and is ready to execute. + let instance = Instance::new(&module, &import_object)?; + + // We get the `NativeFunc` with no parameters and no results from the instance. + // + // Recall that the Wasm module exported a function named "run", this is getting + // that exported function from the `Instance`. + let run_func: NativeFunc<(), ()> = instance + .lookup_function("run") + .ok_or(anyhow::anyhow!("could not find `run` export"))? + .native()?; + + // Finally, we call our exported Wasm function which will call our "say_hello" + // function and return. + run_func.call()?; + + Ok(()) +} diff --git a/runtime/near-vm/examples/imports_exports.rs b/runtime/near-vm/examples/imports_exports.rs new file mode 100644 index 00000000000..23167fbd2bd --- /dev/null +++ b/runtime/near-vm/examples/imports_exports.rs @@ -0,0 +1,124 @@ +//! A Wasm module can import and export entities, like functions, memories, globals and tables. +//! This example illustrates the basics of using these entities. +//! +//! In this example we'll be using a sample Wasm module which exports some entities and requires us +//! to also import some of them. +//! +//! The goal here is to give you an idea of how to work with imports and exports. We won't go into +//! the details of each entities, they'll be covered in more details in the other examples. +//! +//! You can run the example directly by executing in Wasmer root: +//! +//! ```shell +//! cargo run --example imports-exports --release --features "singlepass" +//! ``` +//! +//! Ready? + +use wasmer::{ + imports, wat2wasm, Function, FunctionType, Global, Instance, Module, Store, Type, Value, +}; +use wasmer_compiler_singlepass::Singlepass; +use wasmer_engine_universal::Universal; + +fn main() -> Result<(), Box> { + // Let's declare the Wasm module. + // + // We are using the text representation of the module here but you can also load `.wasm` + // files using the `include_bytes!` macro. + let wasm_bytes = wat2wasm( + br#" +(module + (func $host_function (import "" "host_function") (result i32)) + (global $host_global (import "env" "host_global") i32) + + (func $function (export "guest_function") (result i32) (global.get $global)) + (global $global (export "guest_global") i32 (i32.const 42)) + (table $table (export "guest_table") 1 1 funcref) + (memory $memory (export "guest_memory") 1)) +"#, + )?; + + // Create a Store. + // Note that we don't need to specify the engine/compiler if we want to use + // the default provided by Wasmer. + // You can use `Store::default()` for that. + let store = Store::new(&Universal::new(Singlepass::default()).engine()); + + println!("Compiling module..."); + // Let's compile the Wasm module. + let module = Module::new(&store, wasm_bytes)?; + + // Here we go. + // + // Before we can instantiate our module, we need to define + // the entities we will import. + // + // We won't go into details here as creating entities will be + // covered in more detail in other examples. + println!("Creating the imported function..."); + let host_function_signature = FunctionType::new(vec![], vec![Type::I32]); + let host_function = Function::new(&store, &host_function_signature, |_args| { + Ok(vec![Value::I32(42)]) + }); + + println!("Creating the imported global..."); + let host_global = Global::new(&store, Value::I32(42)); + + // Create an import object. + // + // Imports are stored in namespaces. We'll need to register each of the + // namespaces with a name and add the imported entities there. + // + // Note that the namespace can also have an empty name. + // + // Our module requires us to import: + // * A function `host_function` in a namespace with an empty name; + // * A global `host_global` in the `env` namespace. + // + // Let's do this! + let import_object = imports! { + "" => { + "host_function" => host_function, + }, + "env" => { + "host_global" => host_global, + }, + }; + + println!("Instantiating module..."); + // Let's instantiate the Wasm module. + let instance = Instance::new(&module, &import_object)?; + + // Here we go. + // + // The Wasm module exports some entities: + // * A function: `guest_function` + // * A global: `guest_global` + // * A memory: `guest_memory` + // * A table: `guest_table` + // + // Let's get them. + println!("Getting the exported function..."); + let function = instance.lookup("guest_function"); + println!("Got exported function: {:?}", function); + + println!("Getting the exported global..."); + let global = instance.lookup("guest_global"); + println!("Got exported global: {:?}", global); + + println!("Getting the exported memory..."); + let memory = instance.lookup("guest_memory"); + println!("Got exported memory: {:?}", memory); + + println!("Getting the exported table..."); + let table = instance.lookup("guest_table"); + println!("Got exported table: {:?}", table); + + Ok(()) +} + +#[test] +fn test_imports_exports() -> Result<(), Box> { + main() +} diff --git a/runtime/near-vm/examples/imports_function.rs b/runtime/near-vm/examples/imports_function.rs new file mode 100644 index 00000000000..544bafdbfb6 --- /dev/null +++ b/runtime/near-vm/examples/imports_function.rs @@ -0,0 +1,107 @@ +//! A Wasm module can import entities, like functions, memories, +//! globals and tables. +//! +//! This example illustrates how to use imported functions. They come +//! in 2 flavors: +//! +//! 1. Dynamic functions, where parameters and results are of a +//! slice of `Value`, +//! 2. Native function, where parameters and results are statically +//! typed Rust values. +//! +//! You can run the example directly by executing in Wasmer root: +//! +//! ```shell +//! cargo run --example imported-function --release --features "singlepass" +//! ``` +//! +//! Ready? + +use wasmer::{imports, wat2wasm, Function, FunctionType, Instance, Module, Store, Type, Value}; +use wasmer_compiler_singlepass::Singlepass; +use wasmer_engine_universal::Universal; + +fn main() -> Result<(), Box> { + // Let's declare the Wasm module with the text representation. + let wasm_bytes = wat2wasm( + br#" +(module + (func $multiply_dynamic (import "env" "multiply_dynamic") (param i32) (result i32)) + (func $multiply_native (import "env" "multiply_native") (param i32) (result i32)) + + (type $sum_t (func (param i32) (param i32) (result i32))) + (func $sum_f (type $sum_t) (param $x i32) (param $y i32) (result i32) + (call $multiply_dynamic (local.get $x)) + (call $multiply_native (local.get $y)) + i32.add) + (export "sum" (func $sum_f))) +"#, + )?; + + // Create a Store. + // Note that we don't need to specify the engine/compiler if we want to use + // the default provided by Wasmer. + // You can use `Store::default()` for that. + let store = Store::new(&Universal::new(Singlepass::default()).engine()); + + println!("Compiling module..."); + // Let's compile the Wasm module. + let module = Module::new(&store, wasm_bytes)?; + + // Create the functions + let multiply_dynamic_signature = FunctionType::new(vec![Type::I32], vec![Type::I32]); + let multiply_dynamic = Function::new(&store, &multiply_dynamic_signature, |args| { + println!("Calling `multiply_dynamic`..."); + + let result = args[0].unwrap_i32() * 2; + + println!("Result of `multiply_dynamic`: {:?}", result); + + Ok(vec![Value::I32(result)]) + }); + + fn multiply(a: i32) -> i32 { + println!("Calling `multiply_native`..."); + let result = a * 3; + + println!("Result of `multiply_native`: {:?}", result); + + result + } + let multiply_native = Function::new_native(&store, multiply); + + // Create an import object. + let import_object = imports! { + "env" => { + "multiply_dynamic" => multiply_dynamic, + "multiply_native" => multiply_native, + } + }; + + println!("Instantiating module..."); + // Let's instantiate the Wasm module. + let instance = Instance::new(&module, &import_object)?; + + // Here we go. + // + // The Wasm module exports a function called `sum`. Let's get it. + let sum = instance + .lookup_function("sum") + .ok_or("could not find `sum` export")? + .native::<(i32, i32), i32>()?; + + println!("Calling `sum` function..."); + // Let's call the `sum` exported function. It will call each + // of the imported functions. + let result = sum.call(1, 2)?; + + println!("Results of `sum`: {:?}", result); + assert_eq!(result, 8); + + Ok(()) +} + +#[test] +fn test_exported_function() -> Result<(), Box> { + main() +} diff --git a/runtime/near-vm/examples/imports_function_env.rs b/runtime/near-vm/examples/imports_function_env.rs new file mode 100644 index 00000000000..49ec23621da --- /dev/null +++ b/runtime/near-vm/examples/imports_function_env.rs @@ -0,0 +1,131 @@ +//! A Wasm module can import entities, like functions, memories, +//! globals and tables. +//! +//! In this example, we'll create a system for getting and adjusting a counter value. However, host +//! functions are not limited to storing data outside of Wasm, they're normal host functions and +//! can do anything that the host can do. +//! +//! 1. There will be a `get_counter` function that will return an i32 of +//! the current global counter, +//! 2. There will be an `add_to_counter` function will add the passed +//! i32 value to the counter, and return an i32 of the current +//! global counter. +//! +//! You can run the example directly by executing in Wasmer root: +//! +//! ```shell +//! cargo run --example imported-function-env --release --features "singlepass" +//! ``` +//! +//! Ready? + +use std::sync::{Arc, Mutex}; +use wasmer::{imports, wat2wasm, Function, Instance, Module, Store, WasmerEnv}; +use wasmer_compiler_singlepass::Singlepass; +use wasmer_engine_universal::Universal; + +fn main() -> Result<(), Box> { + // Let's declare the Wasm module with the text representation. + let wasm_bytes = wat2wasm( + br#" +(module + (func $get_counter (import "env" "get_counter") (result i32)) + (func $add_to_counter (import "env" "add_to_counter") (param i32) (result i32)) + + (type $increment_t (func (param i32) (result i32))) + (func $increment_f (type $increment_t) (param $x i32) (result i32) + (block + (loop + (call $add_to_counter (i32.const 1)) + (set_local $x (i32.sub (get_local $x) (i32.const 1))) + (br_if 1 (i32.eq (get_local $x) (i32.const 0))) + (br 0))) + call $get_counter) + (export "increment_counter_loop" (func $increment_f))) +"#, + )?; + + // Create a Store. + // Note that we don't need to specify the engine/compiler if we want to use + // the default provided by Wasmer. + // You can use `Store::default()` for that. + let store = Store::new(&Universal::new(Singlepass::default()).engine()); + + println!("Compiling module..."); + // Let's compile the Wasm module. + let module = Module::new(&store, wasm_bytes)?; + + // We create some shared data here, `Arc` is required because we may + // move our WebAssembly instance to another thread to run it. Mutex + // lets us get shared mutabilty which is fine because we know we won't + // run host calls concurrently. If concurrency is a possibilty, we'd have + // to use a `Mutex`. + let shared_counter: Arc> = Arc::new(Mutex::new(0)); + + // Once we have our counter we'll wrap it inside en `Env` which we'll pass + // to our imported functions. + // + // This struct may have been anything. The only constraint is it must be + // possible to know the size of the `Env` at compile time (i.e it has to + // implement the `Sized` trait) and that it implement the `WasmerEnv` trait. + // We derive a default implementation of `WasmerEnv` here. + #[derive(Clone)] + struct Env { + counter: Arc>, + } + impl WasmerEnv for Env {} + + // Create the functions + fn get_counter(env: &Env) -> i32 { + *env.counter.lock().unwrap() + } + fn add_to_counter(env: &Env, add: i32) -> i32 { + let mut counter_ref = env.counter.lock().unwrap(); + + *counter_ref += add; + *counter_ref + } + + // Create an import object. + let import_object = imports! { + "env" => { + "get_counter" => Function::new_native_with_env(&store, Env { counter: shared_counter.clone() }, get_counter), + "add_to_counter" => Function::new_native_with_env(&store, Env { counter: shared_counter.clone() }, add_to_counter), + } + }; + + println!("Instantiating module..."); + // Let's instantiate the Wasm module. + let instance = Instance::new(&module, &import_object)?; + + // Here we go. + // + // The Wasm module exports a function called `increment_counter_loop`. Let's get it. + let increment_counter_loop = instance + .lookup_function("increment_counter_loop") + .ok_or("could not find `increment_counter_loop` export")? + .native::()?; + + let counter_value: i32 = *shared_counter.lock().unwrap(); + println!("Initial ounter value: {:?}", counter_value); + + println!("Calling `increment_counter_loop` function..."); + // Let's call the `increment_counter_loop` exported function. + // + // It will loop five times thus incrementing our counter five times. + let result = increment_counter_loop.call(5)?; + + let counter_value: i32 = *shared_counter.lock().unwrap(); + println!("New counter value (host): {:?}", counter_value); + assert_eq!(counter_value, 5); + + println!("New counter value (guest): {:?}", result); + assert_eq!(result, 5); + + Ok(()) +} + +#[test] +fn test_imported_function_env() -> Result<(), Box> { + main() +} diff --git a/runtime/near-vm/examples/imports_global.rs b/runtime/near-vm/examples/imports_global.rs new file mode 100644 index 00000000000..d6a38c58cd1 --- /dev/null +++ b/runtime/near-vm/examples/imports_global.rs @@ -0,0 +1,120 @@ +//! A Wasm module can import entities, like functions, memories, +//! globals and tables. +//! +//! This example illustrates how to use imported globals. They come +//! in 2 flavors: +//! +//! 1. Immutable globals (const), +//! 2. Mutable globals. +//! +//! You can run the example directly by executing in Wasmer root: +//! +//! ```shell +//! cargo run --example imported-global --release --features "singlepass" +//! ``` +//! +//! Ready? + +use wasmer::{imports, wat2wasm, Global, Instance, Module, Store, Value}; +use wasmer_compiler_singlepass::Singlepass; +use wasmer_engine_universal::Universal; + +fn main() -> Result<(), Box> { + // Let's declare the Wasm module with the text representation. + let wasm_bytes = wat2wasm( + br#" +(module + (global $some (import "env" "some") f32) + (global $other (import "env" "other") (mut f32)) + + (func (export "get_some") (result f32) (global.get $some)) + (func (export "get_other") (result f32) (global.get $other)) + + (func (export "set_other") (param f32) (global.set $other (local.get 0)))) +"#, + )?; + + // Create a Store. + // Note that we don't need to specify the engine/compiler if we want to use + // the default provided by Wasmer. + // You can use `Store::default()` for that. + let store = Store::new(&Universal::new(Singlepass::default()).engine()); + + println!("Compiling module..."); + // Let's compile the Wasm module. + let module = Module::new(&store, wasm_bytes)?; + + // Create the globals + let some = Global::new(&store, Value::F32(1.0)); + let other = Global::new_mut(&store, Value::F32(2.0)); + + // Create an import object. + // We add the two required globals in the `env` namespace. + let import_object = imports! { + "env" => { + "some" => some.clone(), + "other" => other.clone(), + } + }; + + println!("Instantiating module..."); + // Let's instantiate the Wasm module. + let instance = Instance::new(&module, &import_object)?; + + // Here we go. + // + // The Wasm module only imports some globals. We'll have to interact + // with them either using the Global API or exported functions. + let get_some = instance + .lookup_function("get_some") + .ok_or("could not find `get_some` export")? + .native::<(), f32>()?; + let get_other = instance + .lookup_function("get_other") + .ok_or("could not find `get_other` export")? + .native::<(), f32>()?; + + let some_result = get_some.call()?; + let other_result = get_other.call()?; + + println!("some value (via `get_some`): {:?}", some_result); + println!("some value (via Global API): {:?}", some.get()); + println!("other value (via `get_other`): {:?}", other_result); + println!("other value (via Global API): {:?}", other.get()); + + assert_eq!(some_result, some.get().f32().unwrap()); + assert_eq!(other_result, other.get().f32().unwrap()); + + println!("Setting global values..."); + // Trying to set the value of a immutable global (`const`) + // will result in a `RuntimeError`. + let result = some.set(Value::F32(42.0)); + assert_eq!( + result.expect_err("Expected an error").message(), + "Attempted to set an immutable global" + ); + + other.set(Value::F32(21.0))?; + let other_result = other.get(); + println!("other value after `set`: {:?}", other_result); + assert_eq!(other_result, Value::F32(21.0)); + + println!("Altering global values through exported functions..."); + // Changes made to global through exported functions will + // be reflected on the host side. + let set_other = instance + .lookup_function("set_other") + .ok_or("could not find `set_other` export")? + .native::()?; + set_other.call(42.0)?; + + println!("other value (via Global API): {:?}", other.get()); + assert_eq!(other.get(), Value::F32(42.0)); + + Ok(()) +} + +#[test] +fn test_imported_global() -> Result<(), Box> { + main() +} diff --git a/runtime/near-vm/examples/instance.rs b/runtime/near-vm/examples/instance.rs new file mode 100644 index 00000000000..e2d8e921f45 --- /dev/null +++ b/runtime/near-vm/examples/instance.rs @@ -0,0 +1,80 @@ +//! Wasmer will let you easily run Wasm module in a Rust host. +//! +//! This example illustrates the basics of using Wasmer through a "Hello World"-like project: +//! +//! 1. How to load a Wasm modules as bytes +//! 2. How to compile the module +//! 3. How to create an instance of the module +//! +//! You can run the example directly by executing in Wasmer root: +//! +//! ```shell +//! cargo run --example instance --release --features "singlepass" +//! ``` +//! +//! Ready? + +use wasmer::{imports, wat2wasm, Instance, Module, Store}; +use wasmer_compiler_singlepass::Singlepass; +use wasmer_engine_universal::Universal; + +fn main() -> Result<(), Box> { + // Let's declare the Wasm module. + // + // We are using the text representation of the module here but you can also load `.wasm` + // files using the `include_bytes!` macro. + let wasm_bytes = wat2wasm( + br#" +(module + (type $add_one_t (func (param i32) (result i32))) + (func $add_one_f (type $add_one_t) (param $value i32) (result i32) + local.get $value + i32.const 1 + i32.add) + (export "add_one" (func $add_one_f))) +"#, + )?; + + // Create a Store. + // Note that we don't need to specify the engine/compiler if we want to use + // the default provided by Wasmer. + // You can use `Store::default()` for that. + let store = Store::new(&Universal::new(Singlepass::default()).engine()); + + println!("Compiling module..."); + // Let's compile the Wasm module. + let module = Module::new(&store, wasm_bytes)?; + + // Create an empty import object. + let import_object = imports! {}; + + println!("Instantiating module..."); + // Let's instantiate the Wasm module. + let instance = Instance::new(&module, &import_object)?; + + // We now have an instance ready to be used. + // + // From an `Instance` we can retrieve any exported entities. + // Each of these entities is covered in others examples. + // + // Here we are retrieving the exported function. We won't go into details here + // as the main focus of this example is to show how to create an instance out + // of a Wasm module and have basic interactions with it. + let add_one = instance + .lookup_function("add_one") + .ok_or("could not find `add_one` export")? + .native::()?; + + println!("Calling `add_one` function..."); + let result = add_one.call(1)?; + + println!("Results of `add_one`: {:?}", result); + assert_eq!(result, 2); + + Ok(()) +} + +#[test] +fn test_exported_function() -> Result<(), Box> { + main() +} diff --git a/runtime/near-vm/examples/memory.rs b/runtime/near-vm/examples/memory.rs new file mode 100644 index 00000000000..816b4ba93d9 --- /dev/null +++ b/runtime/near-vm/examples/memory.rs @@ -0,0 +1,155 @@ +//! With Wasmer you'll be able to interact with guest module memory. +//! +//! This example illustrates the basics of interacting with Wasm module memory.: +//! +//! 1. How to load a Wasm modules as bytes +//! 2. How to compile the module +//! 3. How to create an instance of the module +//! +//! You can run the example directly by executing in Wasmer root: +//! +//! ```shell +//! cargo run --example memory --release --features "singlepass" +//! ``` +//! +//! Ready? + +use std::mem; +use wasmer::{imports, wat2wasm, Bytes, Instance, Module, NativeFunc, Pages, Store}; +use wasmer_compiler_singlepass::Singlepass; +use wasmer_engine_universal::Universal; + +// this example is a work in progress: +// TODO: clean it up and comment it https://github.com/wasmerio/wasmer/issues/1749 + +fn main() -> anyhow::Result<()> { + // Let's declare the Wasm module. + // + // We are using the text representation of the module here but you can also load `.wasm` + // files using the `include_bytes!` macro. + let wasm_bytes = wat2wasm( + r#" +(module + (type $mem_size_t (func (result i32))) + (type $get_at_t (func (param i32) (result i32))) + (type $set_at_t (func (param i32) (param i32))) + + (memory $mem 1) + + (func $get_at (type $get_at_t) (param $idx i32) (result i32) + (i32.load (local.get $idx))) + + (func $set_at (type $set_at_t) (param $idx i32) (param $val i32) + (i32.store (local.get $idx) (local.get $val))) + + (func $mem_size (type $mem_size_t) (result i32) + (memory.size)) + + (export "get_at" (func $get_at)) + (export "set_at" (func $set_at)) + (export "mem_size" (func $mem_size)) + (export "memory" (memory $mem))) +"# + .as_bytes(), + )?; + + // Create a Store. + // Note that we don't need to specify the engine/compiler if we want to use + // the default provided by Wasmer. + // You can use `Store::default()` for that. + let store = Store::new(&Universal::new(Singlepass::default()).engine()); + + println!("Compiling module..."); + // Let's compile the Wasm module. + let module = Module::new(&store, wasm_bytes)?; + + // Create an empty import object. + let import_object = imports! {}; + + println!("Instantiating module..."); + // Let's instantiate the Wasm module. + let instance = Instance::new(&module, &import_object)?; + + // The module exports some utility functions, let's get them. + // + // These function will be used later in this example. + let mem_size: NativeFunc<(), i32> = instance + .lookup_function("mem_size") + .ok_or(anyhow::anyhow!("could not find `mem_size` export"))? + .native()?; + let get_at: NativeFunc = instance + .lookup_function("get_at") + .ok_or(anyhow::anyhow!("could not find `get_at` export"))? + .native()?; + let set_at: NativeFunc<(i32, i32), ()> = instance + .lookup_function("set_at") + .ok_or(anyhow::anyhow!("could not find `set_at` export"))? + .native()?; + let memory = match instance.lookup("memory") { + Some(wasmer::Export::Memory(m)) => m, + _ => anyhow::bail!("could not find `memory` as an exported memory"), + }; + + // We now have an instance ready to be used. + // + // We will start by querying the most intersting information + // about the memory: its size. There are mainly two ways of getting + // this: + // * the size as a number of `Page`s + // * the size as a number of bytes + // + // The size in bytes can be found either by querying its pages or by + // querying the memory directly. + println!("Querying memory size..."); + assert_eq!(memory.from.size(), Pages::from(1)); + assert_eq!(memory.from.size().bytes(), Bytes::from(65536 as usize)); + unsafe { + assert_eq!(memory.from.vmmemory().as_ref().current_length, 65536); + } + + // Sometimes, the guest module may also export a function to let you + // query the memory. Here we have a `mem_size` function, let's try it: + let result = mem_size.call()?; + println!("Memory size: {:?}", result); + assert_eq!(Pages::from(result as u32), memory.from.size()); + + // Now that we know the size of our memory, it's time to see how wa + // can change this. + // + // A memory can be grown to allow storing more things into it. Let's + // see how we can do that: + println!("Growing memory..."); + // Here we are requesting two more pages for our memory. + memory.from.grow(Pages::from(2))?; + assert_eq!(memory.from.size(), Pages::from(3)); + unsafe { + assert_eq!(memory.from.vmmemory().as_ref().current_length, 65536 * 3); + } + + // Now that we know how to query and adjust the size of the memory, + // let's see how wa can write to it or read from it. + // + // We'll only focus on how to do this using exported functions, the goal + // is to show how to work with memory addresses. Here we'll use absolute + // addresses to write and read a value. + let mem_addr = 0x2220; + let val = 0xFEFEFFE; + set_at.call(mem_addr, val)?; + + let result = get_at.call(mem_addr)?; + println!("Value at {:#x?}: {:?}", mem_addr, result); + assert_eq!(result, val); + + // Now instead of using hard coded memory addresses, let's try to write + // something at the end of the second memory page and read it. + let page_size = 0x1_0000; + let mem_addr = (page_size * 2) - mem::size_of_val(&val) as i32; + let val = 0xFEA09; + set_at.call(mem_addr, val)?; + + let result = get_at.call(mem_addr)?; + println!("Value at {:#x?}: {:?}", mem_addr, result); + assert_eq!(result, val); + + Ok(()) +} diff --git a/runtime/near-vm/examples/table.rs b/runtime/near-vm/examples/table.rs new file mode 100644 index 00000000000..c63f550bf27 --- /dev/null +++ b/runtime/near-vm/examples/table.rs @@ -0,0 +1,183 @@ +use wasmer::{ + imports, wat2wasm, Function, Instance, Module, NativeFunc, Store, TableType, Type, Value, +}; +use wasmer_compiler_singlepass::Singlepass; +use wasmer_engine_universal::Universal; +use wasmer_vm::TableElement; + +/// A function we'll call through a table. +fn host_callback(arg1: i32, arg2: i32) -> i32 { + arg1 + arg2 +} + +fn main() -> anyhow::Result<()> { + let wasm_bytes = wat2wasm( + r#" +(module + ;; All our callbacks will take 2 i32s and return an i32. + ;; Wasm tables are not limited to 1 type of function, but the code using the + ;; table must have code to handle the type it finds. + (type $callback_t (func (param i32 i32) (result i32))) + + ;; We'll call a callback by passing a table index as an i32 and then the two + ;; arguments that the function expects. + (type $call_callback_t (func (param i32 i32 i32) (result i32))) + + ;; Our table of functions that's exactly size 3 (min 3, max 3). + (table $t1 3 6 funcref) + + ;; Call the function at the given index with the two supplied arguments. + (func $call_callback (type $call_callback_t) (param $idx i32) + (param $arg1 i32) (param $arg2 i32) + (result i32) + (call_indirect (type $callback_t) + (local.get $arg1) (local.get $arg2) + (local.get $idx))) + + ;; A default function that we'll pad the table with. + ;; This function doubles both its inputs and then sums them. + (func $default_fn (type $callback_t) (param $a i32) (param $b i32) (result i32) + (i32.add + (i32.mul (local.get $a) (i32.const 2)) + (i32.mul (local.get $b) (i32.const 2)))) + + ;; Fill our table with the default function. + (elem $t1 (i32.const 0) $default_fn $default_fn $default_fn) + + ;; Export things for the host to call. + (export "call_callback" (func $call_callback)) + (export "__indirect_function_table" (table $t1))) +"# + .as_bytes(), + )?; + + // We set up our store with an engine and a compiler. + let store = Store::new(&Universal::new(Singlepass::default()).engine()); + // Then compile our Wasm. + let module = Module::new(&store, wasm_bytes)?; + let import_object = imports! {}; + // And instantiate it with no imports. + let instance = Instance::new(&module, &import_object)?; + + // We get our function that calls (i32, i32) -> i32 functions via table. + // The first argument is the table index and the next 2 are the 2 arguments + // to be passed to the function found in the table. + let call_via_table: NativeFunc<(i32, i32, i32), i32> = instance + .lookup_function("call_callback") + .ok_or(anyhow::anyhow!("could not find `call_callback` export"))? + .native()?; + + // And then call it with table index 1 and arguments 2 and 7. + let result = call_via_table.call(1, 2, 7)?; + // Because it's the default function, we expect it to double each number and + // then sum it, giving us 18. + assert_eq!(result, 18); + + // We then get the table from the instance. + let export = instance + .lookup("__indirect_function_table") + .ok_or(anyhow::anyhow!( + "could not find `__indirect_function_table` export" + ))?; + let guest_table = if let wasmer::Export::Table(guest_table) = export { + // And demonstrate that it has the properties that we set in the Wasm. + assert_eq!(guest_table.from.size(), 3); + assert_eq!( + guest_table.ty(), + &TableType { + ty: Type::FuncRef, + minimum: 3, + maximum: Some(6) + } + ); + guest_table + } else { + anyhow::bail!("`__indirect_function_table` is not a table") + }; + + // == Setting elements in a table == + + // We first construct a `Function` over our host_callback. + let func = Function::new_native(&store, host_callback); + + // And set table index 1 of that table to the host_callback `Function`. + guest_table + .from + .set(1, func.into()) + .map_err(|t| anyhow::anyhow!(format!("trap: {:?}", t)))?; + + // We then repeat the call from before but this time it will find the host function + // that we put at table index 1. + let result = call_via_table.call(1, 2, 7)?; + // And because our host function simply sums the numbers, we expect 9. + assert_eq!(result, 9); + + // == Growing a table == + + // We again construct a `Function` over our host_callback. + let func = Function::new_native(&store, host_callback); + + // And grow the table by 3 elements, filling in our host_callback in all the + // new elements of the table. + let previous_size = guest_table + .from + .grow(3, func.into()) + .ok_or(anyhow::anyhow!("could not grow the table"))?; + assert_eq!(previous_size, 3); + + assert_eq!(guest_table.from.size(), 6); + assert_eq!( + guest_table.ty(), + &TableType { + ty: Type::FuncRef, + minimum: 3, + maximum: Some(6) + } + ); + // Now demonstrate that the function we grew the table with is actually in the table. + for table_index in 3..6 { + if let Some(TableElement::FuncRef(f)) = guest_table.from.get(table_index as _) { + unsafe { + let result = Function::from_vm_funcref(&store, f) + .expect("funcref should not be null") + .call(&[Value::I32(1), Value::I32(9)])?; + assert_eq!(result[0], Value::I32(10)); + } + } else { + panic!("expected to find funcref in table!"); + } + } + + // Call function at index 0 to show that it's still the same. + let result = call_via_table.call(0, 2, 7)?; + assert_eq!(result, 18); + + // Now overwrite index 0 with our host_callback. + let func = Function::new_native(&store, host_callback); + guest_table + .from + .set(0, func.into()) + .map_err(|e| anyhow::anyhow!(format!("trap: {:?}", e)))?; + // And verify that it does what we expect. + let result = call_via_table.call(0, 2, 7)?; + assert_eq!(result, 9); + + // Now demonstrate that the host and guest see the same table and that both + // get the same result. + for table_index in 3..6 { + if let Some(TableElement::FuncRef(f)) = guest_table.from.get(table_index as _) { + unsafe { + let result = Function::from_vm_funcref(&store, f) + .expect("funcref should not be null") + .call(&[Value::I32(1), Value::I32(9)])?; + assert_eq!(result[0], Value::I32(10)); + } + } else { + panic!("expected to find funcref in table!"); + } + let result = call_via_table.call(table_index, 1, 9)?; + assert_eq!(result, 10); + } + + Ok(()) +} diff --git a/runtime/near-vm/examples/tracy_exec.rs b/runtime/near-vm/examples/tracy_exec.rs new file mode 100644 index 00000000000..81738575a13 --- /dev/null +++ b/runtime/near-vm/examples/tracy_exec.rs @@ -0,0 +1,62 @@ +//! This is a simple example introducing the core concepts of the Wasmer API. +//! +//! You can run the example directly by executing the following in the Wasmer root: +//! +//! ```shell +//! cargo run --example hello-world --release --features "cranelift" +//! ``` + +use anyhow::Context; +use tracing_subscriber::layer::SubscriberExt; +use wasmer::{imports, wat2wasm, Function, Instance, Module, Singlepass, Store}; +use wasmer_engine_universal::Universal; + +// Note: the below makes the code under profiling _much much_ slower (several orders of magnitude) +/* +#[global_allocator] +static GLOBAL: tracy_client::ProfiledAllocator = + tracy_client::ProfiledAllocator::new(std::alloc::System, 100); +*/ + +fn main() -> anyhow::Result<()> { + tracing::subscriber::set_global_default( + tracing_subscriber::registry() + .with(tracing_subscriber::fmt::Layer::new()) + .with(tracing_tracy::TracyLayer::new()), + ) + .expect("Failed setting tracing subscriber"); + + // Prepare rayon so that we don't see a huge 3-4ms for the first rayon usage + tracing::info_span!("init_rayon").in_scope(|| { + rayon::ThreadPoolBuilder::new().build_global().unwrap(); + }); + + // Load the wasm + let args = std::env::args().collect::>(); + let input = std::fs::read(args.get(1).context("Usage: tracy_exec ")?) + .context("Failed reading input file")?; + let wasm_bytes = wat2wasm(&input).context("Failed parsing the input as wasm")?; + + // Configure a Store + let store = Store::new(&Universal::new(Singlepass::new()).engine()); + + // Compile a Module + let module = Module::new(&store, wasm_bytes)?; + + // Link in an Instance with minimal functions + fn gas(_foo: i32) {} + let import_object = imports! { + "env" => { + "gas" => Function::new_native(&store, gas), + } + }; + let _instance = Instance::new(&module, &import_object)?; + + // Then everything is ready and compiled, so there is nothing more to trace. + + // Sleep a bit for Tracy to have enough time to gather everything + tracy_client::non_continuous_frame!("tracy cleanup sleep"); + std::thread::sleep(std::time::Duration::from_millis(100)); + + Ok(()) +} diff --git a/runtime/near-vm/fuzz/.gitignore b/runtime/near-vm/fuzz/.gitignore new file mode 100644 index 00000000000..572e03bdf32 --- /dev/null +++ b/runtime/near-vm/fuzz/.gitignore @@ -0,0 +1,4 @@ + +target +corpus +artifacts diff --git a/runtime/near-vm/fuzz/Cargo.toml b/runtime/near-vm/fuzz/Cargo.toml new file mode 100644 index 00000000000..5cf6247f669 --- /dev/null +++ b/runtime/near-vm/fuzz/Cargo.toml @@ -0,0 +1,32 @@ +[package] +name = "wasmer-bin-fuzz" +version = "0.0.0" +authors = ["Automatically generated"] +publish = false +edition = "2018" + +[package.metadata] +cargo-fuzz = true + +[dependencies] +anyhow = "1" +wasm-smith = "0.4.4" +libfuzzer-sys = "0.4.0" +wasmer = { path = "../lib/api", package = "wasmer-near" } +wasmer-compiler-singlepass = { path = "../lib/compiler-singlepass", package = "wasmer-compiler-singlepass-near", optional = true } +wasmer-engine-universal = { path = "../lib/engine-universal", package = "wasmer-engine-universal-near", optional = true } +wasmprinter = "0.2" + +[features] +singlepass = [ "wasmer-compiler-singlepass" ] +universal = [ "wasmer-engine-universal" ] + +[[bin]] +name = "equivalence_universal" +path = "fuzz_targets/equivalence_universal.rs" +required-features = ["universal"] + +[[bin]] +name = "universal_singlepass" +path = "fuzz_targets/universal_singlepass.rs" +required-features = ["universal", "singlepass"] diff --git a/runtime/near-vm/fuzz/README.md b/runtime/near-vm/fuzz/README.md new file mode 100644 index 00000000000..13e40a304cb --- /dev/null +++ b/runtime/near-vm/fuzz/README.md @@ -0,0 +1,80 @@ +# Wasmer Fuzz Testing + +[Fuzz testing](https://en.wikipedia.org/wiki/Fuzzing) is: + +> An automated testing technique that involves providing invalid, +> unexpected, or random data as inputs to a program. + +We use fuzz testing to automatically discover bugs in the Wasmer runtime. + +This `fuzz/` directory contains the configuration and the fuzz tests +for Wasmer. To generate and to run the fuzz tests, we use the +[`cargo-fuzz`] library. + +## Installation + +You may need to install the [`cargo-fuzz`] library to get the `cargo +fuzz` subcommand. Use + +```sh +$ cargo install cargo-fuzz +``` + +`cargo-fuzz` is documented in the [Rust Fuzz +Book](https://rust-fuzz.github.io/book/cargo-fuzz.html). + +## Running a fuzzer + +This directory provides multiple fuzzers, like for example `validate`. You can run it with: + +```sh +$ cargo fuzz run validate +``` + +Another example with the `universal_cranelift` fuzzer: + +```sh +$ cargo fuzz run universal_cranelift +``` + +See the +[`fuzz/fuzz_targets`](https://github.com/wasmerio/wasmer/tree/fuzz/fuzz_targets/) +directory for the full list of fuzzers. + +You should see output that looks something like this: + +``` +#1408022 NEW cov: 115073 ft: 503843 corp: 4659/1807Kb lim: 4096 exec/s: 889 rss: 857Mb L: 2588/4096 MS: 1 ChangeASCIIInt- +#1408273 NEW cov: 115073 ft: 503844 corp: 4660/1808Kb lim: 4096 exec/s: 888 rss: 857Mb L: 1197/4096 MS: 1 ShuffleBytes- +#1408534 NEW cov: 115073 ft: 503866 corp: 4661/1809Kb lim: 4096 exec/s: 886 rss: 857Mb L: 977/4096 MS: 1 ShuffleBytes- +#1408540 NEW cov: 115073 ft: 503869 corp: 4662/1811Kb lim: 4096 exec/s: 886 rss: 857Mb L: 2067/4096 MS: 1 ChangeBit- +#1408831 NEW cov: 115073 ft: 503945 corp: 4663/1811Kb lim: 4096 exec/s: 885 rss: 857Mb L: 460/4096 MS: 1 CMP- DE: "\x16\x00\x00\x00\x00\x00\x00\x00"- +#1408977 NEW cov: 115073 ft: 503946 corp: 4664/1813Kb lim: 4096 exec/s: 885 rss: 857Mb L: 1972/4096 MS: 1 ShuffleBytes- +#1408999 NEW cov: 115073 ft: 503949 corp: 4665/1814Kb lim: 4096 exec/s: 884 rss: 857Mb L: 964/4096 MS: 2 ChangeBit-ShuffleBytes- +#1409040 NEW cov: 115073 ft: 503950 corp: 4666/1814Kb lim: 4096 exec/s: 884 rss: 857Mb L: 90/4096 MS: 1 ChangeBit- +#1409042 NEW cov: 115073 ft: 503951 corp: 4667/1814Kb lim: 4096 exec/s: 884 rss: 857Mb L: 174/4096 MS: 2 ChangeByte-ChangeASCIIInt- +``` + +It will continue to generate random inputs forever, until it finds a +bug or is terminated. The testcases for bugs it finds go into +`fuzz/artifacts/universal_cranelift` and you can rerun the fuzzer on a +single input by passing it on the command line `cargo fuzz run +universal_cranelift /path/to/testcase`. + +## The corpus + +Each fuzzer has an individual corpus under `fuzz/corpus/test_name`, +created on first run if not already present. The fuzzers use +`wasm-smith` which means that the testcase files are random number +seeds input to the Wasm generator, not `.wasm` files themselves. In +order to debug a testcase, you may find that you need to convert it +into a `.wasm` file. Using the standalone `wasm-smith` tool doesn't +work for this purpose because we use a custom configuration to our +`wasm_smith::Module`. Instead, our fuzzers use an environment variable +`DUMP_TESTCASE=path`. For example: + +```sh +$ DUMP_TESTCASE=/tmp/crash.wasm cargo fuzz run --features=universal,singlepass universal_singlepass fuzz/artifacts/universal_singlepass/crash-0966412eab4f89c52ce5d681807c8030349470f6 +``` + +[`cargo-fuzz`]: https://github.com/rust-fuzz/cargo-fuzz diff --git a/runtime/near-vm/fuzz/fuzz_targets/equivalence_universal.rs b/runtime/near-vm/fuzz/fuzz_targets/equivalence_universal.rs new file mode 100644 index 00000000000..15364cd8cc6 --- /dev/null +++ b/runtime/near-vm/fuzz/fuzz_targets/equivalence_universal.rs @@ -0,0 +1,160 @@ +#![no_main] +#![deny(unused_variables)] + +use anyhow::Result; +use libfuzzer_sys::{arbitrary, arbitrary::Arbitrary, fuzz_target}; +use wasm_smith::{Config, ConfiguredModule}; +use wasmer::{imports, CompilerConfig, Instance, Module, Store, Val}; +#[cfg(feature = "singlepass")] +use wasmer_compiler_singlepass::Singlepass; +use wasmer_engine_universal::Universal; + +#[derive(Arbitrary, Debug, Default, Copy, Clone)] +struct ExportedFunctionConfig; +impl Config for ExportedFunctionConfig { + fn max_imports(&self) -> usize { + 0 + } + fn max_memory_pages(&self) -> u32 { + // https://github.com/wasmerio/wasmer/issues/2187 + 65535 + } + fn min_funcs(&self) -> usize { + 1 + } + fn min_exports(&self) -> usize { + 1 + } +} + +struct WasmSmithModule(ConfiguredModule); +impl<'a> arbitrary::Arbitrary<'a> for WasmSmithModule { + fn arbitrary(u: &mut arbitrary::Unstructured<'a>) -> arbitrary::Result { + let mut module = ConfiguredModule::::arbitrary(u)?; + module.ensure_termination(100000); + Ok(WasmSmithModule(module)) + } +} +impl std::fmt::Debug for WasmSmithModule { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + f.write_str(&wasmprinter::print_bytes(self.0.to_bytes()).unwrap()) + } +} + +#[cfg(feature = "singlepass")] +fn maybe_instantiate_singlepass(wasm_bytes: &[u8]) -> Result> { + let compiler = Singlepass::default(); + let store = Store::new(&Universal::new(compiler).engine()); + let module = Module::new(&store, &wasm_bytes); + let module = match module { + Ok(m) => m, + Err(e) => { + let error_message = format!("{}", e); + if error_message.contains("Validation error: invalid result arity: func type returns multiple values") || error_message.contains("Validation error: blocks, loops, and ifs accept no parameters when multi-value is not enabled") || error_message.contains("multi-value returns not yet implemented") { + return Ok(None); + } + return Err(e.into()); + } + }; + let instance = Instance::new(&module, &imports! {})?; + Ok(Some(instance)) +} + +#[derive(Debug)] +enum FunctionResult { + Error(String), + Values(Vec), +} + +#[derive(Debug, PartialEq, Eq)] +enum InstanceResult { + Error(String), + Functions(Vec), +} + +impl PartialEq for FunctionResult { + fn eq(&self, other: &Self) -> bool { + /* + match self { + FunctionResult::Error(self_message) => { + if let FunctionResult::Error(other_message) = other { + return self_message == other_message; + } + } + FunctionResult::Values(self_values) => { + if let FunctionResult::Values(other_values) = other { + return self_values == other_values; + } + } + } + false + */ + match (self, other) { + (FunctionResult::Values(self_values), FunctionResult::Values(other_values)) => { + self_values.len() == other_values.len() + && self_values + .iter() + .zip(other_values.iter()) + .all(|(x, y)| match (x, y) { + (Val::F32(x), Val::F32(y)) => x.to_bits() == y.to_bits(), + (Val::F64(x), Val::F64(y)) => x.to_bits() == y.to_bits(), + _ => x == y, + }) + } + _ => true, + } + } +} + +impl Eq for FunctionResult {} + +fn evaluate_instance(instance: Result) -> InstanceResult { + if let Err(_err) = instance { + /*let mut error_message = format!("{}", err); + // Remove the stack trace. + if error_message.starts_with("RuntimeError: unreachable\n") { + error_message = "RuntimeError: unreachable\n".into(); + } + InstanceResult::Error(error_message)*/ + InstanceResult::Error("".into()) + } else { + let instance = instance.unwrap(); + let mut results = vec![]; + for it in instance.exports.iter().functions() { + let (_, f) = it; + // TODO: support functions which take params. + if f.ty().params().is_empty() { + let result = f.call(&[]); + let result = if let Ok(values) = result { + FunctionResult::Values(values.into()) + } else { + /* + let err = result.unwrap_err(); + let error_message = err.message(); + FunctionResult::Error(error_message) + */ + FunctionResult::Error("".into()) + }; + results.push(result); + } + } + InstanceResult::Functions(results) + } +} + +fuzz_target!(|module: WasmSmithModule| { + let wasm_bytes = module.0.to_bytes(); + + if let Ok(path) = std::env::var("DUMP_TESTCASE") { + use std::fs::File; + use std::io::Write; + let mut file = File::create(path).unwrap(); + file.write_all(&wasm_bytes).unwrap(); + return; + } + + #[cfg(feature = "singlepass")] + let singlepass = maybe_instantiate_singlepass(&wasm_bytes) + .transpose() + .map(evaluate_instance); +}); diff --git a/runtime/near-vm/fuzz/fuzz_targets/metering.rs b/runtime/near-vm/fuzz/fuzz_targets/metering.rs new file mode 100644 index 00000000000..bbd858147a0 --- /dev/null +++ b/runtime/near-vm/fuzz/fuzz_targets/metering.rs @@ -0,0 +1,72 @@ +#![no_main] + +use libfuzzer_sys::{arbitrary, arbitrary::Arbitrary, fuzz_target}; +use std::sync::Arc; +use wasm_smith::{Config, ConfiguredModule}; +use wasmer::wasmparser::Operator; +use wasmer::{imports, CompilerConfig, Instance, Module, Store}; +use wasmer_engine_universal::Universal; +use wasmer_middlewares::Metering; + +#[derive(Arbitrary, Debug, Default, Copy, Clone)] +struct NoImportsConfig; +impl Config for NoImportsConfig { + fn max_imports(&self) -> usize { + 0 + } + fn max_memory_pages(&self) -> u32 { + // https://github.com/wasmerio/wasmer/issues/2187 + 65535 + } + fn allow_start_export(&self) -> bool { + false + } +} + +#[derive(Arbitrary)] +struct WasmSmithModule(ConfiguredModule); +impl std::fmt::Debug for WasmSmithModule { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + f.write_str(&wasmprinter::print_bytes(self.0.to_bytes()).unwrap()) + } +} + +fn cost(operator: &Operator) -> u64 { + match operator { + Operator::LocalGet { .. } | Operator::I32Const { .. } => 1, + Operator::I32Add { .. } => 2, + _ => 0, + } +} + +fuzz_target!(|module: WasmSmithModule| { + let wasm_bytes = module.0.to_bytes(); + + if let Ok(path) = std::env::var("DUMP_TESTCASE") { + use std::fs::File; + use std::io::Write; + let mut file = File::create(path).unwrap(); + file.write_all(&wasm_bytes).unwrap(); + return; + } + + let mut compiler = Singlepass::default(); + compiler.canonicalize_nans(true); + compiler.enable_verifier(); + let metering = Arc::new(Metering::new(10, cost)); + compiler.push_middleware(metering); + let store = Store::new(&Universal::new(compiler).engine()); + let module = Module::new(&store, &wasm_bytes).unwrap(); + match Instance::new(&module, &imports! {}) { + Ok(_) => {} + Err(e) => { + let error_message = format!("{}", e); + if error_message.starts_with("RuntimeError: ") + && error_message.contains("out of bounds") + { + return; + } + panic!("{}", e); + } + } +}); diff --git a/runtime/near-vm/fuzz/fuzz_targets/universal_singlepass.rs b/runtime/near-vm/fuzz/fuzz_targets/universal_singlepass.rs new file mode 100644 index 00000000000..5e99e15c505 --- /dev/null +++ b/runtime/near-vm/fuzz/fuzz_targets/universal_singlepass.rs @@ -0,0 +1,67 @@ +#![no_main] + +use libfuzzer_sys::{arbitrary, arbitrary::Arbitrary, fuzz_target}; +use wasm_smith::{Config, ConfiguredModule}; +use wasmer::{imports, Instance, Module, Store}; +use wasmer_compiler_singlepass::Singlepass; +use wasmer_engine_universal::Universal; + +#[derive(Arbitrary, Debug, Default, Copy, Clone)] +struct NoImportsConfig; +impl Config for NoImportsConfig { + fn max_imports(&self) -> usize { + 0 + } + fn max_memory_pages(&self) -> u32 { + // https://github.com/wasmerio/wasmer/issues/2187 + 65535 + } + fn allow_start_export(&self) -> bool { + false + } +} +#[derive(Arbitrary)] +struct WasmSmithModule(ConfiguredModule); +impl std::fmt::Debug for WasmSmithModule { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + f.write_str(&wasmprinter::print_bytes(self.0.to_bytes()).unwrap()) + } +} + +fuzz_target!(|module: WasmSmithModule| { + let wasm_bytes = module.0.to_bytes(); + + if let Ok(path) = std::env::var("DUMP_TESTCASE") { + use std::fs::File; + use std::io::Write; + let mut file = File::create(path).unwrap(); + file.write_all(&wasm_bytes).unwrap(); + return; + } + + let compiler = Singlepass::default(); + let store = Store::new(&Universal::new(compiler).engine()); + let module = Module::new(&store, &wasm_bytes); + let module = match module { + Ok(m) => m, + Err(e) => { + let error_message = format!("{}", e); + if error_message.contains("Validation error: invalid result arity: func type returns multiple values") || error_message.contains("Validation error: blocks, loops, and ifs accept no parameters when multi-value is not enabled") || error_message.contains("multi-value returns not yet implemented") { + return; + } + panic!("{}", e); + } + }; + match Instance::new(&module, &imports! {}) { + Ok(_) => {} + Err(e) => { + let error_message = format!("{}", e); + if error_message.starts_with("RuntimeError: ") + && error_message.contains("out of bounds") + { + return; + } + panic!("{}", e); + } + } +}); diff --git a/runtime/near-vm/fuzzbuzz.yaml b/runtime/near-vm/fuzzbuzz.yaml new file mode 100644 index 00000000000..197c3e4133f --- /dev/null +++ b/runtime/near-vm/fuzzbuzz.yaml @@ -0,0 +1,8 @@ +wasmer: + language: rust + features: + - universal + - singlepass + deps: + - run: apt update + - run: apt install -y zlib1g-dev libffi-dev build-essential diff --git a/runtime/near-vm/lib/README.md b/runtime/near-vm/lib/README.md new file mode 100644 index 00000000000..aaf820c8124 --- /dev/null +++ b/runtime/near-vm/lib/README.md @@ -0,0 +1,21 @@ +# The Wasmer runtime crates + +The philosophy of Wasmer is to be very modular by design. It's +composed of a set of crates. We can group them as follows: + +* `api` — The public Rust API exposes everything a user needs to use Wasmer programatically through + the `wasmer` crate, +* `cache` — The traits and types to cache compiled WebAssembly modules, +* `cli` — The Wasmer CLI itself, +* `compiler` — The base for the compiler implementations, it defines + the framework for the compilers and provides everything they need: + * `compiler-singlepass` — A WebAssembly compiler based on our own compilation infrastructure; + recommended for compilation-time speed performance. +* `derive` — A set of procedural macros used inside Wasmer, +* `engine` — The general abstraction for creating an engine, which is responsible of leading the + compiling and running flow. Using the same compiler, the runtime performance will be + approximately the same, however the way it stores and loads the executable code will differ: + * `engine-universal` — stores the code in a custom file format, and loads it in memory, +* `types` — The basic structures to use WebAssembly, +* `vm` — The Wasmer VM runtime library, the low-level base of + everything. diff --git a/runtime/near-vm/lib/api/Cargo.toml b/runtime/near-vm/lib/api/Cargo.toml new file mode 100644 index 00000000000..97f3f19a6ce --- /dev/null +++ b/runtime/near-vm/lib/api/Cargo.toml @@ -0,0 +1,89 @@ +[package] +name = "wasmer-near" +version = "2.4.0" +description = "High-performance WebAssembly runtime" +categories = ["wasm"] +keywords = ["wasm", "webassembly", "runtime", "vm"] +authors = ["Wasmer Engineering Team "] +repository = "https://github.com/wasmerio/wasmer" +license = "MIT" +readme = "README.md" +edition = "2018" + +[lib] +name = "wasmer" + +# Shared dependencies. +[dependencies] +# - Mandatory shared dependencies. +cfg-if = "1.0" +finite-wasm = "0.3.0" +indexmap = { version = "1.6" } +more-asserts = "0.2" +prefix-sum-vec = "0.1.2" +thiserror = "1.0" +tracing = "0.1" + +# - Optional shared dependencies. +wat = { version = "1.0", optional = true } + +# Dependencies and Development Dependencies for `sys`. +[target.'cfg(not(target_arch = "wasm32"))'.dependencies] +# - Mandatory dependencies for `sys`. +wasmer-vm = { path = "../vm", version = "=2.4.0", package = "wasmer-vm-near" } +wasmer-compiler = { path = "../compiler", version = "=2.4.0", package = "wasmer-compiler-near" } +wasmer-engine = { path = "../engine", version = "=2.4.0", package = "wasmer-engine-near" } +wasmer-types = { path = "../types", version = "=2.4.0", package = "wasmer-types-near" } +target-lexicon = { version = "0.12.2", default-features = false } +# - Optional dependencies for `sys`. +wasmer-compiler-singlepass = { path = "../compiler-singlepass", package = "wasmer-compiler-singlepass-near", version = "=2.4.0", optional = true} +wasmer-engine-universal = { path = "../engine-universal", package = "wasmer-engine-universal-near", version = "=2.4.0", optional = true } +# - Mandatory dependencies for `sys` on Windows. +[target.'cfg(all(not(target_arch = "wasm32"), target_os = "windows"))'.dependencies] +winapi = "0.3" +# - Development Dependencies for `sys`. +[target.'cfg(not(target_arch = "wasm32"))'.dev-dependencies] +wat = "1.0" +tempfile = "3.1" +anyhow = "1.0" + +[badges] +maintenance = { status = "actively-developed" } + +[features] +default = ["sys-default"] +std = [] +core = [] + +# Features for `sys`. +sys = [] +sys-default = ["sys", "wat", "default-singlepass", "default-universal"] +# - Compilers. +compiler = [ + "sys", + "wasmer-compiler/translator", + "wasmer-engine-universal/compiler", +] + singlepass = [ + "compiler", + "wasmer-compiler-singlepass", + ] +default-compiler = [] + default-singlepass = [ + "default-compiler", + "singlepass", + ] +# - Engines. +engine = ["sys"] + universal = [ + "engine", + "wasmer-engine-universal", + ] +default-engine = [] + default-universal = [ + "default-engine", + "universal", + ] + +[package.metadata.docs.rs] +features = ["compiler", "core", "default-compiler", "default-engine", "engine", "jit", "native", "singlepass", "sys", "sys-default", "universal"] diff --git a/runtime/near-vm/lib/api/README.md b/runtime/near-vm/lib/api/README.md new file mode 100644 index 00000000000..8005467eb91 --- /dev/null +++ b/runtime/near-vm/lib/api/README.md @@ -0,0 +1,102 @@ +# `wasmer` [![Build Status](https://github.com/wasmerio/wasmer/workflows/build/badge.svg?style=flat-square)](https://github.com/wasmerio/wasmer/actions?query=workflow%3Abuild) [![Join Wasmer Slack](https://img.shields.io/static/v1?label=Slack&message=join%20chat&color=brighgreen&style=flat-square)](https://slack.wasmer.io) [![MIT License](https://img.shields.io/github/license/wasmerio/wasmer.svg?style=flat-square)](https://github.com/wasmerio/wasmer/blob/master/LICENSE) [![crates.io](https://img.shields.io/crates/v/wasmer.svg)](https://crates.io/crates/wasmer) + +[`Wasmer`](https://wasmer.io/) is the most popular +[WebAssembly](https://webassembly.org/) runtime for Rust. It supports +JIT (Just In Time) and AOT (Ahead Of Time) compilation as well as +pluggable compilers suited to your needs. + +It's designed to be safe and secure, and runnable in any kind of environment. + +## Usage + +Here is a small example of using Wasmer to run a WebAssembly module +written with its WAT format (textual format): + +```rust +use wasmer::{Store, Module, Instance, Value, imports}; + +fn main() -> anyhow::Result<()> { + let module_wat = r#" + (module + (type $t0 (func (param i32) (result i32))) + (func $add_one (export "add_one") (type $t0) (param $p0 i32) (result i32) + get_local $p0 + i32.const 1 + i32.add)) + "#; + + let store = Store::default(); + let module = Module::new(&store, &module_wat)?; + // The module doesn't import anything, so we create an empty import object. + let import_object = imports! {}; + let instance = Instance::new(&module, &import_object)?; + + let add_one = instance.exports.get_function("add_one")?; + let result = add_one.call(&[Value::I32(42)])?; + assert_eq!(result[0], Value::I32(43)); + + Ok(()) +} +``` + +[Discover the full collection of examples](https://github.com/wasmerio/wasmer/tree/master/examples). + +## Features + +Wasmer is not only fast, but also designed to be *highly customizable*: + +* **Pluggable engines** — An engine is responsible to drive the + compilation process and to store the generated executable code + somewhere, either: + * in-memory (with [`wasmer-engine-universal`]), + * in a native shared object file (with [`wasmer-engine-dylib`], + `.dylib`, `.so`, `.dll`), then load it with `dlopen`, + * in a native static object file (with [`wasmer-engine-staticlib`]), + in addition to emitting a C header file, which both can be linked + against a sandboxed WebAssembly runtime environment for the + compiled module with no need for runtime compilation. + +* **Pluggable compilers** — A compiler is used by an engine to + transform WebAssembly into executable code: + * [`wasmer-compiler-singlepass`] provides a fast compilation-time + but an unoptimized runtime speed, + +* **Headless mode** — Once a WebAssembly module has been compiled, it + is possible to serialize it in a file for example, and later execute + it with Wasmer with headless mode turned on. Headless Wasmer has no + compiler, which makes it more portable and faster to load. It's + ideal for constrainted environments. + +* **Cross-compilation** — Most compilers support cross-compilation. It + means it possible to pre-compile a WebAssembly module targetting a + different architecture or platform and serialize it, to then run it + on the targetted architecture and platform later. + +* **Run Wasmer in a JavaScript environment** — With the `js` Cargo + feature, it is possible to compile a Rust program using Wasmer to + WebAssembly. In this context, the resulting WebAssembly module will + expect to run in a JavaScript environment, like a browser, Node.js, + Deno and so on. In this specific scenario, there is no engines or + compilers available, it's the one available in the JavaScript + environment that will be used. + +Wasmer ships by default with the Cranelift compiler as its great for +development purposes. However, we strongly encourage to use the LLVM +compiler in production as it performs about 50% faster, achieving +near-native speeds. + +Note: if one wants to use multiple compilers at the same time, it's +also possible! One will need to import them directly via each of the +compiler crates. + +Read [the documentation to learn +more](https://wasmerio.github.io/wasmer/crates/doc/wasmer/). + +--- + +Made with ❤️ by the Wasmer team, for the community + +[`wasmer-engine-universal`]: https://github.com/wasmerio/wasmer/tree/master/lib/engine-universal +[`wasmer-engine-dylib`]: https://github.com/wasmerio/wasmer/tree/master/lib/engine-dylib +[`wasmer-engine-staticlib`]: https://github.com/wasmerio/wasmer/tree/master/lib/engine-staticlib +[`wasmer-compiler-singlepass`]: https://github.com/wasmerio/wasmer/tree/master/lib/compiler-singlepass diff --git a/runtime/near-vm/lib/api/src/lib.rs b/runtime/near-vm/lib/api/src/lib.rs new file mode 100644 index 00000000000..e40a2b7bfb7 --- /dev/null +++ b/runtime/near-vm/lib/api/src/lib.rs @@ -0,0 +1,356 @@ +#![doc( + html_logo_url = "https://github.com/wasmerio.png?size=200", + html_favicon_url = "https://wasmer.io/images/icons/favicon-32x32.png" +)] +#![deny( + missing_docs, + trivial_numeric_casts, + unused_extern_crates, + rustdoc::broken_intra_doc_links +)] +#![warn(unused_import_braces)] +#![cfg_attr( + feature = "cargo-clippy", + allow(clippy::new_without_default, vtable_address_comparisons) +)] +#![cfg_attr( + feature = "cargo-clippy", + warn( + clippy::float_arithmetic, + clippy::mut_mut, + clippy::nonminimal_bool, + clippy::option_map_unwrap_or, + clippy::option_map_unwrap_or_else, + clippy::print_stdout, + clippy::unicode_not_nfc, + clippy::use_self + ) +)] +//! [`Wasmer`](https://wasmer.io/) is the most popular +//! [WebAssembly](https://webassembly.org/) runtime for Rust. It supports +//! JIT (Just In Time) and AOT (Ahead Of Time) compilation as well as +//! pluggable compilers suited to your needs. +//! +//! It's designed to be safe and secure, and runnable in any kind of environment. +//! +//! # Usage +//! +//! Here is a small example of using Wasmer to run a WebAssembly module +//! written with its WAT format (textual format): +//! +//! ```rust +//! use wasmer::{Store, Module, Instance, Value, Export, imports}; +//! +//! fn main() -> anyhow::Result<()> { +//! let module_wat = r#" +//! (module +//! (type $t0 (func (param i32) (result i32))) +//! (func $add_one (export "add_one") (type $t0) (param $p0 i32) (result i32) +//! get_local $p0 +//! i32.const 1 +//! i32.add)) +//! "#; +//! +//! let store = Store::default(); +//! let module = Module::new(&store, &module_wat)?; +//! // The module doesn't import anything, so we create an empty import object. +//! let import_object = imports! {}; +//! let instance = Instance::new(&module, &import_object)?; +//! +//! let add_one = instance.lookup_function("add_one").unwrap(); +//! let result = add_one.call(&[Value::I32(42)])?; +//! assert_eq!(result[0], Value::I32(43)); +//! +//! Ok(()) +//! } +//! ``` +//! +//! [Discover the full collection of examples](https://github.com/wasmerio/wasmer/tree/master/examples). +//! +//! # Overview of the Features +//! +//! Wasmer is not only fast, but also designed to be *highly customizable*: +//! +//! * **Pluggable engines** — An engine is responsible to drive the +//! compilation process and to store the generated executable code +//! somewhere, either: +//! * in-memory (with [`wasmer-engine-universal`]), +//! * in a native shared object file (with [`wasmer-engine-dylib`], +//! `.dylib`, `.so`, `.dll`), then load it with `dlopen`, +//! * in a native static object file (with [`wasmer-engine-staticlib`]), +//! in addition to emitting a C header file, which both can be linked +//! against a sandboxed WebAssembly runtime environment for the +//! compiled module with no need for runtime compilation. +//! +//! * **Pluggable compilers** — A compiler is used by an engine to +//! transform WebAssembly into executable code: +//! * [`wasmer-compiler-singlepass`] provides a fast compilation-time +//! but an unoptimized runtime speed, +//! +//! * **Headless mode** — Once a WebAssembly module has been compiled, it +//! is possible to serialize it in a file for example, and later execute +//! it with Wasmer with headless mode turned on. Headless Wasmer has no +//! compiler, which makes it more portable and faster to load. It's +//! ideal for constrainted environments. +//! +//! * **Cross-compilation** — Most compilers support cross-compilation. It +//! means it possible to pre-compile a WebAssembly module targetting a +//! different architecture or platform and serialize it, to then run it +//! on the targetted architecture and platform later. +//! +//! * **Run Wasmer in a JavaScript environment** — With the `js` Cargo +//! feature, it is possible to compile a Rust program using Wasmer to +//! WebAssembly. In this context, the resulting WebAssembly module will +//! expect to run in a JavaScript environment, like a browser, Node.js, +//! Deno and so on. In this specific scenario, there is no engines or +//! compilers available, it's the one available in the JavaScript +//! environment that will be used. +//! +//! Wasmer ships by default with the Cranelift compiler as its great for +//! development purposes. However, we strongly encourage to use the LLVM +//! compiler in production as it performs about 50% faster, achieving +//! near-native speeds. +//! +//! Note: if one wants to use multiple compilers at the same time, it's +//! also possible! One will need to import them directly via each of the +//! compiler crates. +//! +//! # Table of Contents +//! +//! - [WebAssembly Primitives](#webassembly-primitives) +//! - [Externs](#externs) +//! - [Functions](#functions) +//! - [Memories](#memories) +//! - [Globals](#globals) +//! - [Tables](#tables) +//! - [Project Layout](#project-layout) +//! - [Engines](#engines) +//! - [Compilers](#compilers) +//! - [Cargo Features](#cargo-features) +//! - [Using Wasmer in a JavaScript environment](#using-wasmer-in-a-javascript-environment) +//! +//! +//! # WebAssembly Primitives +//! +//! In order to make use of the power of the `wasmer` API, it's important +//! to understand the primitives around which the API is built. +//! +//! Wasm only deals with a small number of core data types, these data +//! types can be found in the [`Value`] type. +//! +//! In addition to the core Wasm types, the core types of the API are +//! referred to as "externs". +//! +//! ## Externs +//! +//! An [`Extern`] is a type that can be imported or exported from a Wasm +//! module. +//! +//! To import an extern, simply give it a namespace and a name with the +//! [`imports`] macro: +//! +//! ``` +//! # use wasmer::{imports, Function, Memory, MemoryType, Store, ImportObject}; +//! # fn imports_example(store: &Store) -> ImportObject { +//! let memory = Memory::new(&store, MemoryType::new(1, None, false)).unwrap(); +//! imports! { +//! "env" => { +//! "my_function" => Function::new_native(store, || println!("Hello")), +//! "memory" => memory, +//! } +//! } +//! # } +//! ``` +//! +//! And to access an exported extern, see the [`Exports`] API, accessible +//! from any instance via `instance.exports`: +//! +//! ``` +//! # use wasmer::{imports, Instance, Function, Memory, NativeFunc}; +//! # fn exports_example(instance: &Instance) -> anyhow::Result<()> { +//! let memory = instance.lookup("memory").unwrap(); +//! let memory = instance.lookup("some_other_memory").unwrap(); +//! let add: NativeFunc<(i32, i32), i32> = instance.get_native_function("add").unwrap(); +//! let result = add.call(5, 37)?; +//! assert_eq!(result, 42); +//! # Ok(()) +//! # } +//! ``` +//! +//! These are the primary types that the `wasmer` API uses. +//! +//! ### Functions +//! +//! There are 2 types of functions in `wasmer`: +//! 1. Wasm functions, +//! 2. Host functions. +//! +//! A Wasm function is a function defined in a WebAssembly module that can +//! only perform computation without side effects and call other functions. +//! +//! Wasm functions take 0 or more arguments and return 0 or more results. +//! Wasm functions can only deal with the primitive types defined in +//! [`Value`]. +//! +//! A Host function is any function implemented on the host, in this case in +//! Rust. +//! +//! Host functions can optionally be created with an environment that +//! implements [`WasmerEnv`]. This environment is useful for maintaining +//! host state (for example the filesystem in WASI). +//! +//! Thus WebAssembly modules by themselves cannot do anything but computation +//! on the core types in [`Value`]. In order to make them more useful we +//! give them access to the outside world with [`imports`]. +//! +//! If you're looking for a sandboxed, POSIX-like environment to execute Wasm +//! in, check out the [`wasmer-wasi`] crate for our implementation of WASI, +//! the WebAssembly System Interface. +//! +//! In the `wasmer` API we support functions which take their arguments and +//! return their results dynamically, [`Function`], and functions which +//! take their arguments and return their results statically, [`NativeFunc`]. +//! +//! ### Memories +//! +//! Memories store data. +//! +//! In most Wasm programs, nearly all data will live in a [`Memory`]. +//! +//! This data can be shared between the host and guest to allow for more +//! interesting programs. +//! +//! ### Globals +//! +//! A [`Global`] is a type that may be either mutable or immutable, and +//! contains one of the core Wasm types defined in [`Value`]. +//! +//! ### Tables +//! +//! A [`Table`] is an indexed list of items. +//! +//! # Project Layout +//! +//! The Wasmer project is divided into a number of crates, below is a dependency +//! graph with transitive dependencies removed. +//! +//!
+//! +//!
+//! +//! While this crate is the top level API, we also publish crates built +//! on top of this API that you may be interested in using, including: +//! +//! - [`wasmer-cache`] for caching compiled Wasm modules, +//! - [`wasmer-emscripten`] for running Wasm modules compiled to the +//! Emscripten ABI, +//! - [`wasmer-wasi`] for running Wasm modules compiled to the WASI ABI. +//! +//! The Wasmer project has two major abstractions: +//! 1. [Engines][wasmer-engine], +//! 2. [Compilers][wasmer-compiler]. +//! +//! These two abstractions have multiple options that can be enabled +//! with features. +//! +//! ## Engines +//! +//! An engine is a system that uses a compiler to make a WebAssembly +//! module executable. +//! +//! ## Compilers +//! +//! A compiler is a system that handles the details of making a Wasm +//! module executable. For example, by generating native machine code +//! for each Wasm function. +//! +//! # Cargo Features +//! +//! This crate comes in 1 flavor: +//! +//! 1. `sys` +//! where `wasmer` will be compiled to a native executable +//! which provides compilers, engines, a full VM etc. +#![cfg_attr( + feature = "sys", + doc = "## Features for the `sys` feature group (enabled)" +)] +#![cfg_attr( + not(feature = "sys"), + doc = "## Features for the `sys` feature group (disabled)" +)] +//! +//! The default features can be enabled with the `sys-default` feature. +//! +//! The features for the `sys` feature group can be broken down into 2 +//! kinds: features that enable new functionality and features that +//! set defaults. +//! +//! The features that enable new functionality are: +//! - `singlepass` +#![cfg_attr(feature = "singlepass", doc = "(enabled),")] +#![cfg_attr(not(feature = "singlepass"), doc = "(disabled),")] +//! enables Wasmer's [Singlepass compiler][wasmer-compiler-singlepass], +//! - `wat` +#![cfg_attr(feature = "wat", doc = "(enabled),")] +#![cfg_attr(not(feature = "wat"), doc = "(disabled),")] +//! enables `wasmer` to parse the WebAssembly text format, +//! - `universal` +#![cfg_attr(feature = "universal", doc = "(enabled),")] +#![cfg_attr(not(feature = "universal"), doc = "(disabled),")] +//! enables [the Universal engine][`wasmer-engine-universal`], +//! - `dylib` +#![cfg_attr(feature = "dylib", doc = "(enabled),")] +#![cfg_attr(not(feature = "dylib"), doc = "(disabled),")] +//! enables [the Dylib engine][`wasmer-engine-dylib`]. +//! +//! The features that set defaults come in sets that are mutually exclusive. +//! +//! The first set is the default compiler set: +//! - `default-singlepass` +#![cfg_attr(feature = "default-singlepass", doc = "(enabled),")] +#![cfg_attr(not(feature = "default-singlepass"), doc = "(disabled),")] +//! set Wasmer's Singlepass compiler as the default. +//! +//! The next set is the default engine set: +//! - `default-universal` +#![cfg_attr(feature = "default-universal", doc = "(enabled),")] +#![cfg_attr(not(feature = "default-universal"), doc = "(disabled),")] +//! set the Universal engine as the default, +//! - `default-dylib` +#![cfg_attr(feature = "default-dylib", doc = "(enabled),")] +#![cfg_attr(not(feature = "default-dylib"), doc = "(disabled),")] +//! set the Dylib engine as the default. +//! +//! - `wat` +#![cfg_attr(feature = "wat", doc = "(enabled),")] +#![cfg_attr(not(feature = "wat"), doc = "(disabled),")] +//! allows to read a Wasm file in its text format. This feature is +//! normally used only in development environments. It will add +//! around 650kb to the Wasm bundle (120Kb gzipped). +//! +//! [wasm]: https://webassembly.org/ +//! [wasmer-examples]: https://github.com/wasmerio/wasmer/tree/master/examples +//! [`wasmer-cache`]: https://docs.rs/wasmer-cache/ +//! [wasmer-compiler]: https://docs.rs/wasmer-compiler/ +//! [`wasmer-emscripten`]: https://docs.rs/wasmer-emscripten/ +//! [wasmer-engine]: https://docs.rs/wasmer-engine/ +//! [`wasmer-engine-universal`]: https://docs.rs/wasmer-engine-universal/ +//! [`wasmer-engine-dylib`]: https://docs.rs/wasmer-engine-dylib/ +//! [`wasmer-engine-staticlib`]: https://docs.rs/wasmer-engine-staticlib/ +//! [`wasmer-compiler-singlepass`]: https://docs.rs/wasmer-compiler-singlepass/ +//! [`wasmer-wasi`]: https://docs.rs/wasmer-wasi/ +//! [`wasm-pack`]: https://github.com/rustwasm/wasm-pack/ +//! [`wasm-bindgen`]: https://github.com/rustwasm/wasm-bindgen + +#[cfg(not(feature = "sys"))] +compile_error!("At least the `sys` or the `js` feature must be enabled. Please, pick one."); + +#[cfg(all(feature = "sys", target_arch = "wasm32"))] +compile_error!("The `sys` feature must be enabled only for non-`wasm32` target."); + +#[cfg(feature = "sys")] +mod sys; + +#[cfg(feature = "sys")] +pub use sys::*; diff --git a/runtime/near-vm/lib/api/src/sys/cell.rs b/runtime/near-vm/lib/api/src/sys/cell.rs new file mode 100644 index 00000000000..4540c2b305c --- /dev/null +++ b/runtime/near-vm/lib/api/src/sys/cell.rs @@ -0,0 +1,37 @@ +pub use std::cell::Cell; + +/// A mutable Wasm-memory location. +#[repr(transparent)] +pub struct WasmCell<'a, T: ?Sized> { + inner: &'a Cell, +} + +unsafe impl Send for WasmCell<'_, T> where T: Send {} + +unsafe impl Sync for WasmCell<'_, T> {} + +impl<'a, T> WasmCell<'a, T> { + /// Creates a new `WasmCell` containing the given value. + /// + /// # Examples + /// + /// ``` + /// use std::cell::Cell; + /// use wasmer::WasmCell; + /// + /// let cell = Cell::new(5); + /// let wasm_cell = WasmCell::new(&cell); + /// ``` + #[inline] + pub const fn new(cell: &'a Cell) -> WasmCell<'a, T> { + WasmCell { inner: cell } + } +} + +impl WasmCell<'_, T> { + /// Sets the contained value. + #[inline] + pub fn set(&self, val: T) { + self.inner.set(val); + } +} diff --git a/runtime/near-vm/lib/api/src/sys/env.rs b/runtime/near-vm/lib/api/src/sys/env.rs new file mode 100644 index 00000000000..28e35d7815b --- /dev/null +++ b/runtime/near-vm/lib/api/src/sys/env.rs @@ -0,0 +1,187 @@ +use crate::sys::{ExportError, Instance}; +use thiserror::Error; + +/// An error while initializing the user supplied host env with the `WasmerEnv` trait. +#[derive(Error, Debug)] +#[error("Host env initialization error")] +pub enum HostEnvInitError { + /// An error occurred when accessing an export + Export(ExportError), + /// Incorrect gas metering config + IncorrectGasMeteringConfig, +} + +impl From for HostEnvInitError { + fn from(other: ExportError) -> Self { + Self::Export(other) + } +} + +/// Trait for initializing the environments passed to host functions after +/// instantiation but before execution. +/// +/// This is useful for filling an environment with data that can only be accesed +/// after instantiation. For example, exported items such as memories and +/// functions which don't exist prior to instantiation can be accessed here so +/// that host functions can use them. +/// +/// # Examples +/// +/// This trait may also be implemented manually: +/// ``` +/// # use wasmer::{WasmerEnv, LazyInit, Memory, Instance, HostEnvInitError}; +/// #[derive(Clone)] +/// pub struct MyEnv { +/// memory: LazyInit, +/// } +/// +/// impl WasmerEnv for MyEnv { +/// fn init_with_instance(&mut self, instance: &Instance) -> Result<(), HostEnvInitError> { +/// todo!() +/// } +/// } +/// ``` +/// +/// When implementing the trait manually, it's important to get a "weak" export to +/// prevent a cyclic reference leaking memory. You can access a "weak" export with +/// a method like `get_with_generics_weak`. +pub trait WasmerEnv: Clone + Send + Sync { + /// The function that Wasmer will call on your type to let it finish + /// setting up the environment with data from the `Instance`. + /// + /// This function is called after `Instance` is created but before it is + /// returned to the user via `Instance::new`. + fn init_with_instance(&mut self, _instance: &Instance) -> Result<(), HostEnvInitError> { + Ok(()) + } +} + +impl WasmerEnv for u8 {} +impl WasmerEnv for i8 {} +impl WasmerEnv for u16 {} +impl WasmerEnv for i16 {} +impl WasmerEnv for u32 {} +impl WasmerEnv for i32 {} +impl WasmerEnv for u64 {} +impl WasmerEnv for i64 {} +impl WasmerEnv for u128 {} +impl WasmerEnv for i128 {} +impl WasmerEnv for f32 {} +impl WasmerEnv for f64 {} +impl WasmerEnv for usize {} +impl WasmerEnv for isize {} +impl WasmerEnv for char {} +impl WasmerEnv for bool {} +impl WasmerEnv for String {} +impl<'a> WasmerEnv for &'a ::std::sync::atomic::AtomicBool {} +impl<'a> WasmerEnv for &'a ::std::sync::atomic::AtomicI8 {} +impl<'a> WasmerEnv for &'a ::std::sync::atomic::AtomicU8 {} +impl<'a> WasmerEnv for &'a ::std::sync::atomic::AtomicI16 {} +impl<'a> WasmerEnv for &'a ::std::sync::atomic::AtomicU16 {} +impl<'a> WasmerEnv for &'a ::std::sync::atomic::AtomicI32 {} +impl<'a> WasmerEnv for &'a ::std::sync::atomic::AtomicU32 {} +impl<'a> WasmerEnv for &'a ::std::sync::atomic::AtomicI64 {} +impl<'a> WasmerEnv for &'a ::std::sync::atomic::AtomicUsize {} +impl<'a> WasmerEnv for &'a ::std::sync::atomic::AtomicIsize {} +impl WasmerEnv for Box { + fn init_with_instance(&mut self, instance: &Instance) -> Result<(), HostEnvInitError> { + (&mut **self).init_with_instance(instance) + } +} + +impl WasmerEnv for ::std::sync::Arc<::std::sync::Mutex> { + fn init_with_instance(&mut self, instance: &Instance) -> Result<(), HostEnvInitError> { + let mut guard = self.lock().unwrap(); + guard.init_with_instance(instance) + } +} + +/// Lazily init an item +pub struct LazyInit { + /// The data to be initialized + data: std::mem::MaybeUninit, + /// Whether or not the data has been initialized + initialized: bool, +} + +impl LazyInit { + /// Creates an unitialized value. + pub fn new() -> Self { + Self { + data: std::mem::MaybeUninit::uninit(), + initialized: false, + } + } + + /// # Safety + /// - The data must be initialized first + pub unsafe fn get_unchecked(&self) -> &T { + &*self.data.as_ptr() + } + + /// Get the inner data. + pub fn get_ref(&self) -> Option<&T> { + if !self.initialized { + None + } else { + Some(unsafe { self.get_unchecked() }) + } + } + + /// Sets a value and marks the data as initialized. + pub fn initialize(&mut self, value: T) -> bool { + if self.initialized { + return false; + } + unsafe { + self.data.as_mut_ptr().write(value); + } + self.initialized = true; + true + } +} + +impl std::fmt::Debug for LazyInit { + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + f.debug_struct("LazyInit") + .field("data", &self.get_ref()) + .finish() + } +} + +impl Clone for LazyInit { + fn clone(&self) -> Self { + if let Some(inner) = self.get_ref() { + Self { + data: std::mem::MaybeUninit::new(inner.clone()), + initialized: true, + } + } else { + Self { + data: std::mem::MaybeUninit::uninit(), + initialized: false, + } + } + } +} + +impl Drop for LazyInit { + fn drop(&mut self) { + if self.initialized { + unsafe { + let ptr = self.data.as_mut_ptr(); + std::ptr::drop_in_place(ptr); + }; + } + } +} + +impl Default for LazyInit { + fn default() -> Self { + Self::new() + } +} + +unsafe impl Send for LazyInit {} +// I thought we could opt out of sync..., look into this +// unsafe impl !Sync for InitWithInstance {} diff --git a/runtime/near-vm/lib/api/src/sys/exports.rs b/runtime/near-vm/lib/api/src/sys/exports.rs new file mode 100644 index 00000000000..e8ddf816163 --- /dev/null +++ b/runtime/near-vm/lib/api/src/sys/exports.rs @@ -0,0 +1,105 @@ +use crate::sys::externals::Extern; +use crate::sys::import_object::LikeNamespace; +use indexmap::IndexMap; +use std::sync::Arc; +use thiserror::Error; +use wasmer_vm::Export; + +/// The `ExportError` can happen when trying to get a specific +/// export [`Extern`] from the [`Instance`] exports. +/// +/// [`Instance`]: crate::Instance +/// +/// # Examples +/// +/// ## Incompatible export type +/// +/// ```should_panic +/// # use wasmer::{imports, wat2wasm, Function, Instance, Module, Store, Type, Value, ExportError}; +/// # let store = Store::default(); +/// # let wasm_bytes = wat2wasm(r#" +/// # (module +/// # (global $one (export "glob") f32 (f32.const 1))) +/// # "#.as_bytes()).unwrap(); +/// # let module = Module::new(&store, wasm_bytes).unwrap(); +/// # let import_object = imports! {}; +/// # let instance = Instance::new(&module, &import_object).unwrap(); +/// # +/// // This results in an error. +/// let export = instance.lookup_function("glob").unwrap(); +/// ``` +/// +/// ## Missing export +/// +/// ```should_panic +/// # use wasmer::{imports, wat2wasm, Function, Instance, Module, Store, Type, Value, ExportError}; +/// # let store = Store::default(); +/// # let wasm_bytes = wat2wasm("(module)".as_bytes()).unwrap(); +/// # let module = Module::new(&store, wasm_bytes).unwrap(); +/// # let import_object = imports! {}; +/// # let instance = Instance::new(&module, &import_object).unwrap(); +/// # +/// // This results with an error: `ExportError::Missing`. +/// let export = instance.lookup("unknown").unwrap(); +/// ``` +#[derive(Error, Debug)] +pub enum ExportError { + /// An error than occurs when the exported type and the expected type + /// are incompatible. + #[error("Incompatible Export Type")] + IncompatibleType, + /// This error arises when an export is missing + #[error("Missing export {0}")] + Missing(String), +} + +/// Exports is a special kind of map that allows easily unwrapping +/// the types of instances. +/// +/// TODO: add examples of using exports +#[derive(Clone, Default)] +pub struct Exports { + map: Arc>, +} + +impl Exports { + /// Creates a new `Exports`. + pub fn new() -> Self { + Default::default() + } + + /// Insert a new export into this `Exports` map. + pub fn insert(&mut self, name: S, value: E) + where + S: Into, + E: Into, + { + Arc::get_mut(&mut self.map) + .unwrap() + .insert(name.into(), value.into()); + } +} + +impl LikeNamespace for Exports { + fn get_namespace_export(&self, name: &str) -> Option { + self.map.get(name).map(|is_export| is_export.to_export()) + } + + fn get_namespace_exports(&self) -> Vec<(String, Export)> { + self.map + .iter() + .map(|(k, v)| (k.clone(), v.to_export())) + .collect() + } +} + +/// This trait is used to mark types as gettable from an [`Instance`]. +/// +/// [`Instance`]: crate::Instance +pub trait Exportable<'a>: Sized { + /// This function is used when providedd the [`Extern`] as exportable, so it + /// can be used while instantiating the [`Module`]. + /// + /// [`Module`]: crate::Module + fn to_export(&self) -> Export; +} diff --git a/runtime/near-vm/lib/api/src/sys/externals/function.rs b/runtime/near-vm/lib/api/src/sys/externals/function.rs new file mode 100644 index 00000000000..8e1c64ef29f --- /dev/null +++ b/runtime/near-vm/lib/api/src/sys/externals/function.rs @@ -0,0 +1,1600 @@ +use crate::sys::exports::Exportable; +use crate::sys::store::Store; +use crate::sys::types::{Val, ValFuncRef}; +use crate::sys::FunctionType; +use crate::sys::NativeFunc; +use crate::sys::RuntimeError; +use crate::sys::WasmerEnv; +pub use inner::{FromToNativeWasmType, HostFunction, WasmTypeList, WithEnv, WithoutEnv}; + +use std::cmp::max; +use std::ffi::c_void; +use std::fmt; +use std::sync::Arc; +use wasmer_vm::{ + raise_user_trap, resume_panic, wasmer_call_trampoline, Export, ExportFunction, + ExportFunctionMetadata, ImportInitializerFuncPtr, TableElement, VMCallerCheckedAnyfunc, + VMDynamicFunctionContext, VMFuncRef, VMFunction, VMFunctionBody, VMFunctionEnvironment, + VMFunctionKind, VMTrampoline, +}; + +/// A WebAssembly `function` instance. +/// +/// A function instance is the runtime representation of a function. +/// It effectively is a closure of the original function (defined in either +/// the host or the WebAssembly module) over the runtime `Instance` of its +/// originating `Module`. +/// +/// The module instance is used to resolve references to other definitions +/// during execution of the function. +/// +/// Spec: +/// +/// # Panics +/// - Closures (functions with captured environments) are not currently supported +/// with native functions. Attempting to create a native `Function` with one will +/// result in a panic. +/// [Closures as host functions tracking issue](https://github.com/wasmerio/wasmer/issues/1840) +#[derive(PartialEq)] +pub struct Function { + pub(crate) store: Store, + pub(crate) exported: ExportFunction, +} + +impl wasmer_types::WasmValueType for Function { + /// Write the value. + unsafe fn write_value_to(&self, p: *mut i128) { + let func_ref = + Val::into_vm_funcref(&Val::FuncRef(Some(self.clone())), &self.store).unwrap(); + std::ptr::write(p as *mut VMFuncRef, func_ref); + } + + /// Read the value. + // TODO(reftypes): this entire function should be cleaned up, `dyn Any` should + // ideally be removed + unsafe fn read_value_from(store: &dyn std::any::Any, p: *const i128) -> Self { + let func_ref = std::ptr::read(p as *const VMFuncRef); + let store = store.downcast_ref::().expect("Store expected in `Function::read_value_from`. If you see this error message it likely means you're using a function ref in a place we don't yet support it -- sorry about the inconvenience."); + match Val::from_vm_funcref(func_ref, store) { + Val::FuncRef(Some(fr)) => fr, + // these bottom two cases indicate bugs in `wasmer-types` or elsewhere. + // They should never be triggered, so we just panic. + Val::FuncRef(None) => panic!("Null funcref found in `Function::read_value_from`!"), + other => panic!("Invalid value in `Function::read_value_from`: {:?}", other), + } + } +} + +impl Function { + /// Convert a `VMFuncRef` into a `Function`. + /// + /// Returns `None` if the funcref is null. + /// + /// # Safety + /// + /// Must ensure that the returned Function does not outlive the containing instance. + pub unsafe fn from_vm_funcref(store: &Store, func_ref: VMFuncRef) -> Option { + if func_ref.is_null() { + return None; + } + let wasmer_vm::VMCallerCheckedAnyfunc { + func_ptr: address, + type_index: signature, + vmctx, + } = **func_ref; + let export = wasmer_vm::ExportFunction { + // TODO: + // figure out if we ever need a value here: need testing with complicated import patterns + metadata: None, + vm_function: wasmer_vm::VMFunction { + address, + signature, + // TODO: review this comment (unclear if it's still correct): + // All functions in tables are already Static (as dynamic functions + // are converted to use the trampolines with static signatures). + kind: wasmer_vm::VMFunctionKind::Static, + vmctx, + call_trampoline: None, + instance_ref: None, + }, + }; + Some(Function::from_vm_export(store, export)) + } +} + +impl From for TableElement { + fn from(f: Function) -> Self { + TableElement::FuncRef(f.vm_funcref()) + } +} + +fn build_export_function_metadata( + env: Env, + import_init_function_ptr: for<'a> fn( + &'a mut Env, + &'a crate::Instance, + ) -> Result<(), crate::HostEnvInitError>, +) -> (*mut c_void, ExportFunctionMetadata) +where + Env: Clone + Sized + 'static + Send + Sync, +{ + let import_init_function_ptr = Some(unsafe { + std::mem::transmute::<_, ImportInitializerFuncPtr>(import_init_function_ptr) + }); + let host_env_clone_fn = |ptr: *mut c_void| -> *mut c_void { + let env_ref: &Env = unsafe { + ptr.cast::() + .as_ref() + .expect("`ptr` to the environment is null when cloning it") + }; + Box::into_raw(Box::new(env_ref.clone())) as _ + }; + let host_env_drop_fn = |ptr: *mut c_void| { + unsafe { Box::from_raw(ptr.cast::()) }; + }; + let env = Box::into_raw(Box::new(env)) as _; + + // # Safety + // - All these functions work on all threads + // - The host env is `Send`. + let metadata = unsafe { + ExportFunctionMetadata::new( + env, + import_init_function_ptr, + host_env_clone_fn, + host_env_drop_fn, + ) + }; + + (env, metadata) +} + +impl WasmerEnv for WithoutEnv {} + +impl Function { + /// Creates a new host `Function` (dynamic) with the provided signature. + /// + /// If you know the signature of the host function at compile time, + /// consider using [`Function::new_native`] for less runtime overhead. + /// + /// # Examples + /// + /// ``` + /// # use wasmer::{Function, FunctionType, Type, Store, Value}; + /// # let store = Store::default(); + /// # + /// let signature = FunctionType::new(vec![Type::I32, Type::I32], vec![Type::I32]); + /// + /// let f = Function::new(&store, &signature, |args| { + /// let sum = args[0].unwrap_i32() + args[1].unwrap_i32(); + /// Ok(vec![Value::I32(sum)]) + /// }); + /// ``` + /// + /// With constant signature: + /// + /// ``` + /// # use wasmer::{Function, FunctionType, Type, Store, Value}; + /// # let store = Store::default(); + /// # + /// const I32_I32_TO_I32: ([Type; 2], [Type; 1]) = ([Type::I32, Type::I32], [Type::I32]); + /// + /// let f = Function::new(&store, I32_I32_TO_I32, |args| { + /// let sum = args[0].unwrap_i32() + args[1].unwrap_i32(); + /// Ok(vec![Value::I32(sum)]) + /// }); + /// ``` + #[allow(clippy::cast_ptr_alignment)] + pub fn new(store: &Store, ty: FT, func: F) -> Self + where + FT: Into, + F: Fn(&[Val]) -> Result, RuntimeError> + 'static + Send + Sync, + { + let wrapped_func = + move |_env: &WithoutEnv, args: &[Val]| -> Result, RuntimeError> { func(args) }; + Self::new_with_env(store, ty, WithoutEnv, wrapped_func) + } + + /// Creates a new host `Function` (dynamic) with the provided signature and environment. + /// + /// If you know the signature of the host function at compile time, + /// consider using [`Function::new_native_with_env`] for less runtime + /// overhead. + /// + /// # Examples + /// + /// ``` + /// # use wasmer::{Function, FunctionType, Type, Store, Value, WasmerEnv}; + /// # let store = Store::default(); + /// # + /// #[derive(Clone)] + /// struct Env { + /// multiplier: i32, + /// }; + /// impl WasmerEnv for Env {} + /// let env = Env { multiplier: 2 }; + /// + /// let signature = FunctionType::new(vec![Type::I32, Type::I32], vec![Type::I32]); + /// + /// let f = Function::new_with_env(&store, &signature, env, |env, args| { + /// let result = env.multiplier * (args[0].unwrap_i32() + args[1].unwrap_i32()); + /// Ok(vec![Value::I32(result)]) + /// }); + /// ``` + /// + /// With constant signature: + /// + /// ``` + /// # use wasmer::{Function, FunctionType, Type, Store, Value, WasmerEnv}; + /// # let store = Store::default(); + /// const I32_I32_TO_I32: ([Type; 2], [Type; 1]) = ([Type::I32, Type::I32], [Type::I32]); + /// + /// #[derive(Clone)] + /// struct Env { + /// multiplier: i32, + /// }; + /// impl WasmerEnv for Env {} + /// let env = Env { multiplier: 2 }; + /// + /// let f = Function::new_with_env(&store, I32_I32_TO_I32, env, |env, args| { + /// let result = env.multiplier * (args[0].unwrap_i32() + args[1].unwrap_i32()); + /// Ok(vec![Value::I32(result)]) + /// }); + /// ``` + #[allow(clippy::cast_ptr_alignment)] + pub fn new_with_env(store: &Store, ty: FT, env: Env, func: F) -> Self + where + FT: Into, + F: Fn(&Env, &[Val]) -> Result, RuntimeError> + 'static + Send + Sync, + Env: Sized + WasmerEnv + 'static, + { + let ty: FunctionType = ty.into(); + let dynamic_ctx: VMDynamicFunctionContext> = + VMDynamicFunctionContext::from_context(DynamicFunction { + env: Box::new(env), + func: Arc::new(func), + store: store.clone(), + function_type: ty.clone(), + }); + + let import_init_function_ptr: for<'a> fn(&'a mut _, &'a _) -> Result<(), _> = + |env: &mut VMDynamicFunctionContext>, + instance: &crate::Instance| { + Env::init_with_instance(&mut *env.ctx.env, instance) + }; + + let (host_env, metadata) = build_export_function_metadata::< + VMDynamicFunctionContext>, + >(dynamic_ctx, import_init_function_ptr); + + // We don't yet have the address with the Wasm ABI signature. + // The engine linker will replace the address with one pointing to a + // generated dynamic trampoline. + let address = std::ptr::null() as *const VMFunctionBody; + let vmctx = VMFunctionEnvironment { host_env }; + let signature = store + .engine() + // TODO(0-copy): + .register_signature(ty); + + Self { + store: store.clone(), + exported: ExportFunction { + metadata: Some(Arc::new(metadata)), + vm_function: VMFunction { + address, + kind: VMFunctionKind::Dynamic, + vmctx, + signature, + call_trampoline: None, + instance_ref: None, + }, + }, + } + } + + /// Creates a new host `Function` from a native function. + /// + /// The function signature is automatically retrieved using the + /// Rust typing system. + /// + /// # Example + /// + /// ``` + /// # use wasmer::{Store, Function}; + /// # let store = Store::default(); + /// # + /// fn sum(a: i32, b: i32) -> i32 { + /// a + b + /// } + /// + /// let f = Function::new_native(&store, sum); + /// ``` + pub fn new_native(store: &Store, func: F) -> Self + where + F: HostFunction, + Args: WasmTypeList, + Rets: WasmTypeList, + Env: Sized + 'static, + { + if std::mem::size_of::() != 0 { + Self::closures_unsupported_panic(); + } + let function = inner::Function::::new(func); + let address = function.address() as *const VMFunctionBody; + let vmctx = VMFunctionEnvironment { + host_env: std::ptr::null_mut() as *mut _, + }; + let signature = store + .engine() + // TODO(0-copy): + .register_signature(function.ty()); + + Self { + store: store.clone(), + exported: ExportFunction { + // TODO: figure out what's going on in this function: it takes an `Env` + // param but also marks itself as not having an env + metadata: None, + vm_function: VMFunction { + address, + vmctx, + signature, + kind: VMFunctionKind::Static, + call_trampoline: None, + instance_ref: None, + }, + }, + } + } + + /// Creates a new host `Function` from a native function and a provided environment. + /// + /// The function signature is automatically retrieved using the + /// Rust typing system. + /// + /// # Example + /// + /// ``` + /// # use wasmer::{Store, Function, WasmerEnv}; + /// # let store = Store::default(); + /// # + /// #[derive(Clone)] + /// struct Env { + /// multiplier: i32, + /// }; + /// impl WasmerEnv for Env {} + /// let env = Env { multiplier: 2 }; + /// + /// fn sum_and_multiply(env: &Env, a: i32, b: i32) -> i32 { + /// (a + b) * env.multiplier + /// } + /// + /// let f = Function::new_native_with_env(&store, env, sum_and_multiply); + /// ``` + pub fn new_native_with_env(store: &Store, env: Env, func: F) -> Self + where + F: HostFunction, + Args: WasmTypeList, + Rets: WasmTypeList, + Env: Sized + WasmerEnv + 'static, + { + if std::mem::size_of::() != 0 { + Self::closures_unsupported_panic(); + } + let function = inner::Function::::new(func); + let address = function.address(); + + let (host_env, metadata) = + build_export_function_metadata::(env, Env::init_with_instance); + + let vmctx = VMFunctionEnvironment { host_env }; + let signature = store.engine().register_signature(function.ty()); + Self { + store: store.clone(), + exported: ExportFunction { + metadata: Some(Arc::new(metadata)), + vm_function: VMFunction { + address, + kind: VMFunctionKind::Static, + vmctx, + signature, + call_trampoline: None, + instance_ref: None, + }, + }, + } + } + + /// Returns the [`FunctionType`] of the `Function`. + /// + /// # Example + /// + /// ``` + /// # use wasmer::{Function, Store, Type}; + /// # let store = Store::default(); + /// # + /// fn sum(a: i32, b: i32) -> i32 { + /// a + b + /// } + /// + /// let f = Function::new_native(&store, sum); + /// + /// assert_eq!(f.ty().params(), vec![Type::I32, Type::I32]); + /// assert_eq!(f.ty().results(), vec![Type::I32]); + /// ``` + pub fn ty(&self) -> FunctionType { + self.store + .engine() + .lookup_signature(self.exported.vm_function.signature) + .expect("Could not resolve VMSharedFunctionIndex! Mixing engines?") + } + + /// Returns the [`Store`] where the `Function` belongs. + pub fn store(&self) -> &Store { + &self.store + } + + fn call_wasm( + &self, + trampoline: VMTrampoline, + params: &[Val], + results: &mut [Val], + ) -> Result<(), RuntimeError> { + let format_types_for_error_message = |items: &[Val]| { + items + .iter() + .map(|param| param.ty().to_string()) + .collect::>() + .join(", ") + }; + let signature = self.ty(); + if signature.params().len() != params.len() { + return Err(RuntimeError::new(format!( + "Parameters of type [{}] did not match signature {}", + format_types_for_error_message(params), + &signature + ))); + } + if signature.results().len() != results.len() { + return Err(RuntimeError::new(format!( + "Results of type [{}] did not match signature {}", + format_types_for_error_message(results), + &signature, + ))); + } + + let mut values_vec = vec![0; max(params.len(), results.len())]; + + // Store the argument values into `values_vec`. + let param_tys = signature.params().iter(); + for ((arg, slot), ty) in params.iter().zip(&mut values_vec).zip(param_tys) { + if arg.ty() != *ty { + let param_types = format_types_for_error_message(params); + return Err(RuntimeError::new(format!( + "Parameters of type [{}] did not match signature {}", + param_types, &signature, + ))); + } + unsafe { + arg.write_value_to(slot); + } + } + + // Call the trampoline. + if let Err(error) = unsafe { + wasmer_call_trampoline( + self.exported.vm_function.vmctx, + trampoline, + self.exported.vm_function.address, + values_vec.as_mut_ptr() as *mut u8, + ) + } { + return Err(RuntimeError::from_trap(error)); + } + + // Load the return values out of `values_vec`. + for (index, &value_type) in signature.results().iter().enumerate() { + unsafe { + let ptr = values_vec.as_ptr().add(index); + results[index] = Val::read_value_from(&self.store, ptr, value_type); + } + } + + Ok(()) + } + + /// Returns the number of parameters that this function takes. + /// + /// # Example + /// + /// ``` + /// # use wasmer::{Function, Store, Type}; + /// # let store = Store::default(); + /// # + /// fn sum(a: i32, b: i32) -> i32 { + /// a + b + /// } + /// + /// let f = Function::new_native(&store, sum); + /// + /// assert_eq!(f.param_arity(), 2); + /// ``` + pub fn param_arity(&self) -> usize { + self.ty().params().len() + } + + /// Returns the number of results this function produces. + /// + /// # Example + /// + /// ``` + /// # use wasmer::{Function, Store, Type}; + /// # let store = Store::default(); + /// # + /// fn sum(a: i32, b: i32) -> i32 { + /// a + b + /// } + /// + /// let f = Function::new_native(&store, sum); + /// + /// assert_eq!(f.result_arity(), 1); + /// ``` + pub fn result_arity(&self) -> usize { + self.ty().results().len() + } + + /// Call the `Function` function. + /// + /// Depending on where the Function is defined, it will call it. + /// 1. If the function is defined inside a WebAssembly, it will call the trampoline + /// for the function signature. + /// 2. If the function is defined in the host (in a native way), it will + /// call the trampoline. + /// + /// # Examples + /// + /// ``` + /// # use wasmer::{imports, wat2wasm, Function, Instance, Module, Store, Type, Value}; + /// # let store = Store::default(); + /// # let wasm_bytes = wat2wasm(r#" + /// # (module + /// # (func (export "sum") (param $x i32) (param $y i32) (result i32) + /// # local.get $x + /// # local.get $y + /// # i32.add + /// # )) + /// # "#.as_bytes()).unwrap(); + /// # let module = Module::new(&store, wasm_bytes).unwrap(); + /// # let import_object = imports! {}; + /// # let instance = Instance::new(&module, &import_object).unwrap(); + /// # + /// let sum = instance.lookup_function("sum").unwrap(); + /// + /// assert_eq!(sum.call(&[Value::I32(1), Value::I32(2)]).unwrap().to_vec(), vec![Value::I32(3)]); + /// ``` + pub fn call(&self, params: &[Val]) -> Result, RuntimeError> { + // If it's a function defined in the Wasm, it will always have a call_trampoline + if let Some(trampoline) = self.exported.vm_function.call_trampoline { + let mut results = vec![Val::null(); self.result_arity()]; + self.call_wasm(trampoline, params, &mut results)?; + return Ok(results.into_boxed_slice()); + } + + // If it's a function defined in the host + match self.exported.vm_function.kind { + VMFunctionKind::Dynamic => unsafe { + type VMContextWithEnv = VMDynamicFunctionContext>; + let ctx = self.exported.vm_function.vmctx.host_env as *mut VMContextWithEnv; + Ok((*ctx).ctx.call(¶ms)?.into_boxed_slice()) + }, + VMFunctionKind::Static => { + unimplemented!( + "Native function definitions can't be directly called from the host yet" + ); + } + } + } + + pub(crate) fn from_vm_export(store: &Store, wasmer_export: ExportFunction) -> Self { + Self { + store: store.clone(), + exported: wasmer_export, + } + } + + pub(crate) fn vm_funcref(&self) -> VMFuncRef { + let engine = self.store.engine(); + engine.register_function_metadata(VMCallerCheckedAnyfunc { + func_ptr: self.exported.vm_function.address, + type_index: self.exported.vm_function.signature, + vmctx: self.exported.vm_function.vmctx, + }) + } + + /// Transform this WebAssembly function into a function with the + /// native ABI. See [`NativeFunc`] to learn more. + /// + /// # Examples + /// + /// ``` + /// # use wasmer::{imports, wat2wasm, Function, Instance, Module, Store, Type, Value}; + /// # let store = Store::default(); + /// # let wasm_bytes = wat2wasm(r#" + /// # (module + /// # (func (export "sum") (param $x i32) (param $y i32) (result i32) + /// # local.get $x + /// # local.get $y + /// # i32.add + /// # )) + /// # "#.as_bytes()).unwrap(); + /// # let module = Module::new(&store, wasm_bytes).unwrap(); + /// # let import_object = imports! {}; + /// # let instance = Instance::new(&module, &import_object).unwrap(); + /// # + /// let sum = instance.lookup_function("sum").unwrap(); + /// let sum_native = sum.native::<(i32, i32), i32>().unwrap(); + /// + /// assert_eq!(sum_native.call(1, 2).unwrap(), 3); + /// ``` + /// + /// # Errors + /// + /// If the `Args` generic parameter does not match the exported function + /// an error will be raised: + /// + /// ```should_panic + /// # use wasmer::{imports, wat2wasm, Function, Instance, Module, Store, Type, Value}; + /// # let store = Store::default(); + /// # let wasm_bytes = wat2wasm(r#" + /// # (module + /// # (func (export "sum") (param $x i32) (param $y i32) (result i32) + /// # local.get $x + /// # local.get $y + /// # i32.add + /// # )) + /// # "#.as_bytes()).unwrap(); + /// # let module = Module::new(&store, wasm_bytes).unwrap(); + /// # let import_object = imports! {}; + /// # let instance = Instance::new(&module, &import_object).unwrap(); + /// # + /// let sum = instance.lookup_function("sum").unwrap(); + /// + /// // This results in an error: `RuntimeError` + /// let sum_native = sum.native::<(i64, i64), i32>().unwrap(); + /// ``` + /// + /// If the `Rets` generic parameter does not match the exported function + /// an error will be raised: + /// + /// ```should_panic + /// # use wasmer::{imports, wat2wasm, Function, Instance, Module, Store, Type, Value}; + /// # let store = Store::default(); + /// # let wasm_bytes = wat2wasm(r#" + /// # (module + /// # (func (export "sum") (param $x i32) (param $y i32) (result i32) + /// # local.get $x + /// # local.get $y + /// # i32.add + /// # )) + /// # "#.as_bytes()).unwrap(); + /// # let module = Module::new(&store, wasm_bytes).unwrap(); + /// # let import_object = imports! {}; + /// # let instance = Instance::new(&module, &import_object).unwrap(); + /// # + /// let sum = instance.lookup_function("sum").unwrap(); + /// + /// // This results in an error: `RuntimeError` + /// let sum_native = sum.native::<(i32, i32), i64>().unwrap(); + /// ``` + pub fn native(&self) -> Result, RuntimeError> + where + Args: WasmTypeList, + Rets: WasmTypeList, + { + let engine = self.store().engine(); + let signature = engine + .lookup_signature(self.exported.vm_function.signature) + .expect("Could not resolve VMSharedSignatureIndex! Wrong engine?"); + // type check + let expected = signature.params(); + let given = Args::wasm_types(); + if expected != given { + return Err(RuntimeError::new(format!( + "types (`{:?}`) for the function arguments don't match the actual types (`{:?}`)", + given, expected, + ))); + } + let expected = signature.results(); + let given = Rets::wasm_types(); + if expected != given { + // todo: error result types don't match + return Err(RuntimeError::new(format!( + "types (`{:?}`) for the function results don't match the actual types (`{:?}`)", + given, expected, + ))); + } + + Ok(NativeFunc::new(self.store.clone(), self.exported.clone())) + } + + #[track_caller] + fn closures_unsupported_panic() -> ! { + unimplemented!("Closures (functions with captured environments) are currently unsupported with native functions. See: https://github.com/wasmerio/wasmer/issues/1840") + } + + /// Get access to the backing VM value for this extern. This function is for + /// tests it should not be called by users of the Wasmer API. + /// + /// # Safety + /// This function is unsafe to call outside of tests for the wasmer crate + /// because there is no stability guarantee for the returned type and we may + /// make breaking changes to it at any time or remove this method. + #[doc(hidden)] + pub unsafe fn get_vm_function(&self) -> &VMFunction { + &self.exported.vm_function + } +} + +impl<'a> Exportable<'a> for Function { + fn to_export(&self) -> Export { + self.exported.clone().into() + } +} + +impl Clone for Function { + fn clone(&self) -> Self { + let mut exported = self.exported.clone(); + exported.vm_function.upgrade_instance_ref().unwrap(); + + Self { + store: self.store.clone(), + exported, + } + } +} + +impl fmt::Debug for Function { + fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { + formatter + .debug_struct("Function") + .field("ty", &self.ty()) + .finish() + } +} + +/// This trait is one that all dynamic functions must fulfill. +pub(crate) trait VMDynamicFunction: Send + Sync { + fn call(&self, args: &[Val]) -> Result, RuntimeError>; + fn function_type(&self) -> &FunctionType; + fn store(&self) -> &Store; +} + +pub(crate) struct DynamicFunction +where + Env: Sized + 'static + Send + Sync, +{ + function_type: FunctionType, + #[allow(clippy::type_complexity)] + func: Arc Result, RuntimeError> + 'static + Send + Sync>, + store: Store, + env: Box, +} + +impl Clone for DynamicFunction { + fn clone(&self) -> Self { + Self { + env: self.env.clone(), + function_type: self.function_type.clone(), + store: self.store.clone(), + func: self.func.clone(), + } + } +} + +impl VMDynamicFunction for DynamicFunction +where + Env: Sized + 'static + Send + Sync, +{ + fn call(&self, args: &[Val]) -> Result, RuntimeError> { + (*self.func)(&*self.env, &args) + } + fn function_type(&self) -> &FunctionType { + &self.function_type + } + fn store(&self) -> &Store { + &self.store + } +} + +trait VMDynamicFunctionCall { + fn from_context(ctx: T) -> Self; + fn address_ptr() -> *const VMFunctionBody; + unsafe fn func_wrapper(&self, values_vec: *mut i128); +} + +impl VMDynamicFunctionCall for VMDynamicFunctionContext { + fn from_context(ctx: T) -> Self { + Self { + address: Self::address_ptr(), + ctx, + } + } + + fn address_ptr() -> *const VMFunctionBody { + Self::func_wrapper as *const () as *const VMFunctionBody + } + + // This function wraps our func, to make it compatible with the + // reverse trampoline signature + unsafe fn func_wrapper( + // Note: we use the trick that the first param to this function is the `VMDynamicFunctionContext` + // itself, so rather than doing `dynamic_ctx: &VMDynamicFunctionContext`, we simplify it a bit + &self, + values_vec: *mut i128, + ) { + use std::panic::{self, AssertUnwindSafe}; + let result = panic::catch_unwind(AssertUnwindSafe(|| { + let func_ty = self.ctx.function_type(); + let mut args = Vec::with_capacity(func_ty.params().len()); + let store = self.ctx.store(); + for (i, ty) in func_ty.params().iter().enumerate() { + args.push(Val::read_value_from(store, values_vec.add(i), *ty)); + } + let returns = self.ctx.call(&args)?; + + // We need to dynamically check that the returns + // match the expected types, as well as expected length. + let return_types = returns.iter().map(|ret| ret.ty()).collect::>(); + if return_types != func_ty.results() { + return Err(RuntimeError::new(format!( + "Dynamic function returned wrong signature. Expected {:?} but got {:?}", + func_ty.results(), + return_types + ))); + } + for (i, ret) in returns.iter().enumerate() { + ret.write_value_to(values_vec.add(i)); + } + Ok(()) + })); // We get extern ref drops at the end of this block that we don't need. + // By preventing extern ref incs in the code above we can save the work of + // incrementing and decrementing. However the logic as-is is correct. + + match result { + Ok(Ok(())) => {} + Ok(Err(trap)) => raise_user_trap(Box::new(trap)), + Err(panic) => resume_panic(panic), + } + } +} + +/// This private inner module contains the low-level implementation +/// for `Function` and its siblings. +mod inner { + use std::array::TryFromSliceError; + use std::convert::{Infallible, TryInto}; + use std::error::Error; + use std::marker::PhantomData; + use std::panic::{self, AssertUnwindSafe}; + use wasmer_types::{FunctionType, NativeWasmType, Type}; + use wasmer_vm::{raise_user_trap, resume_panic, VMFunctionBody}; + + /// A trait to convert a Rust value to a `WasmNativeType` value, + /// or to convert `WasmNativeType` value to a Rust value. + /// + /// This trait should ideally be split into two traits: + /// `FromNativeWasmType` and `ToNativeWasmType` but it creates a + /// non-negligible complexity in the `WasmTypeList` + /// implementation. + pub unsafe trait FromToNativeWasmType + where + Self: Sized, + { + /// Native Wasm type. + type Native: NativeWasmType; + + /// Convert a value of kind `Self::Native` to `Self`. + /// + /// # Panics + /// + /// This method panics if `native` cannot fit in the `Self` + /// type`. + fn from_native(native: Self::Native) -> Self; + + /// Convert self to `Self::Native`. + /// + /// # Panics + /// + /// This method panics if `self` cannot fit in the + /// `Self::Native` type. + fn to_native(self) -> Self::Native; + } + + macro_rules! from_to_native_wasm_type { + ( $( $type:ty => $native_type:ty ),* ) => { + $( + #[allow(clippy::use_self)] + unsafe impl FromToNativeWasmType for $type { + type Native = $native_type; + + #[inline] + fn from_native(native: Self::Native) -> Self { + native as Self + } + + #[inline] + fn to_native(self) -> Self::Native { + self as Self::Native + } + } + )* + }; + } + + macro_rules! from_to_native_wasm_type_same_size { + ( $( $type:ty => $native_type:ty ),* ) => { + $( + #[allow(clippy::use_self)] + unsafe impl FromToNativeWasmType for $type { + type Native = $native_type; + + #[inline] + fn from_native(native: Self::Native) -> Self { + Self::from_ne_bytes(Self::Native::to_ne_bytes(native)) + } + + #[inline] + fn to_native(self) -> Self::Native { + Self::Native::from_ne_bytes(Self::to_ne_bytes(self)) + } + } + )* + }; + } + + from_to_native_wasm_type!( + i8 => i32, + u8 => i32, + i16 => i32, + u16 => i32 + ); + + from_to_native_wasm_type_same_size!( + i32 => i32, + u32 => i32, + i64 => i64, + u64 => i64, + f32 => f32, + f64 => f64 + ); + + #[cfg(test)] + mod test_from_to_native_wasm_type { + use super::*; + + #[test] + fn test_to_native() { + assert_eq!(7i8.to_native(), 7i32); + assert_eq!(7u8.to_native(), 7i32); + assert_eq!(7i16.to_native(), 7i32); + assert_eq!(7u16.to_native(), 7i32); + assert_eq!(u32::MAX.to_native(), -1); + } + + #[test] + fn test_to_native_same_size() { + assert_eq!(7i32.to_native(), 7i32); + assert_eq!(7u32.to_native(), 7i32); + assert_eq!(7i64.to_native(), 7i64); + assert_eq!(7u64.to_native(), 7i64); + assert_eq!(7f32.to_native(), 7f32); + assert_eq!(7f64.to_native(), 7f64); + } + } + + /// The `WasmTypeList` trait represents a tuple (list) of Wasm + /// typed values. It is used to get low-level representation of + /// such a tuple. + pub trait WasmTypeList + where + Self: Sized, + { + /// The C type (a struct) that can hold/represent all the + /// represented values. + type CStruct; + + /// The array type that can hold all the represented values. + /// + /// Note that all values are stored in their binary form. + type Array: AsMut<[i128]>; + + /// Constructs `Self` based on an array of values. + fn from_array(array: Self::Array) -> Self; + + /// Constructs `Self` based on a slice of values. + /// + /// `from_slice` returns a `Result` because it is possible + /// that the slice doesn't have the same size than + /// `Self::Array`, in which circumstance an error of kind + /// `TryFromSliceError` will be returned. + fn from_slice(slice: &[i128]) -> Result; + + /// Builds and returns an array of type `Array` from a tuple + /// (list) of values. + fn into_array(self) -> Self::Array; + + /// Allocates and return an empty array of type `Array` that + /// will hold a tuple (list) of values, usually to hold the + /// returned values of a WebAssembly function call. + fn empty_array() -> Self::Array; + + /// Builds a tuple (list) of values from a C struct of type + /// `CStruct`. + fn from_c_struct(c_struct: Self::CStruct) -> Self; + + /// Builds and returns a C struct of type `CStruct` from a + /// tuple (list) of values. + fn into_c_struct(self) -> Self::CStruct; + + /// Get the Wasm types for the tuple (list) of currently + /// represented values. + fn wasm_types() -> &'static [Type]; + } + + /// The `IntoResult` trait turns a `WasmTypeList` into a + /// `Result`. + /// + /// It is mostly used to turn result values of a Wasm function + /// call into a `Result`. + pub trait IntoResult + where + T: WasmTypeList, + { + /// The error type for this trait. + type Error: Error + Sync + Send + 'static; + + /// Transforms `Self` into a `Result`. + fn into_result(self) -> Result; + } + + impl IntoResult for T + where + T: WasmTypeList, + { + // `T` is not a `Result`, it's already a value, so no error + // can be built. + type Error = Infallible; + + fn into_result(self) -> Result { + Ok(self) + } + } + + impl IntoResult for Result + where + T: WasmTypeList, + E: Error + Sync + Send + 'static, + { + type Error = E; + + fn into_result(self) -> Self { + self + } + } + + #[cfg(test)] + mod test_into_result { + use super::*; + use std::convert::Infallible; + + #[test] + fn test_into_result_over_t() { + let x: i32 = 42; + let result_of_x: Result = x.into_result(); + + assert_eq!(result_of_x.unwrap(), x); + } + + #[test] + fn test_into_result_over_result() { + { + let x: Result = Ok(42); + let result_of_x: Result = x.into_result(); + + assert_eq!(result_of_x, x); + } + + { + use std::{error, fmt}; + + #[derive(Debug, PartialEq)] + struct E; + + impl fmt::Display for E { + fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result { + write!(formatter, "E") + } + } + + impl error::Error for E {} + + let x: Result = Err(E); + let result_of_x: Result = x.into_result(); + + assert_eq!(result_of_x.unwrap_err(), E); + } + } + } + + /// The `HostFunction` trait represents the set of functions that + /// can be used as host function. To uphold this statement, it is + /// necessary for a function to be transformed into a pointer to + /// `VMFunctionBody`. + pub trait HostFunction + where + Args: WasmTypeList, + Rets: WasmTypeList, + Kind: HostFunctionKind, + T: Sized, + Self: Sized, + { + /// Get the pointer to the function body. + fn function_body_ptr(self) -> *const VMFunctionBody; + } + + /// Empty trait to specify the kind of `HostFunction`: With or + /// without an environment. + /// + /// This trait is never aimed to be used by a user. It is used by + /// the trait system to automatically generate the appropriate + /// host functions. + #[doc(hidden)] + pub trait HostFunctionKind {} + + /// An empty struct to help Rust typing to determine + /// when a `HostFunction` does have an environment. + pub struct WithEnv; + + impl HostFunctionKind for WithEnv {} + + /// An empty struct to help Rust typing to determine + /// when a `HostFunction` does not have an environment. + #[derive(Clone)] + pub struct WithoutEnv; + + impl HostFunctionKind for WithoutEnv {} + + /// Represents a low-level Wasm static host function. See + /// `super::Function::new` and `super::Function::new_env` to learn + /// more. + #[derive(Clone, Debug, Hash, PartialEq, Eq)] + pub struct Function { + address: *const VMFunctionBody, + _phantom: PhantomData<(Args, Rets)>, + } + + unsafe impl Send for Function {} + + impl Function + where + Args: WasmTypeList, + Rets: WasmTypeList, + { + /// Creates a new `Function`. + pub fn new(function: F) -> Self + where + F: HostFunction, + T: HostFunctionKind, + E: Sized, + { + Self { + address: function.function_body_ptr(), + _phantom: PhantomData, + } + } + + /// Get the function type of this `Function`. + pub fn ty(&self) -> FunctionType { + FunctionType::new(Args::wasm_types(), Rets::wasm_types()) + } + + /// Get the address of this `Function`. + pub fn address(&self) -> *const VMFunctionBody { + self.address + } + } + + macro_rules! impl_host_function { + ( [$c_struct_representation:ident] + $c_struct_name:ident, + $( $x:ident ),* ) => { + + /// A structure with a C-compatible representation that can hold a set of Wasm values. + /// This type is used by `WasmTypeList::CStruct`. + #[repr($c_struct_representation)] + pub struct $c_struct_name< $( $x ),* > ( $( <$x as FromToNativeWasmType>::Native ),* ) + where + $( $x: FromToNativeWasmType ),*; + + // Implement `WasmTypeList` for a specific tuple. + #[allow(unused_parens, dead_code)] + impl< $( $x ),* > + WasmTypeList + for + ( $( $x ),* ) + where + $( $x: FromToNativeWasmType ),* + { + type CStruct = $c_struct_name< $( $x ),* >; + + type Array = [i128; count_idents!( $( $x ),* )]; + + fn from_array(array: Self::Array) -> Self { + // Unpack items of the array. + #[allow(non_snake_case)] + let [ $( $x ),* ] = array; + + // Build the tuple. + ( + $( + FromToNativeWasmType::from_native(NativeWasmType::from_binary($x)) + ),* + ) + } + + fn from_slice(slice: &[i128]) -> Result { + Ok(Self::from_array(slice.try_into()?)) + } + + fn into_array(self) -> Self::Array { + // Unpack items of the tuple. + #[allow(non_snake_case)] + let ( $( $x ),* ) = self; + + // Build the array. + [ + $( + FromToNativeWasmType::to_native($x).to_binary() + ),* + ] + } + + fn empty_array() -> Self::Array { + // Build an array initialized with `0`. + [0; count_idents!( $( $x ),* )] + } + + fn from_c_struct(c_struct: Self::CStruct) -> Self { + // Unpack items of the C structure. + #[allow(non_snake_case)] + let $c_struct_name( $( $x ),* ) = c_struct; + + ( + $( + FromToNativeWasmType::from_native($x) + ),* + ) + } + + #[allow(unused_parens, non_snake_case)] + fn into_c_struct(self) -> Self::CStruct { + // Unpack items of the tuple. + let ( $( $x ),* ) = self; + + // Build the C structure. + $c_struct_name( + $( + FromToNativeWasmType::to_native($x) + ),* + ) + } + + fn wasm_types() -> &'static [Type] { + &[ + $( + $x::Native::WASM_TYPE + ),* + ] + } + } + + // Implement `HostFunction` for a function that has the same arity than the tuple. + // This specific function has no environment. + #[allow(unused_parens)] + impl< $( $x, )* Rets, RetsAsResult, Func > + HostFunction<( $( $x ),* ), Rets, WithoutEnv, ()> + for + Func + where + $( $x: FromToNativeWasmType, )* + Rets: WasmTypeList, + RetsAsResult: IntoResult, + Func: Fn($( $x , )*) -> RetsAsResult + 'static + Send, + { + #[allow(non_snake_case)] + fn function_body_ptr(self) -> *const VMFunctionBody { + /// This is a function that wraps the real host + /// function. Its address will be used inside the + /// runtime. + extern fn func_wrapper<$( $x, )* Rets, RetsAsResult, Func>( _: usize, $( $x: $x::Native, )* ) -> Rets::CStruct + where + $( $x: FromToNativeWasmType, )* + Rets: WasmTypeList, + RetsAsResult: IntoResult, + Func: Fn( $( $x ),* ) -> RetsAsResult + 'static + { + let func: &Func = unsafe { &*(&() as *const () as *const Func) }; + let result = panic::catch_unwind(AssertUnwindSafe(|| { + func( $( FromToNativeWasmType::from_native($x) ),* ).into_result() + })); + + match result { + Ok(Ok(result)) => return result.into_c_struct(), + Ok(Err(trap)) => unsafe { raise_user_trap(Box::new(trap)) }, + Err(panic) => unsafe { resume_panic(panic) }, + } + } + + func_wrapper::< $( $x, )* Rets, RetsAsResult, Self > as *const VMFunctionBody + } + } + + // Implement `HostFunction` for a function that has the same arity than the tuple. + // This specific function has an environment. + #[allow(unused_parens)] + impl< $( $x, )* Rets, RetsAsResult, Env, Func > + HostFunction<( $( $x ),* ), Rets, WithEnv, Env> + for + Func + where + $( $x: FromToNativeWasmType, )* + Rets: WasmTypeList, + RetsAsResult: IntoResult, + Env: Sized, + Func: Fn(&Env, $( $x , )*) -> RetsAsResult + Send + 'static, + { + #[allow(non_snake_case)] + fn function_body_ptr(self) -> *const VMFunctionBody { + /// This is a function that wraps the real host + /// function. Its address will be used inside the + /// runtime. + extern fn func_wrapper<$( $x, )* Rets, RetsAsResult, Env, Func>( env: &Env, $( $x: $x::Native, )* ) -> Rets::CStruct + where + $( $x: FromToNativeWasmType, )* + Rets: WasmTypeList, + RetsAsResult: IntoResult, + Env: Sized, + Func: Fn(&Env, $( $x ),* ) -> RetsAsResult + 'static + { + let func: &Func = unsafe { &*(&() as *const () as *const Func) }; + + let result = panic::catch_unwind(AssertUnwindSafe(|| { + func(env, $( FromToNativeWasmType::from_native($x) ),* ).into_result() + })); + + match result { + Ok(Ok(result)) => return result.into_c_struct(), + Ok(Err(trap)) => unsafe { raise_user_trap(Box::new(trap)) }, + Err(panic) => unsafe { resume_panic(panic) }, + } + } + + func_wrapper::< $( $x, )* Rets, RetsAsResult, Env, Self > as *const VMFunctionBody + } + } + }; + } + + // Black-magic to count the number of identifiers at compile-time. + macro_rules! count_idents { + ( $($idents:ident),* ) => { + { + #[allow(dead_code, non_camel_case_types)] + enum Idents { $( $idents, )* __CountIdentsLast } + const COUNT: usize = Idents::__CountIdentsLast as usize; + COUNT + } + }; + } + + // Here we go! Let's generate all the C struct, `WasmTypeList` + // implementations and `HostFunction` implementations. + impl_host_function!([C] S0,); + impl_host_function!([transparent] S1, A1); + impl_host_function!([C] S2, A1, A2); + impl_host_function!([C] S3, A1, A2, A3); + impl_host_function!([C] S4, A1, A2, A3, A4); + impl_host_function!([C] S5, A1, A2, A3, A4, A5); + impl_host_function!([C] S6, A1, A2, A3, A4, A5, A6); + impl_host_function!([C] S7, A1, A2, A3, A4, A5, A6, A7); + impl_host_function!([C] S8, A1, A2, A3, A4, A5, A6, A7, A8); + impl_host_function!([C] S9, A1, A2, A3, A4, A5, A6, A7, A8, A9); + impl_host_function!([C] S10, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10); + impl_host_function!([C] S11, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11); + impl_host_function!([C] S12, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12); + impl_host_function!([C] S13, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13); + impl_host_function!([C] S14, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14); + impl_host_function!([C] S15, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15); + impl_host_function!([C] S16, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16); + impl_host_function!([C] S17, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17); + impl_host_function!([C] S18, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18); + impl_host_function!([C] S19, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19); + impl_host_function!([C] S20, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20); + impl_host_function!([C] S21, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21); + impl_host_function!([C] S22, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22); + impl_host_function!([C] S23, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23); + impl_host_function!([C] S24, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24); + impl_host_function!([C] S25, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25); + impl_host_function!([C] S26, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26); + + // Implement `WasmTypeList` on `Infallible`, which means that + // `Infallible` can be used as a returned type of a host function + // to express that it doesn't return, or to express that it cannot + // fail (with `Result<_, Infallible>`). + impl WasmTypeList for Infallible { + type CStruct = Self; + type Array = [i128; 0]; + + fn from_array(_: Self::Array) -> Self { + unreachable!() + } + + fn from_slice(_: &[i128]) -> Result { + unreachable!() + } + + fn into_array(self) -> Self::Array { + [] + } + + fn empty_array() -> Self::Array { + unreachable!() + } + + fn from_c_struct(_: Self::CStruct) -> Self { + unreachable!() + } + + fn into_c_struct(self) -> Self::CStruct { + unreachable!() + } + + fn wasm_types() -> &'static [Type] { + &[] + } + } + + #[cfg(test)] + mod test_wasm_type_list { + use super::*; + use wasmer_types::Type; + + #[test] + fn test_from_array() { + assert_eq!(<()>::from_array([]), ()); + assert_eq!(::from_array([1]), (1i32)); + assert_eq!(<(i32, i64)>::from_array([1, 2]), (1i32, 2i64)); + assert_eq!( + <(i32, i64, f32, f64)>::from_array([ + 1, + 2, + (3.1f32).to_bits().into(), + (4.2f64).to_bits().into() + ]), + (1, 2, 3.1f32, 4.2f64) + ); + } + + #[test] + fn test_into_array() { + assert_eq!(().into_array(), [0i128; 0]); + assert_eq!((1).into_array(), [1]); + assert_eq!((1i32, 2i64).into_array(), [1, 2]); + assert_eq!( + (1i32, 2i32, 3.1f32, 4.2f64).into_array(), + [1, 2, (3.1f32).to_bits().into(), (4.2f64).to_bits().into()] + ); + } + + #[test] + fn test_empty_array() { + assert_eq!(<()>::empty_array().len(), 0); + assert_eq!(::empty_array().len(), 1); + assert_eq!(<(i32, i64)>::empty_array().len(), 2); + } + + #[test] + fn test_from_c_struct() { + assert_eq!(<()>::from_c_struct(S0()), ()); + assert_eq!(::from_c_struct(S1(1)), (1i32)); + assert_eq!(<(i32, i64)>::from_c_struct(S2(1, 2)), (1i32, 2i64)); + assert_eq!( + <(i32, i64, f32, f64)>::from_c_struct(S4(1, 2, 3.1, 4.2)), + (1i32, 2i64, 3.1f32, 4.2f64) + ); + } + + #[test] + fn test_wasm_types_for_uni_values() { + assert_eq!(::wasm_types(), [Type::I32]); + assert_eq!(::wasm_types(), [Type::I64]); + assert_eq!(::wasm_types(), [Type::F32]); + assert_eq!(::wasm_types(), [Type::F64]); + } + + #[test] + fn test_wasm_types_for_multi_values() { + assert_eq!(<(i32, i32)>::wasm_types(), [Type::I32, Type::I32]); + assert_eq!(<(i64, i64)>::wasm_types(), [Type::I64, Type::I64]); + assert_eq!(<(f32, f32)>::wasm_types(), [Type::F32, Type::F32]); + assert_eq!(<(f64, f64)>::wasm_types(), [Type::F64, Type::F64]); + + assert_eq!( + <(i32, i64, f32, f64)>::wasm_types(), + [Type::I32, Type::I64, Type::F32, Type::F64] + ); + } + } + + #[allow(non_snake_case)] + #[cfg(test)] + mod test_function { + use super::*; + use wasmer_types::Type; + + fn func() {} + fn func__i32() -> i32 { + 0 + } + fn func_i32(_a: i32) {} + fn func_i32__i32(a: i32) -> i32 { + a * 2 + } + fn func_i32_i32__i32(a: i32, b: i32) -> i32 { + a + b + } + fn func_i32_i32__i32_i32(a: i32, b: i32) -> (i32, i32) { + (a, b) + } + fn func_f32_i32__i32_f32(a: f32, b: i32) -> (i32, f32) { + (b, a) + } + + #[test] + fn test_function_types() { + assert_eq!(Function::new(func).ty(), FunctionType::new(vec![], vec![])); + assert_eq!( + Function::new(func__i32).ty(), + FunctionType::new(vec![], vec![Type::I32]) + ); + assert_eq!( + Function::new(func_i32).ty(), + FunctionType::new(vec![Type::I32], vec![]) + ); + assert_eq!( + Function::new(func_i32__i32).ty(), + FunctionType::new(vec![Type::I32], vec![Type::I32]) + ); + assert_eq!( + Function::new(func_i32_i32__i32).ty(), + FunctionType::new(vec![Type::I32, Type::I32], vec![Type::I32]) + ); + assert_eq!( + Function::new(func_i32_i32__i32_i32).ty(), + FunctionType::new(vec![Type::I32, Type::I32], vec![Type::I32, Type::I32]) + ); + assert_eq!( + Function::new(func_f32_i32__i32_f32).ty(), + FunctionType::new(vec![Type::F32, Type::I32], vec![Type::I32, Type::F32]) + ); + } + + #[test] + fn test_function_pointer() { + let f = Function::new(func_i32__i32); + let function = unsafe { std::mem::transmute::<_, fn(usize, i32) -> i32>(f.address) }; + assert_eq!(function(0, 3), 6); + } + } +} diff --git a/runtime/near-vm/lib/api/src/sys/externals/global.rs b/runtime/near-vm/lib/api/src/sys/externals/global.rs new file mode 100644 index 00000000000..23dc09a03ab --- /dev/null +++ b/runtime/near-vm/lib/api/src/sys/externals/global.rs @@ -0,0 +1,219 @@ +use crate::sys::exports::Exportable; +use crate::sys::store::{Store, StoreObject}; +use crate::sys::types::Val; +use crate::sys::GlobalType; +use crate::sys::Mutability; +use crate::sys::RuntimeError; +use std::fmt; +use std::sync::Arc; +use wasmer_vm::{Export, Global as RuntimeGlobal, VMGlobal}; + +/// A WebAssembly `global` instance. +/// +/// A global instance is the runtime representation of a global variable. +/// It consists of an individual value and a flag indicating whether it is mutable. +/// +/// Spec: +pub struct Global { + store: Store, + vm_global: VMGlobal, +} + +impl Global { + /// Create a new `Global` with the initial value [`Val`]. + /// + /// # Example + /// + /// ``` + /// # use wasmer::{Global, Mutability, Store, Value}; + /// # let store = Store::default(); + /// # + /// let g = Global::new(&store, Value::I32(1)); + /// + /// assert_eq!(g.get(), Value::I32(1)); + /// assert_eq!(g.ty().mutability, Mutability::Const); + /// ``` + pub fn new(store: &Store, val: Val) -> Self { + Self::from_value(store, val, Mutability::Const).unwrap() + } + + /// Create a mutable `Global` with the initial value [`Val`]. + /// + /// # Example + /// + /// ``` + /// # use wasmer::{Global, Mutability, Store, Value}; + /// # let store = Store::default(); + /// # + /// let g = Global::new_mut(&store, Value::I32(1)); + /// + /// assert_eq!(g.get(), Value::I32(1)); + /// assert_eq!(g.ty().mutability, Mutability::Var); + /// ``` + pub fn new_mut(store: &Store, val: Val) -> Self { + Self::from_value(store, val, Mutability::Var).unwrap() + } + + /// Create a `Global` with the initial value [`Val`] and the provided [`Mutability`]. + fn from_value(store: &Store, val: Val, mutability: Mutability) -> Result { + if !val.comes_from_same_store(store) { + return Err(RuntimeError::new("cross-`Store` globals are not supported")); + } + let global = RuntimeGlobal::new(GlobalType { + mutability, + ty: val.ty(), + }); + unsafe { + global + .set_unchecked(val.clone()) + .map_err(|e| RuntimeError::new(format!("create global for {:?}: {}", val, e)))?; + }; + + Ok(Self { + store: store.clone(), + vm_global: VMGlobal { + from: Arc::new(global), + instance_ref: None, + }, + }) + } + + /// Returns the [`GlobalType`] of the `Global`. + /// + /// # Example + /// + /// ``` + /// # use wasmer::{Global, Mutability, Store, Type, Value, GlobalType}; + /// # let store = Store::default(); + /// # + /// let c = Global::new(&store, Value::I32(1)); + /// let v = Global::new_mut(&store, Value::I64(1)); + /// + /// assert_eq!(c.ty(), &GlobalType::new(Type::I32, Mutability::Const)); + /// assert_eq!(v.ty(), &GlobalType::new(Type::I64, Mutability::Var)); + /// ``` + pub fn ty(&self) -> &GlobalType { + self.vm_global.from.ty() + } + + /// Returns the [`Store`] where the `Global` belongs. + /// + /// # Example + /// + /// ``` + /// # use wasmer::{Global, Store, Value}; + /// # let store = Store::default(); + /// # + /// let g = Global::new(&store, Value::I32(1)); + /// + /// assert_eq!(g.store(), &store); + /// ``` + pub fn store(&self) -> &Store { + &self.store + } + + /// Retrieves the current value [`Val`] that the Global has. + /// + /// # Example + /// + /// ``` + /// # use wasmer::{Global, Store, Value}; + /// # let store = Store::default(); + /// # + /// let g = Global::new(&store, Value::I32(1)); + /// + /// assert_eq!(g.get(), Value::I32(1)); + /// ``` + pub fn get(&self) -> Val { + self.vm_global.from.get(&self.store) + } + + /// Sets a custom value [`Val`] to the runtime Global. + /// + /// # Example + /// + /// ``` + /// # use wasmer::{Global, Store, Value}; + /// # let store = Store::default(); + /// # + /// let g = Global::new_mut(&store, Value::I32(1)); + /// + /// assert_eq!(g.get(), Value::I32(1)); + /// + /// g.set(Value::I32(2)); + /// + /// assert_eq!(g.get(), Value::I32(2)); + /// ``` + /// + /// # Errors + /// + /// Trying to mutate a immutable global will raise an error: + /// + /// ```should_panic + /// # use wasmer::{Global, Store, Value}; + /// # let store = Store::default(); + /// # + /// let g = Global::new(&store, Value::I32(1)); + /// + /// g.set(Value::I32(2)).unwrap(); + /// ``` + /// + /// Trying to set a value of a incompatible type will raise an error: + /// + /// ```should_panic + /// # use wasmer::{Global, Store, Value}; + /// # let store = Store::default(); + /// # + /// let g = Global::new(&store, Value::I32(1)); + /// + /// // This results in an error: `RuntimeError`. + /// g.set(Value::I64(2)).unwrap(); + /// ``` + pub fn set(&self, val: Val) -> Result<(), RuntimeError> { + if !val.comes_from_same_store(&self.store) { + return Err(RuntimeError::new("cross-`Store` values are not supported")); + } + unsafe { + self.vm_global + .from + .set(val) + .map_err(|e| RuntimeError::new(format!("{}", e)))?; + } + Ok(()) + } + + pub(crate) fn from_vm_export(store: &Store, vm_global: VMGlobal) -> Self { + Self { + store: store.clone(), + vm_global, + } + } +} + +impl Clone for Global { + fn clone(&self) -> Self { + let mut vm_global = self.vm_global.clone(); + vm_global.upgrade_instance_ref().unwrap(); + + Self { + store: self.store.clone(), + vm_global, + } + } +} + +impl fmt::Debug for Global { + fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { + formatter + .debug_struct("Global") + .field("ty", &self.ty()) + .field("value", &self.get()) + .finish() + } +} + +impl<'a> Exportable<'a> for Global { + fn to_export(&self) -> Export { + self.vm_global.clone().into() + } +} diff --git a/runtime/near-vm/lib/api/src/sys/externals/memory.rs b/runtime/near-vm/lib/api/src/sys/externals/memory.rs new file mode 100644 index 00000000000..d84884bd6bc --- /dev/null +++ b/runtime/near-vm/lib/api/src/sys/externals/memory.rs @@ -0,0 +1,232 @@ +use crate::sys::exports::Exportable; +use crate::sys::store::Store; +use crate::sys::{MemoryType, MemoryView}; +use std::convert::TryInto; +use std::slice; +use wasmer_types::{Pages, ValueType}; +use wasmer_vm::{Export, MemoryError, VMMemory}; + +/// A WebAssembly `memory` instance. +/// +/// A memory instance is the runtime representation of a linear memory. +/// It consists of a vector of bytes and an optional maximum size. +/// +/// The length of the vector always is a multiple of the WebAssembly +/// page size, which is defined to be the constant 65536 – abbreviated 64Ki. +/// Like in a memory type, the maximum size in a memory instance is +/// given in units of this page size. +/// +/// A memory created by the host or in WebAssembly code will be accessible and +/// mutable from both host and WebAssembly. +/// +/// Spec: +#[derive(Debug)] +pub struct Memory { + store: Store, + vm_memory: VMMemory, +} + +impl Memory { + /// Creates a new host `Memory` from the provided [`MemoryType`]. + /// + /// This function will construct the `Memory` using the store + /// [`BaseTunables`][crate::sys::BaseTunables]. + /// + /// # Example + /// + /// ``` + /// # use wasmer::{Memory, MemoryType, Pages, Store, Type, Value}; + /// # let store = Store::default(); + /// # + /// let m = Memory::new(&store, MemoryType::new(1, None, false)).unwrap(); + /// ``` + pub fn new(store: &Store, ty: MemoryType) -> Result { + let tunables = store.tunables(); + let style = tunables.memory_style(&ty); + let memory = tunables.create_host_memory(&ty, &style)?; + + Ok(Self { + store: store.clone(), + vm_memory: VMMemory { + from: memory, + // We are creating it from the host, and therefore there is no + // associated instance with this memory + instance_ref: None, + }, + }) + } + + /// Create a `Memory` from `VMMemory`. + pub fn from_vmmemory(store: &Store, vm_memory: VMMemory) -> Self { + Self { + store: store.clone(), + vm_memory, + } + } + + /// Returns the [`MemoryType`] of the `Memory`. + /// + /// # Example + /// + /// ``` + /// # use wasmer::{Memory, MemoryType, Pages, Store, Type, Value}; + /// # let store = Store::default(); + /// # + /// let mt = MemoryType::new(1, None, false); + /// let m = Memory::new(&store, mt).unwrap(); + /// + /// assert_eq!(m.ty(), mt); + /// ``` + pub fn ty(&self) -> MemoryType { + self.vm_memory.from.ty() + } + + /// Returns the [`Store`] where the `Memory` belongs. + /// + /// # Example + /// + /// ``` + /// # use wasmer::{Memory, MemoryType, Pages, Store, Type, Value}; + /// # let store = Store::default(); + /// # + /// let m = Memory::new(&store, MemoryType::new(1, None, false)).unwrap(); + /// + /// assert_eq!(m.store(), &store); + /// ``` + pub fn store(&self) -> &Store { + &self.store + } + + /// Retrieve a slice of the memory contents. + /// + /// # Safety + /// + /// Until the returned slice is dropped, it is undefined behaviour to + /// modify the memory contents in any way including by calling a wasm + /// function that writes to the memory or by resizing the memory. + pub unsafe fn data_unchecked(&self) -> &[u8] { + self.data_unchecked_mut() + } + + /// Retrieve a mutable slice of the memory contents. + /// + /// # Safety + /// + /// This method provides interior mutability without an UnsafeCell. Until + /// the returned value is dropped, it is undefined behaviour to read or + /// write to the pointed-to memory in any way except through this slice, + /// including by calling a wasm function that reads the memory contents or + /// by resizing this Memory. + #[allow(clippy::mut_from_ref)] + pub unsafe fn data_unchecked_mut(&self) -> &mut [u8] { + let definition = self.vm_memory.from.vmmemory(); + let def = definition.as_ref(); + slice::from_raw_parts_mut(def.base, def.current_length.try_into().unwrap()) + } + + /// Returns the pointer to the raw bytes of the `Memory`. + pub fn data_ptr(&self) -> *mut u8 { + let definition = self.vm_memory.from.vmmemory(); + let def = unsafe { definition.as_ref() }; + def.base + } + + /// Returns the size (in bytes) of the `Memory`. + pub fn data_size(&self) -> u64 { + let definition = self.vm_memory.from.vmmemory(); + let def = unsafe { definition.as_ref() }; + def.current_length.try_into().unwrap() + } + + /// Returns the size (in [`Pages`]) of the `Memory`. + /// + /// # Example + /// + /// ``` + /// # use wasmer::{Memory, MemoryType, Pages, Store, Type, Value}; + /// # let store = Store::default(); + /// # + /// let m = Memory::new(&store, MemoryType::new(1, None, false)).unwrap(); + /// + /// assert_eq!(m.size(), Pages(1)); + /// ``` + pub fn size(&self) -> Pages { + self.vm_memory.from.size() + } + + /// Return a "view" of the currently accessible memory. By + /// default, the view is unsynchronized, using regular memory + /// accesses. You can force a memory view to use atomic accesses + /// by calling the [`MemoryView::atomically`] method. + /// + /// # Notes: + /// + /// This method is safe (as in, it won't cause the host to crash or have UB), + /// but it doesn't obey rust's rules involving data races, especially concurrent ones. + /// Therefore, if this memory is shared between multiple threads, a single memory + /// location can be mutated concurrently without synchronization. + /// + /// # Usage: + /// + /// ``` + /// # use wasmer::{Memory, MemoryView}; + /// # use std::{cell::Cell, sync::atomic::Ordering}; + /// # fn view_memory(memory: Memory) { + /// // Without synchronization. + /// let view: MemoryView = memory.view(); + /// for byte in view[0x1000 .. 0x1010].iter().map(Cell::get) { + /// println!("byte: {}", byte); + /// } + /// + /// // With synchronization. + /// let atomic_view = view.atomically(); + /// for byte in atomic_view[0x1000 .. 0x1010].iter().map(|atom| atom.load(Ordering::SeqCst)) { + /// println!("byte: {}", byte); + /// } + /// # } + /// ``` + pub fn view(&self) -> MemoryView { + let base = self.data_ptr(); + + let length = self.size().bytes().0 / std::mem::size_of::(); + + unsafe { MemoryView::new(base as _, length as u32) } + } + + pub(crate) fn from_vm_export(store: &Store, vm_memory: VMMemory) -> Self { + Self { + store: store.clone(), + vm_memory, + } + } + + /// Get access to the backing VM value for this extern. This function is for + /// tests it should not be called by users of the Wasmer API. + /// + /// # Safety + /// This function is unsafe to call outside of tests for the wasmer crate + /// because there is no stability guarantee for the returned type and we may + /// make breaking changes to it at any time or remove this method. + #[doc(hidden)] + pub unsafe fn get_vm_memory(&self) -> &VMMemory { + &self.vm_memory + } +} + +impl Clone for Memory { + fn clone(&self) -> Self { + let mut vm_memory = self.vm_memory.clone(); + vm_memory.upgrade_instance_ref().unwrap(); + + Self { + store: self.store.clone(), + vm_memory, + } + } +} + +impl<'a> Exportable<'a> for Memory { + fn to_export(&self) -> Export { + self.vm_memory.clone().into() + } +} diff --git a/runtime/near-vm/lib/api/src/sys/externals/mod.rs b/runtime/near-vm/lib/api/src/sys/externals/mod.rs new file mode 100644 index 00000000000..2459a537586 --- /dev/null +++ b/runtime/near-vm/lib/api/src/sys/externals/mod.rs @@ -0,0 +1,107 @@ +pub(crate) mod function; +mod global; +mod memory; +mod table; + +pub use self::function::{ + FromToNativeWasmType, Function, HostFunction, WasmTypeList, WithEnv, WithoutEnv, +}; + +pub use self::global::Global; +pub use self::memory::Memory; +pub use self::table::Table; + +use crate::sys::exports::Exportable; +use crate::sys::store::{Store, StoreObject}; +use std::fmt; +use wasmer_vm::Export; + +/// An `Extern` is the runtime representation of an entity that +/// can be imported or exported. +/// +/// Spec: +#[derive(Clone)] +pub enum Extern { + /// A external [`Function`]. + Function(Function), + /// A external [`Global`]. + Global(Global), + /// A external [`Table`]. + Table(Table), + /// A external [`Memory`]. + Memory(Memory), +} + +impl Extern { + /// Create an `Extern` from an `wasmer_engine::Export`. + pub fn from_vm_export(store: &Store, export: Export) -> Self { + match export { + Export::Function(f) => Self::Function(Function::from_vm_export(store, f)), + Export::Memory(m) => Self::Memory(Memory::from_vm_export(store, m)), + Export::Global(g) => Self::Global(Global::from_vm_export(store, g)), + Export::Table(t) => Self::Table(Table::from_vm_export(store, t)), + } + } +} + +impl<'a> Exportable<'a> for Extern { + fn to_export(&self) -> Export { + match self { + Self::Function(f) => f.to_export(), + Self::Global(g) => g.to_export(), + Self::Memory(m) => m.to_export(), + Self::Table(t) => t.to_export(), + } + } +} + +impl StoreObject for Extern { + fn comes_from_same_store(&self, store: &Store) -> bool { + let my_store = match self { + Self::Function(f) => f.store(), + Self::Global(g) => g.store(), + Self::Memory(m) => m.store(), + Self::Table(t) => t.store(), + }; + Store::same(my_store, store) + } +} + +impl fmt::Debug for Extern { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + write!( + f, + "{}", + match self { + Self::Function(_) => "Function(...)", + Self::Global(_) => "Global(...)", + Self::Memory(_) => "Memory(...)", + Self::Table(_) => "Table(...)", + } + ) + } +} + +impl From for Extern { + fn from(r: Function) -> Self { + Self::Function(r) + } +} + +impl From for Extern { + fn from(r: Global) -> Self { + Self::Global(r) + } +} + +impl From for Extern { + fn from(r: Memory) -> Self { + Self::Memory(r) + } +} + +impl From for Extern { + fn from(r: Table) -> Self { + Self::Table(r) + } +} diff --git a/runtime/near-vm/lib/api/src/sys/externals/table.rs b/runtime/near-vm/lib/api/src/sys/externals/table.rs new file mode 100644 index 00000000000..e2afc88a9dc --- /dev/null +++ b/runtime/near-vm/lib/api/src/sys/externals/table.rs @@ -0,0 +1,116 @@ +use crate::sys::exports::Exportable; +use crate::sys::store::Store; +use crate::sys::types::{Val, ValFuncRef}; +use crate::sys::RuntimeError; +use crate::sys::TableType; +use std::sync::Arc; +use wasmer_vm::{Export, Table as RuntimeTable, TableElement, VMTable}; + +/// A WebAssembly `table` instance. +/// +/// The `Table` struct is an array-like structure representing a WebAssembly Table, +/// which stores function references. +/// +/// A table created by the host or in WebAssembly code will be accessible and +/// mutable from both host and WebAssembly. +/// +/// Spec: +pub struct Table { + store: Store, + vm_table: VMTable, +} + +fn set_table_item( + table: &dyn RuntimeTable, + item_index: u32, + item: TableElement, +) -> Result<(), RuntimeError> { + table.set(item_index, item).map_err(|e| e.into()) +} + +impl Table { + /// Creates a new `Table` with the provided [`TableType`] definition. + /// + /// All the elements in the table will be set to the `init` value. + /// + /// This function will construct the `Table` using the store + /// [`BaseTunables`][crate::sys::BaseTunables]. + pub fn new(store: &Store, ty: TableType, init: Val) -> Result { + let item = init.into_table_reference(store)?; + let tunables = store.tunables(); + let style = tunables.table_style(&ty); + let table = tunables + .create_host_table(&ty, &style) + .map_err(RuntimeError::new)?; + + let num_elements = table.size(); + for i in 0..num_elements { + set_table_item(table.as_ref(), i, item.clone())?; + } + + Ok(Self { + store: store.clone(), + vm_table: VMTable { + from: table, + instance_ref: None, + }, + }) + } + + /// Returns the [`TableType`] of the `Table`. + pub fn ty(&self) -> &TableType { + self.vm_table.from.ty() + } + + /// Returns the [`Store`] where the `Table` belongs. + pub fn store(&self) -> &Store { + &self.store + } + + /// Retrieves the size of the `Table` (in elements) + pub fn size(&self) -> u32 { + self.vm_table.from.size() + } + + pub(crate) fn from_vm_export(store: &Store, vm_table: VMTable) -> Self { + Self { + store: store.clone(), + vm_table, + } + } + + /// Returns whether or not these two tables refer to the same data. + pub fn same(&self, other: &Self) -> bool { + Arc::ptr_eq(&self.vm_table.from, &other.vm_table.from) + } + + /// Get access to the backing VM value for this extern. This function is for + /// tests it should not be called by users of the Wasmer API. + /// + /// # Safety + /// This function is unsafe to call outside of tests for the wasmer crate + /// because there is no stability guarantee for the returned type and we may + /// make breaking changes to it at any time or remove this method. + #[doc(hidden)] + pub unsafe fn get_vm_table(&self) -> &VMTable { + &self.vm_table + } +} + +impl Clone for Table { + fn clone(&self) -> Self { + let mut vm_table = self.vm_table.clone(); + vm_table.upgrade_instance_ref().unwrap(); + + Self { + store: self.store.clone(), + vm_table, + } + } +} + +impl<'a> Exportable<'a> for Table { + fn to_export(&self) -> Export { + self.vm_table.clone().into() + } +} diff --git a/runtime/near-vm/lib/api/src/sys/import_object.rs b/runtime/near-vm/lib/api/src/sys/import_object.rs new file mode 100644 index 00000000000..3b7067e5db5 --- /dev/null +++ b/runtime/near-vm/lib/api/src/sys/import_object.rs @@ -0,0 +1,410 @@ +//! The import module contains the implementation data structures and helper functions used to +//! manipulate and access a wasm module's imports including memories, tables, globals, and +//! functions. +use std::borrow::{Borrow, BorrowMut}; +use std::collections::VecDeque; +use std::collections::{hash_map::Entry, HashMap}; +use std::fmt; +use std::sync::{Arc, Mutex}; +use wasmer_vm::{Export, NamedResolver}; + +/// The `LikeNamespace` trait represents objects that act as a namespace for imports. +/// For example, an `Instance` or `Namespace` could be +/// considered namespaces that could provide imports to an instance. +pub trait LikeNamespace { + /// Gets an export by name. + fn get_namespace_export(&self, name: &str) -> Option; + /// Gets all exports in the namespace. + fn get_namespace_exports(&self) -> Vec<(String, Export)>; +} + +/// All of the import data used when instantiating. +/// +/// It's suggested that you use the [`imports!`] macro +/// instead of creating an `ImportObject` by hand. +/// +/// [`imports!`]: macro.imports.html +/// +/// # Usage: +/// ```ignore +/// use wasmer::{Exports, ImportObject, Function}; +/// +/// let mut import_object = ImportObject::new(); +/// let mut env = Exports::new(); +/// +/// env.insert("foo", Function::new_native(foo)); +/// import_object.register("env", env); +/// +/// fn foo(n: i32) -> i32 { +/// n +/// } +/// ``` +#[derive(Clone, Default)] +pub struct ImportObject { + map: Arc>>>, +} + +impl ImportObject { + /// Create a new `ImportObject`. + pub fn new() -> Self { + Default::default() + } + + /// Gets an export given a module and a name + /// + /// # Usage + /// ```ignore + /// # use wasmer_vm::{ImportObject, Instance, Namespace}; + /// let mut import_object = ImportObject::new(); + /// import_object.get_export("module", "name"); + /// ``` + pub fn get_export(&self, module: &str, name: &str) -> Option { + let guard = self.map.lock().unwrap(); + let map_ref = guard.borrow(); + if map_ref.contains_key(module) { + let namespace = map_ref[module].as_ref(); + return namespace.get_namespace_export(name); + } + None + } + + /// Returns true if the ImportObject contains namespace with the provided name. + pub fn contains_namespace(&self, name: &str) -> bool { + self.map.lock().unwrap().borrow().contains_key(name) + } + + /// Register anything that implements `LikeNamespace` as a namespace. + /// + /// # Usage: + /// ```ignore + /// # use wasmer_vm::{ImportObject, Instance, Namespace}; + /// let mut import_object = ImportObject::new(); + /// + /// import_object.register("namespace0", instance); + /// import_object.register("namespace1", namespace); + /// // ... + /// ``` + pub fn register(&mut self, name: S, namespace: N) -> Option> + where + S: Into, + N: LikeNamespace + Send + Sync + 'static, + { + let mut guard = self.map.lock().unwrap(); + let map = guard.borrow_mut(); + + match map.entry(name.into()) { + Entry::Vacant(empty) => { + empty.insert(Box::new(namespace)); + None + } + Entry::Occupied(mut occupied) => Some(occupied.insert(Box::new(namespace))), + } + } + + fn get_objects(&self) -> VecDeque<((String, String), Export)> { + let mut out = VecDeque::new(); + let guard = self.map.lock().unwrap(); + let map = guard.borrow(); + for (name, ns) in map.iter() { + for (id, exp) in ns.get_namespace_exports() { + out.push_back(((name.clone(), id), exp)); + } + } + out + } +} + +impl NamedResolver for ImportObject { + fn resolve_by_name(&self, module: &str, name: &str) -> Option { + self.get_export(module, name) + } +} + +/// Iterator for an `ImportObject`'s exports. +pub struct ImportObjectIterator { + elements: VecDeque<((String, String), Export)>, +} + +impl Iterator for ImportObjectIterator { + type Item = ((String, String), Export); + fn next(&mut self) -> Option { + self.elements.pop_front() + } +} + +impl IntoIterator for ImportObject { + type IntoIter = ImportObjectIterator; + type Item = ((String, String), Export); + + fn into_iter(self) -> Self::IntoIter { + ImportObjectIterator { + elements: self.get_objects(), + } + } +} + +impl fmt::Debug for ImportObject { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + enum SecretMap { + Empty, + Some(usize), + } + + impl SecretMap { + fn new(len: usize) -> Self { + if len == 0 { + Self::Empty + } else { + Self::Some(len) + } + } + } + + impl fmt::Debug for SecretMap { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + match self { + Self::Empty => write!(f, "(empty)"), + Self::Some(len) => write!(f, "(... {} item(s) ...)", len), + } + } + } + + f.debug_struct("ImportObject") + .field( + "map", + &SecretMap::new(self.map.lock().unwrap().borrow().len()), + ) + .finish() + } +} + +// The import! macro for ImportObject + +/// Generate an [`ImportObject`] easily with the `imports!` macro. +/// +/// [`ImportObject`]: struct.ImportObject.html +/// +/// # Usage +/// +/// ``` +/// # use wasmer::{Function, Store}; +/// # let store = Store::default(); +/// use wasmer::imports; +/// +/// let import_object = imports! { +/// "env" => { +/// "foo" => Function::new_native(&store, foo) +/// }, +/// }; +/// +/// fn foo(n: i32) -> i32 { +/// n +/// } +/// ``` +#[macro_export] +macro_rules! imports { + ( $( $ns_name:expr => $ns:tt ),* $(,)? ) => { + { + let mut import_object = $crate::ImportObject::new(); + + $({ + let namespace = $crate::import_namespace!($ns); + + import_object.register($ns_name, namespace); + })* + + import_object + } + }; +} + +#[macro_export] +#[doc(hidden)] +macro_rules! namespace { + ($( $import_name:expr => $import_item:expr ),* $(,)? ) => { + $crate::import_namespace!( { $( $import_name => $import_item, )* } ) + }; +} + +#[macro_export] +#[doc(hidden)] +macro_rules! import_namespace { + ( { $( $import_name:expr => $import_item:expr ),* $(,)? } ) => {{ + let mut namespace = $crate::Exports::new(); + + $( + namespace.insert($import_name, $import_item); + )* + + namespace + }}; + + ( $namespace:ident ) => { + $namespace + }; +} + +#[cfg(test)] +mod test { + use super::*; + use crate::sys::{Global, Store, Val}; + use wasmer_types::Type; + use wasmer_vm::ChainableNamedResolver; + + #[test] + fn chaining_works() { + let store = Store::default(); + let g = Global::new(&store, Val::I32(0)); + + let imports1 = imports! { + "dog" => { + "happy" => g.clone() + } + }; + + let imports2 = imports! { + "dog" => { + "small" => g.clone() + }, + "cat" => { + "small" => g.clone() + } + }; + + let resolver = imports1.chain_front(imports2); + + let small_cat_export = resolver.resolve_by_name("cat", "small"); + assert!(small_cat_export.is_some()); + + let happy = resolver.resolve_by_name("dog", "happy"); + let small = resolver.resolve_by_name("dog", "small"); + assert!(happy.is_some()); + assert!(small.is_some()); + } + + #[test] + fn extending_conflict_overwrites() { + let store = Store::default(); + let g1 = Global::new(&store, Val::I32(0)); + let g2 = Global::new(&store, Val::I64(0)); + + let imports1 = imports! { + "dog" => { + "happy" => g1, + }, + }; + + let imports2 = imports! { + "dog" => { + "happy" => g2, + }, + }; + + let resolver = imports1.chain_front(imports2); + let happy_dog_entry = resolver.resolve_by_name("dog", "happy").unwrap(); + + assert!(if let Export::Global(happy_dog_global) = happy_dog_entry { + happy_dog_global.from.ty().ty == Type::I64 + } else { + false + }); + + // now test it in reverse + let store = Store::default(); + let g1 = Global::new(&store, Val::I32(0)); + let g2 = Global::new(&store, Val::I64(0)); + + let imports1 = imports! { + "dog" => { + "happy" => g1, + }, + }; + + let imports2 = imports! { + "dog" => { + "happy" => g2, + }, + }; + + let resolver = imports1.chain_back(imports2); + let happy_dog_entry = resolver.resolve_by_name("dog", "happy").unwrap(); + + assert!(if let Export::Global(happy_dog_global) = happy_dog_entry { + happy_dog_global.from.ty().ty == Type::I32 + } else { + false + }); + } + + #[test] + fn namespace() { + let store = Store::default(); + let g1 = Global::new(&store, Val::I32(0)); + let namespace = namespace! { + "happy" => g1 + }; + let imports1 = imports! { + "dog" => namespace + }; + + let happy_dog_entry = imports1.resolve_by_name("dog", "happy").unwrap(); + + assert!(if let Export::Global(happy_dog_global) = happy_dog_entry { + happy_dog_global.from.ty().ty == Type::I32 + } else { + false + }); + } + + #[test] + fn imports_macro_allows_trailing_comma_and_none() { + use crate::sys::Function; + + let store = Default::default(); + + fn func(arg: i32) -> i32 { + arg + 1 + } + + let _ = imports! { + "env" => { + "func" => Function::new_native(&store, func), + }, + }; + let _ = imports! { + "env" => { + "func" => Function::new_native(&store, func), + } + }; + let _ = imports! { + "env" => { + "func" => Function::new_native(&store, func), + }, + "abc" => { + "def" => Function::new_native(&store, func), + } + }; + let _ = imports! { + "env" => { + "func" => Function::new_native(&store, func) + }, + }; + let _ = imports! { + "env" => { + "func" => Function::new_native(&store, func) + } + }; + let _ = imports! { + "env" => { + "func1" => Function::new_native(&store, func), + "func2" => Function::new_native(&store, func) + } + }; + let _ = imports! { + "env" => { + "func1" => Function::new_native(&store, func), + "func2" => Function::new_native(&store, func), + } + }; + } +} diff --git a/runtime/near-vm/lib/api/src/sys/instance.rs b/runtime/near-vm/lib/api/src/sys/instance.rs new file mode 100644 index 00000000000..68cd84444ef --- /dev/null +++ b/runtime/near-vm/lib/api/src/sys/instance.rs @@ -0,0 +1,190 @@ +use crate::sys::module::Module; +use crate::sys::{HostEnvInitError, LinkError, RuntimeError}; +use crate::{ExportError, NativeFunc, WasmTypeList}; +use std::sync::{Arc, Mutex}; +use thiserror::Error; +use wasmer_types::InstanceConfig; +use wasmer_vm::{InstanceHandle, Resolver}; + +/// A WebAssembly Instance is a stateful, executable +/// instance of a WebAssembly [`Module`]. +/// +/// Instance objects contain all the exported WebAssembly +/// functions, memories, tables and globals that allow +/// interacting with WebAssembly. +/// +/// Spec: +#[derive(Clone)] +pub struct Instance { + handle: Arc>, + module: Module, +} + +#[cfg(test)] +mod send_test { + use super::*; + + fn is_send() -> bool { + true + } + + #[test] + fn instance_is_send() { + assert!(is_send::()); + } +} + +/// An error while instantiating a module. +/// +/// This is not a common WebAssembly error, however +/// we need to differentiate from a `LinkError` (an error +/// that happens while linking, on instantiation), a +/// Trap that occurs when calling the WebAssembly module +/// start function, and an error when initializing the user's +/// host environments. +#[derive(Error, Debug)] +pub enum InstantiationError { + /// A linking ocurred during instantiation. + #[error(transparent)] + Link(LinkError), + + /// A runtime error occured while invoking the start function + #[error("could not invoke the start function: {0}")] + Start(RuntimeError), + + /// The module was compiled with a CPU feature that is not available on + /// the current host. + #[error("missing requires CPU features: {0:?}")] + CpuFeature(String), + + /// Error occurred when initializing the host environment. + #[error(transparent)] + HostEnvInitialization(HostEnvInitError), +} + +impl From for InstantiationError { + fn from(other: wasmer_engine::InstantiationError) -> Self { + match other { + wasmer_engine::InstantiationError::Link(e) => Self::Link(e), + wasmer_engine::InstantiationError::Start(e) => Self::Start(e), + wasmer_engine::InstantiationError::CpuFeature(e) => Self::CpuFeature(e), + } + } +} + +impl From for InstantiationError { + fn from(other: HostEnvInitError) -> Self { + Self::HostEnvInitialization(other) + } +} + +impl Instance { + /// Creates a new `Instance` from a WebAssembly [`Module`] and a + /// set of imports resolved by the [`Resolver`]. + /// + /// The resolver can be anything that implements the [`Resolver`] trait, + /// so you can plug custom resolution for the imports, if you wish not + /// to use [`ImportObject`]. + /// + /// The [`ImportObject`] is the easiest way to provide imports to the instance. + /// + /// [`ImportObject`]: crate::ImportObject + /// + /// ``` + /// # use wasmer::{imports, Store, Module, Global, Value, Instance}; + /// # fn main() -> anyhow::Result<()> { + /// let store = Store::default(); + /// let module = Module::new(&store, "(module)")?; + /// let imports = imports!{ + /// "host" => { + /// "var" => Global::new(&store, Value::I32(2)) + /// } + /// }; + /// let instance = Instance::new(&module, &imports)?; + /// # Ok(()) + /// # } + /// ``` + /// + /// ## Errors + /// + /// The function can return [`InstantiationError`]s. + /// + /// Those are, as defined by the spec: + /// * Link errors that happen when plugging the imports into the instance + /// * Runtime errors that happen when running the module `start` function. + pub fn new(module: &Module, resolver: &dyn Resolver) -> Result { + Instance::new_with_config(module, InstanceConfig::default(), resolver) + } + + /// New instance with config. + #[tracing::instrument(skip_all)] + pub fn new_with_config( + module: &Module, + config: InstanceConfig, + resolver: &dyn Resolver, + ) -> Result { + let handle = module.instantiate(resolver, config)?; + let instance = Self { + handle: Arc::new(Mutex::new(handle)), + module: module.clone(), + }; + + // # Safety + // `initialize_host_envs` should be called after instantiation but before + // returning an `Instance` to the user. We set up the host environments + // via `WasmerEnv::init_with_instance`. + // + // This usage is correct because we pass a valid pointer to `instance` and the + // correct error type returned by `WasmerEnv::init_with_instance` as a generic + // parameter. + unsafe { + wasmer_vm::initialize_host_envs::( + &*instance.handle, + &instance as *const _ as *const _, + )?; + } + + Ok(instance) + } + + /// Lookup an exported entity by its name. + pub fn lookup(&self, field: &str) -> Option { + let vmextern = self.handle.lock().unwrap().lookup(field)?; + Some(vmextern.into()) + } + + /// Lookup an exported function by its name. + pub fn lookup_function(&self, field: &str) -> Option { + if let crate::Export::Function(f) = self.lookup(field)? { + Some(crate::Function::from_vm_export(self.module.store(), f)) + } else { + None + } + } + + /// Get an export as a `NativeFunc`. + pub fn get_native_function( + &self, + name: &str, + ) -> Result, ExportError> + where + Args: WasmTypeList, + Rets: WasmTypeList, + { + match self.lookup(name) { + Some(crate::Export::Function(f)) => { + crate::Function::from_vm_export(self.module.store(), f) + .native() + .map_err(|_| ExportError::IncompatibleType) + } + Some(_) => Err(ExportError::IncompatibleType), + None => Err(ExportError::Missing("not found".into())), + } + } + + // Used internally by wast only + #[doc(hidden)] + pub fn handle(&self) -> std::sync::MutexGuard<'_, InstanceHandle> { + self.handle.lock().unwrap() + } +} diff --git a/runtime/near-vm/lib/api/src/sys/mod.rs b/runtime/near-vm/lib/api/src/sys/mod.rs new file mode 100644 index 00000000000..70b92891875 --- /dev/null +++ b/runtime/near-vm/lib/api/src/sys/mod.rs @@ -0,0 +1,91 @@ +mod cell; +mod env; +mod exports; +mod externals; +mod import_object; +mod instance; +mod module; +mod native; +mod ptr; +mod store; +mod tunables; +mod types; + +#[doc(hidden)] +pub mod internals { + //! We use the internals module for exporting types that are only + //! intended to use in internal crates such as the compatibility crate + //! `wasmer-vm`. Please don't use any of this types directly, as + //! they might change frequently or be removed in the future. + + pub use crate::sys::externals::{WithEnv, WithoutEnv}; +} + +pub use crate::sys::cell::WasmCell; +pub use crate::sys::env::{HostEnvInitError, LazyInit, WasmerEnv}; +pub use crate::sys::exports::{ExportError, Exportable, Exports}; +pub use crate::sys::externals::{ + Extern, FromToNativeWasmType, Function, Global, HostFunction, Memory, Table, WasmTypeList, +}; +pub use crate::sys::import_object::{ImportObject, ImportObjectIterator, LikeNamespace}; +pub use crate::sys::instance::{Instance, InstantiationError}; +pub use crate::sys::module::Module; +pub use crate::sys::native::NativeFunc; +pub use crate::sys::ptr::{Array, Item, WasmPtr}; +pub use crate::sys::store::{Store, StoreObject}; +pub use crate::sys::tunables::BaseTunables; +pub use crate::sys::types::{ + ExportType, ExternType, FunctionType, GlobalType, MemoryType, Mutability, TableType, Val, + ValType, +}; +pub use crate::sys::types::{Val as Value, ValType as Type}; +pub use target_lexicon::{Architecture, CallingConvention, OperatingSystem, Triple, HOST}; +#[cfg(feature = "compiler")] +pub use wasmer_compiler::{wasmparser, CompilerConfig}; +pub use wasmer_compiler::{ + CompileError, CpuFeature, Features, ParseCpuFeatureError, Target, WasmError, WasmResult, +}; +pub use wasmer_engine::{DeserializeError, Engine, FrameInfo, LinkError, RuntimeError}; +pub use wasmer_types::{ + Atomically, Bytes, ExportIndex, ExternRef, GlobalInit, LocalFunctionIndex, MemoryView, Pages, + ValueType, WASM_MAX_PAGES, WASM_MIN_PAGES, WASM_PAGE_SIZE, +}; +pub use wasmer_vm::{ + ChainableNamedResolver, Export, NamedResolver, NamedResolverChain, Resolver, Tunables, +}; + +// TODO: should those be moved into wasmer::vm as well? +pub use wasmer_vm::{raise_user_trap, MemoryError}; +pub mod vm { + //! The `vm` module re-exports wasmer-vm types. + + pub use wasmer_vm::{ + Memory, MemoryError, MemoryStyle, Table, TableStyle, VMExtern, VMMemoryDefinition, + VMTableDefinition, + }; +} + +#[cfg(feature = "wat")] +pub use wat::parse_bytes as wat2wasm; + +#[cfg(feature = "singlepass")] +pub use wasmer_compiler_singlepass::Singlepass; + +#[cfg(feature = "universal")] +pub use wasmer_engine_universal::{Universal, UniversalArtifact, UniversalEngine}; + +#[cfg(feature = "dylib")] +pub use wasmer_engine_dylib::{Dylib, DylibArtifact, DylibEngine}; + +/// Version number of this crate. +pub const VERSION: &str = env!("CARGO_PKG_VERSION"); + +/// The Deprecated JIT Engine (please use `Universal` instead) +#[cfg(feature = "jit")] +#[deprecated(since = "2.0.0", note = "Please use the `universal` feature instead")] +pub type JIT = Universal; + +/// The Deprecated Native Engine (please use `Dylib` instead) +#[cfg(feature = "native")] +#[deprecated(since = "2.0.0", note = "Please use the `native` feature instead")] +pub type Native = Dylib; diff --git a/runtime/near-vm/lib/api/src/sys/module.rs b/runtime/near-vm/lib/api/src/sys/module.rs new file mode 100644 index 00000000000..07fe5565fc7 --- /dev/null +++ b/runtime/near-vm/lib/api/src/sys/module.rs @@ -0,0 +1,174 @@ +use crate::sys::store::Store; +use crate::sys::InstantiationError; +use std::fmt; +use std::io; +use std::sync::Arc; +use thiserror::Error; +use wasmer_compiler::CompileError; +#[cfg(feature = "wat")] +use wasmer_compiler::WasmError; +use wasmer_engine::RuntimeError; +use wasmer_engine_universal::UniversalArtifact; +use wasmer_types::InstanceConfig; +use wasmer_vm::{InstanceHandle, Instantiatable, Resolver}; + +#[derive(Error, Debug)] +pub enum IoCompileError { + /// An IO error + #[error(transparent)] + Io(#[from] io::Error), + /// A compilation error + #[error(transparent)] + Compile(#[from] CompileError), +} + +/// A WebAssembly Module contains stateless WebAssembly +/// code that has already been compiled and can be instantiated +/// multiple times. +/// +/// ## Cloning a module +/// +/// Cloning a module is cheap: it does a shallow copy of the compiled +/// contents rather than a deep copy. +#[derive(Clone)] +pub struct Module { + store: Store, + artifact: Arc, +} + +impl Module { + /// Creates a new WebAssembly Module given the configuration + /// in the store. + /// + /// If the provided bytes are not WebAssembly-like (start with `b"\0asm"`), + /// and the "wat" feature is enabled for this crate, this function will try to + /// to convert the bytes assuming they correspond to the WebAssembly text + /// format. + /// + /// ## Security + /// + /// Before the code is compiled, it will be validated using the store + /// features. + /// + /// ## Errors + /// + /// Creating a WebAssembly module from bytecode can result in a + /// [`CompileError`] since this operation requires to transorm the Wasm + /// bytecode into code the machine can easily execute. + /// + /// ## Example + /// + /// Reading from a WAT file. + /// + /// ``` + /// use wasmer::*; + /// # fn main() -> anyhow::Result<()> { + /// # let store = Store::default(); + /// let wat = "(module)"; + /// let module = Module::new(&store, wat)?; + /// # Ok(()) + /// # } + /// ``` + /// + /// Reading from bytes: + /// + /// ``` + /// use wasmer::*; + /// # fn main() -> anyhow::Result<()> { + /// # let store = Store::default(); + /// // The following is the same as: + /// // (module + /// // (type $t0 (func (param i32) (result i32))) + /// // (func $add_one (export "add_one") (type $t0) (param $p0 i32) (result i32) + /// // get_local $p0 + /// // i32.const 1 + /// // i32.add) + /// // ) + /// let bytes: Vec = vec![ + /// 0x00, 0x61, 0x73, 0x6d, 0x01, 0x00, 0x00, 0x00, 0x01, 0x06, 0x01, 0x60, + /// 0x01, 0x7f, 0x01, 0x7f, 0x03, 0x02, 0x01, 0x00, 0x07, 0x0b, 0x01, 0x07, + /// 0x61, 0x64, 0x64, 0x5f, 0x6f, 0x6e, 0x65, 0x00, 0x00, 0x0a, 0x09, 0x01, + /// 0x07, 0x00, 0x20, 0x00, 0x41, 0x01, 0x6a, 0x0b, 0x00, 0x1a, 0x04, 0x6e, + /// 0x61, 0x6d, 0x65, 0x01, 0x0a, 0x01, 0x00, 0x07, 0x61, 0x64, 0x64, 0x5f, + /// 0x6f, 0x6e, 0x65, 0x02, 0x07, 0x01, 0x00, 0x01, 0x00, 0x02, 0x70, 0x30, + /// ]; + /// let module = Module::new(&store, bytes)?; + /// # Ok(()) + /// # } + /// ``` + #[allow(unreachable_code)] + #[tracing::instrument(skip_all)] + pub fn new(store: &Store, bytes: impl AsRef<[u8]>) -> Result { + #[cfg(feature = "wat")] + let bytes = wat::parse_bytes(bytes.as_ref()).map_err(|e| { + CompileError::Wasm(WasmError::Generic(format!( + "Error when converting wat: {}", + e + ))) + })?; + + Self::from_binary(store, bytes.as_ref()) + } + + /// Creates a new WebAssembly module from a binary. + /// + /// Opposed to [`Module::new`], this function is not compatible with + /// the WebAssembly text format (if the "wat" feature is enabled for + /// this crate). + #[tracing::instrument(skip_all)] + pub(crate) fn from_binary(store: &Store, binary: &[u8]) -> Result { + store.engine().validate(binary)?; + let module = { + let executable = store.engine().compile(binary, store.tunables())?; + let artifact = store.engine().load(&*executable)?; + match artifact.downcast_arc::() { + Ok(universal) => Self { + store: store.clone(), + artifact: universal, + }, + // We're are probably given an externally defined artifact type + // which I imagine we don't care about for now since this entire crate + // is only used for tests and this crate only defines universal engine. + Err(_) => panic!("unhandled artifact type"), + } + }; + Ok(module) + } + + pub(crate) fn instantiate( + &self, + resolver: &dyn Resolver, + config: InstanceConfig, + ) -> Result { + unsafe { + let instance_handle = Arc::clone(&self.artifact).instantiate( + self.store.tunables(), + resolver, + Box::new((self.store.clone(), Arc::clone(&self.artifact))), + config, + )?; + + // After the instance handle is created, we need to initialize + // the data, call the start function and so. However, if any + // of this steps traps, we still need to keep the instance alive + // as some of the Instance elements may have placed in other + // instance tables. + instance_handle + .finish_instantiation() + .map_err(|t| InstantiationError::Start(RuntimeError::from_trap(t)))?; + + Ok(instance_handle) + } + } + + /// Returns the [`Store`] where the `Instance` belongs. + pub fn store(&self) -> &Store { + &self.store + } +} + +impl fmt::Debug for Module { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.debug_struct("Module").finish() + } +} diff --git a/runtime/near-vm/lib/api/src/sys/native.rs b/runtime/near-vm/lib/api/src/sys/native.rs new file mode 100644 index 00000000000..181dddf181d --- /dev/null +++ b/runtime/near-vm/lib/api/src/sys/native.rs @@ -0,0 +1,241 @@ +//! Native Functions. +//! +//! This module creates the helper `NativeFunc` that let us call WebAssembly +//! functions with the native ABI, that is: +//! +//! ```ignore +//! let add_one = instance.exports.get_function("function_name")?; +//! let add_one_native: NativeFunc = add_one.native().unwrap(); +//! ``` +use std::marker::PhantomData; + +use crate::sys::externals::function::{DynamicFunction, VMDynamicFunction}; +use crate::sys::{FromToNativeWasmType, Function, RuntimeError, Store, WasmTypeList}; +use std::panic::{catch_unwind, AssertUnwindSafe}; +use wasmer_types::NativeWasmType; +use wasmer_vm::{ + ExportFunction, VMDynamicFunctionContext, VMFunctionBody, VMFunctionEnvironment, VMFunctionKind, +}; + +/// A WebAssembly function that can be called natively +/// (using the Native ABI). +pub struct NativeFunc { + store: Store, + exported: ExportFunction, + _phantom: PhantomData<(Args, Rets)>, +} + +unsafe impl Send for NativeFunc {} + +impl NativeFunc +where + Args: WasmTypeList, + Rets: WasmTypeList, +{ + pub(crate) fn new(store: Store, exported: ExportFunction) -> Self { + Self { + store, + exported, + _phantom: PhantomData, + } + } + + pub(crate) fn is_host(&self) -> bool { + self.exported.vm_function.instance_ref.is_none() + } + + pub(crate) fn vmctx(&self) -> VMFunctionEnvironment { + self.exported.vm_function.vmctx + } + + pub(crate) fn address(&self) -> *const VMFunctionBody { + self.exported.vm_function.address + } + + pub(crate) fn arg_kind(&self) -> VMFunctionKind { + self.exported.vm_function.kind + } +} + +/* +impl From<&NativeFunc> for VMFunction +where + Args: WasmTypeList, + Rets: WasmTypeList, +{ + fn from(other: &NativeFunc) -> Self { + let signature = FunctionType::new(Args::wasm_types(), Rets::wasm_types()); + Self { + address: other.address, + vmctx: other.vmctx, + signature, + kind: other.arg_kind, + call_trampoline: None, + instance_ref: None, + } + } +}*/ + +impl Clone for NativeFunc { + fn clone(&self) -> Self { + let mut exported = self.exported.clone(); + exported.vm_function.upgrade_instance_ref().unwrap(); + + Self { + store: self.store.clone(), + exported, + _phantom: PhantomData, + } + } +} + +impl From<&NativeFunc> for ExportFunction +where + Args: WasmTypeList, + Rets: WasmTypeList, +{ + fn from(other: &NativeFunc) -> Self { + other.exported.clone() + } +} + +impl From> for Function +where + Args: WasmTypeList, + Rets: WasmTypeList, +{ + fn from(other: NativeFunc) -> Self { + Self { + store: other.store, + exported: other.exported, + } + } +} + +macro_rules! impl_native_traits { + ( $( $x:ident ),* ) => { + #[allow(unused_parens, non_snake_case)] + impl<$( $x , )* Rets> NativeFunc<( $( $x ),* ), Rets> + where + $( $x: FromToNativeWasmType, )* + Rets: WasmTypeList, + { + /// Call the typed func and return results. + pub fn call(&self, $( $x: $x, )* ) -> Result { + if !self.is_host() { + // We assume the trampoline is always going to be present for + // Wasm functions + let trampoline = self.exported.vm_function.call_trampoline.expect("Call trampoline not found in wasm function"); + // TODO: when `const fn` related features mature more, we can declare a single array + // of the correct size here. + let mut params_list = [ $( $x.to_native().to_binary() ),* ]; + let mut rets_list_array = Rets::empty_array(); + let rets_list = rets_list_array.as_mut(); + let using_rets_array; + let args_rets: &mut [i128] = if params_list.len() > rets_list.len() { + using_rets_array = false; + params_list.as_mut() + } else { + using_rets_array = true; + for (i, &arg) in params_list.iter().enumerate() { + rets_list[i] = arg; + } + rets_list.as_mut() + }; + unsafe { + wasmer_vm::wasmer_call_trampoline( + self.vmctx(), + trampoline, + self.address(), + args_rets.as_mut_ptr() as *mut u8, + ) + }?; + let num_rets = rets_list.len(); + if !using_rets_array && num_rets > 0 { + let src_pointer = params_list.as_ptr(); + let rets_list = &mut rets_list_array.as_mut()[0] as *mut i128; + unsafe { + // TODO: we can probably remove this copy by doing some clever `transmute`s. + // we know it's not overlapping because `using_rets_array` is false + std::ptr::copy_nonoverlapping(src_pointer, + rets_list, + num_rets); + } + } + Ok(Rets::from_array(rets_list_array)) + // TODO: When the Host ABI and Wasm ABI are the same, we could do this instead: + // but we can't currently detect whether that's safe. + // + // let results = unsafe { + // wasmer_vm::catch_traps_with_result(self.vmctx, || { + // let f = std::mem::transmute::<_, unsafe extern "C" fn( *mut VMContext, $( $x, )*) -> Rets::CStruct>(self.address()); + // // We always pass the vmctx + // f( self.vmctx, $( $x, )* ) + // }).map_err(RuntimeError::from_trap)? + // }; + // Ok(Rets::from_c_struct(results)) + + } + else { + match self.arg_kind() { + VMFunctionKind::Static => { + let results = catch_unwind(AssertUnwindSafe(|| unsafe { + let f = std::mem::transmute::<_, unsafe extern "C" fn( VMFunctionEnvironment, $( $x, )*) -> Rets::CStruct>(self.address()); + // We always pass the vmctx + f( self.vmctx(), $( $x, )* ) + })).map_err(|e| RuntimeError::new(format!("{:?}", e)))?; + Ok(Rets::from_c_struct(results)) + }, + VMFunctionKind::Dynamic => { + let params_list = [ $( $x.to_native().to_value() ),* ]; + let results = { + type VMContextWithEnv = VMDynamicFunctionContext>; + unsafe { + let ctx = self.vmctx().host_env as *mut VMContextWithEnv; + (*ctx).ctx.call(¶ms_list)? + } + }; + let mut rets_list_array = Rets::empty_array(); + let mut_rets = rets_list_array.as_mut() as *mut [i128] as *mut i128; + for (i, ret) in results.iter().enumerate() { + unsafe { + ret.write_value_to(mut_rets.add(i)); + } + } + Ok(Rets::from_array(rets_list_array)) + } + } + } + } + + } + }; +} + +impl_native_traits!(); +impl_native_traits!(A1); +impl_native_traits!(A1, A2); +impl_native_traits!(A1, A2, A3); +impl_native_traits!(A1, A2, A3, A4); +impl_native_traits!(A1, A2, A3, A4, A5); +impl_native_traits!(A1, A2, A3, A4, A5, A6); +impl_native_traits!(A1, A2, A3, A4, A5, A6, A7); +impl_native_traits!(A1, A2, A3, A4, A5, A6, A7, A8); +impl_native_traits!(A1, A2, A3, A4, A5, A6, A7, A8, A9); +impl_native_traits!(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10); +impl_native_traits!(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11); +impl_native_traits!(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12); +impl_native_traits!(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13); +impl_native_traits!(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14); +impl_native_traits!(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15); +impl_native_traits!(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16); +impl_native_traits!(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17); +impl_native_traits!( + A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18 +); +impl_native_traits!( + A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19 +); +impl_native_traits!( + A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20 +); diff --git a/runtime/near-vm/lib/api/src/sys/ptr.rs b/runtime/near-vm/lib/api/src/sys/ptr.rs new file mode 100644 index 00000000000..67061532447 --- /dev/null +++ b/runtime/near-vm/lib/api/src/sys/ptr.rs @@ -0,0 +1,149 @@ +//! Types for a reusable pointer abstraction for accessing Wasm linear memory. +//! +//! This abstraction is safe: it ensures the memory is in bounds and that the pointer +//! is aligned (avoiding undefined behavior). +//! +//! Therefore, you should use this abstraction whenever possible to avoid memory +//! related bugs when implementing an ABI. + +use crate::sys::cell::WasmCell; +use crate::sys::{externals::Memory, FromToNativeWasmType}; +use std::{cell::Cell, marker::PhantomData, mem}; +use wasmer_types::ValueType; + +/// The `Array` marker type. This type can be used like `WasmPtr` +/// to get access to methods +pub struct Array; +/// The `Item` marker type. This is the default and does not usually need to be +/// specified. +pub struct Item; + +/// A zero-cost type that represents a pointer to something in Wasm linear +/// memory. +#[repr(transparent)] +pub struct WasmPtr { + offset: u32, + _phantom: PhantomData<(T, Ty)>, +} + +/// Methods relevant to all types of `WasmPtr`. +impl WasmPtr { + /// Create a new `WasmPtr` at the given offset. + #[inline] + pub fn new(offset: u32) -> Self { + Self { + offset, + _phantom: PhantomData, + } + } + + /// Get the offset into Wasm linear memory for this `WasmPtr`. + #[inline] + pub fn offset(self) -> u32 { + self.offset + } +} + +#[inline(always)] +fn align_pointer(ptr: usize, align: usize) -> usize { + // clears bits below aligment amount (assumes power of 2) to align pointer + debug_assert!(align.count_ones() == 1); + ptr & !(align - 1) +} + +/// Methods for `WasmPtr`s to arrays of data that can be dereferenced, namely to +/// types that implement [`ValueType`], meaning that they're valid for all +/// possible bit patterns. +impl WasmPtr { + /// Dereference the `WasmPtr` getting access to a `&[Cell]` allowing for + /// reading and mutating of the inner values. + /// + /// This method is unsound if used with unsynchronized shared memory. + /// If you're unsure what that means, it likely does not apply to you. + /// This invariant will be enforced in the future. + #[inline] + pub fn deref<'a>( + self, + memory: &'a Memory, + index: u32, + length: u32, + ) -> Option>> { + // gets the size of the item in the array with padding added such that + // for any index, we will always result an aligned memory access + let item_size = mem::size_of::(); + let slice_full_len = index as usize + length as usize; + let memory_size = memory.size().bytes().0; + + if (self.offset as usize) + (item_size * slice_full_len) > memory_size + || (self.offset as usize) >= memory_size + || item_size == 0 + { + return None; + } + let cell_ptrs = unsafe { + let cell_ptr = align_pointer( + memory.view::().as_ptr().add(self.offset as usize) as usize, + mem::align_of::(), + ) as *const Cell; + &std::slice::from_raw_parts(cell_ptr, slice_full_len)[index as usize..slice_full_len] + }; + + let wasm_cells = cell_ptrs + .iter() + .map(|ptr| WasmCell::new(ptr)) + .collect::>(); + Some(wasm_cells) + } + + /// Get a UTF-8 `String` from the `WasmPtr` with the given length. + /// + /// an aliasing `WasmPtr` is used to mutate memory. + pub fn get_utf8_string(self, memory: &Memory, str_len: u32) -> Option { + let memory_size = memory.size().bytes().0; + if self.offset as usize + str_len as usize > memory.size().bytes().0 + || self.offset as usize >= memory_size + { + return None; + } + + // TODO: benchmark the internals of this function: there is likely room for + // micro-optimization here and this may be a fairly common function in user code. + let view = memory.view::(); + + let mut vec: Vec = Vec::with_capacity(str_len as usize); + let base = self.offset as usize; + for i in 0..(str_len as usize) { + let byte = view[base + i].get(); + vec.push(byte); + } + + String::from_utf8(vec).ok() + } +} + +unsafe impl FromToNativeWasmType for WasmPtr { + type Native = i32; + + fn to_native(self) -> Self::Native { + self.offset as i32 + } + fn from_native(n: Self::Native) -> Self { + Self { + offset: n as u32, + _phantom: PhantomData, + } + } +} + +unsafe impl ValueType for WasmPtr {} + +impl Clone for WasmPtr { + fn clone(&self) -> Self { + Self { + offset: self.offset, + _phantom: PhantomData, + } + } +} + +impl Copy for WasmPtr {} diff --git a/runtime/near-vm/lib/api/src/sys/store.rs b/runtime/near-vm/lib/api/src/sys/store.rs new file mode 100644 index 00000000000..36f175818b1 --- /dev/null +++ b/runtime/near-vm/lib/api/src/sys/store.rs @@ -0,0 +1,122 @@ +use crate::sys::tunables::BaseTunables; +use std::fmt; +use std::sync::Arc; +#[cfg(all(feature = "compiler", feature = "engine"))] +use wasmer_compiler::CompilerConfig; +use wasmer_engine::Engine; +use wasmer_vm::Tunables; + +/// The store represents all global state that can be manipulated by +/// WebAssembly programs. It consists of the runtime representation +/// of all instances of functions, tables, memories, and globals that +/// have been allocated during the lifetime of the abstract machine. +/// +/// The `Store` holds the engine (that is —amongst many things— used to compile +/// the Wasm bytes into a valid module artifact), in addition to the +/// [`Tunables`] (that are used to create the memories, tables and globals). +/// +/// Spec: +#[derive(Clone)] +pub struct Store { + engine: Arc, + tunables: Arc, +} + +impl Store { + /// Creates a new `Store` with a specific [`Engine`]. + pub fn new(engine: &E) -> Self + where + E: Engine + ?Sized, + { + Self::new_with_tunables(engine, BaseTunables::for_target(engine.target())) + } + + /// Creates a new `Store` with a specific [`Engine`] and [`Tunables`]. + pub fn new_with_tunables(engine: &E, tunables: impl Tunables + Send + Sync + 'static) -> Self + where + E: Engine + ?Sized, + { + Self { + engine: engine.cloned(), + tunables: Arc::new(tunables), + } + } + + /// Returns the [`Tunables`]. + pub fn tunables(&self) -> &dyn Tunables { + self.tunables.as_ref() + } + + /// Returns the [`Engine`]. + pub fn engine(&self) -> &Arc { + &self.engine + } + + /// Checks whether two stores are identical. A store is considered + /// equal to another store if both have the same engine. The + /// tunables are excluded from the logic. + pub fn same(a: &Self, b: &Self) -> bool { + a.engine.id() == b.engine.id() + } +} + +impl PartialEq for Store { + fn eq(&self, other: &Self) -> bool { + Self::same(self, other) + } +} + +unsafe impl Send for Store {} +unsafe impl Sync for Store {} + +// We only implement default if we have assigned a default compiler and engine +#[cfg(all(feature = "default-compiler", feature = "default-engine"))] +impl Default for Store { + fn default() -> Self { + // We store them on a function that returns to make + // sure this function doesn't emit a compile error even if + // more than one compiler is enabled. + #[allow(unreachable_code)] + fn get_config() -> impl CompilerConfig + 'static { + cfg_if::cfg_if! { + if #[cfg(feature = "default-singlepass")] { + wasmer_compiler_singlepass::Singlepass::default() + } else { + compile_error!("No default compiler chosen") + } + } + } + + #[allow(unreachable_code, unused_mut)] + fn get_engine(mut config: impl CompilerConfig + 'static) -> impl Engine + Send + Sync { + cfg_if::cfg_if! { + if #[cfg(feature = "default-universal")] { + wasmer_engine_universal::Universal::new(config) + .engine() + } else if #[cfg(feature = "default-dylib")] { + wasmer_engine_dylib::Dylib::new(config) + .engine() + } else { + compile_error!("No default engine chosen") + } + } + } + + let config = get_config(); + let engine = get_engine(config); + let tunables = BaseTunables::for_target(engine.target()); + Self::new_with_tunables(&engine, tunables) + } +} + +impl fmt::Debug for Store { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + f.debug_struct("Store").finish() + } +} + +/// A trait represinting any object that lives in the `Store`. +pub trait StoreObject { + /// Return true if the object `Store` is the same as the provided `Store`. + fn comes_from_same_store(&self, store: &Store) -> bool; +} diff --git a/runtime/near-vm/lib/api/src/sys/tunables.rs b/runtime/near-vm/lib/api/src/sys/tunables.rs new file mode 100644 index 00000000000..942e3715783 --- /dev/null +++ b/runtime/near-vm/lib/api/src/sys/tunables.rs @@ -0,0 +1,277 @@ +use crate::sys::{MemoryType, Pages, TableType}; +use std::ptr::NonNull; +use std::sync::Arc; +use target_lexicon::PointerWidth; +use wasmer_compiler::Target; +use wasmer_vm::MemoryError; +use wasmer_vm::{ + LinearMemory, LinearTable, Memory, MemoryStyle, Table, TableStyle, Tunables, + VMMemoryDefinition, VMTableDefinition, +}; + +/// Tunable parameters for WebAssembly compilation. +/// This is the reference implementation of the `Tunables` trait, +/// used by default. +/// +/// You can use this as a template for creating a custom Tunables +/// implementation or use composition to wrap your Tunables around +/// this one. The later approach is demonstrated in the +/// tunables-limit-memory example. +#[derive(Clone)] +pub struct BaseTunables { + /// For static heaps, the size in wasm pages of the heap protected by bounds checking. + pub static_memory_bound: Pages, + + /// The size in bytes of the offset guard for static heaps. + pub static_memory_offset_guard_size: u64, + + /// The size in bytes of the offset guard for dynamic heaps. + pub dynamic_memory_offset_guard_size: u64, + + /// The cost of a regular op. + pub regular_op_cost: u64, +} + +impl BaseTunables { + /// Get the `BaseTunables` for a specific Target + pub fn for_target(target: &Target) -> Self { + let triple = target.triple(); + let pointer_width: PointerWidth = triple.pointer_width().unwrap(); + let (static_memory_bound, static_memory_offset_guard_size): (Pages, u64) = + match pointer_width { + PointerWidth::U16 => (0x400.into(), 0x1000), + PointerWidth::U32 => (0x4000.into(), 0x1_0000), + // Static Memory Bound: + // Allocating 4 GiB of address space let us avoid the + // need for explicit bounds checks. + // Static Memory Guard size: + // Allocating 2 GiB of address space lets us translate wasm + // offsets into x86 offsets as aggressively as we can. + PointerWidth::U64 => (0x1_0000.into(), 0x8000_0000), + }; + + // Allocate a small guard to optimize common cases but without + // wasting too much memory. + // The Windows memory manager seems more laxed than the other ones + // And a guard of just 1 page may not be enough is some borderline cases + // So using 2 pages for guard on this platform + #[cfg(target_os = "windows")] + let dynamic_memory_offset_guard_size: u64 = 0x2_0000; + #[cfg(not(target_os = "windows"))] + let dynamic_memory_offset_guard_size: u64 = 0x1_0000; + + Self { + static_memory_bound, + static_memory_offset_guard_size, + dynamic_memory_offset_guard_size, + regular_op_cost: 0, + } + } + + /// Set the regular op cost for this compiler + pub fn set_regular_op_cost(&mut self, cost: u64) -> &mut Self { + self.regular_op_cost = cost; + self + } +} + +impl Tunables for BaseTunables { + /// Get a `MemoryStyle` for the provided `MemoryType` + fn memory_style(&self, memory: &MemoryType) -> MemoryStyle { + // A heap with a maximum that doesn't exceed the static memory bound specified by the + // tunables make it static. + // + // If the module doesn't declare an explicit maximum treat it as 4GiB. + let maximum = memory.maximum.unwrap_or_else(Pages::max_value); + if maximum <= self.static_memory_bound { + MemoryStyle::Static { + // Bound can be larger than the maximum for performance reasons + bound: self.static_memory_bound, + offset_guard_size: self.static_memory_offset_guard_size, + } + } else { + MemoryStyle::Dynamic { + offset_guard_size: self.dynamic_memory_offset_guard_size, + } + } + } + + /// Get a [`TableStyle`] for the provided [`TableType`]. + fn table_style(&self, _table: &TableType) -> TableStyle { + TableStyle::CallerChecksSignature + } + + /// Create a memory owned by the host given a [`MemoryType`] and a [`MemoryStyle`]. + fn create_host_memory( + &self, + ty: &MemoryType, + style: &MemoryStyle, + ) -> Result, MemoryError> { + Ok(Arc::new(LinearMemory::new(&ty, &style)?)) + } + + /// Create a memory owned by the VM given a [`MemoryType`] and a [`MemoryStyle`]. + /// + /// # Safety + /// - `vm_definition_location` must point to a valid, owned `VMMemoryDefinition`, + /// for example in `VMContext`. + unsafe fn create_vm_memory( + &self, + ty: &MemoryType, + style: &MemoryStyle, + vm_definition_location: NonNull, + ) -> Result, MemoryError> { + Ok(Arc::new(LinearMemory::from_definition( + &ty, + &style, + vm_definition_location, + )?)) + } + + /// Create a table owned by the host given a [`TableType`] and a [`TableStyle`]. + fn create_host_table( + &self, + ty: &TableType, + style: &TableStyle, + ) -> Result, String> { + Ok(Arc::new(LinearTable::new(&ty, &style)?)) + } + + /// Create a table owned by the VM given a [`TableType`] and a [`TableStyle`]. + /// + /// # Safety + /// - `vm_definition_location` must point to a valid, owned `VMTableDefinition`, + /// for example in `VMContext`. + unsafe fn create_vm_table( + &self, + ty: &TableType, + style: &TableStyle, + vm_definition_location: NonNull, + ) -> Result, String> { + Ok(Arc::new(LinearTable::from_definition( + &ty, + &style, + vm_definition_location, + )?)) + } + + fn stack_init_gas_cost(&self, stack_size: u64) -> u64 { + (self.regular_op_cost / 8).saturating_mul(stack_size) + } + + /// Instrumentation configuration: stack limiter config + fn stack_limiter_cfg(&self) -> Box { + Box::new(SimpleMaxStackCfg) + } + + /// Instrumentation configuration: gas accounting config + fn gas_cfg(&self) -> Box> { + Box::new(SimpleGasCostCfg(self.regular_op_cost)) + } +} + +struct SimpleMaxStackCfg; + +impl finite_wasm::max_stack::SizeConfig for SimpleMaxStackCfg { + fn size_of_value(&self, ty: finite_wasm::wasmparser::ValType) -> u8 { + use finite_wasm::wasmparser::ValType; + match ty { + ValType::I32 => 4, + ValType::I64 => 8, + ValType::F32 => 4, + ValType::F64 => 8, + ValType::V128 => 16, + ValType::FuncRef => 8, + ValType::ExternRef => 8, + } + } + fn size_of_function_activation( + &self, + locals: &prefix_sum_vec::PrefixSumVec, + ) -> u64 { + let mut res = 0; + res += locals + .max_index() + .map(|l| u64::from(*l).saturating_add(1)) + .unwrap_or(0) + * 8; + // TODO: make the above take into account the types of locals by adding an iter on PrefixSumVec that returns (count, type) + res += 32; // Rough accounting for rip, rbp and some registers spilled. Not exact. + res + } +} + +struct SimpleGasCostCfg(u64); + +macro_rules! gas_cost { + ($( @$proposal:ident $op:ident $({ $($arg:ident: $argty:ty),* })? => $visit:ident)*) => { + $( + fn $visit(&mut self $($(, $arg: $argty)*)?) -> u64 { + gas_cost!(@@$proposal $op self $({ $($arg: $argty),* })? => $visit) + } + )* + }; + + (@@mvp $_op:ident $_self:ident $({ $($_arg:ident: $_argty:ty),* })? => visit_block) => { + 0 + }; + (@@mvp $_op:ident $_self:ident $({ $($_arg:ident: $_argty:ty),* })? => visit_end) => { + 0 + }; + (@@mvp $_op:ident $_self:ident $({ $($_arg:ident: $_argty:ty),* })? => visit_else) => { + 0 + }; + (@@$_proposal:ident $_op:ident $self:ident $({ $($arg:ident: $argty:ty),* })? => $visit:ident) => { + $self.0 + }; +} + +impl<'a> finite_wasm::wasmparser::VisitOperator<'a> for SimpleGasCostCfg { + type Output = u64; + finite_wasm::wasmparser::for_each_operator!(gas_cost); +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn memory_style() { + let tunables = BaseTunables { + static_memory_bound: Pages(2048), + static_memory_offset_guard_size: 128, + dynamic_memory_offset_guard_size: 256, + regular_op_cost: 0, + }; + + // No maximum + let requested = MemoryType::new(3, None, true); + let style = tunables.memory_style(&requested); + match style { + MemoryStyle::Dynamic { offset_guard_size } => assert_eq!(offset_guard_size, 256), + s => panic!("Unexpected memory style: {:?}", s), + } + + // Large maximum + let requested = MemoryType::new(3, Some(5_000_000), true); + let style = tunables.memory_style(&requested); + match style { + MemoryStyle::Dynamic { offset_guard_size } => assert_eq!(offset_guard_size, 256), + s => panic!("Unexpected memory style: {:?}", s), + } + + // Small maximum + let requested = MemoryType::new(3, Some(16), true); + let style = tunables.memory_style(&requested); + match style { + MemoryStyle::Static { + bound, + offset_guard_size, + } => { + assert_eq!(bound, Pages(2048)); + assert_eq!(offset_guard_size, 128); + } + s => panic!("Unexpected memory style: {:?}", s), + } + } +} diff --git a/runtime/near-vm/lib/api/src/sys/types.rs b/runtime/near-vm/lib/api/src/sys/types.rs new file mode 100644 index 00000000000..bad2fd28683 --- /dev/null +++ b/runtime/near-vm/lib/api/src/sys/types.rs @@ -0,0 +1,92 @@ +use crate::sys::externals::Function; +use crate::sys::store::{Store, StoreObject}; +use crate::sys::RuntimeError; +use wasmer_types::Value; +pub use wasmer_types::{ + ExportType, ExternType, FunctionType, GlobalType, MemoryType, Mutability, TableType, + Type as ValType, +}; +use wasmer_vm::VMFuncRef; + +/// WebAssembly computations manipulate values of basic value types: +/// * Integers (32 or 64 bit width) +/// * Floating-point (32 or 64 bit width) +/// * Vectors (128 bits, with 32 or 64 bit lanes) +/// +/// Spec: +pub type Val = Value; + +impl StoreObject for Val { + fn comes_from_same_store(&self, store: &Store) -> bool { + match self { + Self::FuncRef(None) => true, + Self::FuncRef(Some(f)) => Store::same(store, f.store()), + // `ExternRef`s are not tied to specific stores + Self::ExternRef(_) => true, + Self::I32(_) | Self::I64(_) | Self::F32(_) | Self::F64(_) | Self::V128(_) => true, + } + } +} + +impl From for Val { + fn from(val: Function) -> Self { + Self::FuncRef(Some(val)) + } +} + +/// It provides useful functions for converting back and forth +/// from [`Val`] into `FuncRef`. +pub trait ValFuncRef { + fn into_vm_funcref(&self, store: &Store) -> Result; + + unsafe fn from_vm_funcref(item: VMFuncRef, store: &Store) -> Self; + + fn into_table_reference(&self, store: &Store) -> Result; + + unsafe fn from_table_reference(item: wasmer_vm::TableElement, store: &Store) -> Self; +} + +impl ValFuncRef for Val { + fn into_vm_funcref(&self, store: &Store) -> Result { + if !self.comes_from_same_store(store) { + return Err(RuntimeError::new("cross-`Store` values are not supported")); + } + Ok(match self { + Self::FuncRef(None) => VMFuncRef::null(), + Self::FuncRef(Some(f)) => f.vm_funcref(), + _ => return Err(RuntimeError::new("val is not func ref")), + }) + } + + /// # Safety + /// + /// The returned `Val` must outlive the containing instance. + unsafe fn from_vm_funcref(func_ref: VMFuncRef, store: &Store) -> Self { + Self::FuncRef(Function::from_vm_funcref(store, func_ref)) + } + + fn into_table_reference(&self, store: &Store) -> Result { + if !self.comes_from_same_store(store) { + return Err(RuntimeError::new("cross-`Store` values are not supported")); + } + Ok(match self { + // TODO(reftypes): review this clone + Self::ExternRef(extern_ref) => { + wasmer_vm::TableElement::ExternRef(extern_ref.clone().into()) + } + Self::FuncRef(None) => wasmer_vm::TableElement::FuncRef(VMFuncRef::null()), + Self::FuncRef(Some(f)) => wasmer_vm::TableElement::FuncRef(f.vm_funcref()), + _ => return Err(RuntimeError::new("val is not reference")), + }) + } + + /// # Safety + /// + /// The returned `Val` may not outlive the containing instance. + unsafe fn from_table_reference(item: wasmer_vm::TableElement, store: &Store) -> Self { + match item { + wasmer_vm::TableElement::FuncRef(f) => Self::from_vm_funcref(f, store), + wasmer_vm::TableElement::ExternRef(extern_ref) => Self::ExternRef(extern_ref.into()), + } + } +} diff --git a/runtime/near-vm/lib/compiler-singlepass/Cargo.toml b/runtime/near-vm/lib/compiler-singlepass/Cargo.toml new file mode 100644 index 00000000000..383996fd998 --- /dev/null +++ b/runtime/near-vm/lib/compiler-singlepass/Cargo.toml @@ -0,0 +1,44 @@ +[package] +name = "wasmer-compiler-singlepass-near" +version = "2.4.0" +description = "Singlepass compiler for Wasmer WebAssembly runtime" +categories = ["wasm"] +keywords = ["wasm", "webassembly", "compiler", "singlepass"] +authors = ["Wasmer Engineering Team "] +repository = "https://github.com/wasmerio/wasmer" +documentation = "https://docs.rs/wasmer-compiler-singlepass/" +license = "MIT" +readme = "README.md" +edition = "2018" + +[lib] +name = "wasmer_compiler_singlepass" + +[dependencies] +finite-wasm = "0.3.0" +wasmer-compiler = { path = "../compiler", package = "wasmer-compiler-near", version = "=2.4.0", features = ["translator"], default-features = false } +wasmer-vm = { path = "../vm", package = "wasmer-vm-near", version = "=2.4.0" } +wasmer-types = { path = "../types", package = "wasmer-types-near", version = "=2.4.0", default-features = false, features = ["std"] } +byteorder = "1.3" +dynasm = "1.0" +dynasmrt = "1.0" +enumset = "1.0" +hashbrown = { version = "0.11", optional = true } +lazy_static = "1.4" +memoffset = "0.6" +more-asserts = "0.2" +rayon = { version = "1.5", optional = true } +smallvec = "1.6" +strum = { version = "0.24", features = ["derive"] } +tracing = "0.1" + +[dev-dependencies] +target-lexicon = { version = "0.12.2", default-features = false } + +[badges] +maintenance = { status = "actively-developed" } + +[features] +default = ["std", "rayon"] +std = ["wasmer-compiler/std", "wasmer-types/std"] +core = ["hashbrown", "wasmer-types/core"] diff --git a/runtime/near-vm/lib/compiler-singlepass/README.md b/runtime/near-vm/lib/compiler-singlepass/README.md new file mode 100644 index 00000000000..0cef04e0dd4 --- /dev/null +++ b/runtime/near-vm/lib/compiler-singlepass/README.md @@ -0,0 +1,30 @@ +# `wasmer-compiler-singlepass` [![Build Status](https://github.com/wasmerio/wasmer/workflows/build/badge.svg?style=flat-square)](https://github.com/wasmerio/wasmer/actions?query=workflow%3Abuild) [![Join Wasmer Slack](https://img.shields.io/static/v1?label=Slack&message=join%20chat&color=brighgreen&style=flat-square)](https://slack.wasmer.io) [![MIT License](https://img.shields.io/github/license/wasmerio/wasmer.svg?style=flat-square)](https://github.com/wasmerio/wasmer/blob/master/LICENSE) [![crates.io](https://img.shields.io/crates/v/wasmer-compiler-singlepass.svg)](https://crates.io/crates/wasmer-compiler-singlepass) + +This crate contains a compiler implementation based on the Singlepass linear compiler. + +## Usage + +```rust +use wasmer::{Store, Universal}; +use wasmer_compiler_singlepass::Singlepass; + +let compiler = Singlepass::new(); +// Put it into an engine and add it to the store +let store = Store::new(&Universal::new(compiler).engine()); +``` + +*Note: you can find a [full working example using Singlepass compiler +here][example].* + +## When to use Singlepass + +Singlepass is designed to emit compiled code at linear time, as such +is not prone to JIT bombs and also offers great compilation +performance, however with a bit slower runtime speed. + +The fact that singlepass is not prone to JIT bombs and offers a very +predictable compilation speed makes it ideal for **blockchains** and other +systems where fast and consistent compilation times are very critical. + + +[example]: https://github.com/wasmerio/wasmer/blob/master/examples/compiler_singlepass.rs diff --git a/runtime/near-vm/lib/compiler-singlepass/src/address_map.rs b/runtime/near-vm/lib/compiler-singlepass/src/address_map.rs new file mode 100644 index 00000000000..abe18209f93 --- /dev/null +++ b/runtime/near-vm/lib/compiler-singlepass/src/address_map.rs @@ -0,0 +1,20 @@ +use wasmer_compiler::{FunctionAddressMap, FunctionBodyData, InstructionAddressMap, SourceLoc}; + +pub fn get_function_address_map<'data>( + instructions: Vec, + data: &FunctionBodyData<'data>, + body_len: usize, +) -> FunctionAddressMap { + // Generate source loc for a function start/end to identify boundary within module. + // It will wrap around if byte code is larger than 4 GB. + let start_srcloc = SourceLoc::new(data.module_offset as u32); + let end_srcloc = SourceLoc::new((data.module_offset + data.data.len()) as u32); + + FunctionAddressMap { + instructions, + start_srcloc, + end_srcloc, + body_offset: 0, + body_len, + } +} diff --git a/runtime/near-vm/lib/compiler-singlepass/src/codegen_x64.rs b/runtime/near-vm/lib/compiler-singlepass/src/codegen_x64.rs new file mode 100644 index 00000000000..c115f069b9b --- /dev/null +++ b/runtime/near-vm/lib/compiler-singlepass/src/codegen_x64.rs @@ -0,0 +1,8960 @@ +use crate::address_map::get_function_address_map; +use crate::config::IntrinsicKind; +use crate::{config::Singlepass, emitter_x64::*, machine::Machine, x64_decl::*}; +use dynasmrt::{x64::X64Relocation, DynamicLabel, VecAssembler}; +use finite_wasm::gas::InstrumentationKind; +use memoffset::offset_of; +use smallvec::{smallvec, SmallVec}; +use std::convert::TryFrom; +use std::iter; +use std::slice; +use wasmer_compiler::wasmparser::{BlockType as WpBlockType, MemArg, Operator, ValType as WpType}; +use wasmer_compiler::{ + CallingConvention, CompiledFunction, CompiledFunctionFrameInfo, CustomSection, + CustomSectionProtection, FunctionBody, FunctionBodyData, InstructionAddressMap, + ModuleTranslationState, Relocation, RelocationKind, RelocationTarget, SectionBody, + SectionIndex, SourceLoc, Target, +}; +use wasmer_types::{ + entity::{EntityRef, PrimaryMap, SecondaryMap}, + FastGasCounter, FunctionType, +}; +use wasmer_types::{ + FunctionIndex, GlobalIndex, LocalFunctionIndex, LocalMemoryIndex, MemoryIndex, ModuleInfo, + SignatureIndex, TableIndex, Type, +}; +use wasmer_vm::{TableStyle, TrapCode, VMBuiltinFunctionIndex, VMOffsets}; + +type Assembler = VecAssembler; + +/// The singlepass per-function code generator. +pub(crate) struct FuncGen<'a> { + // Immutable properties assigned at creation time. + /// Static module information. + module: &'a ModuleInfo, + + /// State of module translation. + module_translation_state: &'a ModuleTranslationState, + + /// ModuleInfo compilation config. + config: &'a Singlepass, + + /// Target to which we compile + target: &'a Target, + + /// Offsets of vmctx fields. + vmoffsets: &'a VMOffsets, + + // // Memory plans. + // memory_styles: &'a PrimaryMap, + + // // Table plans. + // table_styles: &'a PrimaryMap, + /// Function signature. + signature: FunctionType, + + // Working storage. + /// The assembler. + /// + /// This should be changed to `Vec` for platform independency, but dynasm doesn't (yet) + /// support automatic relative relocations for `Vec`. + assembler: Assembler, + + /// Types of the local variables, including arguments. + local_types: wasmer_types::partial_sum_map::PartialSumMap, + + /// Value stack. + value_stack: Vec, + + /// Metadata about floating point values on the stack. + fp_stack: Vec, + + /// A list of frames describing the current control stack. + control_stack: Vec, + + /// Low-level machine state. + machine: Machine, + + /// Nesting level of unreachable code. + unreachable_depth: usize, + + /// Relocation information. + relocations: Vec, + + /// A set of special labels for trapping. + special_labels: SpecialLabelSet, + + /// The source location for the current operator. + src_loc: u32, + + /// Map from byte offset into wasm function to range of native instructions. + /// + // Ordered by increasing InstructionAddressMap::srcloc. + instructions_address_map: Vec, + + /// Calling convention to use. + calling_convention: CallingConvention, + + /// Cost for initializing the stack of the function + stack_init_gas_cost: u64, + + /// Iterator over the gas instrumentation points + gas_iter: iter::Peekable, slice::Iter<'a, u64>>>, + + /// Maximum size of the stack for this function + stack_size: u32, +} + +struct SpecialLabelSet { + integer_division_by_zero: DynamicLabel, + integer_overflow: DynamicLabel, + bad_conversion_to_integer: DynamicLabel, + heap_access_oob: DynamicLabel, + table_access_oob: DynamicLabel, + indirect_call_null: DynamicLabel, + bad_signature: DynamicLabel, + gas_limit_exceeded: DynamicLabel, + stack_overflow: DynamicLabel, +} + +/// Metadata about a floating-point value. +#[derive(Copy, Clone, Debug)] +struct FloatValue { + /// Do we need to canonicalize the value before its bit pattern is next observed? If so, how? + canonicalization: Option, + + /// Corresponding depth in the main value stack. + depth: usize, +} + +impl FloatValue { + fn new(depth: usize) -> Self { + FloatValue { + canonicalization: None, + depth, + } + } + + fn cncl_f32(depth: usize) -> Self { + FloatValue { + canonicalization: Some(CanonicalizeType::F32), + depth, + } + } + + fn cncl_f64(depth: usize) -> Self { + FloatValue { + canonicalization: Some(CanonicalizeType::F64), + depth, + } + } + + fn promote(self, depth: usize) -> FloatValue { + FloatValue { + canonicalization: match self.canonicalization { + Some(CanonicalizeType::F32) => Some(CanonicalizeType::F64), + Some(CanonicalizeType::F64) => panic!("cannot promote F64"), + None => None, + }, + depth, + } + } + + fn demote(self, depth: usize) -> FloatValue { + FloatValue { + canonicalization: match self.canonicalization { + Some(CanonicalizeType::F64) => Some(CanonicalizeType::F32), + Some(CanonicalizeType::F32) => panic!("cannot demote F32"), + None => None, + }, + depth, + } + } +} + +/// Type of a pending canonicalization floating point value. +/// Sometimes we don't have the type information elsewhere and therefore we need to track it here. +#[derive(Copy, Clone, Debug)] +enum CanonicalizeType { + F32, + F64, +} + +impl CanonicalizeType { + fn to_size(&self) -> Size { + match self { + CanonicalizeType::F32 => Size::S32, + CanonicalizeType::F64 => Size::S64, + } + } +} + +trait PopMany { + fn peek1(&self) -> Result<&T, CodegenError>; + fn pop1(&mut self) -> Result; + fn pop2(&mut self) -> Result<(T, T), CodegenError>; +} + +impl PopMany for Vec { + fn peek1(&self) -> Result<&T, CodegenError> { + self.last().ok_or_else(|| CodegenError { + message: "peek1() expects at least 1 element".into(), + }) + } + fn pop1(&mut self) -> Result { + self.pop().ok_or_else(|| CodegenError { + message: "pop1() expects at least 1 element".into(), + }) + } + fn pop2(&mut self) -> Result<(T, T), CodegenError> { + if self.len() < 2 { + return Err(CodegenError { + message: "pop2() expects at least 2 elements".into(), + }); + } + + let right = self.pop().unwrap(); + let left = self.pop().unwrap(); + Ok((left, right)) + } +} + +trait WpTypeExt { + fn is_float(&self) -> bool; +} + +impl WpTypeExt for WpType { + fn is_float(&self) -> bool { + match self { + WpType::F32 | WpType::F64 => true, + _ => false, + } + } +} + +#[derive(Debug)] +pub(crate) struct ControlFrame { + /// The label to which `br` opcodes should jump + /// + /// This is: + /// * for functions (ie. the control_stack[0]), the start of the epilogue + /// * for `block` or `if`/`else` blocks, the end of the block (after stack cleanup) + /// * for `loop` blocks, the beginning of the loop block + pub(crate) br_label: DynamicLabel, + + pub(crate) loop_like: bool, + pub(crate) if_else: IfElseState, + pub(crate) returns: SmallVec<[WpType; 1]>, + pub(crate) value_stack_depth: usize, + pub(crate) fp_stack_depth: usize, +} + +#[derive(Debug, Copy, Clone)] +pub(crate) enum IfElseState { + None, + If(DynamicLabel), + Else, +} + +#[derive(Debug)] +pub(crate) struct CodegenError { + pub(crate) message: String, +} + +/// Abstraction for a 2-input, 1-output operator. Can be an integer/floating-point +/// binop/cmpop. +struct I2O1 { + loc_a: Location, + loc_b: Location, + ret: Location, +} + +impl<'a> FuncGen<'a> { + /// Set the source location of the Wasm to the given offset. + pub(crate) fn set_srcloc(&mut self, offset: u32) { + self.src_loc = offset; + } + + fn get_location_released(&mut self, loc: Location) -> Location { + self.machine.release_locations(&mut self.assembler, &[loc]); + loc + } + + fn pop_value_released(&mut self) -> Location { + let loc = self + .value_stack + .pop() + .expect("pop_value_released: value stack is empty"); + self.get_location_released(loc) + } + + /// Prepare data for binary operator with 2 inputs and 1 output. + fn i2o1_prepare(&mut self, ty: WpType) -> I2O1 { + let loc_b = self.pop_value_released(); + let loc_a = self.pop_value_released(); + let ret = self + .machine + .acquire_locations(&mut self.assembler, &[(ty)], false)[0]; + self.value_stack.push(ret); + I2O1 { loc_a, loc_b, ret } + } + + fn emit_call(&mut self, function: FunctionIndex) -> Result<(), CodegenError> { + let sig_index = *self.module.functions.get(function).unwrap(); + let sig = self.module.signatures.get(sig_index).unwrap(); + let param_types: SmallVec<[WpType; 8]> = + sig.params().iter().cloned().map(type_to_wp_type).collect(); + let return_types: SmallVec<[WpType; 1]> = + sig.results().iter().cloned().map(type_to_wp_type).collect(); + + let params: SmallVec<[_; 8]> = self + .value_stack + .drain(self.value_stack.len() - param_types.len()..) + .collect(); + self.machine.release_locations_only_regs(¶ms); + + // Pop arguments off the FP stack and canonicalize them if needed. + // + // Canonicalization state will be lost across function calls, so early canonicalization + // is necessary here. + while let Some(fp) = self.fp_stack.last() { + if fp.depth >= self.value_stack.len() { + let index = fp.depth - self.value_stack.len(); + if self.assembler.arch_supports_canonicalize_nan() + && self.config.enable_nan_canonicalization + && fp.canonicalization.is_some() + { + let size = fp.canonicalization.unwrap().to_size(); + self.canonicalize_nan(size, params[index], params[index]); + } + self.fp_stack.pop().unwrap(); + } else { + break; + } + } + + if self.try_intrinsic(function, ¶ms) { + // This was genereated as an intrinsic, we're done. + return Ok(()); + } + + let reloc_at = self.assembler.get_offset().0 + self.assembler.arch_mov64_imm_offset(); + // Imported functions are called through trampolines placed as custom sections. + let reloc_target = match self.module.import_counts.local_function_index(function) { + Ok(local) => RelocationTarget::LocalFunc(local), + Err(imp) => RelocationTarget::CustomSection(SectionIndex::from_u32(imp.as_u32())), + }; + self.relocations.push(Relocation { + kind: RelocationKind::Abs8, + reloc_target, + offset: reloc_at as u32, + addend: 0, + }); + + // RAX is preserved on entry to `emit_call_sysv` callback. + // The Imm64 value is relocated by the JIT linker. + self.assembler.emit_mov( + Size::S64, + Location::Imm64(std::u64::MAX), + Location::GPR(GPR::RAX), + ); + + self.emit_call_native( + |this| { + this.assembler.emit_call_location(Location::GPR(GPR::RAX)); + }, + params.iter().copied(), + )?; + + self.machine + .release_locations_only_stack(&mut self.assembler, ¶ms); + + if !return_types.is_empty() { + let ret = + self.machine + .acquire_locations(&mut self.assembler, &[(return_types[0])], false)[0]; + self.value_stack.push(ret); + if return_types[0].is_float() { + self.assembler + .emit_mov(Size::S64, Location::XMM(XMM::XMM0), ret); + self.fp_stack + .push(FloatValue::new(self.value_stack.len() - 1)); + } else { + self.assembler + .emit_mov(Size::S64, Location::GPR(GPR::RAX), ret); + } + } + Ok(()) + } + + /// Try emitting an intrinsic for a function call of function at index. + fn try_intrinsic(&mut self, function: FunctionIndex, params: &SmallVec<[Location; 8]>) -> bool { + let signature_index = self.module.functions[function]; + let signature = &self.module.signatures[signature_index]; + let import_name = self.module_translation_state.import_map.get(&function); + let intrinsic = import_name.and_then(|import_name| { + self.config.intrinsics.iter().find(|intrinsic| { + intrinsic.name == *import_name + && intrinsic.signature == *signature + && intrinsic.is_params_ok(params) + }) + }); + match intrinsic.map(|i| &i.kind) { + Some(IntrinsicKind::Gas) => self.emit_gas(params[0]), + None => return false, + } + return true; + } + + fn emit_gas_const(&mut self, cost: u64) { + if let Ok(cost) = u32::try_from(cost) { + self.emit_gas(Location::Imm32(cost)); + } else { + let cost_reg = self.machine.acquire_temp_gpr().unwrap(); + self.assembler + .emit_mov(Size::S64, Location::Imm64(cost), Location::GPR(cost_reg)); + self.emit_gas(Location::GPR(cost_reg)); + self.machine.release_temp_gpr(cost_reg); + } + } + + /// Emit a gas charge operation. The gas amount is stored in `cost_location`, which must be either an imm32 or a GPR + // (this is because emit_add can only take up to an imm32) + fn emit_gas(&mut self, cost_location: Location) { + if cost_location == Location::Imm32(0) { + return; // skip, which we must do because emit_add optimizes out the add 0 which leaves CF clobbered otherwise + } + assert!( + matches!(cost_location, Location::Imm32(_) | Location::GPR(_)), + "emit_gas can take only an imm32 or a gpr argument" + ); + + let counter_offset = offset_of!(FastGasCounter, burnt_gas) as i32; + let gas_limit_offset = offset_of!(FastGasCounter, gas_limit) as i32; + // Recheck offsets, to make sure offsets will never change. + assert_eq!(counter_offset, 0); + assert_eq!(gas_limit_offset, 8); + let base_reg = self.machine.acquire_temp_gpr().unwrap(); + // Load gas counter base. + self.assembler.emit_mov( + Size::S64, + Location::Memory( + Machine::get_vmctx_reg(), + self.vmoffsets.vmctx_gas_limiter_pointer() as i32, + ), + Location::GPR(base_reg), + ); + let current_burnt_reg = self.machine.acquire_temp_gpr().unwrap(); + // Read current gas counter. + self.assembler.emit_mov( + Size::S64, + Location::Memory(base_reg, counter_offset), + Location::GPR(current_burnt_reg), + ); + // Compute new cost. + self.assembler + .emit_add(Size::S64, cost_location, Location::GPR(current_burnt_reg)); + self.assembler + .emit_jmp(Condition::Carry, self.special_labels.integer_overflow); + // Compare with the limit. + self.assembler.emit_cmp( + Size::S64, + Location::GPR(current_burnt_reg), + Location::Memory(base_reg, gas_limit_offset), + ); + // Write new gas counter unconditionally, so that runtime can sort out limits case. + self.assembler.emit_mov( + Size::S64, + Location::GPR(current_burnt_reg), + Location::Memory(base_reg, counter_offset), + ); + self.assembler.emit_jmp( + Condition::BelowEqual, + self.special_labels.gas_limit_exceeded, + ); + self.machine.release_temp_gpr(base_reg); + self.machine.release_temp_gpr(current_burnt_reg); + } + + fn emit_trap(&mut self, code: TrapCode) { + let label = self.assembler.get_label(); + self.assembler.emit_label(label); + self.assembler.emit_lea_label( + label, + Machine::get_param_location(0, self.calling_convention), + ); + self.assembler.emit_mov( + Size::S32, + Location::Imm32(code as u32), + Machine::get_param_location(1, self.calling_convention), + ); + // Align stack. + self.assembler.emit_and( + Size::S64, + Location::Imm32(0xfffffff0), + Location::GPR(GPR::RSP), + ); + let offset = self.vmoffsets.vmctx_trap_handler(); + self.assembler + .emit_call_location(Location::Memory(Machine::get_vmctx_reg(), offset as i32)); + } + + /// Canonicalizes the floating point value at `input` into `output`. + fn canonicalize_nan(&mut self, sz: Size, input: Location, output: Location) { + let tmp1 = self.machine.acquire_temp_xmm().unwrap(); + let tmp2 = self.machine.acquire_temp_xmm().unwrap(); + let tmp3 = self.machine.acquire_temp_xmm().unwrap(); + + self.emit_relaxed_binop(Assembler::emit_mov, sz, input, Location::XMM(tmp1)); + let tmpg1 = self.machine.acquire_temp_gpr().unwrap(); + + match sz { + Size::S32 => { + self.assembler + .emit_vcmpunordss(tmp1, XMMOrMemory::XMM(tmp1), tmp2); + self.assembler.emit_mov( + Size::S32, + Location::Imm32(0x7FC0_0000), // Canonical NaN + Location::GPR(tmpg1), + ); + self.assembler + .emit_mov(Size::S64, Location::GPR(tmpg1), Location::XMM(tmp3)); + self.assembler + .emit_vblendvps(tmp2, XMMOrMemory::XMM(tmp3), tmp1, tmp1); + } + Size::S64 => { + self.assembler + .emit_vcmpunordsd(tmp1, XMMOrMemory::XMM(tmp1), tmp2); + self.assembler.emit_mov( + Size::S64, + Location::Imm64(0x7FF8_0000_0000_0000), // Canonical NaN + Location::GPR(tmpg1), + ); + self.assembler + .emit_mov(Size::S64, Location::GPR(tmpg1), Location::XMM(tmp3)); + self.assembler + .emit_vblendvpd(tmp2, XMMOrMemory::XMM(tmp3), tmp1, tmp1); + } + _ => unreachable!(), + } + + self.emit_relaxed_binop(Assembler::emit_mov, sz, Location::XMM(tmp1), output); + + self.machine.release_temp_gpr(tmpg1); + self.machine.release_temp_xmm(tmp3); + self.machine.release_temp_xmm(tmp2); + self.machine.release_temp_xmm(tmp1); + } + + /// Moves `loc` to a valid location for `div`/`idiv`. + fn emit_relaxed_xdiv(&mut self, signed: bool, sz: Size, loc: Location) { + self.assembler.emit_cmp(sz, Location::Imm32(0), loc); + self.assembler.emit_jmp( + Condition::Equal, + self.special_labels.integer_division_by_zero, + ); + + // Boundary checks for integer overflow. It clearly doesn't make sense for + // unsigned division, as numerator is of same size as the actual result, and divisor is + // always >= 1. + // For signed division we can get out of bound only when divide MIN_INT / -1, + // as result will be MAX_INT+1 so test for that case explicitly. + if signed { + let end = self.assembler.get_label(); + // Check if divisor is -1. + self.assembler + .emit_cmp(sz, Location::Imm32(0xffffffff), loc); + self.assembler.emit_jmp(Condition::NotEqual, end); + // Check if numerator is MIN_INT. + match sz { + Size::S32 => { + self.assembler.emit_cmp( + sz, + Location::Imm32(0x80000000u32), + Location::GPR(GPR::RAX), + ); + } + Size::S64 => { + self.assembler.emit_mov( + sz, + Location::Imm64(0x8000000000000000u64), + Location::GPR(GPR::RCX), + ); + self.assembler + .emit_cmp(sz, Location::GPR(GPR::RCX), Location::GPR(GPR::RAX)); + } + _ => assert!(false), + } + self.assembler.emit_jmp(Condition::NotEqual, end); + self.assembler + .emit_jmp(Condition::None, self.special_labels.integer_overflow); + self.assembler.emit_label(end); + } + + match loc { + Location::Imm64(_) | Location::Imm32(_) => { + self.assembler.emit_mov(sz, loc, Location::GPR(GPR::RCX)); // must not be used during div (rax, rdx) + if signed { + self.assembler.emit_idiv(sz, Location::GPR(GPR::RCX)); + } else { + self.assembler.emit_div(sz, Location::GPR(GPR::RCX)); + } + } + _ => { + if signed { + self.assembler.emit_idiv(sz, loc); + } else { + self.assembler.emit_div(sz, loc); + } + } + } + } + + /// Moves `src` and `dst` to valid locations for `movzx`/`movsx`. + fn emit_relaxed_zx_sx( + &mut self, + op: fn(&mut Assembler, Size, Location, Size, Location), + sz_src: Size, + mut src: Location, + sz_dst: Size, + dst: Location, + ) -> Result<(), CodegenError> { + let inner = |m: &mut Machine, a: &mut Assembler, src: Location| match dst { + Location::Imm32(_) | Location::Imm64(_) => { + return Err(CodegenError { + message: "emit_relaxed_zx_sx dst Imm: unreachable code".to_string(), + }) + } + Location::Memory(_, _) => { + let tmp_dst = m.acquire_temp_gpr().unwrap(); + op(a, sz_src, src, sz_dst, Location::GPR(tmp_dst)); + a.emit_mov(Size::S64, Location::GPR(tmp_dst), dst); + + m.release_temp_gpr(tmp_dst); + Ok(()) + } + Location::GPR(_) => { + op(a, sz_src, src, sz_dst, dst); + Ok(()) + } + _ => { + return Err(CodegenError { + message: "emit_relaxed_zx_sx dst: unreachable code".to_string(), + }) + } + }; + + match src { + Location::Imm32(_) | Location::Imm64(_) => { + let tmp_src = self.machine.acquire_temp_gpr().unwrap(); + self.assembler + .emit_mov(Size::S64, src, Location::GPR(tmp_src)); + src = Location::GPR(tmp_src); + + inner(&mut self.machine, &mut self.assembler, src)?; + + self.machine.release_temp_gpr(tmp_src); + } + Location::GPR(_) | Location::Memory(_, _) => { + inner(&mut self.machine, &mut self.assembler, src)? + } + _ => { + return Err(CodegenError { + message: "emit_relaxed_zx_sx src: unreachable code".to_string(), + }) + } + } + Ok(()) + } + + /// Moves `src` and `dst` to valid locations for generic instructions. + fn emit_relaxed_binop( + &mut self, + op: fn(&mut Assembler, Size, Location, Location), + sz: Size, + src: Location, + dst: Location, + ) { + enum RelaxMode { + Direct, + SrcToGPR, + DstToGPR, + BothToGPR, + } + let mode = match (src, dst) { + (Location::GPR(_), Location::GPR(_)) + if (op as *const u8 == Assembler::emit_imul as *const u8) => + { + RelaxMode::Direct + } + _ if (op as *const u8 == Assembler::emit_imul as *const u8) => RelaxMode::BothToGPR, + + (Location::Memory(_, _), Location::Memory(_, _)) => RelaxMode::SrcToGPR, + (Location::Imm64(_), Location::Imm64(_)) | (Location::Imm64(_), Location::Imm32(_)) => { + RelaxMode::BothToGPR + } + (_, Location::Imm32(_)) | (_, Location::Imm64(_)) => RelaxMode::DstToGPR, + (Location::Imm64(_), Location::Memory(_, _)) => RelaxMode::SrcToGPR, + (Location::Imm64(_), Location::GPR(_)) + if (op as *const u8 != Assembler::emit_mov as *const u8) => + { + RelaxMode::SrcToGPR + } + (_, Location::XMM(_)) => RelaxMode::SrcToGPR, + _ => RelaxMode::Direct, + }; + + match mode { + RelaxMode::SrcToGPR => { + let temp = self.machine.acquire_temp_gpr().unwrap(); + self.assembler.emit_mov(sz, src, Location::GPR(temp)); + op(&mut self.assembler, sz, Location::GPR(temp), dst); + self.machine.release_temp_gpr(temp); + } + RelaxMode::DstToGPR => { + let temp = self.machine.acquire_temp_gpr().unwrap(); + self.assembler.emit_mov(sz, dst, Location::GPR(temp)); + op(&mut self.assembler, sz, src, Location::GPR(temp)); + self.machine.release_temp_gpr(temp); + } + RelaxMode::BothToGPR => { + let temp_src = self.machine.acquire_temp_gpr().unwrap(); + let temp_dst = self.machine.acquire_temp_gpr().unwrap(); + self.assembler.emit_mov(sz, src, Location::GPR(temp_src)); + self.assembler.emit_mov(sz, dst, Location::GPR(temp_dst)); + op( + &mut self.assembler, + sz, + Location::GPR(temp_src), + Location::GPR(temp_dst), + ); + match dst { + Location::Memory(_, _) | Location::GPR(_) => { + self.assembler.emit_mov(sz, Location::GPR(temp_dst), dst); + } + _ => {} + } + self.machine.release_temp_gpr(temp_dst); + self.machine.release_temp_gpr(temp_src); + } + RelaxMode::Direct => { + op(&mut self.assembler, sz, src, dst); + } + } + } + + /// Moves `src1` and `src2` to valid locations and possibly adds a layer of indirection for `dst` for AVX instructions. + fn emit_relaxed_avx( + &mut self, + op: fn(&mut Assembler, XMM, XMMOrMemory, XMM), + src1: Location, + src2: Location, + dst: Location, + ) -> Result<(), CodegenError> { + self.emit_relaxed_avx_base( + |this, src1, src2, dst| op(&mut this.assembler, src1, src2, dst), + src1, + src2, + dst, + )?; + Ok(()) + } + + /// Moves `src1` and `src2` to valid locations and possibly adds a layer of indirection for `dst` for AVX instructions. + fn emit_relaxed_avx_base( + &mut self, + op: F, + src1: Location, + src2: Location, + dst: Location, + ) -> Result<(), CodegenError> { + let tmp1 = self.machine.acquire_temp_xmm().unwrap(); + let tmp2 = self.machine.acquire_temp_xmm().unwrap(); + let tmp3 = self.machine.acquire_temp_xmm().unwrap(); + let tmpg = self.machine.acquire_temp_gpr().unwrap(); + + let src1 = match src1 { + Location::XMM(x) => x, + Location::GPR(_) | Location::Memory(_, _) => { + self.assembler + .emit_mov(Size::S64, src1, Location::XMM(tmp1)); + tmp1 + } + Location::Imm32(_) => { + self.assembler + .emit_mov(Size::S32, src1, Location::GPR(tmpg)); + self.assembler + .emit_mov(Size::S32, Location::GPR(tmpg), Location::XMM(tmp1)); + tmp1 + } + Location::Imm64(_) => { + self.assembler + .emit_mov(Size::S64, src1, Location::GPR(tmpg)); + self.assembler + .emit_mov(Size::S64, Location::GPR(tmpg), Location::XMM(tmp1)); + tmp1 + } + _ => { + return Err(CodegenError { + message: "emit_relaxed_avx_base src1: unreachable code".to_string(), + }) + } + }; + + let src2 = match src2 { + Location::XMM(x) => XMMOrMemory::XMM(x), + Location::Memory(base, disp) => XMMOrMemory::Memory(base, disp), + Location::GPR(_) => { + self.assembler + .emit_mov(Size::S64, src2, Location::XMM(tmp2)); + XMMOrMemory::XMM(tmp2) + } + Location::Imm32(_) => { + self.assembler + .emit_mov(Size::S32, src2, Location::GPR(tmpg)); + self.assembler + .emit_mov(Size::S32, Location::GPR(tmpg), Location::XMM(tmp2)); + XMMOrMemory::XMM(tmp2) + } + Location::Imm64(_) => { + self.assembler + .emit_mov(Size::S64, src2, Location::GPR(tmpg)); + self.assembler + .emit_mov(Size::S64, Location::GPR(tmpg), Location::XMM(tmp2)); + XMMOrMemory::XMM(tmp2) + } + _ => { + return Err(CodegenError { + message: "emit_relaxed_avx_base src2: unreachable code".to_string(), + }) + } + }; + + match dst { + Location::XMM(x) => { + op(self, src1, src2, x); + } + Location::Memory(_, _) | Location::GPR(_) => { + op(self, src1, src2, tmp3); + self.assembler.emit_mov(Size::S64, Location::XMM(tmp3), dst); + } + _ => { + return Err(CodegenError { + message: "emit_relaxed_avx_base dst: unreachable code".to_string(), + }) + } + } + + self.machine.release_temp_gpr(tmpg); + self.machine.release_temp_xmm(tmp3); + self.machine.release_temp_xmm(tmp2); + self.machine.release_temp_xmm(tmp1); + Ok(()) + } + + /// I32 binary operation with both operands popped from the virtual stack. + fn emit_binop_i32(&mut self, f: fn(&mut Assembler, Size, Location, Location)) { + // Using Red Zone here. + let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::I32); + if loc_a != ret { + let tmp = self.machine.acquire_temp_gpr().unwrap(); + self.emit_relaxed_binop(Assembler::emit_mov, Size::S32, loc_a, Location::GPR(tmp)); + self.emit_relaxed_binop(f, Size::S32, loc_b, Location::GPR(tmp)); + self.emit_relaxed_binop(Assembler::emit_mov, Size::S32, Location::GPR(tmp), ret); + self.machine.release_temp_gpr(tmp); + } else { + self.emit_relaxed_binop(f, Size::S32, loc_b, ret); + } + } + + /// I64 binary operation with both operands popped from the virtual stack. + fn emit_binop_i64(&mut self, f: fn(&mut Assembler, Size, Location, Location)) { + // Using Red Zone here. + let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::I64); + + if loc_a != ret { + let tmp = self.machine.acquire_temp_gpr().unwrap(); + self.emit_relaxed_binop(Assembler::emit_mov, Size::S64, loc_a, Location::GPR(tmp)); + self.emit_relaxed_binop(f, Size::S64, loc_b, Location::GPR(tmp)); + self.emit_relaxed_binop(Assembler::emit_mov, Size::S64, Location::GPR(tmp), ret); + self.machine.release_temp_gpr(tmp); + } else { + self.emit_relaxed_binop(f, Size::S64, loc_b, ret); + } + } + + /// I32 comparison with `loc_b` from input. + fn emit_cmpop_i32_dynamic_b( + &mut self, + c: Condition, + loc_b: Location, + ) -> Result<(), CodegenError> { + // Using Red Zone here. + let loc_a = self.pop_value_released(); + + let ret = self + .machine + .acquire_locations(&mut self.assembler, &[(WpType::I32)], false)[0]; + match ret { + Location::GPR(x) => { + self.emit_relaxed_binop(Assembler::emit_cmp, Size::S32, loc_b, loc_a); + self.assembler.emit_set(c, x); + self.assembler + .emit_and(Size::S32, Location::Imm32(0xff), Location::GPR(x)); + } + Location::Memory(_, _) => { + let tmp = self.machine.acquire_temp_gpr().unwrap(); + self.emit_relaxed_binop(Assembler::emit_cmp, Size::S32, loc_b, loc_a); + self.assembler.emit_set(c, tmp); + self.assembler + .emit_and(Size::S32, Location::Imm32(0xff), Location::GPR(tmp)); + self.assembler.emit_mov(Size::S32, Location::GPR(tmp), ret); + self.machine.release_temp_gpr(tmp); + } + _ => { + return Err(CodegenError { + message: "emit_cmpop_i32_dynamic_b ret: unreachable code".to_string(), + }) + } + } + self.value_stack.push(ret); + Ok(()) + } + + /// I32 comparison with both operands popped from the virtual stack. + fn emit_cmpop_i32(&mut self, c: Condition) -> Result<(), CodegenError> { + let loc_b = self.pop_value_released(); + self.emit_cmpop_i32_dynamic_b(c, loc_b)?; + Ok(()) + } + + /// I64 comparison with `loc_b` from input. + fn emit_cmpop_i64_dynamic_b( + &mut self, + c: Condition, + loc_b: Location, + ) -> Result<(), CodegenError> { + // Using Red Zone here. + let loc_a = self.pop_value_released(); + + let ret = self + .machine + .acquire_locations(&mut self.assembler, &[(WpType::I32)], false)[0]; + match ret { + Location::GPR(x) => { + self.emit_relaxed_binop(Assembler::emit_cmp, Size::S64, loc_b, loc_a); + self.assembler.emit_set(c, x); + self.assembler + .emit_and(Size::S32, Location::Imm32(0xff), Location::GPR(x)); + } + Location::Memory(_, _) => { + let tmp = self.machine.acquire_temp_gpr().unwrap(); + self.emit_relaxed_binop(Assembler::emit_cmp, Size::S64, loc_b, loc_a); + self.assembler.emit_set(c, tmp); + self.assembler + .emit_and(Size::S32, Location::Imm32(0xff), Location::GPR(tmp)); + self.assembler.emit_mov(Size::S32, Location::GPR(tmp), ret); + self.machine.release_temp_gpr(tmp); + } + _ => { + return Err(CodegenError { + message: "emit_cmpop_i64_dynamic_b ret: unreachable code".to_string(), + }) + } + } + self.value_stack.push(ret); + Ok(()) + } + + /// I64 comparison with both operands popped from the virtual stack. + fn emit_cmpop_i64(&mut self, c: Condition) -> Result<(), CodegenError> { + let loc_b = self.pop_value_released(); + self.emit_cmpop_i64_dynamic_b(c, loc_b)?; + Ok(()) + } + + /// I32 `lzcnt`/`tzcnt`/`popcnt` with operand popped from the virtual stack. + fn emit_xcnt_i32( + &mut self, + f: fn(&mut Assembler, Size, Location, Location), + ) -> Result<(), CodegenError> { + let loc = self.pop_value_released(); + let ret = self + .machine + .acquire_locations(&mut self.assembler, &[(WpType::I32)], false)[0]; + + match loc { + Location::Imm32(_) => { + let tmp = self.machine.acquire_temp_gpr().unwrap(); + self.assembler.emit_mov(Size::S32, loc, Location::GPR(tmp)); + if let Location::Memory(_, _) = ret { + let out_tmp = self.machine.acquire_temp_gpr().unwrap(); + f( + &mut self.assembler, + Size::S32, + Location::GPR(tmp), + Location::GPR(out_tmp), + ); + self.assembler + .emit_mov(Size::S32, Location::GPR(out_tmp), ret); + self.machine.release_temp_gpr(out_tmp); + } else { + f(&mut self.assembler, Size::S32, Location::GPR(tmp), ret); + } + self.machine.release_temp_gpr(tmp); + } + Location::Memory(_, _) | Location::GPR(_) => { + if let Location::Memory(_, _) = ret { + let out_tmp = self.machine.acquire_temp_gpr().unwrap(); + f(&mut self.assembler, Size::S32, loc, Location::GPR(out_tmp)); + self.assembler + .emit_mov(Size::S32, Location::GPR(out_tmp), ret); + self.machine.release_temp_gpr(out_tmp); + } else { + f(&mut self.assembler, Size::S32, loc, ret); + } + } + _ => { + return Err(CodegenError { + message: "emit_xcnt_i32 loc: unreachable code".to_string(), + }) + } + } + self.value_stack.push(ret); + Ok(()) + } + + /// I64 `lzcnt`/`tzcnt`/`popcnt` with operand popped from the virtual stack. + fn emit_xcnt_i64( + &mut self, + f: fn(&mut Assembler, Size, Location, Location), + ) -> Result<(), CodegenError> { + let loc = self.pop_value_released(); + let ret = self + .machine + .acquire_locations(&mut self.assembler, &[(WpType::I64)], false)[0]; + + match loc { + Location::Imm64(_) | Location::Imm32(_) => { + let tmp = self.machine.acquire_temp_gpr().unwrap(); + self.assembler.emit_mov(Size::S64, loc, Location::GPR(tmp)); + if let Location::Memory(_, _) = ret { + let out_tmp = self.machine.acquire_temp_gpr().unwrap(); + f( + &mut self.assembler, + Size::S64, + Location::GPR(tmp), + Location::GPR(out_tmp), + ); + self.assembler + .emit_mov(Size::S64, Location::GPR(out_tmp), ret); + self.machine.release_temp_gpr(out_tmp); + } else { + f(&mut self.assembler, Size::S64, Location::GPR(tmp), ret); + } + self.machine.release_temp_gpr(tmp); + } + Location::Memory(_, _) | Location::GPR(_) => { + if let Location::Memory(_, _) = ret { + let out_tmp = self.machine.acquire_temp_gpr().unwrap(); + f(&mut self.assembler, Size::S64, loc, Location::GPR(out_tmp)); + self.assembler + .emit_mov(Size::S64, Location::GPR(out_tmp), ret); + self.machine.release_temp_gpr(out_tmp); + } else { + f(&mut self.assembler, Size::S64, loc, ret); + } + } + _ => { + return Err(CodegenError { + message: "emit_xcnt_i64 loc: unreachable code".to_string(), + }) + } + } + self.value_stack.push(ret); + Ok(()) + } + + /// I32 shift with both operands popped from the virtual stack. + fn emit_shift_i32(&mut self, f: fn(&mut Assembler, Size, Location, Location)) { + let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::I32); + + self.assembler + .emit_mov(Size::S32, loc_b, Location::GPR(GPR::RCX)); + + if loc_a != ret { + self.emit_relaxed_binop(Assembler::emit_mov, Size::S32, loc_a, ret); + } + + f(&mut self.assembler, Size::S32, Location::GPR(GPR::RCX), ret); + } + + /// I64 shift with both operands popped from the virtual stack. + fn emit_shift_i64(&mut self, f: fn(&mut Assembler, Size, Location, Location)) { + let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::I64); + self.assembler + .emit_mov(Size::S64, loc_b, Location::GPR(GPR::RCX)); + + if loc_a != ret { + self.emit_relaxed_binop(Assembler::emit_mov, Size::S64, loc_a, ret); + } + + f(&mut self.assembler, Size::S64, Location::GPR(GPR::RCX), ret); + } + + /// Floating point (AVX) binary operation with both operands popped from the virtual stack. + fn emit_fp_binop_avx( + &mut self, + f: fn(&mut Assembler, XMM, XMMOrMemory, XMM), + ) -> Result<(), CodegenError> { + let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::F64); + + self.emit_relaxed_avx(f, loc_a, loc_b, ret)?; + Ok(()) + } + + /// Floating point (AVX) comparison with both operands popped from the virtual stack. + fn emit_fp_cmpop_avx( + &mut self, + f: fn(&mut Assembler, XMM, XMMOrMemory, XMM), + ) -> Result<(), CodegenError> { + let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::I32); + + self.emit_relaxed_avx(f, loc_a, loc_b, ret)?; + + // Workaround for behavior inconsistency among different backing implementations. + // (all bits or only the least significant bit are set to one?) + self.assembler.emit_and(Size::S32, Location::Imm32(1), ret); + Ok(()) + } + + /// Floating point (AVX) unop with both operands popped from the virtual stack. + fn emit_fp_unop_avx( + &mut self, + f: fn(&mut Assembler, XMM, XMMOrMemory, XMM), + ) -> Result<(), CodegenError> { + let loc = self.pop_value_released(); + let ret = self + .machine + .acquire_locations(&mut self.assembler, &[(WpType::F64)], false)[0]; + self.value_stack.push(ret); + self.emit_relaxed_avx(f, loc, loc, ret)?; + Ok(()) + } + + /// Emits a System V / Windows call sequence. + /// + /// This function will not use RAX before `cb` is called. + /// + /// The caller MUST NOT hold any temporary registers allocated by `acquire_temp_gpr` when calling + /// this function. + fn emit_call_native, F: FnOnce(&mut Self)>( + &mut self, + cb: F, + params: I, + ) -> Result<(), CodegenError> { + let params: Vec<_> = params.collect(); + + // Save used GPRs. + let used_gprs = self.machine.get_used_gprs(); + for r in used_gprs.iter() { + self.assembler.emit_push(Size::S64, Location::GPR(*r)); + } + + // Save used XMM registers. + let used_xmms = self.machine.get_used_xmms(); + if used_xmms.len() > 0 { + self.assembler.emit_sub( + Size::S64, + Location::Imm32((used_xmms.len() * 8) as u32), + Location::GPR(GPR::RSP), + ); + + for (i, r) in used_xmms.iter().enumerate() { + self.assembler.emit_mov( + Size::S64, + Location::XMM(*r), + Location::Memory(GPR::RSP, (i * 8) as i32), + ); + } + } + let calling_convention = self.calling_convention; + + let stack_padding: usize = match calling_convention { + CallingConvention::WindowsFastcall => 32, + _ => 0, + }; + + let mut stack_offset: usize = 0; + + // Calculate stack offset. + for (i, _param) in params.iter().enumerate() { + if let Location::Memory(_, _) = Machine::get_param_location(1 + i, calling_convention) { + stack_offset += 8; + } + } + + // Align stack to 16 bytes. + if (self.machine.get_stack_offset() + + used_gprs.len() * 8 + + used_xmms.len() * 8 + + stack_offset) + % 16 + != 0 + { + self.assembler + .emit_sub(Size::S64, Location::Imm32(8), Location::GPR(GPR::RSP)); + stack_offset += 8; + } + + let mut call_movs: Vec<(Location, GPR)> = vec![]; + // Prepare register & stack parameters. + for (i, param) in params.iter().enumerate().rev() { + let loc = Machine::get_param_location(1 + i, calling_convention); + match loc { + Location::GPR(x) => { + call_movs.push((*param, x)); + } + Location::Memory(_, _) => { + match *param { + Location::GPR(_) => {} + Location::XMM(_) => {} + Location::Memory(reg, _) => { + if reg != GPR::RBP { + return Err(CodegenError { + message: "emit_call_native loc param: unreachable code" + .to_string(), + }); + } + // TODO: Read value at this offset + } + _ => {} + } + match *param { + Location::Imm64(_) => { + // x86_64 does not support `mov imm64, mem`. We must first place the + // immdiate value into a register and then write the register to the + // memory. Now the problem is that there might not be any registers + // available to clobber. In order to make this work out we spill a + // register thus retaining both the original value of the + // register and producing the required data at the top of the stack. + // + // FIXME(#2723): figure out how to not require spilling a register + // here. It should definitely be possible to `pick_gpr`/`pick_temp_gpr` + // to grab an otherwise unused register and just clobber its value + // here. + self.assembler.emit_push(Size::S64, Location::GPR(GPR::R9)); + self.assembler + .emit_mov(Size::S64, *param, Location::GPR(GPR::R9)); + self.assembler.emit_xchg( + Size::S64, + Location::GPR(GPR::R9), + Location::Memory(GPR::RSP, 0), + ); + } + Location::XMM(_) => { + // Dummy value slot to be filled with `mov`. + self.assembler.emit_push(Size::S64, Location::GPR(GPR::RAX)); + + // XMM registers can be directly stored to memory. + self.assembler.emit_mov( + Size::S64, + *param, + Location::Memory(GPR::RSP, 0), + ); + } + _ => self.assembler.emit_push(Size::S64, *param), + } + } + _ => { + return Err(CodegenError { + message: "emit_call_native loc: unreachable code".to_string(), + }) + } + } + } + + // Sort register moves so that register are not overwritten before read. + sort_call_movs(&mut call_movs); + + // Emit register moves. + for (loc, gpr) in call_movs { + if loc != Location::GPR(gpr) { + self.assembler.emit_mov(Size::S64, loc, Location::GPR(gpr)); + } + } + + // Put vmctx as the first parameter. + self.assembler.emit_mov( + Size::S64, + Location::GPR(Machine::get_vmctx_reg()), + Machine::get_param_location(0, calling_convention), + ); // vmctx + + if stack_padding > 0 { + self.assembler.emit_sub( + Size::S64, + Location::Imm32(stack_padding as u32), + Location::GPR(GPR::RSP), + ); + } + + cb(self); + + // Restore stack. + if stack_offset + stack_padding > 0 { + self.assembler.emit_add( + Size::S64, + Location::Imm32((stack_offset + stack_padding) as u32), + Location::GPR(GPR::RSP), + ); + if (stack_offset % 8) != 0 { + return Err(CodegenError { + message: "emit_call_native: Bad restoring stack alignement".to_string(), + }); + } + } + + // Restore XMMs. + if !used_xmms.is_empty() { + for (i, r) in used_xmms.iter().enumerate() { + self.assembler.emit_mov( + Size::S64, + Location::Memory(GPR::RSP, (i * 8) as i32), + Location::XMM(*r), + ); + } + self.assembler.emit_add( + Size::S64, + Location::Imm32((used_xmms.len() * 8) as u32), + Location::GPR(GPR::RSP), + ); + } + + // Restore GPRs. + for r in used_gprs.iter().rev() { + self.assembler.emit_pop(Size::S64, Location::GPR(*r)); + } + + Ok(()) + } + + /// Emits a System V call sequence, specialized for labels as the call target. + fn _emit_call_native_label>( + &mut self, + label: DynamicLabel, + params: I, + ) -> Result<(), CodegenError> { + self.emit_call_native(|this| this.assembler.emit_call_label(label), params)?; + Ok(()) + } + + /// Emits a memory operation. + fn emit_memory_op Result<(), CodegenError>>( + &mut self, + addr: Location, + memarg: &MemArg, + check_alignment: bool, + value_size: usize, + cb: F, + ) -> Result<(), CodegenError> { + let need_check = true; + let tmp_addr = self.machine.acquire_temp_gpr().unwrap(); + + // Reusing `tmp_addr` for temporary indirection here, since it's not used before the last reference to `{base,bound}_loc`. + let (base_loc, bound_loc) = if self.module.import_counts.memories != 0 { + // Imported memories require one level of indirection. + let offset = self + .vmoffsets + .vmctx_vmmemory_import_definition(MemoryIndex::new(0)); + self.emit_relaxed_binop( + Assembler::emit_mov, + Size::S64, + Location::Memory(Machine::get_vmctx_reg(), offset as i32), + Location::GPR(tmp_addr), + ); + (Location::Memory(tmp_addr, 0), Location::Memory(tmp_addr, 8)) + } else { + let offset = self + .vmoffsets + .vmctx_vmmemory_definition(LocalMemoryIndex::new(0)); + ( + Location::Memory(Machine::get_vmctx_reg(), offset as i32), + Location::Memory(Machine::get_vmctx_reg(), (offset + 8) as i32), + ) + }; + + let tmp_base = self.machine.acquire_temp_gpr().unwrap(); + let tmp_bound = self.machine.acquire_temp_gpr().unwrap(); + + // Load base into temporary register. + self.assembler + .emit_mov(Size::S64, base_loc, Location::GPR(tmp_base)); + + // Load bound into temporary register, if needed. + if need_check { + self.assembler + .emit_mov(Size::S64, bound_loc, Location::GPR(tmp_bound)); + + // Wasm -> Effective. + // Assuming we never underflow - should always be true on Linux/macOS and Windows >=8, + // since the first page from 0x0 to 0x1000 is not accepted by mmap. + + // This `lea` calculates the upper bound allowed for the beginning of the word. + // Since the upper bound of the memory is (exclusively) `tmp_bound + tmp_base`, + // the maximum allowed beginning of word is (inclusively) + // `tmp_bound + tmp_base - value_size`. + self.assembler.emit_lea( + Size::S64, + Location::MemoryAddTriple(tmp_bound, tmp_base, -(value_size as i32)), + Location::GPR(tmp_bound), + ); + } + + // Load effective address. + // `base_loc` and `bound_loc` becomes INVALID after this line, because `tmp_addr` + // might be reused. + self.assembler + .emit_mov(Size::S32, addr, Location::GPR(tmp_addr)); + + // Add offset to memory address. + if memarg.offset != 0 { + self.assembler.emit_add( + Size::S32, + Location::Imm32(u32::try_from(memarg.offset).unwrap()), // we don’t support 64-bit memory, and this module was validated + Location::GPR(tmp_addr), + ); + + // Trap if offset calculation overflowed. + self.assembler + .emit_jmp(Condition::Carry, self.special_labels.heap_access_oob); + } + + // Wasm linear memory -> real memory + self.assembler + .emit_add(Size::S64, Location::GPR(tmp_base), Location::GPR(tmp_addr)); + + if need_check { + // Trap if the end address of the requested area is above that of the linear memory. + self.assembler + .emit_cmp(Size::S64, Location::GPR(tmp_bound), Location::GPR(tmp_addr)); + + // `tmp_bound` is inclusive. So trap only if `tmp_addr > tmp_bound`. + self.assembler + .emit_jmp(Condition::Above, self.special_labels.heap_access_oob); + } + + self.machine.release_temp_gpr(tmp_bound); + self.machine.release_temp_gpr(tmp_base); + + let align = memarg.align; + if check_alignment && align != 1 { + let tmp_aligncheck = self.machine.acquire_temp_gpr().unwrap(); + self.assembler.emit_mov( + Size::S32, + Location::GPR(tmp_addr), + Location::GPR(tmp_aligncheck), + ); + self.assembler.emit_and( + Size::S64, + Location::Imm32((align - 1).into()), + Location::GPR(tmp_aligncheck), + ); + self.assembler + .emit_jmp(Condition::NotEqual, self.special_labels.heap_access_oob); + self.machine.release_temp_gpr(tmp_aligncheck); + } + + cb(self, tmp_addr).unwrap(); + + self.machine.release_temp_gpr(tmp_addr); + Ok(()) + } + + /// Emits a memory operation. + fn emit_compare_and_swap( + &mut self, + loc: Location, + target: Location, + ret: Location, + memarg: &MemArg, + value_size: usize, + memory_sz: Size, + stack_sz: Size, + cb: F, + ) -> Result<(), CodegenError> { + if memory_sz > stack_sz { + return Err(CodegenError { + message: "emit_compare_and_swap: memory size > stack size".to_string(), + }); + } + + let compare = self.machine.reserve_unused_temp_gpr(GPR::RAX); + let value = if loc == Location::GPR(GPR::R14) { + GPR::R13 + } else { + GPR::R14 + }; + self.assembler.emit_push(Size::S64, Location::GPR(value)); + + self.assembler.emit_mov(stack_sz, loc, Location::GPR(value)); + + let retry = self.assembler.get_label(); + self.assembler.emit_label(retry); + + self.emit_memory_op(target, memarg, true, value_size, |this, addr| { + // Memory moves with size < 32b do not zero upper bits. + if memory_sz < Size::S32 { + this.assembler + .emit_xor(Size::S32, Location::GPR(compare), Location::GPR(compare)); + } + this.assembler + .emit_mov(memory_sz, Location::Memory(addr, 0), Location::GPR(compare)); + this.assembler + .emit_mov(stack_sz, Location::GPR(compare), ret); + cb(this, compare, value); + this.assembler.emit_lock_cmpxchg( + memory_sz, + Location::GPR(value), + Location::Memory(addr, 0), + ); + Ok(()) + })?; + + self.assembler.emit_jmp(Condition::NotEqual, retry); + + self.assembler.emit_pop(Size::S64, Location::GPR(value)); + self.machine.release_temp_gpr(compare); + Ok(()) + } + + // Checks for underflow/overflow/nan. + fn emit_f32_int_conv_check( + &mut self, + reg: XMM, + lower_bound: f32, + upper_bound: f32, + underflow_label: ::Label, + overflow_label: ::Label, + nan_label: ::Label, + succeed_label: ::Label, + ) { + let lower_bound = f32::to_bits(lower_bound); + let upper_bound = f32::to_bits(upper_bound); + + let tmp = self.machine.acquire_temp_gpr().unwrap(); + let tmp_x = self.machine.acquire_temp_xmm().unwrap(); + + // Underflow. + self.assembler + .emit_mov(Size::S32, Location::Imm32(lower_bound), Location::GPR(tmp)); + self.assembler + .emit_mov(Size::S32, Location::GPR(tmp), Location::XMM(tmp_x)); + self.assembler + .emit_vcmpless(reg, XMMOrMemory::XMM(tmp_x), tmp_x); + self.assembler + .emit_mov(Size::S32, Location::XMM(tmp_x), Location::GPR(tmp)); + self.assembler + .emit_cmp(Size::S32, Location::Imm32(0), Location::GPR(tmp)); + self.assembler + .emit_jmp(Condition::NotEqual, underflow_label); + + // Overflow. + self.assembler + .emit_mov(Size::S32, Location::Imm32(upper_bound), Location::GPR(tmp)); + self.assembler + .emit_mov(Size::S32, Location::GPR(tmp), Location::XMM(tmp_x)); + self.assembler + .emit_vcmpgess(reg, XMMOrMemory::XMM(tmp_x), tmp_x); + self.assembler + .emit_mov(Size::S32, Location::XMM(tmp_x), Location::GPR(tmp)); + self.assembler + .emit_cmp(Size::S32, Location::Imm32(0), Location::GPR(tmp)); + self.assembler.emit_jmp(Condition::NotEqual, overflow_label); + + // NaN. + self.assembler + .emit_vcmpeqss(reg, XMMOrMemory::XMM(reg), tmp_x); + self.assembler + .emit_mov(Size::S32, Location::XMM(tmp_x), Location::GPR(tmp)); + self.assembler + .emit_cmp(Size::S32, Location::Imm32(0), Location::GPR(tmp)); + self.assembler.emit_jmp(Condition::Equal, nan_label); + + self.assembler.emit_jmp(Condition::None, succeed_label); + + self.machine.release_temp_xmm(tmp_x); + self.machine.release_temp_gpr(tmp); + } + + // Checks for underflow/overflow/nan before IxxTrunc{U/S}F32. + fn emit_f32_int_conv_check_trap(&mut self, reg: XMM, lower_bound: f32, upper_bound: f32) { + let trap_overflow = self.special_labels.integer_overflow; + let trap_badconv = self.special_labels.bad_conversion_to_integer; + let end = self.assembler.get_label(); + + self.emit_f32_int_conv_check( + reg, + lower_bound, + upper_bound, + trap_overflow, + trap_overflow, + trap_badconv, + end, + ); + + self.assembler.emit_label(end); + } + + fn emit_f32_int_conv_check_sat< + F1: FnOnce(&mut Self), + F2: FnOnce(&mut Self), + F3: FnOnce(&mut Self), + F4: FnOnce(&mut Self), + >( + &mut self, + reg: XMM, + lower_bound: f32, + upper_bound: f32, + underflow_cb: F1, + overflow_cb: F2, + nan_cb: Option, + convert_cb: F4, + ) { + // As an optimization nan_cb is optional, and when set to None we turn + // use 'underflow' as the 'nan' label. This is useful for callers who + // set the return value to zero for both underflow and nan. + + let underflow = self.assembler.get_label(); + let overflow = self.assembler.get_label(); + let nan = if nan_cb.is_some() { + self.assembler.get_label() + } else { + underflow + }; + let convert = self.assembler.get_label(); + let end = self.assembler.get_label(); + + self.emit_f32_int_conv_check( + reg, + lower_bound, + upper_bound, + underflow, + overflow, + nan, + convert, + ); + + self.assembler.emit_label(underflow); + underflow_cb(self); + self.assembler.emit_jmp(Condition::None, end); + + self.assembler.emit_label(overflow); + overflow_cb(self); + self.assembler.emit_jmp(Condition::None, end); + + if let Some(cb) = nan_cb { + self.assembler.emit_label(nan); + cb(self); + self.assembler.emit_jmp(Condition::None, end); + } + + self.assembler.emit_label(convert); + convert_cb(self); + self.assembler.emit_label(end); + } + + // Checks for underflow/overflow/nan. + fn emit_f64_int_conv_check( + &mut self, + reg: XMM, + lower_bound: f64, + upper_bound: f64, + underflow_label: ::Label, + overflow_label: ::Label, + nan_label: ::Label, + succeed_label: ::Label, + ) { + let lower_bound = f64::to_bits(lower_bound); + let upper_bound = f64::to_bits(upper_bound); + + let tmp = self.machine.acquire_temp_gpr().unwrap(); + let tmp_x = self.machine.acquire_temp_xmm().unwrap(); + + // Underflow. + self.assembler + .emit_mov(Size::S64, Location::Imm64(lower_bound), Location::GPR(tmp)); + self.assembler + .emit_mov(Size::S64, Location::GPR(tmp), Location::XMM(tmp_x)); + self.assembler + .emit_vcmplesd(reg, XMMOrMemory::XMM(tmp_x), tmp_x); + self.assembler + .emit_mov(Size::S32, Location::XMM(tmp_x), Location::GPR(tmp)); + self.assembler + .emit_cmp(Size::S32, Location::Imm32(0), Location::GPR(tmp)); + self.assembler + .emit_jmp(Condition::NotEqual, underflow_label); + + // Overflow. + self.assembler + .emit_mov(Size::S64, Location::Imm64(upper_bound), Location::GPR(tmp)); + self.assembler + .emit_mov(Size::S64, Location::GPR(tmp), Location::XMM(tmp_x)); + self.assembler + .emit_vcmpgesd(reg, XMMOrMemory::XMM(tmp_x), tmp_x); + self.assembler + .emit_mov(Size::S32, Location::XMM(tmp_x), Location::GPR(tmp)); + self.assembler + .emit_cmp(Size::S32, Location::Imm32(0), Location::GPR(tmp)); + self.assembler.emit_jmp(Condition::NotEqual, overflow_label); + + // NaN. + self.assembler + .emit_vcmpeqsd(reg, XMMOrMemory::XMM(reg), tmp_x); + self.assembler + .emit_mov(Size::S32, Location::XMM(tmp_x), Location::GPR(tmp)); + self.assembler + .emit_cmp(Size::S32, Location::Imm32(0), Location::GPR(tmp)); + self.assembler.emit_jmp(Condition::Equal, nan_label); + + self.assembler.emit_jmp(Condition::None, succeed_label); + + self.machine.release_temp_xmm(tmp_x); + self.machine.release_temp_gpr(tmp); + } + + // Checks for underflow/overflow/nan before IxxTrunc{U/S}F64. + fn emit_f64_int_conv_check_trap(&mut self, reg: XMM, lower_bound: f64, upper_bound: f64) { + let trap_overflow = self.special_labels.integer_overflow; + let trap_badconv = self.special_labels.bad_conversion_to_integer; + let end = self.assembler.get_label(); + + self.emit_f64_int_conv_check( + reg, + lower_bound, + upper_bound, + trap_overflow, + trap_overflow, + trap_badconv, + end, + ); + + self.assembler.emit_label(end); + } + + fn emit_f64_int_conv_check_sat< + F1: FnOnce(&mut Self), + F2: FnOnce(&mut Self), + F3: FnOnce(&mut Self), + F4: FnOnce(&mut Self), + >( + &mut self, + reg: XMM, + lower_bound: f64, + upper_bound: f64, + underflow_cb: F1, + overflow_cb: F2, + nan_cb: Option, + convert_cb: F4, + ) { + // As an optimization nan_cb is optional, and when set to None we turn + // use 'underflow' as the 'nan' label. This is useful for callers who + // set the return value to zero for both underflow and nan. + + let underflow = self.assembler.get_label(); + let overflow = self.assembler.get_label(); + let nan = if nan_cb.is_some() { + self.assembler.get_label() + } else { + underflow + }; + let convert = self.assembler.get_label(); + let end = self.assembler.get_label(); + + self.emit_f64_int_conv_check( + reg, + lower_bound, + upper_bound, + underflow, + overflow, + nan, + convert, + ); + + self.assembler.emit_label(underflow); + underflow_cb(self); + self.assembler.emit_jmp(Condition::None, end); + + self.assembler.emit_label(overflow); + overflow_cb(self); + self.assembler.emit_jmp(Condition::None, end); + + if let Some(cb) = nan_cb { + self.assembler.emit_label(nan); + cb(self); + self.assembler.emit_jmp(Condition::None, end); + } + + self.assembler.emit_label(convert); + convert_cb(self); + self.assembler.emit_label(end); + } + + pub(crate) fn emit_head(&mut self) -> Result<(), CodegenError> { + // TODO: Patchpoint is not emitted for now, and ARM trampoline is not prepended. + + // Normal x86 entry prologue. + self.assembler.emit_push(Size::S64, Location::GPR(GPR::RBP)); + self.assembler + .emit_mov(Size::S64, Location::GPR(GPR::RSP), Location::GPR(GPR::RBP)); + + // Setup the registers (incl. defining the vmctx register) + let local_count = self.local_count(); + self.machine.setup_registers( + &mut self.assembler, + local_count, + self.signature.params().len() as u32, + self.calling_convention, + ); + + // Verify stack height + self.assembler.emit_sub( + Size::S32, + Location::Imm32(self.stack_size), + Location::Memory( + Machine::get_vmctx_reg(), + self.vmoffsets.vmctx_stack_limit_begin() as i32, + ), + ); + self.assembler + .emit_jmp(Condition::Carry, self.special_labels.stack_overflow); + + // Charge for the stack initialization + self.emit_gas_const(self.stack_init_gas_cost); + + // Initialize the locals + let local_count = self.local_count(); + self.machine.init_locals( + &mut self.assembler, + local_count, + self.signature.params().len() as u32, + self.calling_convention, + ); + + self.assembler + .emit_sub(Size::S64, Location::Imm32(32), Location::GPR(GPR::RSP)); // simulate "red zone" if not supported by the platform + + self.control_stack.push(ControlFrame { + br_label: self.assembler.get_label(), + loop_like: false, + if_else: IfElseState::None, + returns: self + .signature + .results() + .iter() + .map(|&x| type_to_wp_type(x)) + .collect(), + value_stack_depth: 0, + fp_stack_depth: 0, + }); + + Ok(()) + } + + /// Pushes the instruction to the address map, calculating the offset from a + /// provided beginning address. + fn mark_instruction_address_end(&mut self, begin: usize) { + self.instructions_address_map.push(InstructionAddressMap { + srcloc: SourceLoc::new(self.src_loc), + code_offset: begin, + code_len: self.assembler.get_offset().0 - begin, + }); + } + + #[tracing::instrument(skip_all)] + pub(crate) fn new( + module: &'a ModuleInfo, + module_translation_state: &'a ModuleTranslationState, + config: &'a Singlepass, + target: &'a Target, + vmoffsets: &'a VMOffsets, + _table_styles: &'a PrimaryMap, + local_func_index: LocalFunctionIndex, + calling_convention: CallingConvention, + stack_init_gas_cost: u64, + gas_offsets: &'a [usize], + gas_costs: &'a [u64], + _gas_kinds: &'a [InstrumentationKind], + stack_size: u64, + ) -> Result, CodegenError> { + let func_index = module.func_index(local_func_index); + let sig_index = module.functions[func_index]; + let signature = module.signatures[sig_index].clone(); + + let mut assembler = Assembler::new(0); + let special_labels = SpecialLabelSet { + integer_division_by_zero: assembler.get_label(), + integer_overflow: assembler.get_label(), + bad_conversion_to_integer: assembler.get_label(), + heap_access_oob: assembler.get_label(), + table_access_oob: assembler.get_label(), + indirect_call_null: assembler.get_label(), + bad_signature: assembler.get_label(), + gas_limit_exceeded: assembler.get_label(), + stack_overflow: assembler.get_label(), + }; + + let mut fg = FuncGen { + module, + module_translation_state, + config, + target, + vmoffsets, + local_types: wasmer_types::partial_sum_map::PartialSumMap::new(), + assembler, + value_stack: vec![], + fp_stack: vec![], + control_stack: vec![], + machine: Machine::new(), + unreachable_depth: 0, + relocations: vec![], + special_labels, + src_loc: 0, + instructions_address_map: vec![], + calling_convention, + signature, + stack_init_gas_cost, + gas_iter: gas_offsets.iter().zip(gas_costs.iter()).peekable(), + stack_size: u32::try_from(stack_size).map_err(|_| CodegenError { + message: "one function has a stack more than u32::MAX deep".to_string(), + })?, + }; + for param in module.signatures[sig_index].params() { + fg.feed_local(1, type_to_wp_type(*param)); + } + Ok(fg) + } + + pub(crate) fn has_control_frames(&self) -> bool { + !self.control_stack.is_empty() + } + + /// Introduce additional local variables to this function. + /// + /// Calling this after [`emit_head`](Self::emit_head) has been invoked is non-sensical. + pub(crate) fn feed_local(&mut self, local_count: u32, local_type: WpType) { + // FIXME: somehow verify that we haven't invoked `emit_head` yet? Doing so could lead us to + // generate code that accesses the stack buffer out of bounds. + self.local_types + .push(local_count, local_type) + .expect("module cannot have more than u32::MAX locals"); + } + + /// Total number of locals and arguments so far. + /// + /// More can be introduced with the [`feed_local`](Self::feed_local) method. + pub(crate) fn local_count(&self) -> u32 { + *self.local_types.size() + } + + /// Obtain the type of the local or argument at the specified index. + /// + /// # Panics + /// + /// Note that this will panic if `index` is out of bounds, which can happen if an + /// implementation error has occurred or if the WASM module hasn't been validated to conform to + /// the web assembly specification. + pub(crate) fn local_type(&self, index: u32) -> WpType { + *self + .local_types + .find(index) + .expect("local index out of bounds") + } + + /// Consume offset self.src_loc, return Some(cost) iff there must be an instrumentation point here + fn consume_gas_offset(&mut self /*, should_be_unreachable: bool */) -> Option { + if let Some(&(&offset, &cost /* (&cost, &kind) */)) = self.gas_iter.peek() { + if offset == self.src_loc as usize { + // assert!(matches!(kind, InstrumentationKind::Unreachable) == should_be_unreachable, "gas computation results are not of the expected reachability: kind is {:?}, expected reachability is {:?}", kind, !should_be_unreachable); + self.gas_iter.next().unwrap(); + return Some(cost); + } + } + None + } + + #[tracing::instrument(skip(self))] + pub(crate) fn feed_operator(&mut self, op: Operator) -> Result<(), CodegenError> { + assert!(self.fp_stack.len() <= self.value_stack.len()); + + let was_unreachable = self.unreachable_depth > 0; + + if was_unreachable { + match op { + Operator::Block { .. } | Operator::Loop { .. } | Operator::If { .. } => { + self.unreachable_depth += 1; + } + Operator::End => { + self.unreachable_depth -= 1; + } + Operator::Else => { + // We are in a reachable true branch + if self.unreachable_depth == 1 { + if let Some(IfElseState::If(_)) = + self.control_stack.last().map(|x| x.if_else) + { + self.unreachable_depth -= 1; + } + } + } + _ => {} + } + if self.unreachable_depth > 0 { + self.consume_gas_offset(/* true */); // do not instrument unreachable code + return Ok(()); + } + } + + if let Some(cost) = self.consume_gas_offset(/* false */) { + self.emit_gas_const(cost); + } + + match op { + Operator::GlobalGet { global_index } => { + let global_index = GlobalIndex::from_u32(global_index); + + let ty = type_to_wp_type(self.module.globals[global_index].ty); + if ty.is_float() { + self.fp_stack.push(FloatValue::new(self.value_stack.len())); + } + let loc = self + .machine + .acquire_locations(&mut self.assembler, &[(ty)], false)[0]; + self.value_stack.push(loc); + + let tmp = self.machine.acquire_temp_gpr().unwrap(); + + let src = if let Some(local_global_index) = + self.module.local_global_index(global_index) + { + let offset = self.vmoffsets.vmctx_vmglobal_definition(local_global_index); + self.emit_relaxed_binop( + Assembler::emit_mov, + Size::S64, + Location::Memory(Machine::get_vmctx_reg(), offset as i32), + Location::GPR(tmp), + ); + Location::Memory(tmp, 0) + } else { + // Imported globals require one level of indirection. + let offset = self + .vmoffsets + .vmctx_vmglobal_import_definition(global_index); + self.emit_relaxed_binop( + Assembler::emit_mov, + Size::S64, + Location::Memory(Machine::get_vmctx_reg(), offset as i32), + Location::GPR(tmp), + ); + Location::Memory(tmp, 0) + }; + + self.emit_relaxed_binop(Assembler::emit_mov, Size::S64, src, loc); + + self.machine.release_temp_gpr(tmp); + } + Operator::GlobalSet { global_index } => { + let global_index = GlobalIndex::from_u32(global_index); + let tmp = self.machine.acquire_temp_gpr().unwrap(); + let dst = if let Some(local_global_index) = + self.module.local_global_index(global_index) + { + let offset = self.vmoffsets.vmctx_vmglobal_definition(local_global_index); + self.emit_relaxed_binop( + Assembler::emit_mov, + Size::S64, + Location::Memory(Machine::get_vmctx_reg(), offset as i32), + Location::GPR(tmp), + ); + Location::Memory(tmp, 0) + } else { + // Imported globals require one level of indirection. + let offset = self + .vmoffsets + .vmctx_vmglobal_import_definition(global_index); + self.emit_relaxed_binop( + Assembler::emit_mov, + Size::S64, + Location::Memory(Machine::get_vmctx_reg(), offset as i32), + Location::GPR(tmp), + ); + Location::Memory(tmp, 0) + }; + let ty = type_to_wp_type(self.module.globals[global_index].ty); + let loc = self.pop_value_released(); + if ty.is_float() { + let fp = self.fp_stack.pop1()?; + if self.assembler.arch_supports_canonicalize_nan() + && self.config.enable_nan_canonicalization + && fp.canonicalization.is_some() + { + self.canonicalize_nan( + match ty { + WpType::F32 => Size::S32, + WpType::F64 => Size::S64, + _ => unreachable!(), + }, + loc, + dst, + ); + } else { + self.emit_relaxed_binop(Assembler::emit_mov, Size::S64, loc, dst); + } + } else { + self.emit_relaxed_binop(Assembler::emit_mov, Size::S64, loc, dst); + } + self.machine.release_temp_gpr(tmp); + } + Operator::LocalGet { local_index } => { + let local_type = self.local_type(local_index); + let ret = + self.machine + .acquire_locations(&mut self.assembler, &[(WpType::I64)], false)[0]; + self.emit_relaxed_binop( + Assembler::emit_mov, + Size::S64, + self.machine.get_local_location(local_index), + ret, + ); + self.value_stack.push(ret); + if local_type.is_float() { + self.fp_stack + .push(FloatValue::new(self.value_stack.len() - 1)); + } + } + Operator::LocalSet { local_index } => { + let loc = self.pop_value_released(); + let local_type = self.local_type(local_index); + + if local_type.is_float() { + let fp = self.fp_stack.pop1()?; + if self.assembler.arch_supports_canonicalize_nan() + && self.config.enable_nan_canonicalization + && fp.canonicalization.is_some() + { + self.canonicalize_nan( + match local_type { + WpType::F32 => Size::S32, + WpType::F64 => Size::S64, + _ => unreachable!(), + }, + loc, + self.machine.get_local_location(local_index), + ); + } else { + self.emit_relaxed_binop( + Assembler::emit_mov, + Size::S64, + loc, + self.machine.get_local_location(local_index), + ); + } + } else { + self.emit_relaxed_binop( + Assembler::emit_mov, + Size::S64, + loc, + self.machine.get_local_location(local_index), + ); + } + } + Operator::LocalTee { local_index } => { + let loc = *self.value_stack.last().unwrap(); + let local_type = self.local_type(local_index); + if local_type.is_float() { + let fp = self.fp_stack.peek1()?; + if self.assembler.arch_supports_canonicalize_nan() + && self.config.enable_nan_canonicalization + && fp.canonicalization.is_some() + { + self.canonicalize_nan( + match local_type { + WpType::F32 => Size::S32, + WpType::F64 => Size::S64, + _ => unreachable!(), + }, + loc, + self.machine.get_local_location(local_index), + ); + } else { + self.emit_relaxed_binop( + Assembler::emit_mov, + Size::S64, + loc, + self.machine.get_local_location(local_index), + ); + } + } else { + self.emit_relaxed_binop( + Assembler::emit_mov, + Size::S64, + loc, + self.machine.get_local_location(local_index), + ); + } + } + Operator::I32Const { value } => { + self.value_stack.push(Location::Imm32(value as u32)); + } + Operator::I32Add => self.emit_binop_i32(Assembler::emit_add), + Operator::I32Sub => self.emit_binop_i32(Assembler::emit_sub), + Operator::I32Mul => self.emit_binop_i32(Assembler::emit_imul), + Operator::I32DivU => { + // We assume that RAX and RDX are temporary registers here. + let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::I32); + self.assembler + .emit_mov(Size::S32, loc_a, Location::GPR(GPR::RAX)); + self.assembler.emit_xor( + Size::S32, + Location::GPR(GPR::RDX), + Location::GPR(GPR::RDX), + ); + self.emit_relaxed_xdiv(false, Size::S32, loc_b); + self.assembler + .emit_mov(Size::S32, Location::GPR(GPR::RAX), ret); + } + Operator::I32DivS => { + // We assume that RAX and RDX are temporary registers here. + let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::I32); + self.assembler + .emit_mov(Size::S32, loc_a, Location::GPR(GPR::RAX)); + self.assembler.emit_cdq(); + self.emit_relaxed_xdiv(true, Size::S32, loc_b); + self.assembler + .emit_mov(Size::S32, Location::GPR(GPR::RAX), ret); + } + Operator::I32RemU => { + // We assume that RAX and RDX are temporary registers here. + let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::I32); + self.assembler + .emit_mov(Size::S32, loc_a, Location::GPR(GPR::RAX)); + self.assembler.emit_xor( + Size::S32, + Location::GPR(GPR::RDX), + Location::GPR(GPR::RDX), + ); + self.emit_relaxed_xdiv(false, Size::S32, loc_b); + self.assembler + .emit_mov(Size::S32, Location::GPR(GPR::RDX), ret); + } + Operator::I32RemS => { + // We assume that RAX and RDX are temporary registers here. + let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::I32); + + let normal_path = self.assembler.get_label(); + let end = self.assembler.get_label(); + + self.emit_relaxed_binop( + Assembler::emit_cmp, + Size::S32, + Location::Imm32(0x80000000), + loc_a, + ); + self.assembler.emit_jmp(Condition::NotEqual, normal_path); + self.emit_relaxed_binop( + Assembler::emit_cmp, + Size::S32, + Location::Imm32(0xffffffff), + loc_b, + ); + self.assembler.emit_jmp(Condition::NotEqual, normal_path); + self.assembler.emit_mov(Size::S32, Location::Imm32(0), ret); + self.assembler.emit_jmp(Condition::None, end); + + self.assembler.emit_label(normal_path); + self.assembler + .emit_mov(Size::S32, loc_a, Location::GPR(GPR::RAX)); + self.assembler.emit_cdq(); + self.emit_relaxed_xdiv(true, Size::S32, loc_b); + self.assembler + .emit_mov(Size::S32, Location::GPR(GPR::RDX), ret); + + self.assembler.emit_label(end); + } + Operator::I32And => self.emit_binop_i32(Assembler::emit_and), + Operator::I32Or => self.emit_binop_i32(Assembler::emit_or), + Operator::I32Xor => self.emit_binop_i32(Assembler::emit_xor), + Operator::I32Eq => self.emit_cmpop_i32(Condition::Equal)?, + Operator::I32Ne => self.emit_cmpop_i32(Condition::NotEqual)?, + Operator::I32Eqz => { + self.emit_cmpop_i32_dynamic_b(Condition::Equal, Location::Imm32(0))? + } + Operator::I32Clz => { + let loc = self.pop_value_released(); + let src = match loc { + Location::Imm32(_) | Location::Memory(_, _) => { + let tmp = self.machine.acquire_temp_gpr().unwrap(); + self.assembler.emit_mov(Size::S32, loc, Location::GPR(tmp)); + tmp + } + Location::GPR(reg) => reg, + _ => { + return Err(CodegenError { + message: "I32Clz src: unreachable code".to_string(), + }) + } + }; + + let ret = + self.machine + .acquire_locations(&mut self.assembler, &[(WpType::I32)], false)[0]; + self.value_stack.push(ret); + + let dst = match ret { + Location::Memory(_, _) => self.machine.acquire_temp_gpr().unwrap(), + Location::GPR(reg) => reg, + _ => { + return Err(CodegenError { + message: "I32Clz dst: unreachable code".to_string(), + }) + } + }; + + if self.assembler.arch_has_xzcnt(self.target.cpu_features()) { + self.assembler.arch_emit_lzcnt( + Size::S32, + Location::GPR(src), + Location::GPR(dst), + ); + } else { + let zero_path = self.assembler.get_label(); + let end = self.assembler.get_label(); + + self.assembler.emit_test_gpr_64(src); + self.assembler.emit_jmp(Condition::Equal, zero_path); + self.assembler + .emit_bsr(Size::S32, Location::GPR(src), Location::GPR(dst)); + self.assembler + .emit_xor(Size::S32, Location::Imm32(31), Location::GPR(dst)); + self.assembler.emit_jmp(Condition::None, end); + self.assembler.emit_label(zero_path); + self.assembler + .emit_mov(Size::S32, Location::Imm32(32), Location::GPR(dst)); + self.assembler.emit_label(end); + } + + match loc { + Location::Imm32(_) | Location::Memory(_, _) => { + self.machine.release_temp_gpr(src); + } + _ => {} + }; + if let Location::Memory(_, _) = ret { + self.assembler.emit_mov(Size::S32, Location::GPR(dst), ret); + self.machine.release_temp_gpr(dst); + }; + } + Operator::I32Ctz => { + let loc = self.pop_value_released(); + let src = match loc { + Location::Imm32(_) | Location::Memory(_, _) => { + let tmp = self.machine.acquire_temp_gpr().unwrap(); + self.assembler.emit_mov(Size::S32, loc, Location::GPR(tmp)); + tmp + } + Location::GPR(reg) => reg, + _ => { + return Err(CodegenError { + message: "I32Ctz src: unreachable code".to_string(), + }) + } + }; + + let ret = + self.machine + .acquire_locations(&mut self.assembler, &[(WpType::I32)], false)[0]; + self.value_stack.push(ret); + + let dst = match ret { + Location::Memory(_, _) => self.machine.acquire_temp_gpr().unwrap(), + Location::GPR(reg) => reg, + _ => { + return Err(CodegenError { + message: "I32Ctz dst: unreachable code".to_string(), + }) + } + }; + + if self.assembler.arch_has_xzcnt(self.target.cpu_features()) { + self.assembler.arch_emit_tzcnt( + Size::S32, + Location::GPR(src), + Location::GPR(dst), + ); + } else { + let zero_path = self.assembler.get_label(); + let end = self.assembler.get_label(); + + self.assembler.emit_test_gpr_64(src); + self.assembler.emit_jmp(Condition::Equal, zero_path); + self.assembler + .emit_bsf(Size::S32, Location::GPR(src), Location::GPR(dst)); + self.assembler.emit_jmp(Condition::None, end); + self.assembler.emit_label(zero_path); + self.assembler + .emit_mov(Size::S32, Location::Imm32(32), Location::GPR(dst)); + self.assembler.emit_label(end); + } + + match loc { + Location::Imm32(_) | Location::Memory(_, _) => { + self.machine.release_temp_gpr(src); + } + _ => {} + }; + if let Location::Memory(_, _) = ret { + self.assembler.emit_mov(Size::S32, Location::GPR(dst), ret); + self.machine.release_temp_gpr(dst); + }; + } + Operator::I32Popcnt => self.emit_xcnt_i32(Assembler::emit_popcnt)?, + Operator::I32Shl => self.emit_shift_i32(Assembler::emit_shl), + Operator::I32ShrU => self.emit_shift_i32(Assembler::emit_shr), + Operator::I32ShrS => self.emit_shift_i32(Assembler::emit_sar), + Operator::I32Rotl => self.emit_shift_i32(Assembler::emit_rol), + Operator::I32Rotr => self.emit_shift_i32(Assembler::emit_ror), + Operator::I32LtU => self.emit_cmpop_i32(Condition::Below)?, + Operator::I32LeU => self.emit_cmpop_i32(Condition::BelowEqual)?, + Operator::I32GtU => self.emit_cmpop_i32(Condition::Above)?, + Operator::I32GeU => self.emit_cmpop_i32(Condition::AboveEqual)?, + Operator::I32LtS => { + self.emit_cmpop_i32(Condition::Less)?; + } + Operator::I32LeS => self.emit_cmpop_i32(Condition::LessEqual)?, + Operator::I32GtS => self.emit_cmpop_i32(Condition::Greater)?, + Operator::I32GeS => self.emit_cmpop_i32(Condition::GreaterEqual)?, + Operator::I64Const { value } => { + let value = value as u64; + self.value_stack.push(Location::Imm64(value)); + } + Operator::I64Add => self.emit_binop_i64(Assembler::emit_add), + Operator::I64Sub => self.emit_binop_i64(Assembler::emit_sub), + Operator::I64Mul => self.emit_binop_i64(Assembler::emit_imul), + Operator::I64DivU => { + // We assume that RAX and RDX are temporary registers here. + let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::I64); + self.assembler + .emit_mov(Size::S64, loc_a, Location::GPR(GPR::RAX)); + self.assembler.emit_xor( + Size::S64, + Location::GPR(GPR::RDX), + Location::GPR(GPR::RDX), + ); + self.emit_relaxed_xdiv(false, Size::S64, loc_b); + self.assembler + .emit_mov(Size::S64, Location::GPR(GPR::RAX), ret); + } + Operator::I64DivS => { + // We assume that RAX and RDX are temporary registers here. + let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::I64); + self.assembler + .emit_mov(Size::S64, loc_a, Location::GPR(GPR::RAX)); + self.assembler.emit_cqo(); + self.emit_relaxed_xdiv(true, Size::S64, loc_b); + self.assembler + .emit_mov(Size::S64, Location::GPR(GPR::RAX), ret); + } + Operator::I64RemU => { + // We assume that RAX and RDX are temporary registers here. + let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::I64); + self.assembler + .emit_mov(Size::S64, loc_a, Location::GPR(GPR::RAX)); + self.assembler.emit_xor( + Size::S64, + Location::GPR(GPR::RDX), + Location::GPR(GPR::RDX), + ); + self.emit_relaxed_xdiv(false, Size::S64, loc_b); + self.assembler + .emit_mov(Size::S64, Location::GPR(GPR::RDX), ret); + } + Operator::I64RemS => { + // We assume that RAX and RDX are temporary registers here. + let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::I64); + + let normal_path = self.assembler.get_label(); + let end = self.assembler.get_label(); + + self.emit_relaxed_binop( + Assembler::emit_cmp, + Size::S64, + Location::Imm64(0x8000000000000000u64), + loc_a, + ); + self.assembler.emit_jmp(Condition::NotEqual, normal_path); + self.emit_relaxed_binop( + Assembler::emit_cmp, + Size::S64, + Location::Imm64(0xffffffffffffffffu64), + loc_b, + ); + self.assembler.emit_jmp(Condition::NotEqual, normal_path); + self.emit_relaxed_binop(Assembler::emit_mov, Size::S64, Location::Imm64(0), ret); + self.assembler.emit_jmp(Condition::None, end); + + self.assembler.emit_label(normal_path); + + self.assembler + .emit_mov(Size::S64, loc_a, Location::GPR(GPR::RAX)); + self.assembler.emit_cqo(); + self.emit_relaxed_xdiv(true, Size::S64, loc_b); + self.assembler + .emit_mov(Size::S64, Location::GPR(GPR::RDX), ret); + self.assembler.emit_label(end); + } + Operator::I64And => self.emit_binop_i64(Assembler::emit_and), + Operator::I64Or => self.emit_binop_i64(Assembler::emit_or), + Operator::I64Xor => self.emit_binop_i64(Assembler::emit_xor), + Operator::I64Eq => self.emit_cmpop_i64(Condition::Equal)?, + Operator::I64Ne => self.emit_cmpop_i64(Condition::NotEqual)?, + Operator::I64Eqz => { + self.emit_cmpop_i64_dynamic_b(Condition::Equal, Location::Imm64(0))? + } + Operator::I64Clz => { + let loc = self.pop_value_released(); + let src = match loc { + Location::Imm64(_) | Location::Imm32(_) | Location::Memory(_, _) => { + let tmp = self.machine.acquire_temp_gpr().unwrap(); + self.assembler.emit_mov(Size::S64, loc, Location::GPR(tmp)); + tmp + } + Location::GPR(reg) => reg, + _ => { + return Err(CodegenError { + message: "I64Clz src: unreachable code".to_string(), + }) + } + }; + + let ret = + self.machine + .acquire_locations(&mut self.assembler, &[(WpType::I64)], false)[0]; + self.value_stack.push(ret); + + let dst = match ret { + Location::Memory(_, _) => self.machine.acquire_temp_gpr().unwrap(), + Location::GPR(reg) => reg, + _ => { + return Err(CodegenError { + message: "I64Clz dst: unreachable code".to_string(), + }) + } + }; + + if self.assembler.arch_has_xzcnt(self.target.cpu_features()) { + self.assembler.arch_emit_lzcnt( + Size::S64, + Location::GPR(src), + Location::GPR(dst), + ); + } else { + let zero_path = self.assembler.get_label(); + let end = self.assembler.get_label(); + + self.assembler.emit_test_gpr_64(src); + self.assembler.emit_jmp(Condition::Equal, zero_path); + self.assembler + .emit_bsr(Size::S64, Location::GPR(src), Location::GPR(dst)); + self.assembler + .emit_xor(Size::S64, Location::Imm32(63), Location::GPR(dst)); + self.assembler.emit_jmp(Condition::None, end); + self.assembler.emit_label(zero_path); + self.assembler + .emit_mov(Size::S64, Location::Imm32(64), Location::GPR(dst)); + self.assembler.emit_label(end); + } + + match loc { + Location::Imm64(_) | Location::Imm32(_) | Location::Memory(_, _) => { + self.machine.release_temp_gpr(src); + } + _ => {} + }; + if let Location::Memory(_, _) = ret { + self.assembler.emit_mov(Size::S64, Location::GPR(dst), ret); + self.machine.release_temp_gpr(dst); + }; + } + Operator::I64Ctz => { + let loc = self.pop_value_released(); + let src = match loc { + Location::Imm64(_) | Location::Imm32(_) | Location::Memory(_, _) => { + let tmp = self.machine.acquire_temp_gpr().unwrap(); + self.assembler.emit_mov(Size::S64, loc, Location::GPR(tmp)); + tmp + } + Location::GPR(reg) => reg, + _ => { + return Err(CodegenError { + message: "I64Ctz src: unreachable code".to_string(), + }) + } + }; + + let ret = + self.machine + .acquire_locations(&mut self.assembler, &[(WpType::I64)], false)[0]; + self.value_stack.push(ret); + + let dst = match ret { + Location::Memory(_, _) => self.machine.acquire_temp_gpr().unwrap(), + Location::GPR(reg) => reg, + _ => { + return Err(CodegenError { + message: "I64Ctz dst: unreachable code".to_string(), + }) + } + }; + + if self.assembler.arch_has_xzcnt(self.target.cpu_features()) { + self.assembler.arch_emit_tzcnt( + Size::S64, + Location::GPR(src), + Location::GPR(dst), + ); + } else { + let zero_path = self.assembler.get_label(); + let end = self.assembler.get_label(); + + self.assembler.emit_test_gpr_64(src); + self.assembler.emit_jmp(Condition::Equal, zero_path); + self.assembler + .emit_bsf(Size::S64, Location::GPR(src), Location::GPR(dst)); + self.assembler.emit_jmp(Condition::None, end); + self.assembler.emit_label(zero_path); + self.assembler + .emit_mov(Size::S64, Location::Imm32(64), Location::GPR(dst)); + self.assembler.emit_label(end); + } + + match loc { + Location::Imm64(_) | Location::Imm32(_) | Location::Memory(_, _) => { + self.machine.release_temp_gpr(src); + } + _ => {} + }; + if let Location::Memory(_, _) = ret { + self.assembler.emit_mov(Size::S64, Location::GPR(dst), ret); + self.machine.release_temp_gpr(dst); + }; + } + Operator::I64Popcnt => self.emit_xcnt_i64(Assembler::emit_popcnt)?, + Operator::I64Shl => self.emit_shift_i64(Assembler::emit_shl), + Operator::I64ShrU => self.emit_shift_i64(Assembler::emit_shr), + Operator::I64ShrS => self.emit_shift_i64(Assembler::emit_sar), + Operator::I64Rotl => self.emit_shift_i64(Assembler::emit_rol), + Operator::I64Rotr => self.emit_shift_i64(Assembler::emit_ror), + Operator::I64LtU => self.emit_cmpop_i64(Condition::Below)?, + Operator::I64LeU => self.emit_cmpop_i64(Condition::BelowEqual)?, + Operator::I64GtU => self.emit_cmpop_i64(Condition::Above)?, + Operator::I64GeU => self.emit_cmpop_i64(Condition::AboveEqual)?, + Operator::I64LtS => { + self.emit_cmpop_i64(Condition::Less)?; + } + Operator::I64LeS => self.emit_cmpop_i64(Condition::LessEqual)?, + Operator::I64GtS => self.emit_cmpop_i64(Condition::Greater)?, + Operator::I64GeS => self.emit_cmpop_i64(Condition::GreaterEqual)?, + Operator::I64ExtendI32U => { + let loc = self.pop_value_released(); + let ret = + self.machine + .acquire_locations(&mut self.assembler, &[(WpType::I64)], false)[0]; + self.value_stack.push(ret); + self.emit_relaxed_binop(Assembler::emit_mov, Size::S32, loc, ret); + + // A 32-bit memory write does not automatically clear the upper 32 bits of a 64-bit word. + // So, we need to explicitly write zero to the upper half here. + if let Location::Memory(base, off) = ret { + self.emit_relaxed_binop( + Assembler::emit_mov, + Size::S32, + Location::Imm32(0), + Location::Memory(base, off + 4), + ); + } + } + Operator::I64ExtendI32S => { + let loc = self.pop_value_released(); + let ret = + self.machine + .acquire_locations(&mut self.assembler, &[(WpType::I64)], false)[0]; + self.value_stack.push(ret); + self.emit_relaxed_zx_sx(Assembler::emit_movsx, Size::S32, loc, Size::S64, ret)?; + } + Operator::I32Extend8S => { + let loc = self.pop_value_released(); + let ret = + self.machine + .acquire_locations(&mut self.assembler, &[(WpType::I32)], false)[0]; + self.value_stack.push(ret); + + self.emit_relaxed_zx_sx(Assembler::emit_movsx, Size::S8, loc, Size::S32, ret)?; + } + Operator::I32Extend16S => { + let loc = self.pop_value_released(); + let ret = + self.machine + .acquire_locations(&mut self.assembler, &[(WpType::I32)], false)[0]; + self.value_stack.push(ret); + + self.emit_relaxed_zx_sx(Assembler::emit_movsx, Size::S16, loc, Size::S32, ret)?; + } + Operator::I64Extend8S => { + let loc = self.pop_value_released(); + let ret = + self.machine + .acquire_locations(&mut self.assembler, &[(WpType::I64)], false)[0]; + self.value_stack.push(ret); + + self.emit_relaxed_zx_sx(Assembler::emit_movsx, Size::S8, loc, Size::S64, ret)?; + } + Operator::I64Extend16S => { + let loc = self.pop_value_released(); + let ret = + self.machine + .acquire_locations(&mut self.assembler, &[(WpType::I64)], false)[0]; + self.value_stack.push(ret); + + self.emit_relaxed_zx_sx(Assembler::emit_movsx, Size::S16, loc, Size::S64, ret)?; + } + Operator::I64Extend32S => { + let loc = self.pop_value_released(); + let ret = + self.machine + .acquire_locations(&mut self.assembler, &[(WpType::I64)], false)[0]; + self.value_stack.push(ret); + + self.emit_relaxed_zx_sx(Assembler::emit_movsx, Size::S32, loc, Size::S64, ret)?; + } + Operator::I32WrapI64 => { + let loc = self.pop_value_released(); + let ret = + self.machine + .acquire_locations(&mut self.assembler, &[(WpType::I32)], false)[0]; + self.value_stack.push(ret); + self.emit_relaxed_binop(Assembler::emit_mov, Size::S32, loc, ret); + } + + Operator::F32Const { value } => { + self.value_stack.push(Location::Imm32(value.bits())); + self.fp_stack + .push(FloatValue::new(self.value_stack.len() - 1)); + } + Operator::F32Add => { + self.fp_stack.pop2()?; + self.fp_stack + .push(FloatValue::cncl_f32(self.value_stack.len() - 2)); + self.emit_fp_binop_avx(Assembler::emit_vaddss)?; + } + Operator::F32Sub => { + self.fp_stack.pop2()?; + self.fp_stack + .push(FloatValue::cncl_f32(self.value_stack.len() - 2)); + self.emit_fp_binop_avx(Assembler::emit_vsubss)? + } + Operator::F32Mul => { + self.fp_stack.pop2()?; + self.fp_stack + .push(FloatValue::cncl_f32(self.value_stack.len() - 2)); + self.emit_fp_binop_avx(Assembler::emit_vmulss)? + } + Operator::F32Div => { + self.fp_stack.pop2()?; + self.fp_stack + .push(FloatValue::cncl_f32(self.value_stack.len() - 2)); + self.emit_fp_binop_avx(Assembler::emit_vdivss)? + } + Operator::F32Max => { + self.fp_stack.pop2()?; + self.fp_stack + .push(FloatValue::new(self.value_stack.len() - 2)); + if !self.assembler.arch_supports_canonicalize_nan() { + self.emit_fp_binop_avx(Assembler::emit_vmaxss)?; + } else { + let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::F64); + + let tmp1 = self.machine.acquire_temp_xmm().unwrap(); + let tmp2 = self.machine.acquire_temp_xmm().unwrap(); + let tmpg1 = self.machine.acquire_temp_gpr().unwrap(); + let tmpg2 = self.machine.acquire_temp_gpr().unwrap(); + + let src1 = match loc_a { + Location::XMM(x) => x, + Location::GPR(_) | Location::Memory(_, _) => { + self.assembler + .emit_mov(Size::S64, loc_a, Location::XMM(tmp1)); + tmp1 + } + Location::Imm32(_) => { + self.assembler + .emit_mov(Size::S32, loc_a, Location::GPR(tmpg1)); + self.assembler.emit_mov( + Size::S32, + Location::GPR(tmpg1), + Location::XMM(tmp1), + ); + tmp1 + } + Location::Imm64(_) => { + self.assembler + .emit_mov(Size::S64, loc_a, Location::GPR(tmpg1)); + self.assembler.emit_mov( + Size::S64, + Location::GPR(tmpg1), + Location::XMM(tmp1), + ); + tmp1 + } + _ => { + return Err(CodegenError { + message: "F32Max src1: unreachable code".to_string(), + }) + } + }; + let src2 = match loc_b { + Location::XMM(x) => x, + Location::GPR(_) | Location::Memory(_, _) => { + self.assembler + .emit_mov(Size::S64, loc_b, Location::XMM(tmp2)); + tmp2 + } + Location::Imm32(_) => { + self.assembler + .emit_mov(Size::S32, loc_b, Location::GPR(tmpg1)); + self.assembler.emit_mov( + Size::S32, + Location::GPR(tmpg1), + Location::XMM(tmp2), + ); + tmp2 + } + Location::Imm64(_) => { + self.assembler + .emit_mov(Size::S64, loc_b, Location::GPR(tmpg1)); + self.assembler.emit_mov( + Size::S64, + Location::GPR(tmpg1), + Location::XMM(tmp2), + ); + tmp2 + } + _ => { + return Err(CodegenError { + message: "F32Max src2: unreachable code".to_string(), + }) + } + }; + + let tmp_xmm1 = XMM::XMM8; + let tmp_xmm2 = XMM::XMM9; + let tmp_xmm3 = XMM::XMM10; + + self.assembler + .emit_mov(Size::S32, Location::XMM(src1), Location::GPR(tmpg1)); + self.assembler + .emit_mov(Size::S32, Location::XMM(src2), Location::GPR(tmpg2)); + self.assembler + .emit_cmp(Size::S32, Location::GPR(tmpg2), Location::GPR(tmpg1)); + self.assembler + .emit_vmaxss(src1, XMMOrMemory::XMM(src2), tmp_xmm1); + let label1 = self.assembler.get_label(); + let label2 = self.assembler.get_label(); + self.assembler.emit_jmp(Condition::NotEqual, label1); + self.assembler + .emit_vmovaps(XMMOrMemory::XMM(tmp_xmm1), XMMOrMemory::XMM(tmp_xmm2)); + self.assembler.emit_jmp(Condition::None, label2); + self.assembler.emit_label(label1); + self.assembler + .emit_vxorps(tmp_xmm2, XMMOrMemory::XMM(tmp_xmm2), tmp_xmm2); + self.assembler.emit_label(label2); + self.assembler + .emit_vcmpeqss(src1, XMMOrMemory::XMM(src2), tmp_xmm3); + self.assembler.emit_vblendvps( + tmp_xmm3, + XMMOrMemory::XMM(tmp_xmm2), + tmp_xmm1, + tmp_xmm1, + ); + self.assembler + .emit_vcmpunordss(src1, XMMOrMemory::XMM(src2), src1); + // load float canonical nan + self.assembler.emit_mov( + Size::S64, + Location::Imm32(0x7FC0_0000), // Canonical NaN + Location::GPR(tmpg1), + ); + self.assembler + .emit_mov(Size::S64, Location::GPR(tmpg1), Location::XMM(src2)); + self.assembler + .emit_vblendvps(src1, XMMOrMemory::XMM(src2), tmp_xmm1, src1); + match ret { + Location::XMM(x) => { + self.assembler + .emit_vmovaps(XMMOrMemory::XMM(src1), XMMOrMemory::XMM(x)); + } + Location::Memory(_, _) | Location::GPR(_) => { + self.assembler.emit_mov(Size::S64, Location::XMM(src1), ret); + } + _ => { + return Err(CodegenError { + message: "F32Max ret: unreachable code".to_string(), + }) + } + } + + self.machine.release_temp_gpr(tmpg2); + self.machine.release_temp_gpr(tmpg1); + self.machine.release_temp_xmm(tmp2); + self.machine.release_temp_xmm(tmp1); + } + } + Operator::F32Min => { + self.fp_stack.pop2()?; + self.fp_stack + .push(FloatValue::new(self.value_stack.len() - 2)); + if !self.assembler.arch_supports_canonicalize_nan() { + self.emit_fp_binop_avx(Assembler::emit_vminss)?; + } else { + let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::F64); + + let tmp1 = self.machine.acquire_temp_xmm().unwrap(); + let tmp2 = self.machine.acquire_temp_xmm().unwrap(); + let tmpg1 = self.machine.acquire_temp_gpr().unwrap(); + let tmpg2 = self.machine.acquire_temp_gpr().unwrap(); + + let src1 = match loc_a { + Location::XMM(x) => x, + Location::GPR(_) | Location::Memory(_, _) => { + self.assembler + .emit_mov(Size::S64, loc_a, Location::XMM(tmp1)); + tmp1 + } + Location::Imm32(_) => { + self.assembler + .emit_mov(Size::S32, loc_a, Location::GPR(tmpg1)); + self.assembler.emit_mov( + Size::S32, + Location::GPR(tmpg1), + Location::XMM(tmp1), + ); + tmp1 + } + Location::Imm64(_) => { + self.assembler + .emit_mov(Size::S64, loc_a, Location::GPR(tmpg1)); + self.assembler.emit_mov( + Size::S64, + Location::GPR(tmpg1), + Location::XMM(tmp1), + ); + tmp1 + } + _ => { + return Err(CodegenError { + message: "F32Min src1: unreachable code".to_string(), + }) + } + }; + let src2 = match loc_b { + Location::XMM(x) => x, + Location::GPR(_) | Location::Memory(_, _) => { + self.assembler + .emit_mov(Size::S64, loc_b, Location::XMM(tmp2)); + tmp2 + } + Location::Imm32(_) => { + self.assembler + .emit_mov(Size::S32, loc_b, Location::GPR(tmpg1)); + self.assembler.emit_mov( + Size::S32, + Location::GPR(tmpg1), + Location::XMM(tmp2), + ); + tmp2 + } + Location::Imm64(_) => { + self.assembler + .emit_mov(Size::S64, loc_b, Location::GPR(tmpg1)); + self.assembler.emit_mov( + Size::S64, + Location::GPR(tmpg1), + Location::XMM(tmp2), + ); + tmp2 + } + _ => { + return Err(CodegenError { + message: "F32Min src2: unreachable code".to_string(), + }) + } + }; + + let tmp_xmm1 = XMM::XMM8; + let tmp_xmm2 = XMM::XMM9; + let tmp_xmm3 = XMM::XMM10; + + self.assembler + .emit_mov(Size::S32, Location::XMM(src1), Location::GPR(tmpg1)); + self.assembler + .emit_mov(Size::S32, Location::XMM(src2), Location::GPR(tmpg2)); + self.assembler + .emit_cmp(Size::S32, Location::GPR(tmpg2), Location::GPR(tmpg1)); + self.assembler + .emit_vminss(src1, XMMOrMemory::XMM(src2), tmp_xmm1); + let label1 = self.assembler.get_label(); + let label2 = self.assembler.get_label(); + self.assembler.emit_jmp(Condition::NotEqual, label1); + self.assembler + .emit_vmovaps(XMMOrMemory::XMM(tmp_xmm1), XMMOrMemory::XMM(tmp_xmm2)); + self.assembler.emit_jmp(Condition::None, label2); + self.assembler.emit_label(label1); + // load float -0.0 + self.assembler.emit_mov( + Size::S64, + Location::Imm32(0x8000_0000), // Negative zero + Location::GPR(tmpg1), + ); + self.assembler.emit_mov( + Size::S64, + Location::GPR(tmpg1), + Location::XMM(tmp_xmm2), + ); + self.assembler.emit_label(label2); + self.assembler + .emit_vcmpeqss(src1, XMMOrMemory::XMM(src2), tmp_xmm3); + self.assembler.emit_vblendvps( + tmp_xmm3, + XMMOrMemory::XMM(tmp_xmm2), + tmp_xmm1, + tmp_xmm1, + ); + self.assembler + .emit_vcmpunordss(src1, XMMOrMemory::XMM(src2), src1); + // load float canonical nan + self.assembler.emit_mov( + Size::S64, + Location::Imm32(0x7FC0_0000), // Canonical NaN + Location::GPR(tmpg1), + ); + self.assembler + .emit_mov(Size::S64, Location::GPR(tmpg1), Location::XMM(src2)); + self.assembler + .emit_vblendvps(src1, XMMOrMemory::XMM(src2), tmp_xmm1, src1); + match ret { + Location::XMM(x) => { + self.assembler + .emit_vmovaps(XMMOrMemory::XMM(src1), XMMOrMemory::XMM(x)); + } + Location::Memory(_, _) | Location::GPR(_) => { + self.assembler.emit_mov(Size::S64, Location::XMM(src1), ret); + } + _ => { + return Err(CodegenError { + message: "F32Min ret: unreachable code".to_string(), + }) + } + } + + self.machine.release_temp_gpr(tmpg2); + self.machine.release_temp_gpr(tmpg1); + self.machine.release_temp_xmm(tmp2); + self.machine.release_temp_xmm(tmp1); + } + } + Operator::F32Eq => { + self.fp_stack.pop2()?; + self.emit_fp_cmpop_avx(Assembler::emit_vcmpeqss)? + } + Operator::F32Ne => { + self.fp_stack.pop2()?; + self.emit_fp_cmpop_avx(Assembler::emit_vcmpneqss)? + } + Operator::F32Lt => { + self.fp_stack.pop2()?; + self.emit_fp_cmpop_avx(Assembler::emit_vcmpltss)? + } + Operator::F32Le => { + self.fp_stack.pop2()?; + self.emit_fp_cmpop_avx(Assembler::emit_vcmpless)? + } + Operator::F32Gt => { + self.fp_stack.pop2()?; + self.emit_fp_cmpop_avx(Assembler::emit_vcmpgtss)? + } + Operator::F32Ge => { + self.fp_stack.pop2()?; + self.emit_fp_cmpop_avx(Assembler::emit_vcmpgess)? + } + Operator::F32Nearest => { + self.fp_stack.pop1()?; + self.fp_stack + .push(FloatValue::cncl_f32(self.value_stack.len() - 1)); + self.emit_fp_unop_avx(Assembler::emit_vroundss_nearest)? + } + Operator::F32Floor => { + self.fp_stack.pop1()?; + self.fp_stack + .push(FloatValue::cncl_f32(self.value_stack.len() - 1)); + self.emit_fp_unop_avx(Assembler::emit_vroundss_floor)? + } + Operator::F32Ceil => { + self.fp_stack.pop1()?; + self.fp_stack + .push(FloatValue::cncl_f32(self.value_stack.len() - 1)); + self.emit_fp_unop_avx(Assembler::emit_vroundss_ceil)? + } + Operator::F32Trunc => { + self.fp_stack.pop1()?; + self.fp_stack + .push(FloatValue::cncl_f32(self.value_stack.len() - 1)); + self.emit_fp_unop_avx(Assembler::emit_vroundss_trunc)? + } + Operator::F32Sqrt => { + self.fp_stack.pop1()?; + self.fp_stack + .push(FloatValue::cncl_f32(self.value_stack.len() - 1)); + self.emit_fp_unop_avx(Assembler::emit_vsqrtss)? + } + + Operator::F32Copysign => { + let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::F32); + + let (fp_src1, fp_src2) = self.fp_stack.pop2()?; + self.fp_stack + .push(FloatValue::new(self.value_stack.len() - 1)); + + let tmp1 = self.machine.acquire_temp_gpr().unwrap(); + let tmp2 = self.machine.acquire_temp_gpr().unwrap(); + + if self.assembler.arch_supports_canonicalize_nan() + && self.config.enable_nan_canonicalization + { + for (fp, loc, tmp) in [(fp_src1, loc_a, tmp1), (fp_src2, loc_b, tmp2)].iter() { + match fp.canonicalization { + Some(_) => { + self.canonicalize_nan(Size::S32, *loc, Location::GPR(*tmp)); + } + None => { + self.assembler + .emit_mov(Size::S32, *loc, Location::GPR(*tmp)); + } + } + } + } else { + self.assembler + .emit_mov(Size::S32, loc_a, Location::GPR(tmp1)); + self.assembler + .emit_mov(Size::S32, loc_b, Location::GPR(tmp2)); + } + self.assembler.emit_and( + Size::S32, + Location::Imm32(0x7fffffffu32), + Location::GPR(tmp1), + ); + self.assembler.emit_and( + Size::S32, + Location::Imm32(0x80000000u32), + Location::GPR(tmp2), + ); + self.assembler + .emit_or(Size::S32, Location::GPR(tmp2), Location::GPR(tmp1)); + self.assembler.emit_mov(Size::S32, Location::GPR(tmp1), ret); + self.machine.release_temp_gpr(tmp2); + self.machine.release_temp_gpr(tmp1); + } + + Operator::F32Abs => { + // Preserve canonicalization state. + + let loc = self.pop_value_released(); + let ret = + self.machine + .acquire_locations(&mut self.assembler, &[(WpType::F32)], false)[0]; + self.value_stack.push(ret); + let tmp = self.machine.acquire_temp_gpr().unwrap(); + self.assembler.emit_mov(Size::S32, loc, Location::GPR(tmp)); + self.assembler.emit_and( + Size::S32, + Location::Imm32(0x7fffffffu32), + Location::GPR(tmp), + ); + self.assembler.emit_mov(Size::S32, Location::GPR(tmp), ret); + self.machine.release_temp_gpr(tmp); + } + + Operator::F32Neg => { + // Preserve canonicalization state. + + let loc = self.pop_value_released(); + let ret = + self.machine + .acquire_locations(&mut self.assembler, &[(WpType::F32)], false)[0]; + self.value_stack.push(ret); + + if self.assembler.arch_has_fneg() { + let tmp = self.machine.acquire_temp_xmm().unwrap(); + self.emit_relaxed_binop( + Assembler::emit_mov, + Size::S32, + loc, + Location::XMM(tmp), + ); + self.assembler.arch_emit_f32_neg(tmp, tmp); + self.emit_relaxed_binop( + Assembler::emit_mov, + Size::S32, + Location::XMM(tmp), + ret, + ); + self.machine.release_temp_xmm(tmp); + } else { + let tmp = self.machine.acquire_temp_gpr().unwrap(); + self.assembler.emit_mov(Size::S32, loc, Location::GPR(tmp)); + self.assembler.emit_btc_gpr_imm8_32(31, tmp); + self.assembler.emit_mov(Size::S32, Location::GPR(tmp), ret); + self.machine.release_temp_gpr(tmp); + } + } + + Operator::F64Const { value } => { + self.value_stack.push(Location::Imm64(value.bits())); + self.fp_stack + .push(FloatValue::new(self.value_stack.len() - 1)); + } + Operator::F64Add => { + self.fp_stack.pop2()?; + self.fp_stack + .push(FloatValue::cncl_f64(self.value_stack.len() - 2)); + self.emit_fp_binop_avx(Assembler::emit_vaddsd)? + } + Operator::F64Sub => { + self.fp_stack.pop2()?; + self.fp_stack + .push(FloatValue::cncl_f64(self.value_stack.len() - 2)); + self.emit_fp_binop_avx(Assembler::emit_vsubsd)? + } + Operator::F64Mul => { + self.fp_stack.pop2()?; + self.fp_stack + .push(FloatValue::cncl_f64(self.value_stack.len() - 2)); + self.emit_fp_binop_avx(Assembler::emit_vmulsd)? + } + Operator::F64Div => { + self.fp_stack.pop2()?; + self.fp_stack + .push(FloatValue::cncl_f64(self.value_stack.len() - 2)); + self.emit_fp_binop_avx(Assembler::emit_vdivsd)? + } + Operator::F64Max => { + self.fp_stack.pop2()?; + self.fp_stack + .push(FloatValue::new(self.value_stack.len() - 2)); + + if !self.assembler.arch_supports_canonicalize_nan() { + self.emit_fp_binop_avx(Assembler::emit_vmaxsd)?; + } else { + let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::F64); + + let tmp1 = self.machine.acquire_temp_xmm().unwrap(); + let tmp2 = self.machine.acquire_temp_xmm().unwrap(); + let tmpg1 = self.machine.acquire_temp_gpr().unwrap(); + let tmpg2 = self.machine.acquire_temp_gpr().unwrap(); + + let src1 = match loc_a { + Location::XMM(x) => x, + Location::GPR(_) | Location::Memory(_, _) => { + self.assembler + .emit_mov(Size::S64, loc_a, Location::XMM(tmp1)); + tmp1 + } + Location::Imm32(_) => { + self.assembler + .emit_mov(Size::S32, loc_a, Location::GPR(tmpg1)); + self.assembler.emit_mov( + Size::S32, + Location::GPR(tmpg1), + Location::XMM(tmp1), + ); + tmp1 + } + Location::Imm64(_) => { + self.assembler + .emit_mov(Size::S64, loc_a, Location::GPR(tmpg1)); + self.assembler.emit_mov( + Size::S64, + Location::GPR(tmpg1), + Location::XMM(tmp1), + ); + tmp1 + } + _ => { + return Err(CodegenError { + message: "F64Max src1: unreachable code".to_string(), + }) + } + }; + let src2 = match loc_b { + Location::XMM(x) => x, + Location::GPR(_) | Location::Memory(_, _) => { + self.assembler + .emit_mov(Size::S64, loc_b, Location::XMM(tmp2)); + tmp2 + } + Location::Imm32(_) => { + self.assembler + .emit_mov(Size::S32, loc_b, Location::GPR(tmpg1)); + self.assembler.emit_mov( + Size::S32, + Location::GPR(tmpg1), + Location::XMM(tmp2), + ); + tmp2 + } + Location::Imm64(_) => { + self.assembler + .emit_mov(Size::S64, loc_b, Location::GPR(tmpg1)); + self.assembler.emit_mov( + Size::S64, + Location::GPR(tmpg1), + Location::XMM(tmp2), + ); + tmp2 + } + _ => { + return Err(CodegenError { + message: "F64Max src2: unreachable code".to_string(), + }) + } + }; + + let tmp_xmm1 = XMM::XMM8; + let tmp_xmm2 = XMM::XMM9; + let tmp_xmm3 = XMM::XMM10; + + self.assembler + .emit_mov(Size::S64, Location::XMM(src1), Location::GPR(tmpg1)); + self.assembler + .emit_mov(Size::S64, Location::XMM(src2), Location::GPR(tmpg2)); + self.assembler + .emit_cmp(Size::S64, Location::GPR(tmpg2), Location::GPR(tmpg1)); + self.assembler + .emit_vmaxsd(src1, XMMOrMemory::XMM(src2), tmp_xmm1); + let label1 = self.assembler.get_label(); + let label2 = self.assembler.get_label(); + self.assembler.emit_jmp(Condition::NotEqual, label1); + self.assembler + .emit_vmovapd(XMMOrMemory::XMM(tmp_xmm1), XMMOrMemory::XMM(tmp_xmm2)); + self.assembler.emit_jmp(Condition::None, label2); + self.assembler.emit_label(label1); + self.assembler + .emit_vxorpd(tmp_xmm2, XMMOrMemory::XMM(tmp_xmm2), tmp_xmm2); + self.assembler.emit_label(label2); + self.assembler + .emit_vcmpeqsd(src1, XMMOrMemory::XMM(src2), tmp_xmm3); + self.assembler.emit_vblendvpd( + tmp_xmm3, + XMMOrMemory::XMM(tmp_xmm2), + tmp_xmm1, + tmp_xmm1, + ); + self.assembler + .emit_vcmpunordsd(src1, XMMOrMemory::XMM(src2), src1); + // load float canonical nan + self.assembler.emit_mov( + Size::S64, + Location::Imm64(0x7FF8_0000_0000_0000), // Canonical NaN + Location::GPR(tmpg1), + ); + self.assembler + .emit_mov(Size::S64, Location::GPR(tmpg1), Location::XMM(src2)); + self.assembler + .emit_vblendvpd(src1, XMMOrMemory::XMM(src2), tmp_xmm1, src1); + match ret { + Location::XMM(x) => { + self.assembler + .emit_vmovapd(XMMOrMemory::XMM(src1), XMMOrMemory::XMM(x)); + } + Location::Memory(_, _) | Location::GPR(_) => { + self.assembler.emit_mov(Size::S64, Location::XMM(src1), ret); + } + _ => { + return Err(CodegenError { + message: "F64Max ret: unreachable code".to_string(), + }) + } + } + + self.machine.release_temp_gpr(tmpg2); + self.machine.release_temp_gpr(tmpg1); + self.machine.release_temp_xmm(tmp2); + self.machine.release_temp_xmm(tmp1); + } + } + Operator::F64Min => { + self.fp_stack.pop2()?; + self.fp_stack + .push(FloatValue::new(self.value_stack.len() - 2)); + + if !self.assembler.arch_supports_canonicalize_nan() { + self.emit_fp_binop_avx(Assembler::emit_vminsd)?; + } else { + let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::F64); + + let tmp1 = self.machine.acquire_temp_xmm().unwrap(); + let tmp2 = self.machine.acquire_temp_xmm().unwrap(); + let tmpg1 = self.machine.acquire_temp_gpr().unwrap(); + let tmpg2 = self.machine.acquire_temp_gpr().unwrap(); + + let src1 = match loc_a { + Location::XMM(x) => x, + Location::GPR(_) | Location::Memory(_, _) => { + self.assembler + .emit_mov(Size::S64, loc_a, Location::XMM(tmp1)); + tmp1 + } + Location::Imm32(_) => { + self.assembler + .emit_mov(Size::S32, loc_a, Location::GPR(tmpg1)); + self.assembler.emit_mov( + Size::S32, + Location::GPR(tmpg1), + Location::XMM(tmp1), + ); + tmp1 + } + Location::Imm64(_) => { + self.assembler + .emit_mov(Size::S64, loc_a, Location::GPR(tmpg1)); + self.assembler.emit_mov( + Size::S64, + Location::GPR(tmpg1), + Location::XMM(tmp1), + ); + tmp1 + } + _ => { + return Err(CodegenError { + message: "F64Min src1: unreachable code".to_string(), + }) + } + }; + let src2 = match loc_b { + Location::XMM(x) => x, + Location::GPR(_) | Location::Memory(_, _) => { + self.assembler + .emit_mov(Size::S64, loc_b, Location::XMM(tmp2)); + tmp2 + } + Location::Imm32(_) => { + self.assembler + .emit_mov(Size::S32, loc_b, Location::GPR(tmpg1)); + self.assembler.emit_mov( + Size::S32, + Location::GPR(tmpg1), + Location::XMM(tmp2), + ); + tmp2 + } + Location::Imm64(_) => { + self.assembler + .emit_mov(Size::S64, loc_b, Location::GPR(tmpg1)); + self.assembler.emit_mov( + Size::S64, + Location::GPR(tmpg1), + Location::XMM(tmp2), + ); + tmp2 + } + _ => { + return Err(CodegenError { + message: "F64Min src2: unreachable code".to_string(), + }) + } + }; + + let tmp_xmm1 = XMM::XMM8; + let tmp_xmm2 = XMM::XMM9; + let tmp_xmm3 = XMM::XMM10; + + self.assembler + .emit_mov(Size::S64, Location::XMM(src1), Location::GPR(tmpg1)); + self.assembler + .emit_mov(Size::S64, Location::XMM(src2), Location::GPR(tmpg2)); + self.assembler + .emit_cmp(Size::S64, Location::GPR(tmpg2), Location::GPR(tmpg1)); + self.assembler + .emit_vminsd(src1, XMMOrMemory::XMM(src2), tmp_xmm1); + let label1 = self.assembler.get_label(); + let label2 = self.assembler.get_label(); + self.assembler.emit_jmp(Condition::NotEqual, label1); + self.assembler + .emit_vmovapd(XMMOrMemory::XMM(tmp_xmm1), XMMOrMemory::XMM(tmp_xmm2)); + self.assembler.emit_jmp(Condition::None, label2); + self.assembler.emit_label(label1); + // load float -0.0 + self.assembler.emit_mov( + Size::S64, + Location::Imm64(0x8000_0000_0000_0000), // Negative zero + Location::GPR(tmpg1), + ); + self.assembler.emit_mov( + Size::S64, + Location::GPR(tmpg1), + Location::XMM(tmp_xmm2), + ); + self.assembler.emit_label(label2); + self.assembler + .emit_vcmpeqsd(src1, XMMOrMemory::XMM(src2), tmp_xmm3); + self.assembler.emit_vblendvpd( + tmp_xmm3, + XMMOrMemory::XMM(tmp_xmm2), + tmp_xmm1, + tmp_xmm1, + ); + self.assembler + .emit_vcmpunordsd(src1, XMMOrMemory::XMM(src2), src1); + // load float canonical nan + self.assembler.emit_mov( + Size::S64, + Location::Imm64(0x7FF8_0000_0000_0000), // Canonical NaN + Location::GPR(tmpg1), + ); + self.assembler + .emit_mov(Size::S64, Location::GPR(tmpg1), Location::XMM(src2)); + self.assembler + .emit_vblendvpd(src1, XMMOrMemory::XMM(src2), tmp_xmm1, src1); + match ret { + Location::XMM(x) => { + self.assembler + .emit_vmovaps(XMMOrMemory::XMM(src1), XMMOrMemory::XMM(x)); + } + Location::Memory(_, _) | Location::GPR(_) => { + self.assembler.emit_mov(Size::S64, Location::XMM(src1), ret); + } + _ => { + return Err(CodegenError { + message: "F64Min ret: unreachable code".to_string(), + }) + } + } + + self.machine.release_temp_gpr(tmpg2); + self.machine.release_temp_gpr(tmpg1); + self.machine.release_temp_xmm(tmp2); + self.machine.release_temp_xmm(tmp1); + } + } + Operator::F64Eq => { + self.fp_stack.pop2()?; + self.emit_fp_cmpop_avx(Assembler::emit_vcmpeqsd)? + } + Operator::F64Ne => { + self.fp_stack.pop2()?; + self.emit_fp_cmpop_avx(Assembler::emit_vcmpneqsd)? + } + Operator::F64Lt => { + self.fp_stack.pop2()?; + self.emit_fp_cmpop_avx(Assembler::emit_vcmpltsd)? + } + Operator::F64Le => { + self.fp_stack.pop2()?; + self.emit_fp_cmpop_avx(Assembler::emit_vcmplesd)? + } + Operator::F64Gt => { + self.fp_stack.pop2()?; + self.emit_fp_cmpop_avx(Assembler::emit_vcmpgtsd)? + } + Operator::F64Ge => { + self.fp_stack.pop2()?; + self.emit_fp_cmpop_avx(Assembler::emit_vcmpgesd)? + } + Operator::F64Nearest => { + self.fp_stack.pop1()?; + self.fp_stack + .push(FloatValue::cncl_f64(self.value_stack.len() - 1)); + self.emit_fp_unop_avx(Assembler::emit_vroundsd_nearest)? + } + Operator::F64Floor => { + self.fp_stack.pop1()?; + self.fp_stack + .push(FloatValue::cncl_f64(self.value_stack.len() - 1)); + self.emit_fp_unop_avx(Assembler::emit_vroundsd_floor)? + } + Operator::F64Ceil => { + self.fp_stack.pop1()?; + self.fp_stack + .push(FloatValue::cncl_f64(self.value_stack.len() - 1)); + self.emit_fp_unop_avx(Assembler::emit_vroundsd_ceil)? + } + Operator::F64Trunc => { + self.fp_stack.pop1()?; + self.fp_stack + .push(FloatValue::cncl_f64(self.value_stack.len() - 1)); + self.emit_fp_unop_avx(Assembler::emit_vroundsd_trunc)? + } + Operator::F64Sqrt => { + self.fp_stack.pop1()?; + self.fp_stack + .push(FloatValue::cncl_f64(self.value_stack.len() - 1)); + self.emit_fp_unop_avx(Assembler::emit_vsqrtsd)? + } + + Operator::F64Copysign => { + let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::F64); + + let (fp_src1, fp_src2) = self.fp_stack.pop2()?; + self.fp_stack + .push(FloatValue::new(self.value_stack.len() - 1)); + + let tmp1 = self.machine.acquire_temp_gpr().unwrap(); + let tmp2 = self.machine.acquire_temp_gpr().unwrap(); + + if self.assembler.arch_supports_canonicalize_nan() + && self.config.enable_nan_canonicalization + { + for (fp, loc, tmp) in [(fp_src1, loc_a, tmp1), (fp_src2, loc_b, tmp2)].iter() { + match fp.canonicalization { + Some(_) => { + self.canonicalize_nan(Size::S64, *loc, Location::GPR(*tmp)); + } + None => { + self.assembler + .emit_mov(Size::S64, *loc, Location::GPR(*tmp)); + } + } + } + } else { + self.assembler + .emit_mov(Size::S64, loc_a, Location::GPR(tmp1)); + self.assembler + .emit_mov(Size::S64, loc_b, Location::GPR(tmp2)); + } + + let c = self.machine.acquire_temp_gpr().unwrap(); + + self.assembler.emit_mov( + Size::S64, + Location::Imm64(0x7fffffffffffffffu64), + Location::GPR(c), + ); + self.assembler + .emit_and(Size::S64, Location::GPR(c), Location::GPR(tmp1)); + + self.assembler.emit_mov( + Size::S64, + Location::Imm64(0x8000000000000000u64), + Location::GPR(c), + ); + self.assembler + .emit_and(Size::S64, Location::GPR(c), Location::GPR(tmp2)); + + self.assembler + .emit_or(Size::S64, Location::GPR(tmp2), Location::GPR(tmp1)); + self.assembler.emit_mov(Size::S64, Location::GPR(tmp1), ret); + + self.machine.release_temp_gpr(c); + self.machine.release_temp_gpr(tmp2); + self.machine.release_temp_gpr(tmp1); + } + + Operator::F64Abs => { + // Preserve canonicalization state. + + let loc = self.pop_value_released(); + let ret = + self.machine + .acquire_locations(&mut self.assembler, &[(WpType::F64)], false)[0]; + self.value_stack.push(ret); + + let tmp = self.machine.acquire_temp_gpr().unwrap(); + let c = self.machine.acquire_temp_gpr().unwrap(); + + self.assembler.emit_mov(Size::S64, loc, Location::GPR(tmp)); + self.assembler.emit_mov( + Size::S64, + Location::Imm64(0x7fffffffffffffffu64), + Location::GPR(c), + ); + self.assembler + .emit_and(Size::S64, Location::GPR(c), Location::GPR(tmp)); + self.assembler.emit_mov(Size::S64, Location::GPR(tmp), ret); + + self.machine.release_temp_gpr(c); + self.machine.release_temp_gpr(tmp); + } + + Operator::F64Neg => { + // Preserve canonicalization state. + + let loc = self.pop_value_released(); + let ret = + self.machine + .acquire_locations(&mut self.assembler, &[(WpType::F64)], false)[0]; + self.value_stack.push(ret); + if self.assembler.arch_has_fneg() { + let tmp = self.machine.acquire_temp_xmm().unwrap(); + self.emit_relaxed_binop( + Assembler::emit_mov, + Size::S64, + loc, + Location::XMM(tmp), + ); + self.assembler.arch_emit_f64_neg(tmp, tmp); + self.emit_relaxed_binop( + Assembler::emit_mov, + Size::S64, + Location::XMM(tmp), + ret, + ); + self.machine.release_temp_xmm(tmp); + } else { + let tmp = self.machine.acquire_temp_gpr().unwrap(); + self.assembler.emit_mov(Size::S64, loc, Location::GPR(tmp)); + self.assembler.emit_btc_gpr_imm8_64(63, tmp); + self.assembler.emit_mov(Size::S64, Location::GPR(tmp), ret); + self.machine.release_temp_gpr(tmp); + } + } + + Operator::F64PromoteF32 => { + let fp = self.fp_stack.pop1()?; + self.fp_stack.push(fp.promote(self.value_stack.len() - 1)); + self.emit_fp_unop_avx(Assembler::emit_vcvtss2sd)? + } + Operator::F32DemoteF64 => { + let fp = self.fp_stack.pop1()?; + self.fp_stack.push(fp.demote(self.value_stack.len() - 1)); + self.emit_fp_unop_avx(Assembler::emit_vcvtsd2ss)? + } + + Operator::I32ReinterpretF32 => { + let loc = self.pop_value_released(); + let ret = + self.machine + .acquire_locations(&mut self.assembler, &[WpType::I32], false)[0]; + self.value_stack.push(ret); + let fp = self.fp_stack.pop1()?; + + if !self.assembler.arch_supports_canonicalize_nan() + || !self.config.enable_nan_canonicalization + || fp.canonicalization.is_none() + { + if loc != ret { + self.emit_relaxed_binop(Assembler::emit_mov, Size::S32, loc, ret); + } + } else { + self.canonicalize_nan(Size::S32, loc, ret); + } + } + Operator::F32ReinterpretI32 => { + let loc = self.pop_value_released(); + let ret = + self.machine + .acquire_locations(&mut self.assembler, &[WpType::F32], false)[0]; + self.value_stack.push(ret); + self.fp_stack + .push(FloatValue::new(self.value_stack.len() - 1)); + + if loc != ret { + self.emit_relaxed_binop(Assembler::emit_mov, Size::S32, loc, ret); + } + } + + Operator::I64ReinterpretF64 => { + let loc = self.pop_value_released(); + let ret = + self.machine + .acquire_locations(&mut self.assembler, &[(WpType::I64)], false)[0]; + self.value_stack.push(ret); + let fp = self.fp_stack.pop1()?; + + if !self.assembler.arch_supports_canonicalize_nan() + || !self.config.enable_nan_canonicalization + || fp.canonicalization.is_none() + { + if loc != ret { + self.emit_relaxed_binop(Assembler::emit_mov, Size::S64, loc, ret); + } + } else { + self.canonicalize_nan(Size::S64, loc, ret); + } + } + Operator::F64ReinterpretI64 => { + let loc = self.pop_value_released(); + let ret = + self.machine + .acquire_locations(&mut self.assembler, &[(WpType::F64)], false)[0]; + self.value_stack.push(ret); + self.fp_stack + .push(FloatValue::new(self.value_stack.len() - 1)); + + if loc != ret { + self.emit_relaxed_binop(Assembler::emit_mov, Size::S64, loc, ret); + } + } + + Operator::I32TruncF32U => { + let loc = self.pop_value_released(); + let ret = + self.machine + .acquire_locations(&mut self.assembler, &[(WpType::I32)], false)[0]; + self.value_stack.push(ret); + self.fp_stack.pop1()?; + + if self.assembler.arch_has_itruncf() { + let tmp_out = self.machine.acquire_temp_gpr().unwrap(); + let tmp_in = self.machine.acquire_temp_xmm().unwrap(); + self.emit_relaxed_binop( + Assembler::emit_mov, + Size::S32, + loc, + Location::XMM(tmp_in), + ); + self.assembler.arch_emit_i32_trunc_uf32(tmp_in, tmp_out); + self.emit_relaxed_binop( + Assembler::emit_mov, + Size::S32, + Location::GPR(tmp_out), + ret, + ); + self.machine.release_temp_xmm(tmp_in); + self.machine.release_temp_gpr(tmp_out); + } else { + let tmp_out = self.machine.acquire_temp_gpr().unwrap(); + let tmp_in = self.machine.acquire_temp_xmm().unwrap(); + self.emit_relaxed_binop( + Assembler::emit_mov, + Size::S32, + loc, + Location::XMM(tmp_in), + ); + self.emit_f32_int_conv_check_trap(tmp_in, GEF32_LT_U32_MIN, LEF32_GT_U32_MAX); + + self.assembler + .emit_cvttss2si_64(XMMOrMemory::XMM(tmp_in), tmp_out); + self.assembler + .emit_mov(Size::S32, Location::GPR(tmp_out), ret); + + self.machine.release_temp_xmm(tmp_in); + self.machine.release_temp_gpr(tmp_out); + } + } + + Operator::I32TruncSatF32U => { + let loc = self.pop_value_released(); + let ret = + self.machine + .acquire_locations(&mut self.assembler, &[(WpType::I32)], false)[0]; + self.value_stack.push(ret); + self.fp_stack.pop1()?; + + let tmp_out = self.machine.acquire_temp_gpr().unwrap(); + let tmp_in = self.machine.acquire_temp_xmm().unwrap(); + self.emit_relaxed_binop(Assembler::emit_mov, Size::S32, loc, Location::XMM(tmp_in)); + self.emit_f32_int_conv_check_sat( + tmp_in, + GEF32_LT_U32_MIN, + LEF32_GT_U32_MAX, + |this| { + this.assembler.emit_mov( + Size::S32, + Location::Imm32(0), + Location::GPR(tmp_out), + ); + }, + |this| { + this.assembler.emit_mov( + Size::S32, + Location::Imm32(std::u32::MAX), + Location::GPR(tmp_out), + ); + }, + None::, + |this| { + if this.assembler.arch_has_itruncf() { + this.assembler.arch_emit_i32_trunc_uf32(tmp_in, tmp_out); + } else { + this.assembler + .emit_cvttss2si_64(XMMOrMemory::XMM(tmp_in), tmp_out); + } + }, + ); + + self.assembler + .emit_mov(Size::S32, Location::GPR(tmp_out), ret); + self.machine.release_temp_xmm(tmp_in); + self.machine.release_temp_gpr(tmp_out); + } + + Operator::I32TruncF32S => { + let loc = self.pop_value_released(); + let ret = + self.machine + .acquire_locations(&mut self.assembler, &[(WpType::I32)], false)[0]; + self.value_stack.push(ret); + self.fp_stack.pop1()?; + + if self.assembler.arch_has_itruncf() { + let tmp_out = self.machine.acquire_temp_gpr().unwrap(); + let tmp_in = self.machine.acquire_temp_xmm().unwrap(); + self.emit_relaxed_binop( + Assembler::emit_mov, + Size::S32, + loc, + Location::XMM(tmp_in), + ); + self.assembler.arch_emit_i32_trunc_sf32(tmp_in, tmp_out); + self.emit_relaxed_binop( + Assembler::emit_mov, + Size::S32, + Location::GPR(tmp_out), + ret, + ); + self.machine.release_temp_xmm(tmp_in); + self.machine.release_temp_gpr(tmp_out); + } else { + let tmp_out = self.machine.acquire_temp_gpr().unwrap(); + let tmp_in = self.machine.acquire_temp_xmm().unwrap(); + + self.emit_relaxed_binop( + Assembler::emit_mov, + Size::S32, + loc, + Location::XMM(tmp_in), + ); + self.emit_f32_int_conv_check_trap(tmp_in, GEF32_LT_I32_MIN, LEF32_GT_I32_MAX); + + self.assembler + .emit_cvttss2si_32(XMMOrMemory::XMM(tmp_in), tmp_out); + self.assembler + .emit_mov(Size::S32, Location::GPR(tmp_out), ret); + + self.machine.release_temp_xmm(tmp_in); + self.machine.release_temp_gpr(tmp_out); + } + } + Operator::I32TruncSatF32S => { + let loc = self.pop_value_released(); + let ret = + self.machine + .acquire_locations(&mut self.assembler, &[(WpType::I32)], false)[0]; + self.value_stack.push(ret); + self.fp_stack.pop1()?; + + let tmp_out = self.machine.acquire_temp_gpr().unwrap(); + let tmp_in = self.machine.acquire_temp_xmm().unwrap(); + + self.emit_relaxed_binop(Assembler::emit_mov, Size::S32, loc, Location::XMM(tmp_in)); + self.emit_f32_int_conv_check_sat( + tmp_in, + GEF32_LT_I32_MIN, + LEF32_GT_I32_MAX, + |this| { + this.assembler.emit_mov( + Size::S32, + Location::Imm32(std::i32::MIN as u32), + Location::GPR(tmp_out), + ); + }, + |this| { + this.assembler.emit_mov( + Size::S32, + Location::Imm32(std::i32::MAX as u32), + Location::GPR(tmp_out), + ); + }, + Some(|this: &mut Self| { + this.assembler.emit_mov( + Size::S32, + Location::Imm32(0), + Location::GPR(tmp_out), + ); + }), + |this| { + if this.assembler.arch_has_itruncf() { + this.assembler.arch_emit_i32_trunc_sf32(tmp_in, tmp_out); + } else { + this.assembler + .emit_cvttss2si_32(XMMOrMemory::XMM(tmp_in), tmp_out); + } + }, + ); + + self.assembler + .emit_mov(Size::S32, Location::GPR(tmp_out), ret); + self.machine.release_temp_xmm(tmp_in); + self.machine.release_temp_gpr(tmp_out); + } + + Operator::I64TruncF32S => { + let loc = self.pop_value_released(); + let ret = + self.machine + .acquire_locations(&mut self.assembler, &[(WpType::I64)], false)[0]; + self.value_stack.push(ret); + self.fp_stack.pop1()?; + + if self.assembler.arch_has_itruncf() { + let tmp_out = self.machine.acquire_temp_gpr().unwrap(); + let tmp_in = self.machine.acquire_temp_xmm().unwrap(); + self.emit_relaxed_binop( + Assembler::emit_mov, + Size::S32, + loc, + Location::XMM(tmp_in), + ); + self.assembler.arch_emit_i64_trunc_sf32(tmp_in, tmp_out); + self.emit_relaxed_binop( + Assembler::emit_mov, + Size::S64, + Location::GPR(tmp_out), + ret, + ); + self.machine.release_temp_xmm(tmp_in); + self.machine.release_temp_gpr(tmp_out); + } else { + let tmp_out = self.machine.acquire_temp_gpr().unwrap(); + let tmp_in = self.machine.acquire_temp_xmm().unwrap(); + + self.emit_relaxed_binop( + Assembler::emit_mov, + Size::S32, + loc, + Location::XMM(tmp_in), + ); + self.emit_f32_int_conv_check_trap(tmp_in, GEF32_LT_I64_MIN, LEF32_GT_I64_MAX); + self.assembler + .emit_cvttss2si_64(XMMOrMemory::XMM(tmp_in), tmp_out); + self.assembler + .emit_mov(Size::S64, Location::GPR(tmp_out), ret); + + self.machine.release_temp_xmm(tmp_in); + self.machine.release_temp_gpr(tmp_out); + } + } + + Operator::I64TruncSatF32S => { + let loc = self.pop_value_released(); + let ret = + self.machine + .acquire_locations(&mut self.assembler, &[(WpType::I64)], false)[0]; + self.value_stack.push(ret); + self.fp_stack.pop1()?; + + let tmp_out = self.machine.acquire_temp_gpr().unwrap(); + let tmp_in = self.machine.acquire_temp_xmm().unwrap(); + + self.emit_relaxed_binop(Assembler::emit_mov, Size::S32, loc, Location::XMM(tmp_in)); + self.emit_f32_int_conv_check_sat( + tmp_in, + GEF32_LT_I64_MIN, + LEF32_GT_I64_MAX, + |this| { + this.assembler.emit_mov( + Size::S64, + Location::Imm64(std::i64::MIN as u64), + Location::GPR(tmp_out), + ); + }, + |this| { + this.assembler.emit_mov( + Size::S64, + Location::Imm64(std::i64::MAX as u64), + Location::GPR(tmp_out), + ); + }, + Some(|this: &mut Self| { + this.assembler.emit_mov( + Size::S64, + Location::Imm64(0), + Location::GPR(tmp_out), + ); + }), + |this| { + if this.assembler.arch_has_itruncf() { + this.assembler.arch_emit_i64_trunc_sf32(tmp_in, tmp_out); + } else { + this.assembler + .emit_cvttss2si_64(XMMOrMemory::XMM(tmp_in), tmp_out); + } + }, + ); + + self.assembler + .emit_mov(Size::S64, Location::GPR(tmp_out), ret); + self.machine.release_temp_xmm(tmp_in); + self.machine.release_temp_gpr(tmp_out); + } + + Operator::I64TruncF32U => { + let loc = self.pop_value_released(); + let ret = + self.machine + .acquire_locations(&mut self.assembler, &[(WpType::I64)], false)[0]; + self.value_stack.push(ret); + self.fp_stack.pop1()?; + + if self.assembler.arch_has_itruncf() { + let tmp_out = self.machine.acquire_temp_gpr().unwrap(); + let tmp_in = self.machine.acquire_temp_xmm().unwrap(); + self.emit_relaxed_binop( + Assembler::emit_mov, + Size::S32, + loc, + Location::XMM(tmp_in), + ); + self.assembler.arch_emit_i64_trunc_uf32(tmp_in, tmp_out); + self.emit_relaxed_binop( + Assembler::emit_mov, + Size::S64, + Location::GPR(tmp_out), + ret, + ); + self.machine.release_temp_xmm(tmp_in); + self.machine.release_temp_gpr(tmp_out); + } else { + let tmp_out = self.machine.acquire_temp_gpr().unwrap(); + let tmp_in = self.machine.acquire_temp_xmm().unwrap(); // xmm2 + + self.emit_relaxed_binop( + Assembler::emit_mov, + Size::S32, + loc, + Location::XMM(tmp_in), + ); + self.emit_f32_int_conv_check_trap(tmp_in, GEF32_LT_U64_MIN, LEF32_GT_U64_MAX); + + let tmp = self.machine.acquire_temp_gpr().unwrap(); // r15 + let tmp_x1 = self.machine.acquire_temp_xmm().unwrap(); // xmm1 + let tmp_x2 = self.machine.acquire_temp_xmm().unwrap(); // xmm3 + + self.assembler.emit_mov( + Size::S32, + Location::Imm32(1593835520u32), + Location::GPR(tmp), + ); //float 9.22337203E+18 + self.assembler + .emit_mov(Size::S32, Location::GPR(tmp), Location::XMM(tmp_x1)); + self.assembler.emit_mov( + Size::S32, + Location::XMM(tmp_in), + Location::XMM(tmp_x2), + ); + self.assembler + .emit_vsubss(tmp_in, XMMOrMemory::XMM(tmp_x1), tmp_in); + self.assembler + .emit_cvttss2si_64(XMMOrMemory::XMM(tmp_in), tmp_out); + self.assembler.emit_mov( + Size::S64, + Location::Imm64(0x8000000000000000u64), + Location::GPR(tmp), + ); + self.assembler + .emit_xor(Size::S64, Location::GPR(tmp_out), Location::GPR(tmp)); + self.assembler + .emit_cvttss2si_64(XMMOrMemory::XMM(tmp_x2), tmp_out); + self.assembler + .emit_ucomiss(XMMOrMemory::XMM(tmp_x1), tmp_x2); + self.assembler.emit_cmovae_gpr_64(tmp, tmp_out); + self.assembler + .emit_mov(Size::S64, Location::GPR(tmp_out), ret); + + self.machine.release_temp_xmm(tmp_x2); + self.machine.release_temp_xmm(tmp_x1); + self.machine.release_temp_gpr(tmp); + self.machine.release_temp_xmm(tmp_in); + self.machine.release_temp_gpr(tmp_out); + } + } + Operator::I64TruncSatF32U => { + let loc = self.pop_value_released(); + let ret = + self.machine + .acquire_locations(&mut self.assembler, &[(WpType::I64)], false)[0]; + self.value_stack.push(ret); + self.fp_stack.pop1()?; + + let tmp_out = self.machine.acquire_temp_gpr().unwrap(); + let tmp_in = self.machine.acquire_temp_xmm().unwrap(); + + self.emit_relaxed_binop(Assembler::emit_mov, Size::S32, loc, Location::XMM(tmp_in)); + self.emit_f32_int_conv_check_sat( + tmp_in, + GEF32_LT_U64_MIN, + LEF32_GT_U64_MAX, + |this| { + this.assembler.emit_mov( + Size::S64, + Location::Imm64(0), + Location::GPR(tmp_out), + ); + }, + |this| { + this.assembler.emit_mov( + Size::S64, + Location::Imm64(std::u64::MAX), + Location::GPR(tmp_out), + ); + }, + None::, + |this| { + if this.assembler.arch_has_itruncf() { + this.assembler.arch_emit_i64_trunc_uf32(tmp_in, tmp_out); + } else { + let tmp = this.machine.acquire_temp_gpr().unwrap(); + let tmp_x1 = this.machine.acquire_temp_xmm().unwrap(); + let tmp_x2 = this.machine.acquire_temp_xmm().unwrap(); + + this.assembler.emit_mov( + Size::S32, + Location::Imm32(1593835520u32), + Location::GPR(tmp), + ); //float 9.22337203E+18 + this.assembler.emit_mov( + Size::S32, + Location::GPR(tmp), + Location::XMM(tmp_x1), + ); + this.assembler.emit_mov( + Size::S32, + Location::XMM(tmp_in), + Location::XMM(tmp_x2), + ); + this.assembler + .emit_vsubss(tmp_in, XMMOrMemory::XMM(tmp_x1), tmp_in); + this.assembler + .emit_cvttss2si_64(XMMOrMemory::XMM(tmp_in), tmp_out); + this.assembler.emit_mov( + Size::S64, + Location::Imm64(0x8000000000000000u64), + Location::GPR(tmp), + ); + this.assembler.emit_xor( + Size::S64, + Location::GPR(tmp_out), + Location::GPR(tmp), + ); + this.assembler + .emit_cvttss2si_64(XMMOrMemory::XMM(tmp_x2), tmp_out); + this.assembler + .emit_ucomiss(XMMOrMemory::XMM(tmp_x1), tmp_x2); + this.assembler.emit_cmovae_gpr_64(tmp, tmp_out); + + this.machine.release_temp_xmm(tmp_x2); + this.machine.release_temp_xmm(tmp_x1); + this.machine.release_temp_gpr(tmp); + } + }, + ); + + self.assembler + .emit_mov(Size::S64, Location::GPR(tmp_out), ret); + self.machine.release_temp_xmm(tmp_in); + self.machine.release_temp_gpr(tmp_out); + } + + Operator::I32TruncF64U => { + let loc = self.pop_value_released(); + let ret = + self.machine + .acquire_locations(&mut self.assembler, &[(WpType::I32)], false)[0]; + self.value_stack.push(ret); + self.fp_stack.pop1()?; + + if self.assembler.arch_has_itruncf() { + let tmp_out = self.machine.acquire_temp_gpr().unwrap(); + let tmp_in = self.machine.acquire_temp_xmm().unwrap(); + self.emit_relaxed_binop( + Assembler::emit_mov, + Size::S64, + loc, + Location::XMM(tmp_in), + ); + self.assembler.arch_emit_i32_trunc_uf64(tmp_in, tmp_out); + self.emit_relaxed_binop( + Assembler::emit_mov, + Size::S32, + Location::GPR(tmp_out), + ret, + ); + self.machine.release_temp_xmm(tmp_in); + self.machine.release_temp_gpr(tmp_out); + } else { + let tmp_out = self.machine.acquire_temp_gpr().unwrap(); + let tmp_in = self.machine.acquire_temp_xmm().unwrap(); + + self.emit_relaxed_binop( + Assembler::emit_mov, + Size::S64, + loc, + Location::XMM(tmp_in), + ); + self.emit_f64_int_conv_check_trap(tmp_in, GEF64_LT_U32_MIN, LEF64_GT_U32_MAX); + + self.assembler + .emit_cvttsd2si_64(XMMOrMemory::XMM(tmp_in), tmp_out); + self.assembler + .emit_mov(Size::S32, Location::GPR(tmp_out), ret); + + self.machine.release_temp_xmm(tmp_in); + self.machine.release_temp_gpr(tmp_out); + } + } + + Operator::I32TruncSatF64U => { + let loc = self.pop_value_released(); + let ret = + self.machine + .acquire_locations(&mut self.assembler, &[(WpType::I32)], false)[0]; + self.value_stack.push(ret); + self.fp_stack.pop1()?; + + let tmp_out = self.machine.acquire_temp_gpr().unwrap(); + let tmp_in = self.machine.acquire_temp_xmm().unwrap(); + + self.emit_relaxed_binop(Assembler::emit_mov, Size::S64, loc, Location::XMM(tmp_in)); + self.emit_f64_int_conv_check_sat( + tmp_in, + GEF64_LT_U32_MIN, + LEF64_GT_U32_MAX, + |this| { + this.assembler.emit_mov( + Size::S32, + Location::Imm32(0), + Location::GPR(tmp_out), + ); + }, + |this| { + this.assembler.emit_mov( + Size::S32, + Location::Imm32(std::u32::MAX), + Location::GPR(tmp_out), + ); + }, + None::, + |this| { + if this.assembler.arch_has_itruncf() { + this.assembler.arch_emit_i32_trunc_uf64(tmp_in, tmp_out); + } else { + this.assembler + .emit_cvttsd2si_64(XMMOrMemory::XMM(tmp_in), tmp_out); + } + }, + ); + + self.assembler + .emit_mov(Size::S32, Location::GPR(tmp_out), ret); + self.machine.release_temp_xmm(tmp_in); + self.machine.release_temp_gpr(tmp_out); + } + + Operator::I32TruncF64S => { + let loc = self.pop_value_released(); + let ret = + self.machine + .acquire_locations(&mut self.assembler, &[(WpType::I32)], false)[0]; + self.value_stack.push(ret); + self.fp_stack.pop1()?; + + if self.assembler.arch_has_itruncf() { + let tmp_out = self.machine.acquire_temp_gpr().unwrap(); + let tmp_in = self.machine.acquire_temp_xmm().unwrap(); + self.emit_relaxed_binop( + Assembler::emit_mov, + Size::S64, + loc, + Location::XMM(tmp_in), + ); + self.assembler.arch_emit_i32_trunc_sf64(tmp_in, tmp_out); + self.emit_relaxed_binop( + Assembler::emit_mov, + Size::S32, + Location::GPR(tmp_out), + ret, + ); + self.machine.release_temp_xmm(tmp_in); + self.machine.release_temp_gpr(tmp_out); + } else { + let tmp_out = self.machine.acquire_temp_gpr().unwrap(); + let tmp_in = self.machine.acquire_temp_xmm().unwrap(); + + let real_in = match loc { + Location::Imm32(_) | Location::Imm64(_) => { + self.assembler + .emit_mov(Size::S64, loc, Location::GPR(tmp_out)); + self.assembler.emit_mov( + Size::S64, + Location::GPR(tmp_out), + Location::XMM(tmp_in), + ); + tmp_in + } + Location::XMM(x) => x, + _ => { + self.assembler + .emit_mov(Size::S64, loc, Location::XMM(tmp_in)); + tmp_in + } + }; + + self.emit_f64_int_conv_check_trap(real_in, GEF64_LT_I32_MIN, LEF64_GT_I32_MAX); + + self.assembler + .emit_cvttsd2si_32(XMMOrMemory::XMM(real_in), tmp_out); + self.assembler + .emit_mov(Size::S32, Location::GPR(tmp_out), ret); + + self.machine.release_temp_xmm(tmp_in); + self.machine.release_temp_gpr(tmp_out); + } + } + + Operator::I32TruncSatF64S => { + let loc = self.pop_value_released(); + let ret = + self.machine + .acquire_locations(&mut self.assembler, &[(WpType::I32)], false)[0]; + self.value_stack.push(ret); + self.fp_stack.pop1()?; + + let tmp_out = self.machine.acquire_temp_gpr().unwrap(); + let tmp_in = self.machine.acquire_temp_xmm().unwrap(); + + let real_in = match loc { + Location::Imm32(_) | Location::Imm64(_) => { + self.assembler + .emit_mov(Size::S64, loc, Location::GPR(tmp_out)); + self.assembler.emit_mov( + Size::S64, + Location::GPR(tmp_out), + Location::XMM(tmp_in), + ); + tmp_in + } + Location::XMM(x) => x, + _ => { + self.assembler + .emit_mov(Size::S64, loc, Location::XMM(tmp_in)); + tmp_in + } + }; + + self.emit_f64_int_conv_check_sat( + real_in, + GEF64_LT_I32_MIN, + LEF64_GT_I32_MAX, + |this| { + this.assembler.emit_mov( + Size::S32, + Location::Imm32(std::i32::MIN as u32), + Location::GPR(tmp_out), + ); + }, + |this| { + this.assembler.emit_mov( + Size::S32, + Location::Imm32(std::i32::MAX as u32), + Location::GPR(tmp_out), + ); + }, + Some(|this: &mut Self| { + this.assembler.emit_mov( + Size::S32, + Location::Imm32(0), + Location::GPR(tmp_out), + ); + }), + |this| { + if this.assembler.arch_has_itruncf() { + this.assembler.arch_emit_i32_trunc_sf64(tmp_in, tmp_out); + } else { + this.assembler + .emit_cvttsd2si_32(XMMOrMemory::XMM(real_in), tmp_out); + } + }, + ); + + self.assembler + .emit_mov(Size::S32, Location::GPR(tmp_out), ret); + self.machine.release_temp_xmm(tmp_in); + self.machine.release_temp_gpr(tmp_out); + } + + Operator::I64TruncF64S => { + let loc = self.pop_value_released(); + let ret = + self.machine + .acquire_locations(&mut self.assembler, &[(WpType::I64)], false)[0]; + self.value_stack.push(ret); + self.fp_stack.pop1()?; + + if self.assembler.arch_has_itruncf() { + let tmp_out = self.machine.acquire_temp_gpr().unwrap(); + let tmp_in = self.machine.acquire_temp_xmm().unwrap(); + self.emit_relaxed_binop( + Assembler::emit_mov, + Size::S64, + loc, + Location::XMM(tmp_in), + ); + self.assembler.arch_emit_i64_trunc_sf64(tmp_in, tmp_out); + self.emit_relaxed_binop( + Assembler::emit_mov, + Size::S64, + Location::GPR(tmp_out), + ret, + ); + self.machine.release_temp_xmm(tmp_in); + self.machine.release_temp_gpr(tmp_out); + } else { + let tmp_out = self.machine.acquire_temp_gpr().unwrap(); + let tmp_in = self.machine.acquire_temp_xmm().unwrap(); + + self.emit_relaxed_binop( + Assembler::emit_mov, + Size::S64, + loc, + Location::XMM(tmp_in), + ); + self.emit_f64_int_conv_check_trap(tmp_in, GEF64_LT_I64_MIN, LEF64_GT_I64_MAX); + + self.assembler + .emit_cvttsd2si_64(XMMOrMemory::XMM(tmp_in), tmp_out); + self.assembler + .emit_mov(Size::S64, Location::GPR(tmp_out), ret); + + self.machine.release_temp_xmm(tmp_in); + self.machine.release_temp_gpr(tmp_out); + } + } + + Operator::I64TruncSatF64S => { + let loc = self.pop_value_released(); + let ret = + self.machine + .acquire_locations(&mut self.assembler, &[(WpType::I64)], false)[0]; + self.value_stack.push(ret); + self.fp_stack.pop1()?; + + let tmp_out = self.machine.acquire_temp_gpr().unwrap(); + let tmp_in = self.machine.acquire_temp_xmm().unwrap(); + + self.emit_relaxed_binop(Assembler::emit_mov, Size::S64, loc, Location::XMM(tmp_in)); + self.emit_f64_int_conv_check_sat( + tmp_in, + GEF64_LT_I64_MIN, + LEF64_GT_I64_MAX, + |this| { + this.assembler.emit_mov( + Size::S64, + Location::Imm64(std::i64::MIN as u64), + Location::GPR(tmp_out), + ); + }, + |this| { + this.assembler.emit_mov( + Size::S64, + Location::Imm64(std::i64::MAX as u64), + Location::GPR(tmp_out), + ); + }, + Some(|this: &mut Self| { + this.assembler.emit_mov( + Size::S64, + Location::Imm64(0), + Location::GPR(tmp_out), + ); + }), + |this| { + if this.assembler.arch_has_itruncf() { + this.assembler.arch_emit_i64_trunc_sf64(tmp_in, tmp_out); + } else { + this.assembler + .emit_cvttsd2si_64(XMMOrMemory::XMM(tmp_in), tmp_out); + } + }, + ); + + self.assembler + .emit_mov(Size::S64, Location::GPR(tmp_out), ret); + self.machine.release_temp_xmm(tmp_in); + self.machine.release_temp_gpr(tmp_out); + } + + Operator::I64TruncF64U => { + let loc = self.pop_value_released(); + let ret = + self.machine + .acquire_locations(&mut self.assembler, &[(WpType::I64)], false)[0]; + self.value_stack.push(ret); + self.fp_stack.pop1()?; + + if self.assembler.arch_has_itruncf() { + let tmp_out = self.machine.acquire_temp_gpr().unwrap(); + let tmp_in = self.machine.acquire_temp_xmm().unwrap(); + self.emit_relaxed_binop( + Assembler::emit_mov, + Size::S64, + loc, + Location::XMM(tmp_in), + ); + self.assembler.arch_emit_i64_trunc_uf64(tmp_in, tmp_out); + self.emit_relaxed_binop( + Assembler::emit_mov, + Size::S64, + Location::GPR(tmp_out), + ret, + ); + self.machine.release_temp_xmm(tmp_in); + self.machine.release_temp_gpr(tmp_out); + } else { + let tmp_out = self.machine.acquire_temp_gpr().unwrap(); + let tmp_in = self.machine.acquire_temp_xmm().unwrap(); // xmm2 + + self.emit_relaxed_binop( + Assembler::emit_mov, + Size::S64, + loc, + Location::XMM(tmp_in), + ); + self.emit_f64_int_conv_check_trap(tmp_in, GEF64_LT_U64_MIN, LEF64_GT_U64_MAX); + + let tmp = self.machine.acquire_temp_gpr().unwrap(); // r15 + let tmp_x1 = self.machine.acquire_temp_xmm().unwrap(); // xmm1 + let tmp_x2 = self.machine.acquire_temp_xmm().unwrap(); // xmm3 + + self.assembler.emit_mov( + Size::S64, + Location::Imm64(4890909195324358656u64), + Location::GPR(tmp), + ); //double 9.2233720368547758E+18 + self.assembler + .emit_mov(Size::S64, Location::GPR(tmp), Location::XMM(tmp_x1)); + self.assembler.emit_mov( + Size::S64, + Location::XMM(tmp_in), + Location::XMM(tmp_x2), + ); + self.assembler + .emit_vsubsd(tmp_in, XMMOrMemory::XMM(tmp_x1), tmp_in); + self.assembler + .emit_cvttsd2si_64(XMMOrMemory::XMM(tmp_in), tmp_out); + self.assembler.emit_mov( + Size::S64, + Location::Imm64(0x8000000000000000u64), + Location::GPR(tmp), + ); + self.assembler + .emit_xor(Size::S64, Location::GPR(tmp_out), Location::GPR(tmp)); + self.assembler + .emit_cvttsd2si_64(XMMOrMemory::XMM(tmp_x2), tmp_out); + self.assembler + .emit_ucomisd(XMMOrMemory::XMM(tmp_x1), tmp_x2); + self.assembler.emit_cmovae_gpr_64(tmp, tmp_out); + self.assembler + .emit_mov(Size::S64, Location::GPR(tmp_out), ret); + + self.machine.release_temp_xmm(tmp_x2); + self.machine.release_temp_xmm(tmp_x1); + self.machine.release_temp_gpr(tmp); + self.machine.release_temp_xmm(tmp_in); + self.machine.release_temp_gpr(tmp_out); + } + } + + Operator::I64TruncSatF64U => { + let loc = self.pop_value_released(); + let ret = + self.machine + .acquire_locations(&mut self.assembler, &[(WpType::I64)], false)[0]; + self.value_stack.push(ret); + self.fp_stack.pop1()?; + + let tmp_out = self.machine.acquire_temp_gpr().unwrap(); + let tmp_in = self.machine.acquire_temp_xmm().unwrap(); + + self.emit_relaxed_binop(Assembler::emit_mov, Size::S64, loc, Location::XMM(tmp_in)); + self.emit_f64_int_conv_check_sat( + tmp_in, + GEF64_LT_U64_MIN, + LEF64_GT_U64_MAX, + |this| { + this.assembler.emit_mov( + Size::S64, + Location::Imm64(0), + Location::GPR(tmp_out), + ); + }, + |this| { + this.assembler.emit_mov( + Size::S64, + Location::Imm64(std::u64::MAX), + Location::GPR(tmp_out), + ); + }, + None::, + |this| { + if this.assembler.arch_has_itruncf() { + this.assembler.arch_emit_i64_trunc_uf64(tmp_in, tmp_out); + } else { + let tmp = this.machine.acquire_temp_gpr().unwrap(); + let tmp_x1 = this.machine.acquire_temp_xmm().unwrap(); + let tmp_x2 = this.machine.acquire_temp_xmm().unwrap(); + + this.assembler.emit_mov( + Size::S64, + Location::Imm64(4890909195324358656u64), + Location::GPR(tmp), + ); //double 9.2233720368547758E+18 + this.assembler.emit_mov( + Size::S64, + Location::GPR(tmp), + Location::XMM(tmp_x1), + ); + this.assembler.emit_mov( + Size::S64, + Location::XMM(tmp_in), + Location::XMM(tmp_x2), + ); + this.assembler + .emit_vsubsd(tmp_in, XMMOrMemory::XMM(tmp_x1), tmp_in); + this.assembler + .emit_cvttsd2si_64(XMMOrMemory::XMM(tmp_in), tmp_out); + this.assembler.emit_mov( + Size::S64, + Location::Imm64(0x8000000000000000u64), + Location::GPR(tmp), + ); + this.assembler.emit_xor( + Size::S64, + Location::GPR(tmp_out), + Location::GPR(tmp), + ); + this.assembler + .emit_cvttsd2si_64(XMMOrMemory::XMM(tmp_x2), tmp_out); + this.assembler + .emit_ucomisd(XMMOrMemory::XMM(tmp_x1), tmp_x2); + this.assembler.emit_cmovae_gpr_64(tmp, tmp_out); + + this.machine.release_temp_xmm(tmp_x2); + this.machine.release_temp_xmm(tmp_x1); + this.machine.release_temp_gpr(tmp); + } + }, + ); + + self.assembler + .emit_mov(Size::S64, Location::GPR(tmp_out), ret); + self.machine.release_temp_xmm(tmp_in); + self.machine.release_temp_gpr(tmp_out); + } + + Operator::F32ConvertI32S => { + let loc = self.pop_value_released(); + let ret = + self.machine + .acquire_locations(&mut self.assembler, &[(WpType::F32)], false)[0]; + self.value_stack.push(ret); + self.fp_stack + .push(FloatValue::new(self.value_stack.len() - 1)); // Converting i32 to f32 never results in NaN. + + if self.assembler.arch_has_fconverti() { + let tmp_out = self.machine.acquire_temp_xmm().unwrap(); + let tmp_in = self.machine.acquire_temp_gpr().unwrap(); + self.emit_relaxed_binop( + Assembler::emit_mov, + Size::S32, + loc, + Location::GPR(tmp_in), + ); + self.assembler.arch_emit_f32_convert_si32(tmp_in, tmp_out); + self.emit_relaxed_binop( + Assembler::emit_mov, + Size::S32, + Location::XMM(tmp_out), + ret, + ); + self.machine.release_temp_gpr(tmp_in); + self.machine.release_temp_xmm(tmp_out); + } else { + let tmp_out = self.machine.acquire_temp_xmm().unwrap(); + let tmp_in = self.machine.acquire_temp_gpr().unwrap(); + + self.assembler + .emit_mov(Size::S32, loc, Location::GPR(tmp_in)); + self.assembler + .emit_vcvtsi2ss_32(tmp_out, GPROrMemory::GPR(tmp_in), tmp_out); + self.assembler + .emit_mov(Size::S32, Location::XMM(tmp_out), ret); + + self.machine.release_temp_gpr(tmp_in); + self.machine.release_temp_xmm(tmp_out); + } + } + Operator::F32ConvertI32U => { + let loc = self.pop_value_released(); + let ret = + self.machine + .acquire_locations(&mut self.assembler, &[(WpType::F32)], false)[0]; + self.value_stack.push(ret); + self.fp_stack + .push(FloatValue::new(self.value_stack.len() - 1)); // Converting i32 to f32 never results in NaN. + + if self.assembler.arch_has_fconverti() { + let tmp_out = self.machine.acquire_temp_xmm().unwrap(); + let tmp_in = self.machine.acquire_temp_gpr().unwrap(); + self.emit_relaxed_binop( + Assembler::emit_mov, + Size::S32, + loc, + Location::GPR(tmp_in), + ); + self.assembler.arch_emit_f32_convert_ui32(tmp_in, tmp_out); + self.emit_relaxed_binop( + Assembler::emit_mov, + Size::S32, + Location::XMM(tmp_out), + ret, + ); + self.machine.release_temp_gpr(tmp_in); + self.machine.release_temp_xmm(tmp_out); + } else { + let tmp_out = self.machine.acquire_temp_xmm().unwrap(); + let tmp_in = self.machine.acquire_temp_gpr().unwrap(); + + self.assembler + .emit_mov(Size::S32, loc, Location::GPR(tmp_in)); + self.assembler + .emit_vcvtsi2ss_64(tmp_out, GPROrMemory::GPR(tmp_in), tmp_out); + self.assembler + .emit_mov(Size::S32, Location::XMM(tmp_out), ret); + + self.machine.release_temp_gpr(tmp_in); + self.machine.release_temp_xmm(tmp_out); + } + } + Operator::F32ConvertI64S => { + let loc = self.pop_value_released(); + let ret = + self.machine + .acquire_locations(&mut self.assembler, &[(WpType::F32)], false)[0]; + self.value_stack.push(ret); + self.fp_stack + .push(FloatValue::new(self.value_stack.len() - 1)); // Converting i64 to f32 never results in NaN. + + if self.assembler.arch_has_fconverti() { + let tmp_out = self.machine.acquire_temp_xmm().unwrap(); + let tmp_in = self.machine.acquire_temp_gpr().unwrap(); + self.emit_relaxed_binop( + Assembler::emit_mov, + Size::S64, + loc, + Location::GPR(tmp_in), + ); + self.assembler.arch_emit_f32_convert_si64(tmp_in, tmp_out); + self.emit_relaxed_binop( + Assembler::emit_mov, + Size::S32, + Location::XMM(tmp_out), + ret, + ); + self.machine.release_temp_gpr(tmp_in); + self.machine.release_temp_xmm(tmp_out); + } else { + let tmp_out = self.machine.acquire_temp_xmm().unwrap(); + let tmp_in = self.machine.acquire_temp_gpr().unwrap(); + + self.assembler + .emit_mov(Size::S64, loc, Location::GPR(tmp_in)); + self.assembler + .emit_vcvtsi2ss_64(tmp_out, GPROrMemory::GPR(tmp_in), tmp_out); + self.assembler + .emit_mov(Size::S32, Location::XMM(tmp_out), ret); + + self.machine.release_temp_gpr(tmp_in); + self.machine.release_temp_xmm(tmp_out); + } + } + Operator::F32ConvertI64U => { + let loc = self.pop_value_released(); + let ret = + self.machine + .acquire_locations(&mut self.assembler, &[(WpType::F32)], false)[0]; + self.value_stack.push(ret); + self.fp_stack + .push(FloatValue::new(self.value_stack.len() - 1)); // Converting i64 to f32 never results in NaN. + + if self.assembler.arch_has_fconverti() { + let tmp_out = self.machine.acquire_temp_xmm().unwrap(); + let tmp_in = self.machine.acquire_temp_gpr().unwrap(); + self.emit_relaxed_binop( + Assembler::emit_mov, + Size::S64, + loc, + Location::GPR(tmp_in), + ); + self.assembler.arch_emit_f32_convert_ui64(tmp_in, tmp_out); + self.emit_relaxed_binop( + Assembler::emit_mov, + Size::S32, + Location::XMM(tmp_out), + ret, + ); + self.machine.release_temp_gpr(tmp_in); + self.machine.release_temp_xmm(tmp_out); + } else { + let tmp_out = self.machine.acquire_temp_xmm().unwrap(); + let tmp_in = self.machine.acquire_temp_gpr().unwrap(); + let tmp = self.machine.acquire_temp_gpr().unwrap(); + + let do_convert = self.assembler.get_label(); + let end_convert = self.assembler.get_label(); + + self.assembler + .emit_mov(Size::S64, loc, Location::GPR(tmp_in)); + self.assembler.emit_test_gpr_64(tmp_in); + self.assembler.emit_jmp(Condition::Signed, do_convert); + self.assembler + .emit_vcvtsi2ss_64(tmp_out, GPROrMemory::GPR(tmp_in), tmp_out); + self.assembler.emit_jmp(Condition::None, end_convert); + self.assembler.emit_label(do_convert); + self.assembler + .emit_mov(Size::S64, Location::GPR(tmp_in), Location::GPR(tmp)); + self.assembler + .emit_and(Size::S64, Location::Imm32(1), Location::GPR(tmp)); + self.assembler + .emit_shr(Size::S64, Location::Imm8(1), Location::GPR(tmp_in)); + self.assembler + .emit_or(Size::S64, Location::GPR(tmp), Location::GPR(tmp_in)); + self.assembler + .emit_vcvtsi2ss_64(tmp_out, GPROrMemory::GPR(tmp_in), tmp_out); + self.assembler + .emit_vaddss(tmp_out, XMMOrMemory::XMM(tmp_out), tmp_out); + self.assembler.emit_label(end_convert); + self.assembler + .emit_mov(Size::S32, Location::XMM(tmp_out), ret); + + self.machine.release_temp_gpr(tmp); + self.machine.release_temp_gpr(tmp_in); + self.machine.release_temp_xmm(tmp_out); + } + } + + Operator::F64ConvertI32S => { + let loc = self.pop_value_released(); + let ret = + self.machine + .acquire_locations(&mut self.assembler, &[(WpType::F64)], false)[0]; + self.value_stack.push(ret); + self.fp_stack + .push(FloatValue::new(self.value_stack.len() - 1)); // Converting i32 to f64 never results in NaN. + + if self.assembler.arch_has_fconverti() { + let tmp_out = self.machine.acquire_temp_xmm().unwrap(); + let tmp_in = self.machine.acquire_temp_gpr().unwrap(); + self.emit_relaxed_binop( + Assembler::emit_mov, + Size::S32, + loc, + Location::GPR(tmp_in), + ); + self.assembler.arch_emit_f64_convert_si32(tmp_in, tmp_out); + self.emit_relaxed_binop( + Assembler::emit_mov, + Size::S64, + Location::XMM(tmp_out), + ret, + ); + self.machine.release_temp_gpr(tmp_in); + self.machine.release_temp_xmm(tmp_out); + } else { + let tmp_out = self.machine.acquire_temp_xmm().unwrap(); + let tmp_in = self.machine.acquire_temp_gpr().unwrap(); + + self.assembler + .emit_mov(Size::S32, loc, Location::GPR(tmp_in)); + self.assembler + .emit_vcvtsi2sd_32(tmp_out, GPROrMemory::GPR(tmp_in), tmp_out); + self.assembler + .emit_mov(Size::S64, Location::XMM(tmp_out), ret); + + self.machine.release_temp_gpr(tmp_in); + self.machine.release_temp_xmm(tmp_out); + } + } + Operator::F64ConvertI32U => { + let loc = self.pop_value_released(); + let ret = + self.machine + .acquire_locations(&mut self.assembler, &[(WpType::F64)], false)[0]; + self.value_stack.push(ret); + self.fp_stack + .push(FloatValue::new(self.value_stack.len() - 1)); // Converting i32 to f64 never results in NaN. + + if self.assembler.arch_has_fconverti() { + let tmp_out = self.machine.acquire_temp_xmm().unwrap(); + let tmp_in = self.machine.acquire_temp_gpr().unwrap(); + self.emit_relaxed_binop( + Assembler::emit_mov, + Size::S32, + loc, + Location::GPR(tmp_in), + ); + self.assembler.arch_emit_f64_convert_ui32(tmp_in, tmp_out); + self.emit_relaxed_binop( + Assembler::emit_mov, + Size::S64, + Location::XMM(tmp_out), + ret, + ); + self.machine.release_temp_gpr(tmp_in); + self.machine.release_temp_xmm(tmp_out); + } else { + let tmp_out = self.machine.acquire_temp_xmm().unwrap(); + let tmp_in = self.machine.acquire_temp_gpr().unwrap(); + + self.assembler + .emit_mov(Size::S32, loc, Location::GPR(tmp_in)); + self.assembler + .emit_vcvtsi2sd_64(tmp_out, GPROrMemory::GPR(tmp_in), tmp_out); + self.assembler + .emit_mov(Size::S64, Location::XMM(tmp_out), ret); + + self.machine.release_temp_gpr(tmp_in); + self.machine.release_temp_xmm(tmp_out); + } + } + Operator::F64ConvertI64S => { + let loc = self.pop_value_released(); + let ret = + self.machine + .acquire_locations(&mut self.assembler, &[(WpType::F64)], false)[0]; + self.value_stack.push(ret); + self.fp_stack + .push(FloatValue::new(self.value_stack.len() - 1)); // Converting i64 to f64 never results in NaN. + + if self.assembler.arch_has_fconverti() { + let tmp_out = self.machine.acquire_temp_xmm().unwrap(); + let tmp_in = self.machine.acquire_temp_gpr().unwrap(); + self.emit_relaxed_binop( + Assembler::emit_mov, + Size::S64, + loc, + Location::GPR(tmp_in), + ); + self.assembler.arch_emit_f64_convert_si64(tmp_in, tmp_out); + self.emit_relaxed_binop( + Assembler::emit_mov, + Size::S64, + Location::XMM(tmp_out), + ret, + ); + self.machine.release_temp_gpr(tmp_in); + self.machine.release_temp_xmm(tmp_out); + } else { + let tmp_out = self.machine.acquire_temp_xmm().unwrap(); + let tmp_in = self.machine.acquire_temp_gpr().unwrap(); + + self.assembler + .emit_mov(Size::S64, loc, Location::GPR(tmp_in)); + self.assembler + .emit_vcvtsi2sd_64(tmp_out, GPROrMemory::GPR(tmp_in), tmp_out); + self.assembler + .emit_mov(Size::S64, Location::XMM(tmp_out), ret); + + self.machine.release_temp_gpr(tmp_in); + self.machine.release_temp_xmm(tmp_out); + } + } + Operator::F64ConvertI64U => { + let loc = self.pop_value_released(); + let ret = + self.machine + .acquire_locations(&mut self.assembler, &[(WpType::F64)], false)[0]; + self.value_stack.push(ret); + self.fp_stack + .push(FloatValue::new(self.value_stack.len() - 1)); // Converting i64 to f64 never results in NaN. + + if self.assembler.arch_has_fconverti() { + let tmp_out = self.machine.acquire_temp_xmm().unwrap(); + let tmp_in = self.machine.acquire_temp_gpr().unwrap(); + self.emit_relaxed_binop( + Assembler::emit_mov, + Size::S64, + loc, + Location::GPR(tmp_in), + ); + self.assembler.arch_emit_f64_convert_ui64(tmp_in, tmp_out); + self.emit_relaxed_binop( + Assembler::emit_mov, + Size::S64, + Location::XMM(tmp_out), + ret, + ); + self.machine.release_temp_gpr(tmp_in); + self.machine.release_temp_xmm(tmp_out); + } else { + let tmp_out = self.machine.acquire_temp_xmm().unwrap(); + let tmp_in = self.machine.acquire_temp_gpr().unwrap(); + let tmp = self.machine.acquire_temp_gpr().unwrap(); + + let do_convert = self.assembler.get_label(); + let end_convert = self.assembler.get_label(); + + self.assembler + .emit_mov(Size::S64, loc, Location::GPR(tmp_in)); + self.assembler.emit_test_gpr_64(tmp_in); + self.assembler.emit_jmp(Condition::Signed, do_convert); + self.assembler + .emit_vcvtsi2sd_64(tmp_out, GPROrMemory::GPR(tmp_in), tmp_out); + self.assembler.emit_jmp(Condition::None, end_convert); + self.assembler.emit_label(do_convert); + self.assembler + .emit_mov(Size::S64, Location::GPR(tmp_in), Location::GPR(tmp)); + self.assembler + .emit_and(Size::S64, Location::Imm32(1), Location::GPR(tmp)); + self.assembler + .emit_shr(Size::S64, Location::Imm8(1), Location::GPR(tmp_in)); + self.assembler + .emit_or(Size::S64, Location::GPR(tmp), Location::GPR(tmp_in)); + self.assembler + .emit_vcvtsi2sd_64(tmp_out, GPROrMemory::GPR(tmp_in), tmp_out); + self.assembler + .emit_vaddsd(tmp_out, XMMOrMemory::XMM(tmp_out), tmp_out); + self.assembler.emit_label(end_convert); + self.assembler + .emit_mov(Size::S64, Location::XMM(tmp_out), ret); + + self.machine.release_temp_gpr(tmp); + self.machine.release_temp_gpr(tmp_in); + self.machine.release_temp_xmm(tmp_out); + } + } + + Operator::Call { function_index } => { + self.emit_call(FunctionIndex::from_u32(function_index))? + } + Operator::CallIndirect { + type_index, + table_index, + table_byte: _, + } => { + // TODO: removed restriction on always being table idx 0; + // does any code depend on this? + let table_index = TableIndex::new(table_index as _); + let index = SignatureIndex::new(type_index as usize); + let sig = self.module.signatures.get(index).unwrap(); + let param_types: SmallVec<[WpType; 8]> = + sig.params().iter().cloned().map(type_to_wp_type).collect(); + let return_types: SmallVec<[WpType; 1]> = + sig.results().iter().cloned().map(type_to_wp_type).collect(); + + let func_index = self.pop_value_released(); + + let params: SmallVec<[_; 8]> = self + .value_stack + .drain(self.value_stack.len() - param_types.len()..) + .collect(); + self.machine.release_locations_only_regs(¶ms); + + // Pop arguments off the FP stack and canonicalize them if needed. + // + // Canonicalization state will be lost across function calls, so early canonicalization + // is necessary here. + while let Some(fp) = self.fp_stack.last() { + if fp.depth >= self.value_stack.len() { + let index = fp.depth - self.value_stack.len(); + if self.assembler.arch_supports_canonicalize_nan() + && self.config.enable_nan_canonicalization + && fp.canonicalization.is_some() + { + let size = fp.canonicalization.unwrap().to_size(); + self.canonicalize_nan(size, params[index], params[index]); + } + self.fp_stack.pop().unwrap(); + } else { + break; + } + } + + let table_base = self.machine.acquire_temp_gpr().unwrap(); + let table_count = self.machine.acquire_temp_gpr().unwrap(); + let sigidx = self.machine.acquire_temp_gpr().unwrap(); + + if let Some(local_table_index) = self.module.local_table_index(table_index) { + let (vmctx_offset_base, vmctx_offset_len) = ( + self.vmoffsets.vmctx_vmtable_definition(local_table_index), + self.vmoffsets + .vmctx_vmtable_definition_current_elements(local_table_index), + ); + self.assembler.emit_mov( + Size::S64, + Location::Memory(Machine::get_vmctx_reg(), vmctx_offset_base as i32), + Location::GPR(table_base), + ); + self.assembler.emit_mov( + Size::S32, + Location::Memory(Machine::get_vmctx_reg(), vmctx_offset_len as i32), + Location::GPR(table_count), + ); + } else { + // Do an indirection. + let import_offset = self.vmoffsets.vmctx_vmtable_import(table_index); + self.assembler.emit_mov( + Size::S64, + Location::Memory(Machine::get_vmctx_reg(), import_offset as i32), + Location::GPR(table_base), + ); + + // Load len. + self.assembler.emit_mov( + Size::S32, + Location::Memory( + table_base, + self.vmoffsets.vmtable_definition_current_elements() as _, + ), + Location::GPR(table_count), + ); + + // Load base. + self.assembler.emit_mov( + Size::S64, + Location::Memory(table_base, self.vmoffsets.vmtable_definition_base() as _), + Location::GPR(table_base), + ); + } + + self.assembler + .emit_cmp(Size::S32, func_index, Location::GPR(table_count)); + self.assembler + .emit_jmp(Condition::BelowEqual, self.special_labels.table_access_oob); + self.assembler + .emit_mov(Size::S32, func_index, Location::GPR(table_count)); + self.assembler + .emit_imul_imm32_gpr64(self.vmoffsets.size_of_vm_funcref() as u32, table_count); + self.assembler.emit_add( + Size::S64, + Location::GPR(table_base), + Location::GPR(table_count), + ); + + // deref the table to get a VMFuncRef + self.assembler.emit_mov( + Size::S64, + Location::Memory(table_count, self.vmoffsets.vm_funcref_anyfunc_ptr() as i32), + Location::GPR(table_count), + ); + // Trap if the FuncRef is null + self.assembler + .emit_cmp(Size::S64, Location::Imm32(0), Location::GPR(table_count)); + self.assembler + .emit_jmp(Condition::Equal, self.special_labels.indirect_call_null); + self.assembler.emit_mov( + Size::S64, + Location::Memory( + Machine::get_vmctx_reg(), + self.vmoffsets.vmctx_vmshared_signature_id(index) as i32, + ), + Location::GPR(sigidx), + ); + + // Trap if signature mismatches. + self.assembler.emit_cmp( + Size::S32, + Location::GPR(sigidx), + Location::Memory( + table_count, + (self.vmoffsets.vmcaller_checked_anyfunc_type_index() as usize) as i32, + ), + ); + self.assembler + .emit_jmp(Condition::NotEqual, self.special_labels.bad_signature); + + self.machine.release_temp_gpr(sigidx); + self.machine.release_temp_gpr(table_count); + self.machine.release_temp_gpr(table_base); + + if table_count != GPR::RAX { + self.assembler.emit_mov( + Size::S64, + Location::GPR(table_count), + Location::GPR(GPR::RAX), + ); + } + + let vmcaller_checked_anyfunc_func_ptr = + self.vmoffsets.vmcaller_checked_anyfunc_func_ptr() as usize; + let vmcaller_checked_anyfunc_vmctx = + self.vmoffsets.vmcaller_checked_anyfunc_vmctx() as usize; + let calling_convention = self.calling_convention; + + self.emit_call_native( + |this| { + if this.assembler.arch_requires_indirect_call_trampoline() { + this.assembler.arch_emit_indirect_call_with_trampoline( + Location::Memory( + GPR::RAX, + vmcaller_checked_anyfunc_func_ptr as i32, + ), + ); + } else { + // We set the context pointer + this.assembler.emit_mov( + Size::S64, + Location::Memory(GPR::RAX, vmcaller_checked_anyfunc_vmctx as i32), + Machine::get_param_location(0, calling_convention), + ); + + this.assembler.emit_call_location(Location::Memory( + GPR::RAX, + vmcaller_checked_anyfunc_func_ptr as i32, + )); + } + }, + params.iter().copied(), + )?; + + self.machine + .release_locations_only_stack(&mut self.assembler, ¶ms); + + if !return_types.is_empty() { + let ret = self.machine.acquire_locations( + &mut self.assembler, + &[return_types[0]], + false, + )[0]; + self.value_stack.push(ret); + if return_types[0].is_float() { + self.assembler + .emit_mov(Size::S64, Location::XMM(XMM::XMM0), ret); + self.fp_stack + .push(FloatValue::new(self.value_stack.len() - 1)); + } else { + self.assembler + .emit_mov(Size::S64, Location::GPR(GPR::RAX), ret); + } + } + } + Operator::If { blockty } => { + let label_end = self.assembler.get_label(); + let label_else = self.assembler.get_label(); + + let cond = self.pop_value_released(); + + let frame = ControlFrame { + br_label: label_end, + loop_like: false, + if_else: IfElseState::If(label_else), + returns: match blockty { + WpBlockType::Empty => smallvec![], + WpBlockType::Type(inner_ty) => smallvec![inner_ty], + WpBlockType::FuncType(_) => { + return Err(CodegenError { + message: "If: multi-value returns not yet implemented".to_string(), + }) + } + }, + value_stack_depth: self.value_stack.len(), + fp_stack_depth: self.fp_stack.len(), + }; + self.control_stack.push(frame); + self.emit_relaxed_binop(Assembler::emit_cmp, Size::S32, Location::Imm32(0), cond); + self.assembler.emit_jmp(Condition::Equal, label_else); + } + Operator::Else => { + let frame = self.control_stack.last_mut().unwrap(); + + if !was_unreachable && !frame.returns.is_empty() { + let first_return = frame.returns[0]; + let loc = *self.value_stack.last().unwrap(); + if first_return.is_float() { + let fp = self.fp_stack.peek1()?; + if self.assembler.arch_supports_canonicalize_nan() + && self.config.enable_nan_canonicalization + && fp.canonicalization.is_some() + { + self.canonicalize_nan( + match first_return { + WpType::F32 => Size::S32, + WpType::F64 => Size::S64, + _ => unreachable!(), + }, + loc, + Location::GPR(GPR::RAX), + ); + } else { + self.emit_relaxed_binop( + Assembler::emit_mov, + Size::S64, + loc, + Location::GPR(GPR::RAX), + ); + } + } else { + self.emit_relaxed_binop( + Assembler::emit_mov, + Size::S64, + loc, + Location::GPR(GPR::RAX), + ); + } + } + + let mut frame = self.control_stack.last_mut().unwrap(); + + let released: &[Location] = &self.value_stack[frame.value_stack_depth..]; + self.machine + .release_locations(&mut self.assembler, released); + self.value_stack.truncate(frame.value_stack_depth); + self.fp_stack.truncate(frame.fp_stack_depth); + + match frame.if_else { + IfElseState::If(label) => { + self.assembler.emit_jmp(Condition::None, frame.br_label); + self.assembler.emit_label(label); + frame.if_else = IfElseState::Else; + } + _ => { + return Err(CodegenError { + message: "Else: frame.if_else unreachable code".to_string(), + }) + } + } + } + // `TypedSelect` must be used for extern refs so ref counting should + // be done with TypedSelect. But otherwise they're the same. + Operator::TypedSelect { .. } | Operator::Select => { + let cond = self.pop_value_released(); + let v_b = self.pop_value_released(); + let v_a = self.pop_value_released(); + let cncl: Option<(Option, Option)> = + if self.fp_stack.len() >= 2 + && self.fp_stack[self.fp_stack.len() - 2].depth == self.value_stack.len() + && self.fp_stack[self.fp_stack.len() - 1].depth + == self.value_stack.len() + 1 + { + let (left, right) = self.fp_stack.pop2()?; + self.fp_stack.push(FloatValue::new(self.value_stack.len())); + Some((left.canonicalization, right.canonicalization)) + } else { + None + }; + let ret = + self.machine + .acquire_locations(&mut self.assembler, &[(WpType::I64)], false)[0]; + self.value_stack.push(ret); + + let end_label = self.assembler.get_label(); + let zero_label = self.assembler.get_label(); + + self.emit_relaxed_binop(Assembler::emit_cmp, Size::S32, Location::Imm32(0), cond); + self.assembler.emit_jmp(Condition::Equal, zero_label); + match cncl { + Some((Some(fp), _)) + if self.assembler.arch_supports_canonicalize_nan() + && self.config.enable_nan_canonicalization => + { + self.canonicalize_nan(fp.to_size(), v_a, ret); + } + _ => { + if v_a != ret { + self.emit_relaxed_binop(Assembler::emit_mov, Size::S64, v_a, ret); + } + } + } + self.assembler.emit_jmp(Condition::None, end_label); + self.assembler.emit_label(zero_label); + match cncl { + Some((_, Some(fp))) + if self.assembler.arch_supports_canonicalize_nan() + && self.config.enable_nan_canonicalization => + { + self.canonicalize_nan(fp.to_size(), v_b, ret); + } + _ => { + if v_b != ret { + self.emit_relaxed_binop(Assembler::emit_mov, Size::S64, v_b, ret); + } + } + } + self.assembler.emit_label(end_label); + } + Operator::Block { blockty } => { + let frame = ControlFrame { + br_label: self.assembler.get_label(), + loop_like: false, + if_else: IfElseState::None, + returns: match blockty { + WpBlockType::Empty => smallvec![], + WpBlockType::Type(inner_ty) => smallvec![inner_ty], + WpBlockType::FuncType(_) => { + return Err(CodegenError { + message: "Block: multi-value returns not yet implemented" + .to_string(), + }) + } + }, + value_stack_depth: self.value_stack.len(), + fp_stack_depth: self.fp_stack.len(), + }; + self.control_stack.push(frame); + } + Operator::Loop { blockty } => { + // Pad with NOPs to the next 16-byte boundary. + // Here we don't use the dynasm `.align 16` attribute because it pads the alignment with single-byte nops + // which may lead to efficiency problems. + match self.assembler.get_offset().0 % 16 { + 0 => {} + x => { + self.assembler.emit_nop_n(16 - x); + } + } + assert_eq!(self.assembler.get_offset().0 % 16, 0); + + let br_label = self.assembler.get_label(); + let _activate_offset = self.assembler.get_offset().0; + + self.control_stack.push(ControlFrame { + br_label, + loop_like: true, + if_else: IfElseState::None, + returns: match blockty { + WpBlockType::Empty => smallvec![], + WpBlockType::Type(inner_ty) => smallvec![inner_ty], + WpBlockType::FuncType(_) => { + return Err(CodegenError { + message: "Loop: multi-value returns not yet implemented" + .to_string(), + }) + } + }, + value_stack_depth: self.value_stack.len(), + fp_stack_depth: self.fp_stack.len(), + }); + self.assembler.emit_label(br_label); + + // TODO: Re-enable interrupt signal check without branching + } + Operator::Nop => {} + Operator::MemorySize { mem, mem_byte: _ } => { + let memory_index = MemoryIndex::new(mem as usize); + self.assembler.emit_mov( + Size::S64, + Location::Memory( + Machine::get_vmctx_reg(), + self.vmoffsets.vmctx_builtin_function( + if self.module.local_memory_index(memory_index).is_some() { + VMBuiltinFunctionIndex::get_memory32_size_index() + } else { + VMBuiltinFunctionIndex::get_imported_memory32_size_index() + }, + ) as i32, + ), + Location::GPR(GPR::RAX), + ); + self.emit_call_native( + |this| { + this.assembler.emit_call_register(GPR::RAX); + }, + // [vmctx, memory_index] + iter::once(Location::Imm32(memory_index.index() as u32)), + )?; + let ret = + self.machine + .acquire_locations(&mut self.assembler, &[(WpType::I64)], false)[0]; + self.value_stack.push(ret); + self.assembler + .emit_mov(Size::S64, Location::GPR(GPR::RAX), ret); + } + Operator::MemoryInit { data_index, mem } => { + let len = self.value_stack.pop().unwrap(); + let src = self.value_stack.pop().unwrap(); + let dst = self.value_stack.pop().unwrap(); + self.machine.release_locations_only_regs(&[len, src, dst]); + + self.assembler.emit_mov( + Size::S64, + Location::Memory( + Machine::get_vmctx_reg(), + self.vmoffsets + .vmctx_builtin_function(VMBuiltinFunctionIndex::get_memory_init_index()) + as i32, + ), + Location::GPR(GPR::RAX), + ); + + self.emit_call_native( + |this| { + this.assembler.emit_call_register(GPR::RAX); + }, + // [vmctx, memory_index, segment_index, dst, src, len] + [ + Location::Imm32(mem), + Location::Imm32(data_index), + dst, + src, + len, + ] + .iter() + .cloned(), + )?; + self.machine + .release_locations_only_stack(&mut self.assembler, &[dst, src, len]); + } + Operator::DataDrop { data_index } => { + self.assembler.emit_mov( + Size::S64, + Location::Memory( + Machine::get_vmctx_reg(), + self.vmoffsets + .vmctx_builtin_function(VMBuiltinFunctionIndex::get_data_drop_index()) + as i32, + ), + Location::GPR(GPR::RAX), + ); + + self.emit_call_native( + |this| { + this.assembler.emit_call_register(GPR::RAX); + }, + // [vmctx, segment_index] + iter::once(Location::Imm32(data_index)), + )?; + } + Operator::MemoryCopy { src_mem, dst_mem } => { + // ignore until we support multiple memories + let _dst = dst_mem; + let len = self.value_stack.pop().unwrap(); + let src_pos = self.value_stack.pop().unwrap(); + let dst_pos = self.value_stack.pop().unwrap(); + self.machine + .release_locations_only_regs(&[len, src_pos, dst_pos]); + + let memory_index = MemoryIndex::new(src_mem as usize); + let (memory_copy_index, memory_index) = + if self.module.local_memory_index(memory_index).is_some() { + ( + VMBuiltinFunctionIndex::get_memory_copy_index(), + memory_index, + ) + } else { + ( + VMBuiltinFunctionIndex::get_imported_memory_copy_index(), + memory_index, + ) + }; + + self.assembler.emit_mov( + Size::S64, + Location::Memory( + Machine::get_vmctx_reg(), + self.vmoffsets.vmctx_builtin_function(memory_copy_index) as i32, + ), + Location::GPR(GPR::RAX), + ); + + self.emit_call_native( + |this| { + this.assembler.emit_call_register(GPR::RAX); + }, + // [vmctx, memory_index, dst, src, len] + [ + Location::Imm32(memory_index.index() as u32), + dst_pos, + src_pos, + len, + ] + .iter() + .cloned(), + )?; + self.machine + .release_locations_only_stack(&mut self.assembler, &[dst_pos, src_pos, len]); + } + Operator::MemoryFill { mem } => { + let len = self.value_stack.pop().unwrap(); + let val = self.value_stack.pop().unwrap(); + let dst = self.value_stack.pop().unwrap(); + self.machine.release_locations_only_regs(&[len, val, dst]); + + let memory_index = MemoryIndex::new(mem as usize); + let (memory_fill_index, memory_index) = + if self.module.local_memory_index(memory_index).is_some() { + ( + VMBuiltinFunctionIndex::get_memory_fill_index(), + memory_index, + ) + } else { + ( + VMBuiltinFunctionIndex::get_imported_memory_fill_index(), + memory_index, + ) + }; + + self.assembler.emit_mov( + Size::S64, + Location::Memory( + Machine::get_vmctx_reg(), + self.vmoffsets.vmctx_builtin_function(memory_fill_index) as i32, + ), + Location::GPR(GPR::RAX), + ); + + self.emit_call_native( + |this| { + this.assembler.emit_call_register(GPR::RAX); + }, + // [vmctx, memory_index, dst, src, len] + [Location::Imm32(memory_index.index() as u32), dst, val, len] + .iter() + .cloned(), + )?; + self.machine + .release_locations_only_stack(&mut self.assembler, &[dst, val, len]); + } + Operator::MemoryGrow { mem, mem_byte: _ } => { + let memory_index = MemoryIndex::new(mem as usize); + let param_pages = self.value_stack.pop().unwrap(); + + self.machine.release_locations_only_regs(&[param_pages]); + + self.assembler.emit_mov( + Size::S64, + Location::Memory( + Machine::get_vmctx_reg(), + self.vmoffsets.vmctx_builtin_function( + if self.module.local_memory_index(memory_index).is_some() { + VMBuiltinFunctionIndex::get_memory32_grow_index() + } else { + VMBuiltinFunctionIndex::get_imported_memory32_grow_index() + }, + ) as i32, + ), + Location::GPR(GPR::RAX), + ); + + self.emit_call_native( + |this| { + this.assembler.emit_call_register(GPR::RAX); + }, + // [vmctx, val, memory_index] + iter::once(param_pages) + .chain(iter::once(Location::Imm32(memory_index.index() as u32))), + )?; + + self.machine + .release_locations_only_stack(&mut self.assembler, &[param_pages]); + + let ret = + self.machine + .acquire_locations(&mut self.assembler, &[(WpType::I64)], false)[0]; + self.value_stack.push(ret); + self.assembler + .emit_mov(Size::S64, Location::GPR(GPR::RAX), ret); + } + Operator::I32Load { ref memarg } => { + let target = self.pop_value_released(); + let ret = + self.machine + .acquire_locations(&mut self.assembler, &[(WpType::I32)], false)[0]; + self.value_stack.push(ret); + + self.emit_memory_op(target, memarg, false, 4, |this, addr| { + this.emit_relaxed_binop( + Assembler::emit_mov, + Size::S32, + Location::Memory(addr, 0), + ret, + ); + Ok(()) + })?; + } + Operator::F32Load { ref memarg } => { + let target = self.pop_value_released(); + let ret = + self.machine + .acquire_locations(&mut self.assembler, &[(WpType::F32)], false)[0]; + self.value_stack.push(ret); + self.fp_stack + .push(FloatValue::new(self.value_stack.len() - 1)); + + self.emit_memory_op(target, memarg, false, 4, |this, addr| { + this.emit_relaxed_binop( + Assembler::emit_mov, + Size::S32, + Location::Memory(addr, 0), + ret, + ); + Ok(()) + })?; + } + Operator::I32Load8U { ref memarg } => { + let target = self.pop_value_released(); + let ret = + self.machine + .acquire_locations(&mut self.assembler, &[(WpType::I32)], false)[0]; + self.value_stack.push(ret); + + self.emit_memory_op(target, memarg, false, 1, |this, addr| { + this.emit_relaxed_zx_sx( + Assembler::emit_movzx, + Size::S8, + Location::Memory(addr, 0), + Size::S32, + ret, + )?; + Ok(()) + })?; + } + Operator::I32Load8S { ref memarg } => { + let target = self.pop_value_released(); + let ret = + self.machine + .acquire_locations(&mut self.assembler, &[(WpType::I32)], false)[0]; + self.value_stack.push(ret); + + self.emit_memory_op(target, memarg, false, 1, |this, addr| { + this.emit_relaxed_zx_sx( + Assembler::emit_movsx, + Size::S8, + Location::Memory(addr, 0), + Size::S32, + ret, + )?; + Ok(()) + })?; + } + Operator::I32Load16U { ref memarg } => { + let target = self.pop_value_released(); + let ret = + self.machine + .acquire_locations(&mut self.assembler, &[(WpType::I32)], false)[0]; + self.value_stack.push(ret); + + self.emit_memory_op(target, memarg, false, 2, |this, addr| { + this.emit_relaxed_zx_sx( + Assembler::emit_movzx, + Size::S16, + Location::Memory(addr, 0), + Size::S32, + ret, + )?; + Ok(()) + })?; + } + Operator::I32Load16S { ref memarg } => { + let target = self.pop_value_released(); + let ret = + self.machine + .acquire_locations(&mut self.assembler, &[(WpType::I32)], false)[0]; + self.value_stack.push(ret); + + self.emit_memory_op(target, memarg, false, 2, |this, addr| { + this.emit_relaxed_zx_sx( + Assembler::emit_movsx, + Size::S16, + Location::Memory(addr, 0), + Size::S32, + ret, + )?; + Ok(()) + })?; + } + Operator::I32Store { ref memarg } => { + let target_value = self.pop_value_released(); + let target_addr = self.pop_value_released(); + + self.emit_memory_op(target_addr, memarg, false, 4, |this, addr| { + this.emit_relaxed_binop( + Assembler::emit_mov, + Size::S32, + target_value, + Location::Memory(addr, 0), + ); + Ok(()) + })?; + } + Operator::F32Store { ref memarg } => { + let target_value = self.pop_value_released(); + let target_addr = self.pop_value_released(); + let fp = self.fp_stack.pop1()?; + let config_nan_canonicalization = self.config.enable_nan_canonicalization; + + self.emit_memory_op(target_addr, memarg, false, 4, |this, addr| { + if !this.assembler.arch_supports_canonicalize_nan() + || !config_nan_canonicalization + || fp.canonicalization.is_none() + { + this.emit_relaxed_binop( + Assembler::emit_mov, + Size::S32, + target_value, + Location::Memory(addr, 0), + ); + } else { + this.canonicalize_nan(Size::S32, target_value, Location::Memory(addr, 0)); + } + + Ok(()) + })?; + } + Operator::I32Store8 { ref memarg } => { + let target_value = self.pop_value_released(); + let target_addr = self.pop_value_released(); + + self.emit_memory_op(target_addr, memarg, false, 1, |this, addr| { + this.emit_relaxed_binop( + Assembler::emit_mov, + Size::S8, + target_value, + Location::Memory(addr, 0), + ); + Ok(()) + })?; + } + Operator::I32Store16 { ref memarg } => { + let target_value = self.pop_value_released(); + let target_addr = self.pop_value_released(); + + self.emit_memory_op(target_addr, memarg, false, 2, |this, addr| { + this.emit_relaxed_binop( + Assembler::emit_mov, + Size::S16, + target_value, + Location::Memory(addr, 0), + ); + Ok(()) + })?; + } + Operator::I64Load { ref memarg } => { + let target = self.pop_value_released(); + let ret = + self.machine + .acquire_locations(&mut self.assembler, &[(WpType::I64)], false)[0]; + self.value_stack.push(ret); + + self.emit_memory_op(target, memarg, false, 8, |this, addr| { + this.emit_relaxed_binop( + Assembler::emit_mov, + Size::S64, + Location::Memory(addr, 0), + ret, + ); + Ok(()) + })?; + } + Operator::F64Load { ref memarg } => { + let target = self.pop_value_released(); + let ret = + self.machine + .acquire_locations(&mut self.assembler, &[(WpType::F64)], false)[0]; + self.value_stack.push(ret); + self.fp_stack + .push(FloatValue::new(self.value_stack.len() - 1)); + + self.emit_memory_op(target, memarg, false, 8, |this, addr| { + this.emit_relaxed_binop( + Assembler::emit_mov, + Size::S64, + Location::Memory(addr, 0), + ret, + ); + Ok(()) + })?; + } + Operator::I64Load8U { ref memarg } => { + let target = self.pop_value_released(); + let ret = + self.machine + .acquire_locations(&mut self.assembler, &[(WpType::I64)], false)[0]; + self.value_stack.push(ret); + + self.emit_memory_op(target, memarg, false, 1, |this, addr| { + this.emit_relaxed_zx_sx( + Assembler::emit_movzx, + Size::S8, + Location::Memory(addr, 0), + Size::S64, + ret, + )?; + Ok(()) + })?; + } + Operator::I64Load8S { ref memarg } => { + let target = self.pop_value_released(); + let ret = + self.machine + .acquire_locations(&mut self.assembler, &[(WpType::I64)], false)[0]; + self.value_stack.push(ret); + + self.emit_memory_op(target, memarg, false, 1, |this, addr| { + this.emit_relaxed_zx_sx( + Assembler::emit_movsx, + Size::S8, + Location::Memory(addr, 0), + Size::S64, + ret, + )?; + Ok(()) + })?; + } + Operator::I64Load16U { ref memarg } => { + let target = self.pop_value_released(); + let ret = + self.machine + .acquire_locations(&mut self.assembler, &[(WpType::I64)], false)[0]; + self.value_stack.push(ret); + + self.emit_memory_op(target, memarg, false, 2, |this, addr| { + this.emit_relaxed_zx_sx( + Assembler::emit_movzx, + Size::S16, + Location::Memory(addr, 0), + Size::S64, + ret, + )?; + Ok(()) + })?; + } + Operator::I64Load16S { ref memarg } => { + let target = self.pop_value_released(); + let ret = + self.machine + .acquire_locations(&mut self.assembler, &[(WpType::I64)], false)[0]; + self.value_stack.push(ret); + + self.emit_memory_op(target, memarg, false, 2, |this, addr| { + this.emit_relaxed_zx_sx( + Assembler::emit_movsx, + Size::S16, + Location::Memory(addr, 0), + Size::S64, + ret, + )?; + Ok(()) + })?; + } + Operator::I64Load32U { ref memarg } => { + let target = self.pop_value_released(); + let ret = + self.machine + .acquire_locations(&mut self.assembler, &[(WpType::I64)], false)[0]; + self.value_stack.push(ret); + + self.emit_memory_op(target, memarg, false, 4, |this, addr| { + match ret { + Location::GPR(_) => {} + Location::Memory(base, offset) => { + this.assembler.emit_mov( + Size::S32, + Location::Imm32(0), + Location::Memory(base, offset + 4), + ); // clear upper bits + } + _ => { + return Err(CodegenError { + message: "I64Load32U ret: unreachable code".to_string(), + }) + } + } + this.emit_relaxed_binop( + Assembler::emit_mov, + Size::S32, + Location::Memory(addr, 0), + ret, + ); + Ok(()) + })?; + } + Operator::I64Load32S { ref memarg } => { + let target = self.pop_value_released(); + let ret = + self.machine + .acquire_locations(&mut self.assembler, &[(WpType::I64)], false)[0]; + self.value_stack.push(ret); + + self.emit_memory_op(target, memarg, false, 4, |this, addr| { + this.emit_relaxed_zx_sx( + Assembler::emit_movsx, + Size::S32, + Location::Memory(addr, 0), + Size::S64, + ret, + )?; + Ok(()) + })?; + } + Operator::I64Store { ref memarg } => { + let target_value = self.pop_value_released(); + let target_addr = self.pop_value_released(); + + self.emit_memory_op(target_addr, memarg, false, 8, |this, addr| { + this.emit_relaxed_binop( + Assembler::emit_mov, + Size::S64, + target_value, + Location::Memory(addr, 0), + ); + Ok(()) + })?; + } + Operator::F64Store { ref memarg } => { + let target_value = self.pop_value_released(); + let target_addr = self.pop_value_released(); + let fp = self.fp_stack.pop1()?; + let config_nan_canonicalization = self.config.enable_nan_canonicalization; + + self.emit_memory_op(target_addr, memarg, false, 8, |this, addr| { + if !this.assembler.arch_supports_canonicalize_nan() + || !config_nan_canonicalization + || fp.canonicalization.is_none() + { + this.emit_relaxed_binop( + Assembler::emit_mov, + Size::S64, + target_value, + Location::Memory(addr, 0), + ); + } else { + this.canonicalize_nan(Size::S64, target_value, Location::Memory(addr, 0)); + } + Ok(()) + })?; + } + Operator::I64Store8 { ref memarg } => { + let target_value = self.pop_value_released(); + let target_addr = self.pop_value_released(); + + self.emit_memory_op(target_addr, memarg, false, 1, |this, addr| { + this.emit_relaxed_binop( + Assembler::emit_mov, + Size::S8, + target_value, + Location::Memory(addr, 0), + ); + Ok(()) + })?; + } + Operator::I64Store16 { ref memarg } => { + let target_value = self.pop_value_released(); + let target_addr = self.pop_value_released(); + + self.emit_memory_op(target_addr, memarg, false, 2, |this, addr| { + this.emit_relaxed_binop( + Assembler::emit_mov, + Size::S16, + target_value, + Location::Memory(addr, 0), + ); + Ok(()) + })?; + } + Operator::I64Store32 { ref memarg } => { + let target_value = self.pop_value_released(); + let target_addr = self.pop_value_released(); + + self.emit_memory_op(target_addr, memarg, false, 4, |this, addr| { + this.emit_relaxed_binop( + Assembler::emit_mov, + Size::S32, + target_value, + Location::Memory(addr, 0), + ); + Ok(()) + })?; + } + Operator::Unreachable => { + let offset = self.assembler.get_offset().0; + self.emit_trap(TrapCode::UnreachableCodeReached); + self.mark_instruction_address_end(offset); + self.unreachable_depth = 1; + } + Operator::Return => { + let frame = &self.control_stack[0]; + if !frame.returns.is_empty() { + if frame.returns.len() != 1 { + return Err(CodegenError { + message: "Return: incorrect frame.returns".to_string(), + }); + } + let first_return = frame.returns[0]; + let loc = *self.value_stack.last().unwrap(); + if first_return.is_float() { + let fp = self.fp_stack.peek1()?; + if self.assembler.arch_supports_canonicalize_nan() + && self.config.enable_nan_canonicalization + && fp.canonicalization.is_some() + { + self.canonicalize_nan( + match first_return { + WpType::F32 => Size::S32, + WpType::F64 => Size::S64, + _ => unreachable!(), + }, + loc, + Location::GPR(GPR::RAX), + ); + } else { + self.emit_relaxed_binop( + Assembler::emit_mov, + Size::S64, + loc, + Location::GPR(GPR::RAX), + ); + } + } else { + self.emit_relaxed_binop( + Assembler::emit_mov, + Size::S64, + loc, + Location::GPR(GPR::RAX), + ); + } + } + let frame = &self.control_stack[0]; + let released = &self.value_stack[frame.value_stack_depth..]; + self.machine + .release_locations_keep_state(&mut self.assembler, released); + self.assembler.emit_jmp(Condition::None, frame.br_label); + self.unreachable_depth = 1; + } + Operator::Br { relative_depth } => { + let frame = + &self.control_stack[self.control_stack.len() - 1 - (relative_depth as usize)]; + if !frame.loop_like && !frame.returns.is_empty() { + if frame.returns.len() != 1 { + return Err(CodegenError { + message: "Br: incorrect frame.returns".to_string(), + }); + } + let first_return = frame.returns[0]; + let loc = *self.value_stack.last().unwrap(); + + if first_return.is_float() { + let fp = self.fp_stack.peek1()?; + if self.assembler.arch_supports_canonicalize_nan() + && self.config.enable_nan_canonicalization + && fp.canonicalization.is_some() + { + self.canonicalize_nan( + match first_return { + WpType::F32 => Size::S32, + WpType::F64 => Size::S64, + _ => unreachable!(), + }, + loc, + Location::GPR(GPR::RAX), + ); + } else { + self.emit_relaxed_binop( + Assembler::emit_mov, + Size::S64, + loc, + Location::GPR(GPR::RAX), + ); + } + } else { + self.assembler + .emit_mov(Size::S64, loc, Location::GPR(GPR::RAX)); + } + } + let frame = + &self.control_stack[self.control_stack.len() - 1 - (relative_depth as usize)]; + + let released = &self.value_stack[frame.value_stack_depth..]; + self.machine + .release_locations_keep_state(&mut self.assembler, released); + self.assembler.emit_jmp(Condition::None, frame.br_label); + self.unreachable_depth = 1; + } + Operator::BrIf { relative_depth } => { + let after = self.assembler.get_label(); + let cond = self.pop_value_released(); + self.emit_relaxed_binop(Assembler::emit_cmp, Size::S32, Location::Imm32(0), cond); + self.assembler.emit_jmp(Condition::Equal, after); + + let frame = + &self.control_stack[self.control_stack.len() - 1 - (relative_depth as usize)]; + if !frame.loop_like && !frame.returns.is_empty() { + if frame.returns.len() != 1 { + return Err(CodegenError { + message: "BrIf: incorrect frame.returns".to_string(), + }); + } + + let first_return = frame.returns[0]; + let loc = *self.value_stack.last().unwrap(); + if first_return.is_float() { + let fp = self.fp_stack.peek1()?; + if self.assembler.arch_supports_canonicalize_nan() + && self.config.enable_nan_canonicalization + && fp.canonicalization.is_some() + { + self.canonicalize_nan( + match first_return { + WpType::F32 => Size::S32, + WpType::F64 => Size::S64, + _ => unreachable!(), + }, + loc, + Location::GPR(GPR::RAX), + ); + } else { + self.emit_relaxed_binop( + Assembler::emit_mov, + Size::S64, + loc, + Location::GPR(GPR::RAX), + ); + } + } else { + self.assembler + .emit_mov(Size::S64, loc, Location::GPR(GPR::RAX)); + } + } + let frame = + &self.control_stack[self.control_stack.len() - 1 - (relative_depth as usize)]; + let released = &self.value_stack[frame.value_stack_depth..]; + self.machine + .release_locations_keep_state(&mut self.assembler, released); + self.assembler.emit_jmp(Condition::None, frame.br_label); + + self.assembler.emit_label(after); + } + Operator::BrTable { ref targets } => { + let default_target = targets.default(); + let targets = targets + .targets() + .collect::, _>>() + .map_err(|e| CodegenError { + message: format!("BrTable read_table: {:?}", e), + })?; + let cond = self.pop_value_released(); + let table_label = self.assembler.get_label(); + let mut table: Vec = vec![]; + let default_br = self.assembler.get_label(); + self.emit_relaxed_binop( + Assembler::emit_cmp, + Size::S32, + Location::Imm32(targets.len() as u32), + cond, + ); + self.assembler.emit_jmp(Condition::AboveEqual, default_br); + + self.assembler + .emit_lea_label(table_label, Location::GPR(GPR::RCX)); + self.assembler + .emit_mov(Size::S32, cond, Location::GPR(GPR::RDX)); + + let instr_size = self.assembler.get_jmp_instr_size(); + self.assembler + .emit_imul_imm32_gpr64(instr_size as _, GPR::RDX); + self.assembler.emit_add( + Size::S64, + Location::GPR(GPR::RCX), + Location::GPR(GPR::RDX), + ); + self.assembler.emit_jmp_location(Location::GPR(GPR::RDX)); + + for target in targets.iter() { + let label = self.assembler.get_label(); + self.assembler.emit_label(label); + table.push(label); + let frame = + &self.control_stack[self.control_stack.len() - 1 - (*target as usize)]; + if !frame.loop_like && !frame.returns.is_empty() { + if frame.returns.len() != 1 { + return Err(CodegenError { + message: format!( + "BrTable: incorrect frame.returns for {:?}", + target + ), + }); + } + + let first_return = frame.returns[0]; + let loc = *self.value_stack.last().unwrap(); + if first_return.is_float() { + let fp = self.fp_stack.peek1()?; + if self.assembler.arch_supports_canonicalize_nan() + && self.config.enable_nan_canonicalization + && fp.canonicalization.is_some() + { + self.canonicalize_nan( + match first_return { + WpType::F32 => Size::S32, + WpType::F64 => Size::S64, + _ => unreachable!(), + }, + loc, + Location::GPR(GPR::RAX), + ); + } else { + self.emit_relaxed_binop( + Assembler::emit_mov, + Size::S64, + loc, + Location::GPR(GPR::RAX), + ); + } + } else { + self.assembler + .emit_mov(Size::S64, loc, Location::GPR(GPR::RAX)); + } + } + let frame = + &self.control_stack[self.control_stack.len() - 1 - (*target as usize)]; + let released = &self.value_stack[frame.value_stack_depth..]; + self.machine + .release_locations_keep_state(&mut self.assembler, released); + self.assembler.emit_jmp(Condition::None, frame.br_label); + } + self.assembler.emit_label(default_br); + + { + let frame = &self.control_stack + [self.control_stack.len() - 1 - (default_target as usize)]; + if !frame.loop_like && !frame.returns.is_empty() { + if frame.returns.len() != 1 { + return Err(CodegenError { + message: "BrTable: incorrect frame.returns".to_string(), + }); + } + + let first_return = frame.returns[0]; + let loc = *self.value_stack.last().unwrap(); + if first_return.is_float() { + let fp = self.fp_stack.peek1()?; + if self.assembler.arch_supports_canonicalize_nan() + && self.config.enable_nan_canonicalization + && fp.canonicalization.is_some() + { + self.canonicalize_nan( + match first_return { + WpType::F32 => Size::S32, + WpType::F64 => Size::S64, + _ => unreachable!(), + }, + loc, + Location::GPR(GPR::RAX), + ); + } else { + self.emit_relaxed_binop( + Assembler::emit_mov, + Size::S64, + loc, + Location::GPR(GPR::RAX), + ); + } + } else { + self.assembler + .emit_mov(Size::S64, loc, Location::GPR(GPR::RAX)); + } + } + let frame = &self.control_stack + [self.control_stack.len() - 1 - (default_target as usize)]; + let released = &self.value_stack[frame.value_stack_depth..]; + self.machine + .release_locations_keep_state(&mut self.assembler, released); + self.assembler.emit_jmp(Condition::None, frame.br_label); + } + + self.assembler.emit_label(table_label); + for x in table { + self.assembler.emit_jmp(Condition::None, x); + } + self.unreachable_depth = 1; + } + Operator::Drop => { + self.pop_value_released(); + if let Some(x) = self.fp_stack.last() { + if x.depth == self.value_stack.len() { + self.fp_stack.pop1()?; + } + } + } + Operator::End => { + let frame = self.control_stack.pop().unwrap(); + + if !was_unreachable && !frame.returns.is_empty() { + let loc = *self.value_stack.last().unwrap(); + if frame.returns[0].is_float() { + let fp = self.fp_stack.peek1()?; + if self.assembler.arch_supports_canonicalize_nan() + && self.config.enable_nan_canonicalization + && fp.canonicalization.is_some() + { + self.canonicalize_nan( + match frame.returns[0] { + WpType::F32 => Size::S32, + WpType::F64 => Size::S64, + _ => unreachable!(), + }, + loc, + Location::GPR(GPR::RAX), + ); + } else { + self.emit_relaxed_binop( + Assembler::emit_mov, + Size::S64, + loc, + Location::GPR(GPR::RAX), + ); + } + } else { + self.emit_relaxed_binop( + Assembler::emit_mov, + Size::S64, + loc, + Location::GPR(GPR::RAX), + ); + } + } + + if self.control_stack.is_empty() { + self.assembler.emit_label(frame.br_label); + let local_count = self.local_count(); + self.machine.finalize_locals(&mut self.assembler); + + // Restore stack height + self.assembler.emit_add( + Size::S32, + Location::Imm32(self.stack_size), + Location::Memory( + Machine::get_vmctx_reg(), + self.vmoffsets.vmctx_stack_limit_begin() as i32, + ), + ); + + self.machine.restore_registers( + &mut self.assembler, + self.calling_convention, + local_count, + ); + self.assembler.emit_mov( + Size::S64, + Location::GPR(GPR::RBP), + Location::GPR(GPR::RSP), + ); + self.assembler.emit_pop(Size::S64, Location::GPR(GPR::RBP)); + + // Make a copy of the return value in XMM0, as required by the SysV CC. + match self.signature.results() { + [x] if *x == Type::F32 || *x == Type::F64 => { + self.assembler.emit_mov( + Size::S64, + Location::GPR(GPR::RAX), + Location::XMM(XMM::XMM0), + ); + } + _ => {} + } + self.assembler.emit_ret(); + } else { + let released = &self.value_stack[frame.value_stack_depth..]; + self.machine + .release_locations(&mut self.assembler, released); + self.value_stack.truncate(frame.value_stack_depth); + self.fp_stack.truncate(frame.fp_stack_depth); + + if !frame.loop_like { + self.assembler.emit_label(frame.br_label); + } + + if let IfElseState::If(label) = frame.if_else { + self.assembler.emit_label(label); + } + + if !frame.returns.is_empty() { + if frame.returns.len() != 1 { + return Err(CodegenError { + message: "End: incorrect frame.returns".to_string(), + }); + } + let loc = self.machine.acquire_locations( + &mut self.assembler, + &[(frame.returns[0])], + false, + )[0]; + self.assembler + .emit_mov(Size::S64, Location::GPR(GPR::RAX), loc); + self.value_stack.push(loc); + if frame.returns[0].is_float() { + self.fp_stack + .push(FloatValue::new(self.value_stack.len() - 1)); + // we already canonicalized at the `Br*` instruction or here previously. + } + } + } + } + Operator::AtomicFence => { + // Fence is a nop. + // + // Fence was added to preserve information about fences from + // source languages. If in the future Wasm extends the memory + // model, and if we hadn't recorded what fences used to be there, + // it would lead to data races that weren't present in the + // original source language. + } + Operator::I32AtomicLoad { ref memarg } => { + let target = self.pop_value_released(); + let ret = + self.machine + .acquire_locations(&mut self.assembler, &[(WpType::I32)], false)[0]; + self.value_stack.push(ret); + + self.emit_memory_op(target, memarg, true, 4, |this, addr| { + this.emit_relaxed_binop( + Assembler::emit_mov, + Size::S32, + Location::Memory(addr, 0), + ret, + ); + Ok(()) + })?; + } + Operator::I32AtomicLoad8U { ref memarg } => { + let target = self.pop_value_released(); + let ret = + self.machine + .acquire_locations(&mut self.assembler, &[(WpType::I32)], false)[0]; + self.value_stack.push(ret); + + self.emit_memory_op(target, memarg, true, 1, |this, addr| { + this.emit_relaxed_zx_sx( + Assembler::emit_movzx, + Size::S8, + Location::Memory(addr, 0), + Size::S32, + ret, + )?; + Ok(()) + })?; + } + Operator::I32AtomicLoad16U { ref memarg } => { + let target = self.pop_value_released(); + let ret = + self.machine + .acquire_locations(&mut self.assembler, &[(WpType::I32)], false)[0]; + self.value_stack.push(ret); + + self.emit_memory_op(target, memarg, true, 2, |this, addr| { + this.emit_relaxed_zx_sx( + Assembler::emit_movzx, + Size::S16, + Location::Memory(addr, 0), + Size::S32, + ret, + )?; + Ok(()) + })?; + } + Operator::I32AtomicStore { ref memarg } => { + let target_value = self.pop_value_released(); + let target_addr = self.pop_value_released(); + + self.emit_memory_op(target_addr, memarg, true, 4, |this, addr| { + this.emit_relaxed_binop( + Assembler::emit_xchg, + Size::S32, + target_value, + Location::Memory(addr, 0), + ); + Ok(()) + })?; + } + Operator::I32AtomicStore8 { ref memarg } => { + let target_value = self.pop_value_released(); + let target_addr = self.pop_value_released(); + + self.emit_memory_op(target_addr, memarg, true, 1, |this, addr| { + this.emit_relaxed_binop( + Assembler::emit_xchg, + Size::S8, + target_value, + Location::Memory(addr, 0), + ); + Ok(()) + })?; + } + Operator::I32AtomicStore16 { ref memarg } => { + let target_value = self.pop_value_released(); + let target_addr = self.pop_value_released(); + + self.emit_memory_op(target_addr, memarg, true, 2, |this, addr| { + this.emit_relaxed_binop( + Assembler::emit_xchg, + Size::S16, + target_value, + Location::Memory(addr, 0), + ); + Ok(()) + })?; + } + Operator::I64AtomicLoad { ref memarg } => { + let target = self.pop_value_released(); + let ret = + self.machine + .acquire_locations(&mut self.assembler, &[(WpType::I64)], false)[0]; + self.value_stack.push(ret); + + self.emit_memory_op(target, memarg, true, 8, |this, addr| { + this.emit_relaxed_binop( + Assembler::emit_mov, + Size::S64, + Location::Memory(addr, 0), + ret, + ); + Ok(()) + })?; + } + Operator::I64AtomicLoad8U { ref memarg } => { + let target = self.pop_value_released(); + let ret = + self.machine + .acquire_locations(&mut self.assembler, &[(WpType::I64)], false)[0]; + self.value_stack.push(ret); + + self.emit_memory_op(target, memarg, true, 1, |this, addr| { + this.emit_relaxed_zx_sx( + Assembler::emit_movzx, + Size::S8, + Location::Memory(addr, 0), + Size::S64, + ret, + )?; + Ok(()) + })?; + } + Operator::I64AtomicLoad16U { ref memarg } => { + let target = self.pop_value_released(); + let ret = + self.machine + .acquire_locations(&mut self.assembler, &[(WpType::I64)], false)[0]; + self.value_stack.push(ret); + + self.emit_memory_op(target, memarg, true, 2, |this, addr| { + this.emit_relaxed_zx_sx( + Assembler::emit_movzx, + Size::S16, + Location::Memory(addr, 0), + Size::S64, + ret, + )?; + Ok(()) + })?; + } + Operator::I64AtomicLoad32U { ref memarg } => { + let target = self.pop_value_released(); + let ret = + self.machine + .acquire_locations(&mut self.assembler, &[(WpType::I64)], false)[0]; + self.value_stack.push(ret); + + self.emit_memory_op(target, memarg, true, 4, |this, addr| { + match ret { + Location::GPR(_) => {} + Location::Memory(base, offset) => { + this.assembler.emit_mov( + Size::S32, + Location::Imm32(0), + Location::Memory(base, offset + 4), + ); // clear upper bits + } + _ => { + return Err(CodegenError { + message: "I64AtomicLoad32U ret: unreachable code".to_string(), + }) + } + } + this.emit_relaxed_binop( + Assembler::emit_mov, + Size::S32, + Location::Memory(addr, 0), + ret, + ); + Ok(()) + })?; + } + Operator::I64AtomicStore { ref memarg } => { + let target_value = self.pop_value_released(); + let target_addr = self.pop_value_released(); + + self.emit_memory_op(target_addr, memarg, true, 8, |this, addr| { + this.emit_relaxed_binop( + Assembler::emit_xchg, + Size::S64, + target_value, + Location::Memory(addr, 0), + ); + Ok(()) + })?; + } + Operator::I64AtomicStore8 { ref memarg } => { + let target_value = self.pop_value_released(); + let target_addr = self.pop_value_released(); + + self.emit_memory_op(target_addr, memarg, true, 1, |this, addr| { + this.emit_relaxed_binop( + Assembler::emit_xchg, + Size::S8, + target_value, + Location::Memory(addr, 0), + ); + Ok(()) + })?; + } + Operator::I64AtomicStore16 { ref memarg } => { + let target_value = self.pop_value_released(); + let target_addr = self.pop_value_released(); + + self.emit_memory_op(target_addr, memarg, true, 2, |this, addr| { + this.emit_relaxed_binop( + Assembler::emit_xchg, + Size::S16, + target_value, + Location::Memory(addr, 0), + ); + Ok(()) + })?; + } + Operator::I64AtomicStore32 { ref memarg } => { + let target_value = self.pop_value_released(); + let target_addr = self.pop_value_released(); + + self.emit_memory_op(target_addr, memarg, true, 4, |this, addr| { + this.emit_relaxed_binop( + Assembler::emit_xchg, + Size::S32, + target_value, + Location::Memory(addr, 0), + ); + Ok(()) + })?; + } + Operator::I32AtomicRmwAdd { ref memarg } => { + let loc = self.pop_value_released(); + let target = self.pop_value_released(); + let ret = + self.machine + .acquire_locations(&mut self.assembler, &[(WpType::I32)], false)[0]; + self.value_stack.push(ret); + + let value = self.machine.acquire_temp_gpr().unwrap(); + self.assembler + .emit_mov(Size::S32, loc, Location::GPR(value)); + self.emit_memory_op(target, memarg, true, 4, |this, addr| { + this.assembler.emit_lock_xadd( + Size::S32, + Location::GPR(value), + Location::Memory(addr, 0), + ); + Ok(()) + })?; + self.assembler + .emit_mov(Size::S32, Location::GPR(value), ret); + self.machine.release_temp_gpr(value); + } + Operator::I64AtomicRmwAdd { ref memarg } => { + let loc = self.pop_value_released(); + let target = self.pop_value_released(); + let ret = + self.machine + .acquire_locations(&mut self.assembler, &[(WpType::I64)], false)[0]; + self.value_stack.push(ret); + + let value = self.machine.acquire_temp_gpr().unwrap(); + self.assembler + .emit_mov(Size::S64, loc, Location::GPR(value)); + self.emit_memory_op(target, memarg, true, 8, |this, addr| { + this.assembler.emit_lock_xadd( + Size::S64, + Location::GPR(value), + Location::Memory(addr, 0), + ); + Ok(()) + })?; + self.assembler + .emit_mov(Size::S64, Location::GPR(value), ret); + self.machine.release_temp_gpr(value); + } + Operator::I32AtomicRmw8AddU { ref memarg } => { + let loc = self.pop_value_released(); + let target = self.pop_value_released(); + let ret = + self.machine + .acquire_locations(&mut self.assembler, &[(WpType::I32)], false)[0]; + self.value_stack.push(ret); + + let value = self.machine.acquire_temp_gpr().unwrap(); + self.assembler + .emit_movzx(Size::S8, loc, Size::S32, Location::GPR(value)); + self.emit_memory_op(target, memarg, true, 1, |this, addr| { + this.assembler.emit_lock_xadd( + Size::S8, + Location::GPR(value), + Location::Memory(addr, 0), + ); + Ok(()) + })?; + self.assembler + .emit_mov(Size::S32, Location::GPR(value), ret); + self.machine.release_temp_gpr(value); + } + Operator::I32AtomicRmw16AddU { ref memarg } => { + let loc = self.pop_value_released(); + let target = self.pop_value_released(); + let ret = + self.machine + .acquire_locations(&mut self.assembler, &[(WpType::I32)], false)[0]; + self.value_stack.push(ret); + + let value = self.machine.acquire_temp_gpr().unwrap(); + self.assembler + .emit_movzx(Size::S16, loc, Size::S32, Location::GPR(value)); + self.emit_memory_op(target, memarg, true, 2, |this, addr| { + this.assembler.emit_lock_xadd( + Size::S16, + Location::GPR(value), + Location::Memory(addr, 0), + ); + Ok(()) + })?; + self.assembler + .emit_mov(Size::S32, Location::GPR(value), ret); + self.machine.release_temp_gpr(value); + } + Operator::I64AtomicRmw8AddU { ref memarg } => { + let loc = self.pop_value_released(); + let target = self.pop_value_released(); + let ret = + self.machine + .acquire_locations(&mut self.assembler, &[(WpType::I64)], false)[0]; + self.value_stack.push(ret); + + let value = self.machine.acquire_temp_gpr().unwrap(); + self.assembler + .emit_movzx(Size::S8, loc, Size::S64, Location::GPR(value)); + self.emit_memory_op(target, memarg, true, 1, |this, addr| { + this.assembler.emit_lock_xadd( + Size::S8, + Location::GPR(value), + Location::Memory(addr, 0), + ); + Ok(()) + })?; + self.assembler + .emit_mov(Size::S64, Location::GPR(value), ret); + self.machine.release_temp_gpr(value); + } + Operator::I64AtomicRmw16AddU { ref memarg } => { + let loc = self.pop_value_released(); + let target = self.pop_value_released(); + let ret = + self.machine + .acquire_locations(&mut self.assembler, &[(WpType::I64)], false)[0]; + self.value_stack.push(ret); + + let value = self.machine.acquire_temp_gpr().unwrap(); + self.assembler + .emit_movzx(Size::S16, loc, Size::S64, Location::GPR(value)); + self.emit_memory_op(target, memarg, true, 2, |this, addr| { + this.assembler.emit_lock_xadd( + Size::S16, + Location::GPR(value), + Location::Memory(addr, 0), + ); + Ok(()) + })?; + self.assembler + .emit_mov(Size::S64, Location::GPR(value), ret); + self.machine.release_temp_gpr(value); + } + Operator::I64AtomicRmw32AddU { ref memarg } => { + let loc = self.pop_value_released(); + let target = self.pop_value_released(); + let ret = + self.machine + .acquire_locations(&mut self.assembler, &[(WpType::I64)], false)[0]; + self.value_stack.push(ret); + + let value = self.machine.acquire_temp_gpr().unwrap(); + self.assembler + .emit_mov(Size::S32, loc, Location::GPR(value)); + self.emit_memory_op(target, memarg, true, 4, |this, addr| { + this.assembler.emit_lock_xadd( + Size::S32, + Location::GPR(value), + Location::Memory(addr, 0), + ); + Ok(()) + })?; + self.assembler + .emit_mov(Size::S64, Location::GPR(value), ret); + self.machine.release_temp_gpr(value); + } + Operator::I32AtomicRmwSub { ref memarg } => { + let loc = self.pop_value_released(); + let target = self.pop_value_released(); + let ret = + self.machine + .acquire_locations(&mut self.assembler, &[(WpType::I32)], false)[0]; + self.value_stack.push(ret); + + let value = self.machine.acquire_temp_gpr().unwrap(); + self.assembler + .emit_mov(Size::S32, loc, Location::GPR(value)); + self.assembler.emit_neg(Size::S32, Location::GPR(value)); + self.emit_memory_op(target, memarg, true, 4, |this, addr| { + this.assembler.emit_lock_xadd( + Size::S32, + Location::GPR(value), + Location::Memory(addr, 0), + ); + Ok(()) + })?; + self.assembler + .emit_mov(Size::S32, Location::GPR(value), ret); + self.machine.release_temp_gpr(value); + } + Operator::I64AtomicRmwSub { ref memarg } => { + let loc = self.pop_value_released(); + let target = self.pop_value_released(); + let ret = + self.machine + .acquire_locations(&mut self.assembler, &[(WpType::I64)], false)[0]; + self.value_stack.push(ret); + + let value = self.machine.acquire_temp_gpr().unwrap(); + self.assembler + .emit_mov(Size::S64, loc, Location::GPR(value)); + self.assembler.emit_neg(Size::S64, Location::GPR(value)); + self.emit_memory_op(target, memarg, true, 8, |this, addr| { + this.assembler.emit_lock_xadd( + Size::S64, + Location::GPR(value), + Location::Memory(addr, 0), + ); + Ok(()) + })?; + self.assembler + .emit_mov(Size::S64, Location::GPR(value), ret); + self.machine.release_temp_gpr(value); + } + Operator::I32AtomicRmw8SubU { ref memarg } => { + let loc = self.pop_value_released(); + let target = self.pop_value_released(); + let ret = + self.machine + .acquire_locations(&mut self.assembler, &[(WpType::I32)], false)[0]; + self.value_stack.push(ret); + + let value = self.machine.acquire_temp_gpr().unwrap(); + self.assembler + .emit_movzx(Size::S8, loc, Size::S32, Location::GPR(value)); + self.assembler.emit_neg(Size::S8, Location::GPR(value)); + self.emit_memory_op(target, memarg, true, 1, |this, addr| { + this.assembler.emit_lock_xadd( + Size::S8, + Location::GPR(value), + Location::Memory(addr, 0), + ); + Ok(()) + })?; + self.assembler + .emit_mov(Size::S32, Location::GPR(value), ret); + self.machine.release_temp_gpr(value); + } + Operator::I32AtomicRmw16SubU { ref memarg } => { + let loc = self.pop_value_released(); + let target = self.pop_value_released(); + let ret = + self.machine + .acquire_locations(&mut self.assembler, &[(WpType::I32)], false)[0]; + self.value_stack.push(ret); + + let value = self.machine.acquire_temp_gpr().unwrap(); + self.assembler + .emit_movzx(Size::S16, loc, Size::S32, Location::GPR(value)); + self.assembler.emit_neg(Size::S16, Location::GPR(value)); + self.emit_memory_op(target, memarg, true, 2, |this, addr| { + this.assembler.emit_lock_xadd( + Size::S16, + Location::GPR(value), + Location::Memory(addr, 0), + ); + Ok(()) + })?; + self.assembler + .emit_mov(Size::S32, Location::GPR(value), ret); + self.machine.release_temp_gpr(value); + } + Operator::I64AtomicRmw8SubU { ref memarg } => { + let loc = self.pop_value_released(); + let target = self.pop_value_released(); + let ret = + self.machine + .acquire_locations(&mut self.assembler, &[(WpType::I64)], false)[0]; + self.value_stack.push(ret); + + let value = self.machine.acquire_temp_gpr().unwrap(); + self.assembler + .emit_movzx(Size::S8, loc, Size::S64, Location::GPR(value)); + self.assembler.emit_neg(Size::S8, Location::GPR(value)); + self.emit_memory_op(target, memarg, true, 1, |this, addr| { + this.assembler.emit_lock_xadd( + Size::S8, + Location::GPR(value), + Location::Memory(addr, 0), + ); + Ok(()) + })?; + self.assembler + .emit_mov(Size::S64, Location::GPR(value), ret); + self.machine.release_temp_gpr(value); + } + Operator::I64AtomicRmw16SubU { ref memarg } => { + let loc = self.pop_value_released(); + let target = self.pop_value_released(); + let ret = + self.machine + .acquire_locations(&mut self.assembler, &[(WpType::I64)], false)[0]; + self.value_stack.push(ret); + + let value = self.machine.acquire_temp_gpr().unwrap(); + self.assembler + .emit_movzx(Size::S16, loc, Size::S64, Location::GPR(value)); + self.assembler.emit_neg(Size::S16, Location::GPR(value)); + self.emit_memory_op(target, memarg, true, 2, |this, addr| { + this.assembler.emit_lock_xadd( + Size::S16, + Location::GPR(value), + Location::Memory(addr, 0), + ); + Ok(()) + })?; + self.assembler + .emit_mov(Size::S64, Location::GPR(value), ret); + self.machine.release_temp_gpr(value); + } + Operator::I64AtomicRmw32SubU { ref memarg } => { + let loc = self.pop_value_released(); + let target = self.pop_value_released(); + let ret = + self.machine + .acquire_locations(&mut self.assembler, &[(WpType::I64)], false)[0]; + self.value_stack.push(ret); + + let value = self.machine.acquire_temp_gpr().unwrap(); + self.assembler + .emit_mov(Size::S32, loc, Location::GPR(value)); + self.assembler.emit_neg(Size::S32, Location::GPR(value)); + self.emit_memory_op(target, memarg, true, 2, |this, addr| { + this.assembler.emit_lock_xadd( + Size::S32, + Location::GPR(value), + Location::Memory(addr, 0), + ); + Ok(()) + })?; + self.assembler + .emit_mov(Size::S64, Location::GPR(value), ret); + self.machine.release_temp_gpr(value); + } + Operator::I32AtomicRmwAnd { ref memarg } => { + let loc = self.pop_value_released(); + let target = self.pop_value_released(); + let ret = + self.machine + .acquire_locations(&mut self.assembler, &[(WpType::I32)], false)[0]; + self.value_stack.push(ret); + + self.emit_compare_and_swap( + loc, + target, + ret, + memarg, + 4, + Size::S32, + Size::S32, + |this, src, dst| { + this.assembler + .emit_and(Size::S32, Location::GPR(src), Location::GPR(dst)); + }, + )?; + } + Operator::I64AtomicRmwAnd { ref memarg } => { + let loc = self.pop_value_released(); + let target = self.pop_value_released(); + let ret = + self.machine + .acquire_locations(&mut self.assembler, &[(WpType::I64)], false)[0]; + self.value_stack.push(ret); + + self.emit_compare_and_swap( + loc, + target, + ret, + memarg, + 8, + Size::S64, + Size::S64, + |this, src, dst| { + this.assembler + .emit_and(Size::S64, Location::GPR(src), Location::GPR(dst)); + }, + )?; + } + Operator::I32AtomicRmw8AndU { ref memarg } => { + let loc = self.pop_value_released(); + let target = self.pop_value_released(); + let ret = + self.machine + .acquire_locations(&mut self.assembler, &[(WpType::I32)], false)[0]; + self.value_stack.push(ret); + + self.emit_compare_and_swap( + loc, + target, + ret, + memarg, + 1, + Size::S8, + Size::S32, + |this, src, dst| { + this.assembler + .emit_and(Size::S32, Location::GPR(src), Location::GPR(dst)); + }, + )?; + } + Operator::I32AtomicRmw16AndU { ref memarg } => { + let loc = self.pop_value_released(); + let target = self.pop_value_released(); + let ret = + self.machine + .acquire_locations(&mut self.assembler, &[(WpType::I32)], false)[0]; + self.value_stack.push(ret); + + self.emit_compare_and_swap( + loc, + target, + ret, + memarg, + 1, + Size::S16, + Size::S32, + |this, src, dst| { + this.assembler + .emit_and(Size::S32, Location::GPR(src), Location::GPR(dst)); + }, + )?; + } + Operator::I64AtomicRmw8AndU { ref memarg } => { + let loc = self.pop_value_released(); + let target = self.pop_value_released(); + let ret = + self.machine + .acquire_locations(&mut self.assembler, &[(WpType::I64)], false)[0]; + self.value_stack.push(ret); + + self.emit_compare_and_swap( + loc, + target, + ret, + memarg, + 1, + Size::S8, + Size::S64, + |this, src, dst| { + this.assembler + .emit_and(Size::S64, Location::GPR(src), Location::GPR(dst)); + }, + )?; + } + Operator::I64AtomicRmw16AndU { ref memarg } => { + let loc = self.pop_value_released(); + let target = self.pop_value_released(); + let ret = + self.machine + .acquire_locations(&mut self.assembler, &[(WpType::I64)], false)[0]; + self.value_stack.push(ret); + + self.emit_compare_and_swap( + loc, + target, + ret, + memarg, + 1, + Size::S16, + Size::S64, + |this, src, dst| { + this.assembler + .emit_and(Size::S64, Location::GPR(src), Location::GPR(dst)); + }, + )?; + } + Operator::I64AtomicRmw32AndU { ref memarg } => { + let loc = self.pop_value_released(); + let target = self.pop_value_released(); + let ret = + self.machine + .acquire_locations(&mut self.assembler, &[(WpType::I64)], false)[0]; + self.value_stack.push(ret); + + self.emit_compare_and_swap( + loc, + target, + ret, + memarg, + 1, + Size::S32, + Size::S64, + |this, src, dst| { + this.assembler + .emit_and(Size::S64, Location::GPR(src), Location::GPR(dst)); + }, + )?; + } + Operator::I32AtomicRmwOr { ref memarg } => { + let loc = self.pop_value_released(); + let target = self.pop_value_released(); + let ret = + self.machine + .acquire_locations(&mut self.assembler, &[(WpType::I32)], false)[0]; + self.value_stack.push(ret); + + self.emit_compare_and_swap( + loc, + target, + ret, + memarg, + 4, + Size::S32, + Size::S32, + |this, src, dst| { + this.assembler + .emit_or(Size::S32, Location::GPR(src), Location::GPR(dst)); + }, + )?; + } + Operator::I64AtomicRmwOr { ref memarg } => { + let loc = self.pop_value_released(); + let target = self.pop_value_released(); + let ret = + self.machine + .acquire_locations(&mut self.assembler, &[(WpType::I64)], false)[0]; + self.value_stack.push(ret); + + self.emit_compare_and_swap( + loc, + target, + ret, + memarg, + 8, + Size::S64, + Size::S64, + |this, src, dst| { + this.assembler + .emit_or(Size::S64, Location::GPR(src), Location::GPR(dst)); + }, + )?; + } + Operator::I32AtomicRmw8OrU { ref memarg } => { + let loc = self.pop_value_released(); + let target = self.pop_value_released(); + let ret = + self.machine + .acquire_locations(&mut self.assembler, &[(WpType::I32)], false)[0]; + self.value_stack.push(ret); + + self.emit_compare_and_swap( + loc, + target, + ret, + memarg, + 1, + Size::S8, + Size::S32, + |this, src, dst| { + this.assembler + .emit_or(Size::S32, Location::GPR(src), Location::GPR(dst)); + }, + )?; + } + Operator::I32AtomicRmw16OrU { ref memarg } => { + let loc = self.pop_value_released(); + let target = self.pop_value_released(); + let ret = + self.machine + .acquire_locations(&mut self.assembler, &[(WpType::I32)], false)[0]; + self.value_stack.push(ret); + + self.emit_compare_and_swap( + loc, + target, + ret, + memarg, + 1, + Size::S16, + Size::S32, + |this, src, dst| { + this.assembler + .emit_or(Size::S32, Location::GPR(src), Location::GPR(dst)); + }, + )?; + } + Operator::I64AtomicRmw8OrU { ref memarg } => { + let loc = self.pop_value_released(); + let target = self.pop_value_released(); + let ret = + self.machine + .acquire_locations(&mut self.assembler, &[(WpType::I64)], false)[0]; + self.value_stack.push(ret); + + self.emit_compare_and_swap( + loc, + target, + ret, + memarg, + 1, + Size::S8, + Size::S64, + |this, src, dst| { + this.assembler + .emit_or(Size::S64, Location::GPR(src), Location::GPR(dst)); + }, + )?; + } + Operator::I64AtomicRmw16OrU { ref memarg } => { + let loc = self.pop_value_released(); + let target = self.pop_value_released(); + let ret = + self.machine + .acquire_locations(&mut self.assembler, &[(WpType::I64)], false)[0]; + self.value_stack.push(ret); + + self.emit_compare_and_swap( + loc, + target, + ret, + memarg, + 1, + Size::S16, + Size::S64, + |this, src, dst| { + this.assembler + .emit_or(Size::S64, Location::GPR(src), Location::GPR(dst)); + }, + )?; + } + Operator::I64AtomicRmw32OrU { ref memarg } => { + let loc = self.pop_value_released(); + let target = self.pop_value_released(); + let ret = + self.machine + .acquire_locations(&mut self.assembler, &[(WpType::I64)], false)[0]; + self.value_stack.push(ret); + + self.emit_compare_and_swap( + loc, + target, + ret, + memarg, + 1, + Size::S32, + Size::S64, + |this, src, dst| { + this.assembler + .emit_or(Size::S64, Location::GPR(src), Location::GPR(dst)); + }, + )?; + } + Operator::I32AtomicRmwXor { ref memarg } => { + let loc = self.pop_value_released(); + let target = self.pop_value_released(); + let ret = + self.machine + .acquire_locations(&mut self.assembler, &[(WpType::I32)], false)[0]; + self.value_stack.push(ret); + + self.emit_compare_and_swap( + loc, + target, + ret, + memarg, + 4, + Size::S32, + Size::S32, + |this, src, dst| { + this.assembler + .emit_xor(Size::S32, Location::GPR(src), Location::GPR(dst)); + }, + )?; + } + Operator::I64AtomicRmwXor { ref memarg } => { + let loc = self.pop_value_released(); + let target = self.pop_value_released(); + let ret = + self.machine + .acquire_locations(&mut self.assembler, &[(WpType::I64)], false)[0]; + self.value_stack.push(ret); + + self.emit_compare_and_swap( + loc, + target, + ret, + memarg, + 8, + Size::S64, + Size::S64, + |this, src, dst| { + this.assembler + .emit_xor(Size::S64, Location::GPR(src), Location::GPR(dst)); + }, + )?; + } + Operator::I32AtomicRmw8XorU { ref memarg } => { + let loc = self.pop_value_released(); + let target = self.pop_value_released(); + let ret = + self.machine + .acquire_locations(&mut self.assembler, &[(WpType::I32)], false)[0]; + self.value_stack.push(ret); + + self.emit_compare_and_swap( + loc, + target, + ret, + memarg, + 1, + Size::S8, + Size::S32, + |this, src, dst| { + this.assembler + .emit_xor(Size::S32, Location::GPR(src), Location::GPR(dst)); + }, + )?; + } + Operator::I32AtomicRmw16XorU { ref memarg } => { + let loc = self.pop_value_released(); + let target = self.pop_value_released(); + let ret = + self.machine + .acquire_locations(&mut self.assembler, &[(WpType::I32)], false)[0]; + self.value_stack.push(ret); + + self.emit_compare_and_swap( + loc, + target, + ret, + memarg, + 1, + Size::S16, + Size::S32, + |this, src, dst| { + this.assembler + .emit_xor(Size::S32, Location::GPR(src), Location::GPR(dst)); + }, + )?; + } + Operator::I64AtomicRmw8XorU { ref memarg } => { + let loc = self.pop_value_released(); + let target = self.pop_value_released(); + let ret = + self.machine + .acquire_locations(&mut self.assembler, &[(WpType::I64)], false)[0]; + self.value_stack.push(ret); + + self.emit_compare_and_swap( + loc, + target, + ret, + memarg, + 1, + Size::S8, + Size::S64, + |this, src, dst| { + this.assembler + .emit_xor(Size::S64, Location::GPR(src), Location::GPR(dst)); + }, + )?; + } + Operator::I64AtomicRmw16XorU { ref memarg } => { + let loc = self.pop_value_released(); + let target = self.pop_value_released(); + let ret = + self.machine + .acquire_locations(&mut self.assembler, &[(WpType::I64)], false)[0]; + self.value_stack.push(ret); + + self.emit_compare_and_swap( + loc, + target, + ret, + memarg, + 1, + Size::S16, + Size::S64, + |this, src, dst| { + this.assembler + .emit_xor(Size::S64, Location::GPR(src), Location::GPR(dst)); + }, + )?; + } + Operator::I64AtomicRmw32XorU { ref memarg } => { + let loc = self.pop_value_released(); + let target = self.pop_value_released(); + let ret = + self.machine + .acquire_locations(&mut self.assembler, &[(WpType::I64)], false)[0]; + self.value_stack.push(ret); + + self.emit_compare_and_swap( + loc, + target, + ret, + memarg, + 1, + Size::S32, + Size::S64, + |this, src, dst| { + this.assembler + .emit_xor(Size::S64, Location::GPR(src), Location::GPR(dst)); + }, + )?; + } + Operator::I32AtomicRmwXchg { ref memarg } => { + let loc = self.pop_value_released(); + let target = self.pop_value_released(); + let ret = + self.machine + .acquire_locations(&mut self.assembler, &[(WpType::I32)], false)[0]; + self.value_stack.push(ret); + + let value = self.machine.acquire_temp_gpr().unwrap(); + self.assembler + .emit_mov(Size::S32, loc, Location::GPR(value)); + self.emit_memory_op(target, memarg, true, 4, |this, addr| { + this.assembler.emit_xchg( + Size::S32, + Location::GPR(value), + Location::Memory(addr, 0), + ); + Ok(()) + })?; + self.assembler + .emit_mov(Size::S32, Location::GPR(value), ret); + self.machine.release_temp_gpr(value); + } + Operator::I64AtomicRmwXchg { ref memarg } => { + let loc = self.pop_value_released(); + let target = self.pop_value_released(); + let ret = + self.machine + .acquire_locations(&mut self.assembler, &[(WpType::I64)], false)[0]; + self.value_stack.push(ret); + + let value = self.machine.acquire_temp_gpr().unwrap(); + self.assembler + .emit_mov(Size::S64, loc, Location::GPR(value)); + self.emit_memory_op(target, memarg, true, 8, |this, addr| { + this.assembler.emit_xchg( + Size::S64, + Location::GPR(value), + Location::Memory(addr, 0), + ); + Ok(()) + })?; + self.assembler + .emit_mov(Size::S64, Location::GPR(value), ret); + self.machine.release_temp_gpr(value); + } + Operator::I32AtomicRmw8XchgU { ref memarg } => { + let loc = self.pop_value_released(); + let target = self.pop_value_released(); + let ret = + self.machine + .acquire_locations(&mut self.assembler, &[(WpType::I32)], false)[0]; + self.value_stack.push(ret); + + let value = self.machine.acquire_temp_gpr().unwrap(); + self.assembler + .emit_movzx(Size::S8, loc, Size::S32, Location::GPR(value)); + self.emit_memory_op(target, memarg, true, 1, |this, addr| { + this.assembler.emit_xchg( + Size::S8, + Location::GPR(value), + Location::Memory(addr, 0), + ); + Ok(()) + })?; + self.assembler + .emit_mov(Size::S32, Location::GPR(value), ret); + self.machine.release_temp_gpr(value); + } + Operator::I32AtomicRmw16XchgU { ref memarg } => { + let loc = self.pop_value_released(); + let target = self.pop_value_released(); + let ret = + self.machine + .acquire_locations(&mut self.assembler, &[(WpType::I32)], false)[0]; + self.value_stack.push(ret); + + let value = self.machine.acquire_temp_gpr().unwrap(); + self.assembler + .emit_movzx(Size::S16, loc, Size::S32, Location::GPR(value)); + self.emit_memory_op(target, memarg, true, 2, |this, addr| { + this.assembler.emit_xchg( + Size::S16, + Location::GPR(value), + Location::Memory(addr, 0), + ); + Ok(()) + })?; + self.assembler + .emit_mov(Size::S32, Location::GPR(value), ret); + self.machine.release_temp_gpr(value); + } + Operator::I64AtomicRmw8XchgU { ref memarg } => { + let loc = self.pop_value_released(); + let target = self.pop_value_released(); + let ret = + self.machine + .acquire_locations(&mut self.assembler, &[(WpType::I64)], false)[0]; + self.value_stack.push(ret); + + let value = self.machine.acquire_temp_gpr().unwrap(); + self.assembler + .emit_movzx(Size::S8, loc, Size::S64, Location::GPR(value)); + self.emit_memory_op(target, memarg, true, 1, |this, addr| { + this.assembler.emit_xchg( + Size::S8, + Location::GPR(value), + Location::Memory(addr, 0), + ); + Ok(()) + })?; + self.assembler + .emit_mov(Size::S64, Location::GPR(value), ret); + self.machine.release_temp_gpr(value); + } + Operator::I64AtomicRmw16XchgU { ref memarg } => { + let loc = self.pop_value_released(); + let target = self.pop_value_released(); + let ret = + self.machine + .acquire_locations(&mut self.assembler, &[(WpType::I64)], false)[0]; + self.value_stack.push(ret); + + let value = self.machine.acquire_temp_gpr().unwrap(); + self.assembler + .emit_movzx(Size::S16, loc, Size::S64, Location::GPR(value)); + self.emit_memory_op(target, memarg, true, 2, |this, addr| { + this.assembler.emit_xchg( + Size::S16, + Location::GPR(value), + Location::Memory(addr, 0), + ); + Ok(()) + })?; + self.assembler + .emit_mov(Size::S64, Location::GPR(value), ret); + self.machine.release_temp_gpr(value); + } + Operator::I64AtomicRmw32XchgU { ref memarg } => { + let loc = self.pop_value_released(); + let target = self.pop_value_released(); + let ret = + self.machine + .acquire_locations(&mut self.assembler, &[(WpType::I64)], false)[0]; + self.value_stack.push(ret); + + let value = self.machine.acquire_temp_gpr().unwrap(); + self.assembler + .emit_mov(Size::S32, loc, Location::GPR(value)); + self.emit_memory_op(target, memarg, true, 4, |this, addr| { + this.assembler.emit_xchg( + Size::S32, + Location::GPR(value), + Location::Memory(addr, 0), + ); + Ok(()) + })?; + self.assembler + .emit_mov(Size::S64, Location::GPR(value), ret); + self.machine.release_temp_gpr(value); + } + Operator::I32AtomicRmwCmpxchg { ref memarg } => { + let new = self.pop_value_released(); + let cmp = self.pop_value_released(); + let target = self.pop_value_released(); + let ret = + self.machine + .acquire_locations(&mut self.assembler, &[(WpType::I32)], false)[0]; + self.value_stack.push(ret); + + let compare = self.machine.reserve_unused_temp_gpr(GPR::RAX); + let value = if cmp == Location::GPR(GPR::R14) { + if new == Location::GPR(GPR::R13) { + GPR::R12 + } else { + GPR::R13 + } + } else { + GPR::R14 + }; + self.assembler.emit_push(Size::S64, Location::GPR(value)); + self.assembler + .emit_mov(Size::S32, cmp, Location::GPR(compare)); + self.assembler + .emit_mov(Size::S32, new, Location::GPR(value)); + + self.emit_memory_op(target, memarg, true, 4, |this, addr| { + this.assembler.emit_lock_cmpxchg( + Size::S32, + Location::GPR(value), + Location::Memory(addr, 0), + ); + this.assembler + .emit_mov(Size::S32, Location::GPR(compare), ret); + Ok(()) + })?; + self.assembler.emit_pop(Size::S64, Location::GPR(value)); + self.machine.release_temp_gpr(compare); + } + Operator::I64AtomicRmwCmpxchg { ref memarg } => { + let new = self.pop_value_released(); + let cmp = self.pop_value_released(); + let target = self.pop_value_released(); + let ret = + self.machine + .acquire_locations(&mut self.assembler, &[(WpType::I64)], false)[0]; + self.value_stack.push(ret); + + let compare = self.machine.reserve_unused_temp_gpr(GPR::RAX); + let value = if cmp == Location::GPR(GPR::R14) { + if new == Location::GPR(GPR::R13) { + GPR::R12 + } else { + GPR::R13 + } + } else { + GPR::R14 + }; + self.assembler.emit_push(Size::S64, Location::GPR(value)); + self.assembler + .emit_mov(Size::S64, cmp, Location::GPR(compare)); + self.assembler + .emit_mov(Size::S64, new, Location::GPR(value)); + + self.emit_memory_op(target, memarg, true, 8, |this, addr| { + this.assembler.emit_lock_cmpxchg( + Size::S64, + Location::GPR(value), + Location::Memory(addr, 0), + ); + this.assembler + .emit_mov(Size::S64, Location::GPR(compare), ret); + Ok(()) + })?; + self.assembler.emit_pop(Size::S64, Location::GPR(value)); + self.machine.release_temp_gpr(compare); + } + Operator::I32AtomicRmw8CmpxchgU { ref memarg } => { + let new = self.pop_value_released(); + let cmp = self.pop_value_released(); + let target = self.pop_value_released(); + let ret = + self.machine + .acquire_locations(&mut self.assembler, &[(WpType::I32)], false)[0]; + self.value_stack.push(ret); + + let compare = self.machine.reserve_unused_temp_gpr(GPR::RAX); + let value = if cmp == Location::GPR(GPR::R14) { + if new == Location::GPR(GPR::R13) { + GPR::R12 + } else { + GPR::R13 + } + } else { + GPR::R14 + }; + self.assembler.emit_push(Size::S64, Location::GPR(value)); + self.assembler + .emit_mov(Size::S32, cmp, Location::GPR(compare)); + self.assembler + .emit_mov(Size::S32, new, Location::GPR(value)); + + self.emit_memory_op(target, memarg, true, 1, |this, addr| { + this.assembler.emit_lock_cmpxchg( + Size::S8, + Location::GPR(value), + Location::Memory(addr, 0), + ); + this.assembler + .emit_movzx(Size::S8, Location::GPR(compare), Size::S32, ret); + Ok(()) + })?; + self.assembler.emit_pop(Size::S64, Location::GPR(value)); + self.machine.release_temp_gpr(compare); + } + Operator::I32AtomicRmw16CmpxchgU { ref memarg } => { + let new = self.pop_value_released(); + let cmp = self.pop_value_released(); + let target = self.pop_value_released(); + let ret = + self.machine + .acquire_locations(&mut self.assembler, &[(WpType::I32)], false)[0]; + self.value_stack.push(ret); + + let compare = self.machine.reserve_unused_temp_gpr(GPR::RAX); + let value = if cmp == Location::GPR(GPR::R14) { + if new == Location::GPR(GPR::R13) { + GPR::R12 + } else { + GPR::R13 + } + } else { + GPR::R14 + }; + self.assembler.emit_push(Size::S64, Location::GPR(value)); + self.assembler + .emit_mov(Size::S32, cmp, Location::GPR(compare)); + self.assembler + .emit_mov(Size::S32, new, Location::GPR(value)); + + self.emit_memory_op(target, memarg, true, 1, |this, addr| { + this.assembler.emit_lock_cmpxchg( + Size::S16, + Location::GPR(value), + Location::Memory(addr, 0), + ); + this.assembler + .emit_movzx(Size::S16, Location::GPR(compare), Size::S32, ret); + Ok(()) + })?; + self.assembler.emit_pop(Size::S64, Location::GPR(value)); + self.machine.release_temp_gpr(compare); + } + Operator::I64AtomicRmw8CmpxchgU { ref memarg } => { + let new = self.pop_value_released(); + let cmp = self.pop_value_released(); + let target = self.pop_value_released(); + let ret = + self.machine + .acquire_locations(&mut self.assembler, &[(WpType::I64)], false)[0]; + self.value_stack.push(ret); + + let compare = self.machine.reserve_unused_temp_gpr(GPR::RAX); + let value = if cmp == Location::GPR(GPR::R14) { + if new == Location::GPR(GPR::R13) { + GPR::R12 + } else { + GPR::R13 + } + } else { + GPR::R14 + }; + self.assembler.emit_push(Size::S64, Location::GPR(value)); + self.assembler + .emit_mov(Size::S64, cmp, Location::GPR(compare)); + self.assembler + .emit_mov(Size::S64, new, Location::GPR(value)); + + self.emit_memory_op(target, memarg, true, 1, |this, addr| { + this.assembler.emit_lock_cmpxchg( + Size::S8, + Location::GPR(value), + Location::Memory(addr, 0), + ); + this.assembler + .emit_movzx(Size::S8, Location::GPR(compare), Size::S64, ret); + Ok(()) + })?; + self.assembler.emit_pop(Size::S64, Location::GPR(value)); + self.machine.release_temp_gpr(compare); + } + Operator::I64AtomicRmw16CmpxchgU { ref memarg } => { + let new = self.pop_value_released(); + let cmp = self.pop_value_released(); + let target = self.pop_value_released(); + let ret = + self.machine + .acquire_locations(&mut self.assembler, &[(WpType::I64)], false)[0]; + self.value_stack.push(ret); + + let compare = self.machine.reserve_unused_temp_gpr(GPR::RAX); + let value = if cmp == Location::GPR(GPR::R14) { + if new == Location::GPR(GPR::R13) { + GPR::R12 + } else { + GPR::R13 + } + } else { + GPR::R14 + }; + self.assembler.emit_push(Size::S64, Location::GPR(value)); + self.assembler + .emit_mov(Size::S64, cmp, Location::GPR(compare)); + self.assembler + .emit_mov(Size::S64, new, Location::GPR(value)); + + self.emit_memory_op(target, memarg, true, 1, |this, addr| { + this.assembler.emit_lock_cmpxchg( + Size::S16, + Location::GPR(value), + Location::Memory(addr, 0), + ); + this.assembler + .emit_movzx(Size::S16, Location::GPR(compare), Size::S64, ret); + Ok(()) + })?; + self.assembler.emit_pop(Size::S64, Location::GPR(value)); + self.machine.release_temp_gpr(compare); + } + Operator::I64AtomicRmw32CmpxchgU { ref memarg } => { + let new = self.pop_value_released(); + let cmp = self.pop_value_released(); + let target = self.pop_value_released(); + let ret = + self.machine + .acquire_locations(&mut self.assembler, &[(WpType::I64)], false)[0]; + self.value_stack.push(ret); + + let compare = self.machine.reserve_unused_temp_gpr(GPR::RAX); + let value = if cmp == Location::GPR(GPR::R14) { + if new == Location::GPR(GPR::R13) { + GPR::R12 + } else { + GPR::R13 + } + } else { + GPR::R14 + }; + self.assembler.emit_push(Size::S64, Location::GPR(value)); + self.assembler + .emit_mov(Size::S64, cmp, Location::GPR(compare)); + self.assembler + .emit_mov(Size::S64, new, Location::GPR(value)); + + self.emit_memory_op(target, memarg, true, 1, |this, addr| { + this.assembler.emit_lock_cmpxchg( + Size::S32, + Location::GPR(value), + Location::Memory(addr, 0), + ); + this.assembler + .emit_mov(Size::S32, Location::GPR(compare), ret); + Ok(()) + })?; + self.assembler.emit_pop(Size::S64, Location::GPR(value)); + self.machine.release_temp_gpr(compare); + } + + Operator::RefNull { .. } => { + self.value_stack.push(Location::Imm64(0)); + } + Operator::RefFunc { function_index } => { + self.assembler.emit_mov( + Size::S64, + Location::Memory( + Machine::get_vmctx_reg(), + self.vmoffsets + .vmctx_builtin_function(VMBuiltinFunctionIndex::get_func_ref_index()) + as i32, + ), + Location::GPR(GPR::RAX), + ); + + self.emit_call_native( + |this| { + this.assembler.emit_call_register(GPR::RAX); + }, + // [vmctx, func_index] -> funcref + iter::once(Location::Imm32(function_index as u32)), + )?; + + let ret = self.machine.acquire_locations( + &mut self.assembler, + &[(WpType::FuncRef)], + false, + )[0]; + self.value_stack.push(ret); + self.assembler + .emit_mov(Size::S64, Location::GPR(GPR::RAX), ret); + } + Operator::RefIsNull => { + self.emit_cmpop_i64_dynamic_b(Condition::Equal, Location::Imm64(0))?; + } + Operator::TableSet { table: index } => { + let table_index = TableIndex::new(index as _); + let value = self.value_stack.pop().unwrap(); + let index = self.value_stack.pop().unwrap(); + // double check this does what I think it does + self.machine.release_locations_only_regs(&[value, index]); + + self.assembler.emit_mov( + Size::S64, + Location::Memory( + Machine::get_vmctx_reg(), + self.vmoffsets.vmctx_builtin_function( + if self.module.local_table_index(table_index).is_some() { + VMBuiltinFunctionIndex::get_table_set_index() + } else { + VMBuiltinFunctionIndex::get_imported_table_set_index() + }, + ) as i32, + ), + Location::GPR(GPR::RAX), + ); + + self.emit_call_native( + |this| { + this.assembler.emit_call_register(GPR::RAX); + }, + // [vmctx, table_index, elem_index, reftype] + [Location::Imm32(table_index.index() as u32), index, value] + .iter() + .cloned(), + )?; + + self.machine + .release_locations_only_stack(&mut self.assembler, &[index, value]); + } + Operator::TableGet { table: index } => { + let table_index = TableIndex::new(index as _); + let index = self.value_stack.pop().unwrap(); + self.machine.release_locations_only_regs(&[index]); + + self.assembler.emit_mov( + Size::S64, + Location::Memory( + Machine::get_vmctx_reg(), + self.vmoffsets.vmctx_builtin_function( + if self.module.local_table_index(table_index).is_some() { + VMBuiltinFunctionIndex::get_table_get_index() + } else { + VMBuiltinFunctionIndex::get_imported_table_get_index() + }, + ) as i32, + ), + Location::GPR(GPR::RAX), + ); + + self.emit_call_native( + |this| { + this.assembler.emit_call_register(GPR::RAX); + }, + // [vmctx, table_index, elem_index] -> reftype + [Location::Imm32(table_index.index() as u32), index] + .iter() + .cloned(), + )?; + + self.machine + .release_locations_only_stack(&mut self.assembler, &[index]); + + let ret = self.machine.acquire_locations( + &mut self.assembler, + &[(WpType::FuncRef)], + false, + )[0]; + self.value_stack.push(ret); + self.assembler + .emit_mov(Size::S64, Location::GPR(GPR::RAX), ret); + } + Operator::TableSize { table: index } => { + let table_index = TableIndex::new(index as _); + + self.assembler.emit_mov( + Size::S64, + Location::Memory( + Machine::get_vmctx_reg(), + self.vmoffsets.vmctx_builtin_function( + if self.module.local_table_index(table_index).is_some() { + VMBuiltinFunctionIndex::get_table_size_index() + } else { + VMBuiltinFunctionIndex::get_imported_table_size_index() + }, + ) as i32, + ), + Location::GPR(GPR::RAX), + ); + + self.emit_call_native( + |this| { + this.assembler.emit_call_register(GPR::RAX); + }, + // [vmctx, table_index] -> i32 + iter::once(Location::Imm32(table_index.index() as u32)), + )?; + + let ret = + self.machine + .acquire_locations(&mut self.assembler, &[(WpType::I32)], false)[0]; + self.value_stack.push(ret); + self.assembler + .emit_mov(Size::S32, Location::GPR(GPR::RAX), ret); + } + Operator::TableGrow { table: index } => { + let table_index = TableIndex::new(index as _); + let delta = self.value_stack.pop().unwrap(); + let init_value = self.value_stack.pop().unwrap(); + self.machine + .release_locations_only_regs(&[delta, init_value]); + + self.assembler.emit_mov( + Size::S64, + Location::Memory( + Machine::get_vmctx_reg(), + self.vmoffsets.vmctx_builtin_function( + if self.module.local_table_index(table_index).is_some() { + VMBuiltinFunctionIndex::get_table_grow_index() + } else { + VMBuiltinFunctionIndex::get_imported_table_get_index() + }, + ) as i32, + ), + Location::GPR(GPR::RAX), + ); + + // TODO: should this be 2? + self.emit_call_native( + |this| { + this.assembler.emit_call_register(GPR::RAX); + }, + // [vmctx, init_value, delta, table_index] -> u32 + [ + init_value, + delta, + Location::Imm32(table_index.index() as u32), + ] + .iter() + .cloned(), + )?; + + self.machine + .release_locations_only_stack(&mut self.assembler, &[init_value, delta]); + + let ret = + self.machine + .acquire_locations(&mut self.assembler, &[(WpType::I32)], false)[0]; + self.value_stack.push(ret); + self.assembler + .emit_mov(Size::S32, Location::GPR(GPR::RAX), ret); + } + Operator::TableCopy { + dst_table, + src_table, + } => { + let len = self.value_stack.pop().unwrap(); + let src = self.value_stack.pop().unwrap(); + let dest = self.value_stack.pop().unwrap(); + self.machine.release_locations_only_regs(&[len, src, dest]); + + self.assembler.emit_mov( + Size::S64, + Location::Memory( + Machine::get_vmctx_reg(), + self.vmoffsets + .vmctx_builtin_function(VMBuiltinFunctionIndex::get_table_copy_index()) + as i32, + ), + Location::GPR(GPR::RAX), + ); + + // TODO: should this be 3? + self.emit_call_native( + |this| { + this.assembler.emit_call_register(GPR::RAX); + }, + // [vmctx, dst_table_index, src_table_index, dst, src, len] + [ + Location::Imm32(dst_table), + Location::Imm32(src_table), + dest, + src, + len, + ] + .iter() + .cloned(), + )?; + + self.machine + .release_locations_only_stack(&mut self.assembler, &[dest, src, len]); + } + + Operator::TableFill { table } => { + let len = self.value_stack.pop().unwrap(); + let val = self.value_stack.pop().unwrap(); + let dest = self.value_stack.pop().unwrap(); + self.machine.release_locations_only_regs(&[len, val, dest]); + + self.assembler.emit_mov( + Size::S64, + Location::Memory( + Machine::get_vmctx_reg(), + self.vmoffsets + .vmctx_builtin_function(VMBuiltinFunctionIndex::get_table_fill_index()) + as i32, + ), + Location::GPR(GPR::RAX), + ); + + // TODO: should this be 3? + self.emit_call_native( + |this| { + this.assembler.emit_call_register(GPR::RAX); + }, + // [vmctx, table_index, start_idx, item, len] + [Location::Imm32(table), dest, val, len].iter().cloned(), + )?; + + self.machine + .release_locations_only_stack(&mut self.assembler, &[dest, val, len]); + } + Operator::TableInit { elem_index, table } => { + let len = self.value_stack.pop().unwrap(); + let src = self.value_stack.pop().unwrap(); + let dest = self.value_stack.pop().unwrap(); + self.machine.release_locations_only_regs(&[len, src, dest]); + + self.assembler.emit_mov( + Size::S64, + Location::Memory( + Machine::get_vmctx_reg(), + self.vmoffsets + .vmctx_builtin_function(VMBuiltinFunctionIndex::get_table_init_index()) + as i32, + ), + Location::GPR(GPR::RAX), + ); + + // TODO: should this be 3? + self.emit_call_native( + |this| { + this.assembler.emit_call_register(GPR::RAX); + }, + // [vmctx, table_index, elem_index, dst, src, len] + [ + Location::Imm32(table), + Location::Imm32(elem_index), + dest, + src, + len, + ] + .iter() + .cloned(), + )?; + + self.machine + .release_locations_only_stack(&mut self.assembler, &[dest, src, len]); + } + Operator::ElemDrop { elem_index } => { + self.assembler.emit_mov( + Size::S64, + Location::Memory( + Machine::get_vmctx_reg(), + self.vmoffsets + .vmctx_builtin_function(VMBuiltinFunctionIndex::get_elem_drop_index()) + as i32, + ), + Location::GPR(GPR::RAX), + ); + + self.emit_call_native( + |this| { + this.assembler.emit_call_register(GPR::RAX); + }, + // [vmctx, elem_index] + [Location::Imm32(elem_index)].iter().cloned(), + )?; + } + _ => { + return Err(CodegenError { + message: format!("not yet implemented: {:?}", op), + }); + } + } + + Ok(()) + } + + #[tracing::instrument(skip_all)] + pub(crate) fn finalize(mut self, data: &FunctionBodyData) -> CompiledFunction { + debug_assert!( + self.gas_iter.next().is_none(), + "finalizing function but not all instrumentation points were inserted" + ); + + // Generate actual code for special labels. + self.assembler + .emit_label(self.special_labels.integer_division_by_zero); + self.emit_trap(TrapCode::IntegerDivisionByZero); + + self.assembler + .emit_label(self.special_labels.integer_overflow); + self.emit_trap(TrapCode::IntegerOverflow); + + self.assembler + .emit_label(self.special_labels.bad_conversion_to_integer); + self.emit_trap(TrapCode::BadConversionToInteger); + + self.assembler + .emit_label(self.special_labels.heap_access_oob); + self.emit_trap(TrapCode::HeapAccessOutOfBounds); + + self.assembler + .emit_label(self.special_labels.table_access_oob); + self.emit_trap(TrapCode::TableAccessOutOfBounds); + + self.assembler + .emit_label(self.special_labels.indirect_call_null); + self.emit_trap(TrapCode::IndirectCallToNull); + + self.assembler.emit_label(self.special_labels.bad_signature); + self.emit_trap(TrapCode::BadSignature); + + self.assembler + .emit_label(self.special_labels.gas_limit_exceeded); + self.emit_trap(TrapCode::GasExceeded); + + self.assembler + .emit_label(self.special_labels.stack_overflow); + self.emit_trap(TrapCode::StackOverflow); + + // Notify the assembler backend to generate necessary code at end of function. + self.assembler.finalize_function(); + + let body_len = self.assembler.get_offset().0; + let instructions_address_map = self.instructions_address_map; + let address_map = get_function_address_map(instructions_address_map, data, body_len); + let mut body = self.assembler.finalize().unwrap(); + body.shrink_to_fit(); + + CompiledFunction { + body: FunctionBody { + body, + unwind_info: None, + }, + relocations: self.relocations, + jt_offsets: SecondaryMap::new(), + frame_info: CompiledFunctionFrameInfo { + traps: vec![], + address_map, + }, + } + } +} + +fn type_to_wp_type(ty: Type) -> WpType { + match ty { + Type::I32 => WpType::I32, + Type::I64 => WpType::I64, + Type::F32 => WpType::F32, + Type::F64 => WpType::F64, + Type::V128 => WpType::V128, + Type::ExternRef => WpType::ExternRef, + Type::FuncRef => WpType::FuncRef, // TODO: FuncRef or Func? + } +} + +// FIXME: This implementation seems to be not enough to resolve all kinds of register dependencies +// at call place. +fn sort_call_movs(movs: &mut [(Location, GPR)]) { + for i in 0..movs.len() { + for j in (i + 1)..movs.len() { + if let Location::GPR(src_gpr) = movs[j].0 { + if src_gpr == movs[i].1 { + movs.swap(i, j); + } + } + } + } + + // Cycle detector. Uncomment this to debug possibly incorrect call-mov sequences. + /* + { + use std::collections::{HashMap, HashSet, VecDeque}; + let mut mov_map: HashMap> = HashMap::new(); + for mov in movs.iter() { + if let Location::GPR(src_gpr) = mov.0 { + if src_gpr != mov.1 { + mov_map.entry(src_gpr).or_insert_with(|| HashSet::new()).insert(mov.1); + } + } + } + + for (start, _) in mov_map.iter() { + let mut q: VecDeque = VecDeque::new(); + let mut black: HashSet = HashSet::new(); + + q.push_back(*start); + black.insert(*start); + + while q.len() > 0 { + let reg = q.pop_front().unwrap(); + let empty_set = HashSet::new(); + for x in mov_map.get(®).unwrap_or(&empty_set).iter() { + if black.contains(x) { + panic!("cycle detected"); + } + q.push_back(*x); + black.insert(*x); + } + } + } + } + */ +} + +// Standard entry trampoline. +#[tracing::instrument] +pub(crate) fn gen_std_trampoline( + sig: &FunctionType, + calling_convention: CallingConvention, +) -> FunctionBody { + let mut a = Assembler::new(0); + + // Calculate stack offset. + let mut stack_offset: u32 = 0; + for (i, _param) in sig.params().iter().enumerate() { + if let Location::Memory(_, _) = Machine::get_param_location(1 + i, calling_convention) { + stack_offset += 8; + } + } + let stack_padding: u32 = match calling_convention { + CallingConvention::WindowsFastcall => 32, + _ => 0, + }; + + // Align to 16 bytes. We push two 8-byte registers below, so here we need to ensure stack_offset % 16 == 8. + if stack_offset % 16 != 8 { + stack_offset += 8; + } + + // Used callee-saved registers + a.emit_push(Size::S64, Location::GPR(GPR::R15)); + a.emit_push(Size::S64, Location::GPR(GPR::R14)); + + // Prepare stack space. + a.emit_sub( + Size::S64, + Location::Imm32(stack_offset + stack_padding), + Location::GPR(GPR::RSP), + ); + + // Arguments + a.emit_mov( + Size::S64, + Machine::get_param_location(1, calling_convention), + Location::GPR(GPR::R15), + ); // func_ptr + a.emit_mov( + Size::S64, + Machine::get_param_location(2, calling_convention), + Location::GPR(GPR::R14), + ); // args_rets + + // Move arguments to their locations. + // `callee_vmctx` is already in the first argument register, so no need to move. + { + let mut n_stack_args: usize = 0; + for (i, _param) in sig.params().iter().enumerate() { + let src_loc = Location::Memory(GPR::R14, (i * 16) as _); // args_rets[i] + let dst_loc = Machine::get_param_location(1 + i, calling_convention); + + match dst_loc { + Location::GPR(_) => { + a.emit_mov(Size::S64, src_loc, dst_loc); + } + Location::Memory(_, _) => { + // This location is for reading arguments but we are writing arguments here. + // So recalculate it. + a.emit_mov(Size::S64, src_loc, Location::GPR(GPR::RAX)); + a.emit_mov( + Size::S64, + Location::GPR(GPR::RAX), + Location::Memory( + GPR::RSP, + (stack_padding as usize + n_stack_args * 8) as _, + ), + ); + n_stack_args += 1; + } + _ => unreachable!(), + } + } + } + + // Call. + a.emit_call_location(Location::GPR(GPR::R15)); + + // Restore stack. + a.emit_add( + Size::S64, + Location::Imm32(stack_offset + stack_padding), + Location::GPR(GPR::RSP), + ); + + // Write return value. + if !sig.results().is_empty() { + a.emit_mov( + Size::S64, + Location::GPR(GPR::RAX), + Location::Memory(GPR::R14, 0), + ); + } + + // Restore callee-saved registers. + a.emit_pop(Size::S64, Location::GPR(GPR::R14)); + a.emit_pop(Size::S64, Location::GPR(GPR::R15)); + + a.emit_ret(); + + let mut body = a.finalize().unwrap(); + body.shrink_to_fit(); + FunctionBody { + body, + unwind_info: None, + } +} + +/// Generates dynamic import function call trampoline for a function type. +#[tracing::instrument(skip(vmoffsets))] +pub(crate) fn gen_std_dynamic_import_trampoline( + vmoffsets: &VMOffsets, + sig: &FunctionType, + calling_convention: CallingConvention, +) -> FunctionBody { + let mut a = Assembler::new(0); + + // Allocate argument array. + let stack_offset: usize = 16 * std::cmp::max(sig.params().len(), sig.results().len()) + 8; // 16 bytes each + 8 bytes sysv call padding + let stack_padding: usize = match calling_convention { + CallingConvention::WindowsFastcall => 32, + _ => 0, + }; + a.emit_sub( + Size::S64, + Location::Imm32((stack_offset + stack_padding) as _), + Location::GPR(GPR::RSP), + ); + + // Copy arguments. + if !sig.params().is_empty() { + let mut argalloc = ArgumentRegisterAllocator::default(); + argalloc.next(Type::I64, calling_convention).unwrap(); // skip VMContext + + let mut stack_param_count: usize = 0; + + for (i, ty) in sig.params().iter().enumerate() { + let source_loc = match argalloc.next(*ty, calling_convention) { + Some(X64Register::GPR(gpr)) => Location::GPR(gpr), + Some(X64Register::XMM(xmm)) => Location::XMM(xmm), + None => { + a.emit_mov( + Size::S64, + Location::Memory( + GPR::RSP, + (stack_padding * 2 + stack_offset + 8 + stack_param_count * 8) as _, + ), + Location::GPR(GPR::RAX), + ); + stack_param_count += 1; + Location::GPR(GPR::RAX) + } + }; + a.emit_mov( + Size::S64, + source_loc, + Location::Memory(GPR::RSP, (stack_padding + i * 16) as _), + ); + + // Zero upper 64 bits. + a.emit_mov( + Size::S64, + Location::Imm32(0), + Location::Memory(GPR::RSP, (stack_padding + i * 16 + 8) as _), + ); + } + } + + match calling_convention { + CallingConvention::WindowsFastcall => { + // Load target address. + a.emit_mov( + Size::S64, + Location::Memory( + GPR::RCX, + vmoffsets.vmdynamicfunction_import_context_address() as i32, + ), + Location::GPR(GPR::RAX), + ); + // Load values array. + a.emit_lea( + Size::S64, + Location::Memory(GPR::RSP, stack_padding as i32), + Location::GPR(GPR::RDX), + ); + } + _ => { + // Load target address. + a.emit_mov( + Size::S64, + Location::Memory( + GPR::RDI, + vmoffsets.vmdynamicfunction_import_context_address() as i32, + ), + Location::GPR(GPR::RAX), + ); + // Load values array. + a.emit_mov(Size::S64, Location::GPR(GPR::RSP), Location::GPR(GPR::RSI)); + } + }; + + // Call target. + a.emit_call_location(Location::GPR(GPR::RAX)); + + // Fetch return value. + if !sig.results().is_empty() { + assert_eq!(sig.results().len(), 1); + a.emit_mov( + Size::S64, + Location::Memory(GPR::RSP, stack_padding as i32), + Location::GPR(GPR::RAX), + ); + } + + // Release values array. + a.emit_add( + Size::S64, + Location::Imm32((stack_offset + stack_padding) as _), + Location::GPR(GPR::RSP), + ); + + // Return. + a.emit_ret(); + + let mut body = a.finalize().unwrap(); + body.shrink_to_fit(); + FunctionBody { + body, + unwind_info: None, + } +} + +// Singlepass calls import functions through a trampoline. +#[tracing::instrument(skip(vmoffsets))] +pub(crate) fn gen_import_call_trampoline( + vmoffsets: &VMOffsets, + index: FunctionIndex, + sig: &FunctionType, + calling_convention: CallingConvention, +) -> CustomSection { + let mut a = Assembler::new(0); + + // TODO: ARM entry trampoline is not emitted. + + // Singlepass internally treats all arguments as integers + // For the standard Windows calling convention requires + // floating point arguments to be passed in XMM registers for the 4 first arguments only + // That's the only change to do, other arguments are not to be changed + // For the standard System V calling convention requires + // floating point arguments to be passed in XMM registers. + // Translation is expensive, so only do it if needed. + if sig + .params() + .iter() + .any(|&x| x == Type::F32 || x == Type::F64) + { + match calling_convention { + CallingConvention::WindowsFastcall => { + let mut param_locations: Vec = vec![]; + for i in 0..sig.params().len() { + let loc = match i { + 0..=2 => { + static PARAM_REGS: &[GPR] = &[GPR::RDX, GPR::R8, GPR::R9]; + Location::GPR(PARAM_REGS[i]) + } + _ => Location::Memory(GPR::RSP, 32 + 8 + ((i - 3) * 8) as i32), // will not be used anyway + }; + param_locations.push(loc); + } + // Copy Float arguments to XMM from GPR. + let mut argalloc = ArgumentRegisterAllocator::default(); + for (i, ty) in sig.params().iter().enumerate() { + let prev_loc = param_locations[i]; + match argalloc.next(*ty, calling_convention) { + Some(X64Register::GPR(_gpr)) => continue, + Some(X64Register::XMM(xmm)) => { + a.emit_mov(Size::S64, prev_loc, Location::XMM(xmm)) + } + None => continue, + }; + } + } + _ => { + let mut param_locations: Vec = vec![]; + + // Allocate stack space for arguments. + let stack_offset: i32 = if sig.params().len() > 5 { + 5 * 8 + } else { + (sig.params().len() as i32) * 8 + }; + if stack_offset > 0 { + a.emit_sub( + Size::S64, + Location::Imm32(stack_offset as u32), + Location::GPR(GPR::RSP), + ); + } + + // Store all arguments to the stack to prevent overwrite. + for i in 0..sig.params().len() { + let loc = match i { + 0..=4 => { + static PARAM_REGS: &[GPR] = + &[GPR::RSI, GPR::RDX, GPR::RCX, GPR::R8, GPR::R9]; + let loc = Location::Memory(GPR::RSP, (i * 8) as i32); + a.emit_mov(Size::S64, Location::GPR(PARAM_REGS[i]), loc); + loc + } + _ => Location::Memory(GPR::RSP, stack_offset + 8 + ((i - 5) * 8) as i32), + }; + param_locations.push(loc); + } + + // Copy arguments. + let mut argalloc = ArgumentRegisterAllocator::default(); + argalloc.next(Type::I64, calling_convention).unwrap(); // skip VMContext + let mut caller_stack_offset: i32 = 0; + for (i, ty) in sig.params().iter().enumerate() { + let prev_loc = param_locations[i]; + let targ = match argalloc.next(*ty, calling_convention) { + Some(X64Register::GPR(gpr)) => Location::GPR(gpr), + Some(X64Register::XMM(xmm)) => Location::XMM(xmm), + None => { + // No register can be allocated. Put this argument on the stack. + // + // Since here we never use fewer registers than by the original call, on the caller's frame + // we always have enough space to store the rearranged arguments, and the copy "backward" between different + // slots in the caller argument region will always work. + a.emit_mov(Size::S64, prev_loc, Location::GPR(GPR::RAX)); + a.emit_mov( + Size::S64, + Location::GPR(GPR::RAX), + Location::Memory(GPR::RSP, stack_offset + 8 + caller_stack_offset), + ); + caller_stack_offset += 8; + continue; + } + }; + a.emit_mov(Size::S64, prev_loc, targ); + } + + // Restore stack pointer. + if stack_offset > 0 { + a.emit_add( + Size::S64, + Location::Imm32(stack_offset as u32), + Location::GPR(GPR::RSP), + ); + } + } + } + } + + // Emits a tail call trampoline that loads the address of the target import function + // from Ctx and jumps to it. + + let body_offset = vmoffsets.vmctx_vmfunction_import_body(index); + let vmctx_offset = vmoffsets.vmctx_vmfunction_import_vmctx(index); + + match calling_convention { + CallingConvention::WindowsFastcall => { + a.emit_mov( + Size::S64, + Location::Memory(GPR::RCX, body_offset as i32), // function pointer + Location::GPR(GPR::RAX), + ); + a.emit_mov( + Size::S64, + Location::Memory(GPR::RCX, vmctx_offset as i32), // target vmctx + Location::GPR(GPR::RCX), + ); + } + _ => { + a.emit_mov( + Size::S64, + Location::Memory(GPR::RDI, body_offset as i32), // function pointer + Location::GPR(GPR::RAX), + ); + a.emit_mov( + Size::S64, + Location::Memory(GPR::RDI, vmctx_offset as i32), // target vmctx + Location::GPR(GPR::RDI), + ); + } + } + a.emit_host_redirection(GPR::RAX); + + let mut contents = a.finalize().unwrap(); + contents.shrink_to_fit(); + let section_body = SectionBody::new_with_vec(contents); + + CustomSection { + protection: CustomSectionProtection::ReadExecute, + bytes: section_body, + relocations: vec![], + } +} + +// Constants for the bounds of truncation operations. These are the least or +// greatest exact floats in either f32 or f64 representation less-than (for +// least) or greater-than (for greatest) the i32 or i64 or u32 or u64 +// min (for least) or max (for greatest), when rounding towards zero. + +/// Greatest Exact Float (32 bits) less-than i32::MIN when rounding towards zero. +const GEF32_LT_I32_MIN: f32 = -2147483904.0; +/// Least Exact Float (32 bits) greater-than i32::MAX when rounding towards zero. +const LEF32_GT_I32_MAX: f32 = 2147483648.0; +/// Greatest Exact Float (32 bits) less-than i64::MIN when rounding towards zero. +const GEF32_LT_I64_MIN: f32 = -9223373136366403584.0; +/// Least Exact Float (32 bits) greater-than i64::MAX when rounding towards zero. +const LEF32_GT_I64_MAX: f32 = 9223372036854775808.0; +/// Greatest Exact Float (32 bits) less-than u32::MIN when rounding towards zero. +const GEF32_LT_U32_MIN: f32 = -1.0; +/// Least Exact Float (32 bits) greater-than u32::MAX when rounding towards zero. +const LEF32_GT_U32_MAX: f32 = 4294967296.0; +/// Greatest Exact Float (32 bits) less-than u64::MIN when rounding towards zero. +const GEF32_LT_U64_MIN: f32 = -1.0; +/// Least Exact Float (32 bits) greater-than u64::MAX when rounding towards zero. +const LEF32_GT_U64_MAX: f32 = 18446744073709551616.0; + +/// Greatest Exact Float (64 bits) less-than i32::MIN when rounding towards zero. +const GEF64_LT_I32_MIN: f64 = -2147483649.0; +/// Least Exact Float (64 bits) greater-than i32::MAX when rounding towards zero. +const LEF64_GT_I32_MAX: f64 = 2147483648.0; +/// Greatest Exact Float (64 bits) less-than i64::MIN when rounding towards zero. +const GEF64_LT_I64_MIN: f64 = -9223372036854777856.0; +/// Least Exact Float (64 bits) greater-than i64::MAX when rounding towards zero. +const LEF64_GT_I64_MAX: f64 = 9223372036854775808.0; +/// Greatest Exact Float (64 bits) less-than u32::MIN when rounding towards zero. +const GEF64_LT_U32_MIN: f64 = -1.0; +/// Least Exact Float (64 bits) greater-than u32::MAX when rounding towards zero. +const LEF64_GT_U32_MAX: f64 = 4294967296.0; +/// Greatest Exact Float (64 bits) less-than u64::MIN when rounding towards zero. +const GEF64_LT_U64_MIN: f64 = -1.0; +/// Least Exact Float (64 bits) greater-than u64::MAX when rounding towards zero. +const LEF64_GT_U64_MAX: f64 = 18446744073709551616.0; diff --git a/runtime/near-vm/lib/compiler-singlepass/src/compiler.rs b/runtime/near-vm/lib/compiler-singlepass/src/compiler.rs new file mode 100644 index 00000000000..0e350804150 --- /dev/null +++ b/runtime/near-vm/lib/compiler-singlepass/src/compiler.rs @@ -0,0 +1,330 @@ +//! Support for compiling with Singlepass. +// Allow unused imports while developing. +#![allow(unused_imports, dead_code)] + +use crate::codegen_x64::{ + gen_import_call_trampoline, gen_std_dynamic_import_trampoline, gen_std_trampoline, + CodegenError, FuncGen, +}; +use crate::config::Singlepass; +#[cfg(feature = "rayon")] +use rayon::prelude::{IntoParallelIterator, ParallelIterator}; +use std::sync::Arc; +use wasmer_compiler::{ + Architecture, CallingConvention, Compilation, CompileError, CompileModuleInfo, + CompiledFunction, Compiler, CompilerConfig, CpuFeature, FunctionBody, FunctionBodyData, + ModuleTranslationState, OperatingSystem, SectionIndex, Target, TrapInformation, +}; +use wasmer_types::entity::{EntityRef, PrimaryMap}; +use wasmer_types::{ + FunctionIndex, FunctionType, LocalFunctionIndex, MemoryIndex, ModuleInfo, TableIndex, +}; +use wasmer_vm::{TrapCode, VMOffsets}; + +/// A compiler that compiles a WebAssembly module with Singlepass. +/// It does the compilation in one pass +pub struct SinglepassCompiler { + config: Singlepass, +} + +impl SinglepassCompiler { + /// Creates a new Singlepass compiler + pub fn new(config: Singlepass) -> Self { + Self { config } + } + + /// Gets the config for this Compiler + fn config(&self) -> &Singlepass { + &self.config + } +} + +impl Compiler for SinglepassCompiler { + /// Compile the module using Singlepass, producing a compilation result with + /// associated relocations. + #[tracing::instrument(skip_all)] + fn compile_module( + &self, + target: &Target, + compile_info: &CompileModuleInfo, + module_translation: &ModuleTranslationState, + function_body_inputs: PrimaryMap>, + tunables: &dyn wasmer_vm::Tunables, + instrumentation: &finite_wasm::AnalysisOutcome, + ) -> Result { + /*if target.triple().operating_system == OperatingSystem::Windows { + return Err(CompileError::UnsupportedTarget( + OperatingSystem::Windows.to_string(), + )); + }*/ + if target.triple().architecture != Architecture::X86_64 { + return Err(CompileError::UnsupportedTarget( + target.triple().architecture.to_string(), + )); + } + if !target.cpu_features().contains(CpuFeature::AVX) { + return Err(CompileError::UnsupportedTarget( + "x86_64 without AVX".to_string(), + )); + } + if compile_info.features.multi_value { + return Err(CompileError::UnsupportedFeature("multivalue".to_string())); + } + let calling_convention = match target.triple().default_calling_convention() { + Ok(CallingConvention::WindowsFastcall) => CallingConvention::WindowsFastcall, + Ok(CallingConvention::SystemV) => CallingConvention::SystemV, + //Ok(CallingConvention::AppleAarch64) => AppleAarch64, + _ => panic!("Unsupported Calling convention for Singlepass compiler"), + }; + + let table_styles = &compile_info.table_styles; + let module = &compile_info.module; + let pointer_width = target + .triple() + .pointer_width() + .map_err(|()| { + CompileError::UnsupportedTarget("target with unknown pointer width".into()) + })? + .bytes(); + let vmoffsets = VMOffsets::new(pointer_width).with_module_info(&module); + let import_idxs = 0..module.import_counts.functions as usize; + let import_trampolines: PrimaryMap = + tracing::info_span!("import_trampolines", n_imports = import_idxs.len()).in_scope( + || { + import_idxs + .into_par_iter_if_rayon() + .map(|i| { + let i = FunctionIndex::new(i); + gen_import_call_trampoline( + &vmoffsets, + i, + &module.signatures[module.functions[i]], + calling_convention, + ) + }) + .collect::>() + .into_iter() + .collect() + }, + ); + let functions = function_body_inputs + .iter() + .collect::)>>() + .into_par_iter_if_rayon() + .map(|(i, input)| { + tracing::info_span!("function", i = i.index()).in_scope(|| { + let reader = + wasmer_compiler::FunctionReader::new(input.module_offset, input.data); + let stack_init_gas_cost = tunables + .stack_init_gas_cost(instrumentation.function_frame_sizes[i.index()]); + let stack_size = instrumentation.function_frame_sizes[i.index()] + .checked_add(instrumentation.function_operand_stack_sizes[i.index()]) + .ok_or_else(|| { + CompileError::Codegen(String::from( + "got function with frame size going beyond u64::MAX", + )) + })?; + let mut generator = FuncGen::new( + module, + module_translation, + &self.config, + &target, + &vmoffsets, + &table_styles, + i, + calling_convention, + stack_init_gas_cost, + &instrumentation.gas_offsets[i.index()], + &instrumentation.gas_costs[i.index()], + &instrumentation.gas_kinds[i.index()], + stack_size, + ) + .map_err(to_compile_error)?; + + let mut local_reader = reader.get_locals_reader()?; + for _ in 0..local_reader.get_count() { + let (count, ty) = local_reader.read()?; + // Overflows feeding a local here have most likely already been caught by the + // validator, but it is possible that the validator hasn't been run at all, or + // that the validator does not impose any limits on the number of locals. + generator.feed_local(count, ty); + } + + generator.emit_head().map_err(to_compile_error)?; + + let mut operator_reader = + reader.get_operators_reader()?.into_iter_with_offsets(); + while generator.has_control_frames() { + let (op, pos) = tracing::info_span!("parsing-next-operator") + .in_scope(|| operator_reader.next().unwrap())?; + generator.set_srcloc(pos as u32); + generator.feed_operator(op).map_err(to_compile_error)?; + } + + Ok(generator.finalize(&input)) + }) + }) + .collect::, CompileError>>()? + .into_iter() // TODO: why not just collect to PrimaryMap directly? + .collect::>(); + + let function_call_trampolines = + tracing::info_span!("function_call_trampolines").in_scope(|| { + module + .signatures + .values() + .collect::>() + .into_par_iter_if_rayon() + .map(|func_type| gen_std_trampoline(&func_type, calling_convention)) + .collect::>() + .into_iter() + .collect::>() + }); + + let dynamic_function_trampolines = tracing::info_span!("dynamic_function_trampolines") + .in_scope(|| { + module + .imported_function_types() + .collect::>() + .into_par_iter_if_rayon() + .map(|func_type| { + gen_std_dynamic_import_trampoline( + &vmoffsets, + &func_type, + calling_convention, + ) + }) + .collect::>() + .into_iter() + .collect::>() + }); + + Ok(Compilation { + functions, + custom_sections: import_trampolines, + function_call_trampolines, + dynamic_function_trampolines, + debug: None, + trampolines: None, + }) + } +} + +trait ToCompileError { + fn to_compile_error(self) -> CompileError; +} + +impl ToCompileError for CodegenError { + fn to_compile_error(self) -> CompileError { + CompileError::Codegen(self.message) + } +} + +fn to_compile_error(x: T) -> CompileError { + x.to_compile_error() +} + +trait IntoParIterIfRayon { + type Output; + fn into_par_iter_if_rayon(self) -> Self::Output; +} + +#[cfg(feature = "rayon")] +impl IntoParIterIfRayon for T { + type Output = ::Iter; + fn into_par_iter_if_rayon(self) -> Self::Output { + return self.into_par_iter(); + } +} + +#[cfg(not(feature = "rayon"))] +impl IntoParIterIfRayon for T { + type Output = ::IntoIter; + fn into_par_iter_if_rayon(self) -> Self::Output { + return self.into_iter(); + } +} + +#[cfg(test)] +mod tests { + use super::*; + use std::str::FromStr; + use target_lexicon::triple; + use wasmer_compiler::{CpuFeature, Features, Triple}; + use wasmer_vm::{MemoryStyle, TableStyle}; + + fn dummy_compilation_ingredients<'a>() -> ( + CompileModuleInfo, + ModuleTranslationState, + PrimaryMap>, + finite_wasm::AnalysisOutcome, + ) { + let compile_info = CompileModuleInfo { + features: Features::new(), + module: Arc::new(ModuleInfo::new()), + memory_styles: PrimaryMap::::new(), + table_styles: PrimaryMap::::new(), + }; + let module_translation = ModuleTranslationState::new(); + let function_body_inputs = PrimaryMap::>::new(); + let analysis = finite_wasm::AnalysisOutcome { + function_frame_sizes: Vec::new(), + function_operand_stack_sizes: Vec::new(), + gas_offsets: Vec::new(), + gas_costs: Vec::new(), + gas_kinds: Vec::new(), + }; + ( + compile_info, + module_translation, + function_body_inputs, + analysis, + ) + } + + #[test] + fn errors_for_unsupported_targets() { + let compiler = SinglepassCompiler::new(Singlepass::default()); + + // Compile for win64 + /*let win64 = Target::new(triple!("x86_64-pc-windows-msvc"), CpuFeature::for_host()); + let (mut info, translation, inputs) = dummy_compilation_ingredients(); + let result = compiler.compile_module(&win64, &mut info, &translation, inputs); + match result.unwrap_err() { + CompileError::UnsupportedTarget(name) => assert_eq!(name, "windows"), + error => panic!("Unexpected error: {:?}", error), + };*/ + + // Compile for 32bit Linux + let linux32 = Target::new(triple!("i686-unknown-linux-gnu"), CpuFeature::for_host()); + let (mut info, translation, inputs, analysis) = dummy_compilation_ingredients(); + let result = compiler.compile_module( + &linux32, + &mut info, + &translation, + inputs, + &wasmer_vm::TestTunables, + &analysis, + ); + match result.unwrap_err() { + CompileError::UnsupportedTarget(name) => assert_eq!(name, "i686"), + error => panic!("Unexpected error: {:?}", error), + }; + + // Compile for win32 + let win32 = Target::new(triple!("i686-pc-windows-gnu"), CpuFeature::for_host()); + let (mut info, translation, inputs, analysis) = dummy_compilation_ingredients(); + let result = compiler.compile_module( + &win32, + &mut info, + &translation, + inputs, + &wasmer_vm::TestTunables, + &analysis, + ); + match result.unwrap_err() { + CompileError::UnsupportedTarget(name) => assert_eq!(name, "i686"), // Windows should be checked before architecture + error => panic!("Unexpected error: {:?}", error), + }; + } +} diff --git a/runtime/near-vm/lib/compiler-singlepass/src/config.rs b/runtime/near-vm/lib/compiler-singlepass/src/config.rs new file mode 100644 index 00000000000..038d31bd503 --- /dev/null +++ b/runtime/near-vm/lib/compiler-singlepass/src/config.rs @@ -0,0 +1,102 @@ +// Allow unused imports while developing +#![allow(unused_imports, dead_code)] + +use crate::compiler::SinglepassCompiler; +use crate::emitter_x64::Location; +use smallvec::SmallVec; +use std::sync::Arc; +use wasmer_compiler::{Compiler, CompilerConfig, CpuFeature, Target}; +use wasmer_types::{Features, FunctionType, Type}; + +#[derive(Debug, Clone)] +pub(crate) enum IntrinsicKind { + Gas, +} + +#[derive(Debug, Clone)] +pub(crate) struct Intrinsic { + pub(crate) kind: IntrinsicKind, + pub(crate) name: String, + pub(crate) signature: FunctionType, +} + +#[derive(Debug, Clone)] +pub struct Singlepass { + pub(crate) enable_nan_canonicalization: bool, + pub(crate) enable_stack_check: bool, + /// Compiler intrinsics. + pub(crate) intrinsics: Vec, +} + +impl Singlepass { + /// Creates a new configuration object with the default configuration + /// specified. + pub fn new() -> Self { + Self { + enable_nan_canonicalization: true, + enable_stack_check: false, + intrinsics: vec![Intrinsic { + kind: IntrinsicKind::Gas, + name: "gas".to_string(), + signature: ([Type::I32], []).into(), + }], + } + } + + /// Enable stack check. + /// + /// When enabled, an explicit stack depth check will be performed on entry + /// to each function to prevent stack overflow. + /// + /// Note that this doesn't guarantee deterministic execution across + /// different platforms. + pub fn enable_stack_check(&mut self, enable: bool) -> &mut Self { + self.enable_stack_check = enable; + self + } + + fn enable_nan_canonicalization(&mut self) { + self.enable_nan_canonicalization = true; + } + + pub fn canonicalize_nans(&mut self, enable: bool) -> &mut Self { + self.enable_nan_canonicalization = enable; + self + } +} + +impl CompilerConfig for Singlepass { + fn enable_pic(&mut self) { + // Do nothing, since singlepass already emits + // PIC code. + } + + /// Transform it into the compiler + fn compiler(self: Box) -> Box { + Box::new(SinglepassCompiler::new(*self)) + } + + /// Gets the default features for this compiler in the given target + fn default_features_for_target(&self, _target: &Target) -> Features { + let mut features = Features::default(); + features.multi_value(false); + features + } +} + +impl Default for Singlepass { + fn default() -> Singlepass { + Self::new() + } +} + +impl Intrinsic { + pub(crate) fn is_params_ok(&self, params: &SmallVec<[Location; 8]>) -> bool { + match self.kind { + IntrinsicKind::Gas => match params[0] { + Location::Imm32(value) => value < i32::MAX as u32, + _ => false, + }, + } + } +} diff --git a/runtime/near-vm/lib/compiler-singlepass/src/emitter_x64.rs b/runtime/near-vm/lib/compiler-singlepass/src/emitter_x64.rs new file mode 100644 index 00000000000..79bd18a5cd1 --- /dev/null +++ b/runtime/near-vm/lib/compiler-singlepass/src/emitter_x64.rs @@ -0,0 +1,1448 @@ +pub(crate) use crate::x64_decl::{GPR, XMM}; +use dynasm::dynasm; +use dynasmrt::{ + x64::X64Relocation, AssemblyOffset, DynamicLabel, DynasmApi, DynasmLabelApi, VecAssembler, +}; +use enumset::EnumSet; +use wasmer_compiler::CpuFeature; + +type Assembler = VecAssembler; + +/// Force `dynasm!` to use the correct arch (x64) when cross-compiling. +/// `dynasm!` proc-macro tries to auto-detect it by default by looking at the +/// `target_arch`, but it sees the `target_arch` of the proc-macro itself, which +/// is always equal to host, even when cross-compiling. +macro_rules! dynasm { + ($a:expr ; $($tt:tt)*) => { + dynasm::dynasm!( + $a + ; .arch x64 + ; $($tt)* + ) + }; +} + +#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)] +pub(crate) enum Location { + Imm8(u8), + Imm32(u32), + Imm64(u64), + // Imm128(u128), + GPR(GPR), + XMM(XMM), + Memory(GPR, i32), + MemoryAddTriple(GPR, GPR, i32), +} + +#[allow(dead_code)] +#[derive(Copy, Clone, Debug, Eq, PartialEq)] +pub(crate) enum Condition { + None, + Above, + AboveEqual, + Below, + BelowEqual, + Greater, + GreaterEqual, + Less, + LessEqual, + Equal, + NotEqual, + Signed, + Carry, + Overflow, +} + +#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd)] +pub(crate) enum Size { + S8, + S16, + S32, + S64, +} + +#[derive(Copy, Clone, Debug, Eq, PartialEq)] +#[allow(dead_code)] +pub(crate) enum XMMOrMemory { + XMM(XMM), + Memory(GPR, i32), +} + +#[derive(Copy, Clone, Debug)] +#[allow(dead_code)] +pub(crate) enum GPROrMemory { + GPR(GPR), + Memory(GPR, i32), +} + +pub(crate) trait Emitter { + type Label; + type Offset; + + fn get_label(&mut self) -> Self::Label; + fn get_offset(&self) -> Self::Offset; + fn get_jmp_instr_size(&self) -> u8; + + fn finalize_function(&mut self) {} + + fn emit_u64(&mut self, x: u64); + fn emit_bytes(&mut self, bytes: &[u8]); + + fn emit_label(&mut self, label: Self::Label); + + fn emit_nop(&mut self); + + /// A high-level assembler method. Emits an instruction sequence of length `n` that is functionally + /// equivalent to a `nop` instruction, without guarantee about the underlying implementation. + fn emit_nop_n(&mut self, n: usize); + + fn emit_mov(&mut self, sz: Size, src: Location, dst: Location); + fn emit_lea(&mut self, sz: Size, src: Location, dst: Location); + fn emit_lea_label(&mut self, label: Self::Label, dst: Location); + fn emit_cdq(&mut self); + fn emit_cqo(&mut self); + fn emit_xor(&mut self, sz: Size, src: Location, dst: Location); + fn emit_jmp(&mut self, condition: Condition, label: Self::Label); + fn emit_jmp_location(&mut self, loc: Location); + fn emit_set(&mut self, condition: Condition, dst: GPR); + fn emit_push(&mut self, sz: Size, src: Location); + fn emit_pop(&mut self, sz: Size, dst: Location); + fn emit_cmp(&mut self, sz: Size, left: Location, right: Location); + fn emit_add(&mut self, sz: Size, src: Location, dst: Location); + fn emit_sub(&mut self, sz: Size, src: Location, dst: Location); + fn emit_neg(&mut self, sz: Size, value: Location); + fn emit_imul(&mut self, sz: Size, src: Location, dst: Location); + fn emit_imul_imm32_gpr64(&mut self, src: u32, dst: GPR); + fn emit_div(&mut self, sz: Size, divisor: Location); + fn emit_idiv(&mut self, sz: Size, divisor: Location); + fn emit_shl(&mut self, sz: Size, src: Location, dst: Location); + fn emit_shr(&mut self, sz: Size, src: Location, dst: Location); + fn emit_sar(&mut self, sz: Size, src: Location, dst: Location); + fn emit_rol(&mut self, sz: Size, src: Location, dst: Location); + fn emit_ror(&mut self, sz: Size, src: Location, dst: Location); + fn emit_and(&mut self, sz: Size, src: Location, dst: Location); + fn emit_or(&mut self, sz: Size, src: Location, dst: Location); + fn emit_bsr(&mut self, sz: Size, src: Location, dst: Location); + fn emit_bsf(&mut self, sz: Size, src: Location, dst: Location); + fn emit_popcnt(&mut self, sz: Size, src: Location, dst: Location); + fn emit_movzx(&mut self, sz_src: Size, src: Location, sz_dst: Size, dst: Location); + fn emit_movsx(&mut self, sz_src: Size, src: Location, sz_dst: Size, dst: Location); + fn emit_xchg(&mut self, sz: Size, src: Location, dst: Location); + fn emit_lock_xadd(&mut self, sz: Size, src: Location, dst: Location); + fn emit_lock_cmpxchg(&mut self, sz: Size, src: Location, dst: Location); + fn emit_rep_stosq(&mut self); + + fn emit_btc_gpr_imm8_32(&mut self, src: u8, dst: GPR); + fn emit_btc_gpr_imm8_64(&mut self, src: u8, dst: GPR); + + fn emit_cmovae_gpr_32(&mut self, src: GPR, dst: GPR); + fn emit_cmovae_gpr_64(&mut self, src: GPR, dst: GPR); + + fn emit_vmovaps(&mut self, src: XMMOrMemory, dst: XMMOrMemory); + fn emit_vmovapd(&mut self, src: XMMOrMemory, dst: XMMOrMemory); + fn emit_vxorps(&mut self, src1: XMM, src2: XMMOrMemory, dst: XMM); + fn emit_vxorpd(&mut self, src1: XMM, src2: XMMOrMemory, dst: XMM); + + fn emit_vaddss(&mut self, src1: XMM, src2: XMMOrMemory, dst: XMM); + fn emit_vaddsd(&mut self, src1: XMM, src2: XMMOrMemory, dst: XMM); + fn emit_vsubss(&mut self, src1: XMM, src2: XMMOrMemory, dst: XMM); + fn emit_vsubsd(&mut self, src1: XMM, src2: XMMOrMemory, dst: XMM); + fn emit_vmulss(&mut self, src1: XMM, src2: XMMOrMemory, dst: XMM); + fn emit_vmulsd(&mut self, src1: XMM, src2: XMMOrMemory, dst: XMM); + fn emit_vdivss(&mut self, src1: XMM, src2: XMMOrMemory, dst: XMM); + fn emit_vdivsd(&mut self, src1: XMM, src2: XMMOrMemory, dst: XMM); + fn emit_vmaxss(&mut self, src1: XMM, src2: XMMOrMemory, dst: XMM); + fn emit_vmaxsd(&mut self, src1: XMM, src2: XMMOrMemory, dst: XMM); + fn emit_vminss(&mut self, src1: XMM, src2: XMMOrMemory, dst: XMM); + fn emit_vminsd(&mut self, src1: XMM, src2: XMMOrMemory, dst: XMM); + + fn emit_vcmpeqss(&mut self, src1: XMM, src2: XMMOrMemory, dst: XMM); + fn emit_vcmpeqsd(&mut self, src1: XMM, src2: XMMOrMemory, dst: XMM); + + fn emit_vcmpneqss(&mut self, src1: XMM, src2: XMMOrMemory, dst: XMM); + fn emit_vcmpneqsd(&mut self, src1: XMM, src2: XMMOrMemory, dst: XMM); + + fn emit_vcmpltss(&mut self, src1: XMM, src2: XMMOrMemory, dst: XMM); + fn emit_vcmpltsd(&mut self, src1: XMM, src2: XMMOrMemory, dst: XMM); + + fn emit_vcmpless(&mut self, src1: XMM, src2: XMMOrMemory, dst: XMM); + fn emit_vcmplesd(&mut self, src1: XMM, src2: XMMOrMemory, dst: XMM); + + fn emit_vcmpgtss(&mut self, src1: XMM, src2: XMMOrMemory, dst: XMM); + fn emit_vcmpgtsd(&mut self, src1: XMM, src2: XMMOrMemory, dst: XMM); + + fn emit_vcmpgess(&mut self, src1: XMM, src2: XMMOrMemory, dst: XMM); + fn emit_vcmpgesd(&mut self, src1: XMM, src2: XMMOrMemory, dst: XMM); + + fn emit_vcmpunordss(&mut self, src1: XMM, src2: XMMOrMemory, dst: XMM); + fn emit_vcmpunordsd(&mut self, src1: XMM, src2: XMMOrMemory, dst: XMM); + + fn emit_vcmpordss(&mut self, src1: XMM, src2: XMMOrMemory, dst: XMM); + fn emit_vcmpordsd(&mut self, src1: XMM, src2: XMMOrMemory, dst: XMM); + + fn emit_vsqrtss(&mut self, src1: XMM, src2: XMMOrMemory, dst: XMM); + fn emit_vsqrtsd(&mut self, src1: XMM, src2: XMMOrMemory, dst: XMM); + + fn emit_vroundss_nearest(&mut self, src1: XMM, src2: XMMOrMemory, dst: XMM); + fn emit_vroundss_floor(&mut self, src1: XMM, src2: XMMOrMemory, dst: XMM); + fn emit_vroundss_ceil(&mut self, src1: XMM, src2: XMMOrMemory, dst: XMM); + fn emit_vroundss_trunc(&mut self, src1: XMM, src2: XMMOrMemory, dst: XMM); + fn emit_vroundsd_nearest(&mut self, src1: XMM, src2: XMMOrMemory, dst: XMM); + fn emit_vroundsd_floor(&mut self, src1: XMM, src2: XMMOrMemory, dst: XMM); + fn emit_vroundsd_ceil(&mut self, src1: XMM, src2: XMMOrMemory, dst: XMM); + fn emit_vroundsd_trunc(&mut self, src1: XMM, src2: XMMOrMemory, dst: XMM); + + fn emit_vcvtss2sd(&mut self, src1: XMM, src2: XMMOrMemory, dst: XMM); + fn emit_vcvtsd2ss(&mut self, src1: XMM, src2: XMMOrMemory, dst: XMM); + + fn emit_ucomiss(&mut self, src: XMMOrMemory, dst: XMM); + fn emit_ucomisd(&mut self, src: XMMOrMemory, dst: XMM); + + fn emit_cvttss2si_32(&mut self, src: XMMOrMemory, dst: GPR); + fn emit_cvttss2si_64(&mut self, src: XMMOrMemory, dst: GPR); + fn emit_cvttsd2si_32(&mut self, src: XMMOrMemory, dst: GPR); + fn emit_cvttsd2si_64(&mut self, src: XMMOrMemory, dst: GPR); + + fn emit_vcvtsi2ss_32(&mut self, src1: XMM, src2: GPROrMemory, dst: XMM); + fn emit_vcvtsi2ss_64(&mut self, src1: XMM, src2: GPROrMemory, dst: XMM); + fn emit_vcvtsi2sd_32(&mut self, src1: XMM, src2: GPROrMemory, dst: XMM); + fn emit_vcvtsi2sd_64(&mut self, src1: XMM, src2: GPROrMemory, dst: XMM); + + fn emit_vblendvps(&mut self, src1: XMM, src2: XMMOrMemory, mask: XMM, dst: XMM); + fn emit_vblendvpd(&mut self, src1: XMM, src2: XMMOrMemory, mask: XMM, dst: XMM); + + fn emit_test_gpr_64(&mut self, reg: GPR); + + fn emit_ud2(&mut self); + fn emit_ret(&mut self); + fn emit_call_label(&mut self, label: Self::Label); + fn emit_call_location(&mut self, loc: Location); + + fn emit_call_register(&mut self, reg: GPR); + + fn emit_bkpt(&mut self); + + fn emit_host_redirection(&mut self, target: GPR); + + fn arch_has_itruncf(&self) -> bool { + false + } + fn arch_emit_i32_trunc_sf32(&mut self, _src: XMM, _dst: GPR) { + unimplemented!() + } + fn arch_emit_i32_trunc_sf64(&mut self, _src: XMM, _dst: GPR) { + unimplemented!() + } + fn arch_emit_i32_trunc_uf32(&mut self, _src: XMM, _dst: GPR) { + unimplemented!() + } + fn arch_emit_i32_trunc_uf64(&mut self, _src: XMM, _dst: GPR) { + unimplemented!() + } + fn arch_emit_i64_trunc_sf32(&mut self, _src: XMM, _dst: GPR) { + unimplemented!() + } + fn arch_emit_i64_trunc_sf64(&mut self, _src: XMM, _dst: GPR) { + unimplemented!() + } + fn arch_emit_i64_trunc_uf32(&mut self, _src: XMM, _dst: GPR) { + unimplemented!() + } + fn arch_emit_i64_trunc_uf64(&mut self, _src: XMM, _dst: GPR) { + unimplemented!() + } + + fn arch_has_fconverti(&self) -> bool { + false + } + fn arch_emit_f32_convert_si32(&mut self, _src: GPR, _dst: XMM) { + unimplemented!() + } + fn arch_emit_f32_convert_si64(&mut self, _src: GPR, _dst: XMM) { + unimplemented!() + } + fn arch_emit_f32_convert_ui32(&mut self, _src: GPR, _dst: XMM) { + unimplemented!() + } + fn arch_emit_f32_convert_ui64(&mut self, _src: GPR, _dst: XMM) { + unimplemented!() + } + fn arch_emit_f64_convert_si32(&mut self, _src: GPR, _dst: XMM) { + unimplemented!() + } + fn arch_emit_f64_convert_si64(&mut self, _src: GPR, _dst: XMM) { + unimplemented!() + } + fn arch_emit_f64_convert_ui32(&mut self, _src: GPR, _dst: XMM) { + unimplemented!() + } + fn arch_emit_f64_convert_ui64(&mut self, _src: GPR, _dst: XMM) { + unimplemented!() + } + + fn arch_has_fneg(&self) -> bool { + false + } + fn arch_emit_f32_neg(&mut self, _src: XMM, _dst: XMM) { + unimplemented!() + } + fn arch_emit_f64_neg(&mut self, _src: XMM, _dst: XMM) { + unimplemented!() + } + + fn arch_has_xzcnt(&self, _cpu: &EnumSet) -> bool { + false + } + fn arch_emit_lzcnt(&mut self, _sz: Size, _src: Location, _dst: Location) { + unimplemented!() + } + fn arch_emit_tzcnt(&mut self, _sz: Size, _src: Location, _dst: Location) { + unimplemented!() + } + + fn arch_supports_canonicalize_nan(&self) -> bool { + true + } + + fn arch_requires_indirect_call_trampoline(&self) -> bool { + false + } + + fn arch_emit_indirect_call_with_trampoline(&mut self, _loc: Location) { + unimplemented!() + } + + // Emits entry trampoline just before the real function. + fn arch_emit_entry_trampoline(&mut self) {} + + // Byte offset from the beginning of a `mov Imm64, GPR` instruction to the imm64 value. + // Required to support emulation on Aarch64. + fn arch_mov64_imm_offset(&self) -> usize { + unimplemented!() + } +} + +macro_rules! unop_gpr { + ($ins:ident, $assembler:tt, $sz:expr, $loc:expr, $otherwise:block) => { + match ($sz, $loc) { + (Size::S32, Location::GPR(loc)) => { + dynasm!($assembler ; $ins Rd(loc as u8)); + }, + (Size::S64, Location::GPR(loc)) => { + dynasm!($assembler ; $ins Rq(loc as u8)); + }, + _ => $otherwise + } + }; +} + +macro_rules! unop_mem { + ($ins:ident, $assembler:tt, $sz:expr, $loc:expr, $otherwise:block) => { + match ($sz, $loc) { + (Size::S32, Location::Memory(loc, disp)) => { + dynasm!($assembler ; $ins DWORD [Rq(loc as u8) + disp] ); + }, + (Size::S64, Location::Memory(loc, disp)) => { + dynasm!($assembler ; $ins QWORD [Rq(loc as u8) + disp] ); + }, + _ => $otherwise + } + }; +} + +macro_rules! unop_gpr_or_mem { + ($ins:ident, $assembler:tt, $sz:expr, $loc:expr, $otherwise:block) => { + unop_gpr!($ins, $assembler, $sz, $loc, { + unop_mem!($ins, $assembler, $sz, $loc, $otherwise) + }) + }; +} + +macro_rules! binop_imm32_gpr { + ($ins:ident, $assembler:tt, $sz:expr, $src:expr, $dst:expr, $otherwise:block) => { + match ($sz, $src, $dst) { + (Size::S32, Location::Imm32(src), Location::GPR(dst)) => { + dynasm!($assembler ; $ins Rd(dst as u8), src as i32); // IMM32_2GPR + }, + (Size::S64, Location::Imm32(src), Location::GPR(dst)) => { + dynasm!($assembler ; $ins Rq(dst as u8), src as i32); // IMM32_2GPR + }, + _ => $otherwise + } + }; +} + +macro_rules! binop_imm32_mem { + ($ins:ident, $assembler:tt, $sz:expr, $src:expr, $dst:expr, $otherwise:block) => { + match ($sz, $src, $dst) { + (Size::S32, Location::Imm32(src), Location::Memory(dst, disp)) => { + dynasm!($assembler ; $ins DWORD [Rq(dst as u8) + disp], src as i32); + }, + (Size::S64, Location::Imm32(src), Location::Memory(dst, disp)) => { + dynasm!($assembler ; $ins QWORD [Rq(dst as u8) + disp], src as i32); + }, + _ => $otherwise + } + }; +} + +macro_rules! binop_imm64_gpr { + ($ins:ident, $assembler:tt, $sz:expr, $src:expr, $dst:expr, $otherwise:block) => { + match ($sz, $src, $dst) { + (Size::S64, Location::Imm64(src), Location::GPR(dst)) => { + dynasm!($assembler ; $ins Rq(dst as u8), QWORD src as i64); // IMM32_2GPR + }, + _ => $otherwise + } + }; +} + +macro_rules! binop_gpr_gpr { + ($ins:ident, $assembler:tt, $sz:expr, $src:expr, $dst:expr, $otherwise:block) => { + match ($sz, $src, $dst) { + (Size::S32, Location::GPR(src), Location::GPR(dst)) => { + dynasm!($assembler ; $ins Rd(dst as u8), Rd(src as u8)); // GPR2GPR + }, + (Size::S64, Location::GPR(src), Location::GPR(dst)) => { + dynasm!($assembler ; $ins Rq(dst as u8), Rq(src as u8)); // GPR2GPR + }, + _ => $otherwise + } + }; +} + +macro_rules! binop_gpr_mem { + ($ins:ident, $assembler:tt, $sz:expr, $src:expr, $dst:expr, $otherwise:block) => { + match ($sz, $src, $dst) { + (Size::S32, Location::GPR(src), Location::Memory(dst, disp)) => { + dynasm!($assembler ; $ins [Rq(dst as u8) + disp], Rd(src as u8)); // GPR2MEM + }, + (Size::S64, Location::GPR(src), Location::Memory(dst, disp)) => { + dynasm!($assembler ; $ins [Rq(dst as u8) + disp], Rq(src as u8)); // GPR2MEM + }, + _ => $otherwise + } + }; +} + +macro_rules! binop_mem_gpr { + ($ins:ident, $assembler:tt, $sz:expr, $src:expr, $dst:expr, $otherwise:block) => { + match ($sz, $src, $dst) { + (Size::S32, Location::Memory(src, disp), Location::GPR(dst)) => { + dynasm!($assembler ; $ins Rd(dst as u8), [Rq(src as u8) + disp]); // MEM2GPR + }, + (Size::S64, Location::Memory(src, disp), Location::GPR(dst)) => { + dynasm!($assembler ; $ins Rq(dst as u8), [Rq(src as u8) + disp]); // MEM2GPR + }, + _ => $otherwise + } + }; +} + +macro_rules! binop_all_nofp { + ($ins:ident, $assembler:tt, $sz:expr, $src:expr, $dst:expr, $otherwise:block) => { + binop_imm32_gpr!($ins, $assembler, $sz, $src, $dst, { + binop_imm32_mem!($ins, $assembler, $sz, $src, $dst, { + binop_gpr_gpr!($ins, $assembler, $sz, $src, $dst, { + binop_gpr_mem!($ins, $assembler, $sz, $src, $dst, { + binop_mem_gpr!($ins, $assembler, $sz, $src, $dst, $otherwise) + }) + }) + }) + }) + }; +} + +macro_rules! binop_shift { + ($ins:ident, $assembler:tt, $sz:expr, $src:expr, $dst:expr, $otherwise:block) => { + match ($sz, $src, $dst) { + (Size::S32, Location::GPR(GPR::RCX), Location::GPR(dst)) => { + dynasm!($assembler ; $ins Rd(dst as u8), cl); + }, + (Size::S32, Location::GPR(GPR::RCX), Location::Memory(dst, disp)) => { + dynasm!($assembler ; $ins DWORD [Rq(dst as u8) + disp], cl); + }, + (Size::S32, Location::Imm8(imm), Location::GPR(dst)) => { + dynasm!($assembler ; $ins Rd(dst as u8), imm as i8); + }, + (Size::S32, Location::Imm8(imm), Location::Memory(dst, disp)) => { + dynasm!($assembler ; $ins DWORD [Rq(dst as u8) + disp], imm as i8); + }, + (Size::S64, Location::GPR(GPR::RCX), Location::GPR(dst)) => { + dynasm!($assembler ; $ins Rq(dst as u8), cl); + }, + (Size::S64, Location::GPR(GPR::RCX), Location::Memory(dst, disp)) => { + dynasm!($assembler ; $ins QWORD [Rq(dst as u8) + disp], cl); + }, + (Size::S64, Location::Imm8(imm), Location::GPR(dst)) => { + dynasm!($assembler ; $ins Rq(dst as u8), imm as i8); + }, + (Size::S64, Location::Imm8(imm), Location::Memory(dst, disp)) => { + dynasm!($assembler ; $ins QWORD [Rq(dst as u8) + disp], imm as i8); + }, + _ => $otherwise + } + } +} + +macro_rules! jmp_op { + ($ins:ident, $assembler:tt, $label:ident) => { + dynasm!($assembler ; $ins =>$label) + } +} + +macro_rules! avx_fn { + ($ins:ident, $name:ident) => { + fn $name(&mut self, src1: XMM, src2: XMMOrMemory, dst: XMM) { + // Dynasm bug: AVX instructions are not encoded correctly. + match src2 { + XMMOrMemory::XMM(x) => match src1 { + XMM::XMM0 => dynasm!(self ; $ins Rx((dst as u8)), xmm0, Rx((x as u8))), + XMM::XMM1 => dynasm!(self ; $ins Rx((dst as u8)), xmm1, Rx((x as u8))), + XMM::XMM2 => dynasm!(self ; $ins Rx((dst as u8)), xmm2, Rx((x as u8))), + XMM::XMM3 => dynasm!(self ; $ins Rx((dst as u8)), xmm3, Rx((x as u8))), + XMM::XMM4 => dynasm!(self ; $ins Rx((dst as u8)), xmm4, Rx((x as u8))), + XMM::XMM5 => dynasm!(self ; $ins Rx((dst as u8)), xmm5, Rx((x as u8))), + XMM::XMM6 => dynasm!(self ; $ins Rx((dst as u8)), xmm6, Rx((x as u8))), + XMM::XMM7 => dynasm!(self ; $ins Rx((dst as u8)), xmm7, Rx((x as u8))), + XMM::XMM8 => dynasm!(self ; $ins Rx((dst as u8)), xmm8, Rx((x as u8))), + XMM::XMM9 => dynasm!(self ; $ins Rx((dst as u8)), xmm9, Rx((x as u8))), + XMM::XMM10 => dynasm!(self ; $ins Rx((dst as u8)), xmm10, Rx((x as u8))), + XMM::XMM11 => dynasm!(self ; $ins Rx((dst as u8)), xmm11, Rx((x as u8))), + XMM::XMM12 => dynasm!(self ; $ins Rx((dst as u8)), xmm12, Rx((x as u8))), + XMM::XMM13 => dynasm!(self ; $ins Rx((dst as u8)), xmm13, Rx((x as u8))), + XMM::XMM14 => dynasm!(self ; $ins Rx((dst as u8)), xmm14, Rx((x as u8))), + XMM::XMM15 => dynasm!(self ; $ins Rx((dst as u8)), xmm15, Rx((x as u8))), + }, + XMMOrMemory::Memory(base, disp) => match src1 { + XMM::XMM0 => dynasm!(self ; $ins Rx((dst as u8)), xmm0, [Rq((base as u8)) + disp]), + XMM::XMM1 => dynasm!(self ; $ins Rx((dst as u8)), xmm1, [Rq((base as u8)) + disp]), + XMM::XMM2 => dynasm!(self ; $ins Rx((dst as u8)), xmm2, [Rq((base as u8)) + disp]), + XMM::XMM3 => dynasm!(self ; $ins Rx((dst as u8)), xmm3, [Rq((base as u8)) + disp]), + XMM::XMM4 => dynasm!(self ; $ins Rx((dst as u8)), xmm4, [Rq((base as u8)) + disp]), + XMM::XMM5 => dynasm!(self ; $ins Rx((dst as u8)), xmm5, [Rq((base as u8)) + disp]), + XMM::XMM6 => dynasm!(self ; $ins Rx((dst as u8)), xmm6, [Rq((base as u8)) + disp]), + XMM::XMM7 => dynasm!(self ; $ins Rx((dst as u8)), xmm7, [Rq((base as u8)) + disp]), + XMM::XMM8 => dynasm!(self ; $ins Rx((dst as u8)), xmm8, [Rq((base as u8)) + disp]), + XMM::XMM9 => dynasm!(self ; $ins Rx((dst as u8)), xmm9, [Rq((base as u8)) + disp]), + XMM::XMM10 => dynasm!(self ; $ins Rx((dst as u8)), xmm10, [Rq((base as u8)) + disp]), + XMM::XMM11 => dynasm!(self ; $ins Rx((dst as u8)), xmm11, [Rq((base as u8)) + disp]), + XMM::XMM12 => dynasm!(self ; $ins Rx((dst as u8)), xmm12, [Rq((base as u8)) + disp]), + XMM::XMM13 => dynasm!(self ; $ins Rx((dst as u8)), xmm13, [Rq((base as u8)) + disp]), + XMM::XMM14 => dynasm!(self ; $ins Rx((dst as u8)), xmm14, [Rq((base as u8)) + disp]), + XMM::XMM15 => dynasm!(self ; $ins Rx((dst as u8)), xmm15, [Rq((base as u8)) + disp]), + }, + } + } + } +} + +macro_rules! avx_i2f_64_fn { + ($ins:ident, $name:ident) => { + fn $name(&mut self, src1: XMM, src2: GPROrMemory, dst: XMM) { + match src2 { + GPROrMemory::GPR(x) => match src1 { + XMM::XMM0 => dynasm!(self ; $ins Rx((dst as u8)), xmm0, Rq((x as u8))), + XMM::XMM1 => dynasm!(self ; $ins Rx((dst as u8)), xmm1, Rq((x as u8))), + XMM::XMM2 => dynasm!(self ; $ins Rx((dst as u8)), xmm2, Rq((x as u8))), + XMM::XMM3 => dynasm!(self ; $ins Rx((dst as u8)), xmm3, Rq((x as u8))), + XMM::XMM4 => dynasm!(self ; $ins Rx((dst as u8)), xmm4, Rq((x as u8))), + XMM::XMM5 => dynasm!(self ; $ins Rx((dst as u8)), xmm5, Rq((x as u8))), + XMM::XMM6 => dynasm!(self ; $ins Rx((dst as u8)), xmm6, Rq((x as u8))), + XMM::XMM7 => dynasm!(self ; $ins Rx((dst as u8)), xmm7, Rq((x as u8))), + XMM::XMM8 => dynasm!(self ; $ins Rx((dst as u8)), xmm8, Rq((x as u8))), + XMM::XMM9 => dynasm!(self ; $ins Rx((dst as u8)), xmm9, Rq((x as u8))), + XMM::XMM10 => dynasm!(self ; $ins Rx((dst as u8)), xmm10, Rq((x as u8))), + XMM::XMM11 => dynasm!(self ; $ins Rx((dst as u8)), xmm11, Rq((x as u8))), + XMM::XMM12 => dynasm!(self ; $ins Rx((dst as u8)), xmm12, Rq((x as u8))), + XMM::XMM13 => dynasm!(self ; $ins Rx((dst as u8)), xmm13, Rq((x as u8))), + XMM::XMM14 => dynasm!(self ; $ins Rx((dst as u8)), xmm14, Rq((x as u8))), + XMM::XMM15 => dynasm!(self ; $ins Rx((dst as u8)), xmm15, Rq((x as u8))), + }, + GPROrMemory::Memory(base, disp) => match src1 { + XMM::XMM0 => dynasm!(self ; $ins Rx((dst as u8)), xmm0, QWORD [Rq((base as u8)) + disp]), + XMM::XMM1 => dynasm!(self ; $ins Rx((dst as u8)), xmm1, QWORD [Rq((base as u8)) + disp]), + XMM::XMM2 => dynasm!(self ; $ins Rx((dst as u8)), xmm2, QWORD [Rq((base as u8)) + disp]), + XMM::XMM3 => dynasm!(self ; $ins Rx((dst as u8)), xmm3, QWORD [Rq((base as u8)) + disp]), + XMM::XMM4 => dynasm!(self ; $ins Rx((dst as u8)), xmm4, QWORD [Rq((base as u8)) + disp]), + XMM::XMM5 => dynasm!(self ; $ins Rx((dst as u8)), xmm5, QWORD [Rq((base as u8)) + disp]), + XMM::XMM6 => dynasm!(self ; $ins Rx((dst as u8)), xmm6, QWORD [Rq((base as u8)) + disp]), + XMM::XMM7 => dynasm!(self ; $ins Rx((dst as u8)), xmm7, QWORD [Rq((base as u8)) + disp]), + XMM::XMM8 => dynasm!(self ; $ins Rx((dst as u8)), xmm8, QWORD [Rq((base as u8)) + disp]), + XMM::XMM9 => dynasm!(self ; $ins Rx((dst as u8)), xmm9, QWORD [Rq((base as u8)) + disp]), + XMM::XMM10 => dynasm!(self ; $ins Rx((dst as u8)), xmm10, QWORD [Rq((base as u8)) + disp]), + XMM::XMM11 => dynasm!(self ; $ins Rx((dst as u8)), xmm11, QWORD [Rq((base as u8)) + disp]), + XMM::XMM12 => dynasm!(self ; $ins Rx((dst as u8)), xmm12, QWORD [Rq((base as u8)) + disp]), + XMM::XMM13 => dynasm!(self ; $ins Rx((dst as u8)), xmm13, QWORD [Rq((base as u8)) + disp]), + XMM::XMM14 => dynasm!(self ; $ins Rx((dst as u8)), xmm14, QWORD [Rq((base as u8)) + disp]), + XMM::XMM15 => dynasm!(self ; $ins Rx((dst as u8)), xmm15, QWORD [Rq((base as u8)) + disp]), + }, + } + } + } +} + +macro_rules! avx_i2f_32_fn { + ($ins:ident, $name:ident) => { + fn $name(&mut self, src1: XMM, src2: GPROrMemory, dst: XMM) { + match src2 { + GPROrMemory::GPR(x) => match src1 { + XMM::XMM0 => dynasm!(self ; $ins Rx((dst as u8)), xmm0, Rd((x as u8))), + XMM::XMM1 => dynasm!(self ; $ins Rx((dst as u8)), xmm1, Rd((x as u8))), + XMM::XMM2 => dynasm!(self ; $ins Rx((dst as u8)), xmm2, Rd((x as u8))), + XMM::XMM3 => dynasm!(self ; $ins Rx((dst as u8)), xmm3, Rd((x as u8))), + XMM::XMM4 => dynasm!(self ; $ins Rx((dst as u8)), xmm4, Rd((x as u8))), + XMM::XMM5 => dynasm!(self ; $ins Rx((dst as u8)), xmm5, Rd((x as u8))), + XMM::XMM6 => dynasm!(self ; $ins Rx((dst as u8)), xmm6, Rd((x as u8))), + XMM::XMM7 => dynasm!(self ; $ins Rx((dst as u8)), xmm7, Rd((x as u8))), + XMM::XMM8 => dynasm!(self ; $ins Rx((dst as u8)), xmm8, Rd((x as u8))), + XMM::XMM9 => dynasm!(self ; $ins Rx((dst as u8)), xmm9, Rd((x as u8))), + XMM::XMM10 => dynasm!(self ; $ins Rx((dst as u8)), xmm10, Rd((x as u8))), + XMM::XMM11 => dynasm!(self ; $ins Rx((dst as u8)), xmm11, Rd((x as u8))), + XMM::XMM12 => dynasm!(self ; $ins Rx((dst as u8)), xmm12, Rd((x as u8))), + XMM::XMM13 => dynasm!(self ; $ins Rx((dst as u8)), xmm13, Rd((x as u8))), + XMM::XMM14 => dynasm!(self ; $ins Rx((dst as u8)), xmm14, Rd((x as u8))), + XMM::XMM15 => dynasm!(self ; $ins Rx((dst as u8)), xmm15, Rd((x as u8))), + }, + GPROrMemory::Memory(base, disp) => match src1 { + XMM::XMM0 => dynasm!(self ; $ins Rx((dst as u8)), xmm0, DWORD [Rq((base as u8)) + disp]), + XMM::XMM1 => dynasm!(self ; $ins Rx((dst as u8)), xmm1, DWORD [Rq((base as u8)) + disp]), + XMM::XMM2 => dynasm!(self ; $ins Rx((dst as u8)), xmm2, DWORD [Rq((base as u8)) + disp]), + XMM::XMM3 => dynasm!(self ; $ins Rx((dst as u8)), xmm3, DWORD [Rq((base as u8)) + disp]), + XMM::XMM4 => dynasm!(self ; $ins Rx((dst as u8)), xmm4, DWORD [Rq((base as u8)) + disp]), + XMM::XMM5 => dynasm!(self ; $ins Rx((dst as u8)), xmm5, DWORD [Rq((base as u8)) + disp]), + XMM::XMM6 => dynasm!(self ; $ins Rx((dst as u8)), xmm6, DWORD [Rq((base as u8)) + disp]), + XMM::XMM7 => dynasm!(self ; $ins Rx((dst as u8)), xmm7, DWORD [Rq((base as u8)) + disp]), + XMM::XMM8 => dynasm!(self ; $ins Rx((dst as u8)), xmm8, DWORD [Rq((base as u8)) + disp]), + XMM::XMM9 => dynasm!(self ; $ins Rx((dst as u8)), xmm9, DWORD [Rq((base as u8)) + disp]), + XMM::XMM10 => dynasm!(self ; $ins Rx((dst as u8)), xmm10, DWORD [Rq((base as u8)) + disp]), + XMM::XMM11 => dynasm!(self ; $ins Rx((dst as u8)), xmm11, DWORD [Rq((base as u8)) + disp]), + XMM::XMM12 => dynasm!(self ; $ins Rx((dst as u8)), xmm12, DWORD [Rq((base as u8)) + disp]), + XMM::XMM13 => dynasm!(self ; $ins Rx((dst as u8)), xmm13, DWORD [Rq((base as u8)) + disp]), + XMM::XMM14 => dynasm!(self ; $ins Rx((dst as u8)), xmm14, DWORD [Rq((base as u8)) + disp]), + XMM::XMM15 => dynasm!(self ; $ins Rx((dst as u8)), xmm15, DWORD [Rq((base as u8)) + disp]), + }, + } + } + } +} + +macro_rules! avx_round_fn { + ($ins:ident, $name:ident, $mode:expr) => { + fn $name(&mut self, src1: XMM, src2: XMMOrMemory, dst: XMM) { + match src2 { + XMMOrMemory::XMM(x) => dynasm!(self ; $ins Rx((dst as u8)), Rx((src1 as u8)), Rx((x as u8)), $mode), + XMMOrMemory::Memory(base, disp) => dynasm!(self ; $ins Rx((dst as u8)), Rx((src1 as u8)), [Rq((base as u8)) + disp], $mode), + } + } + } +} + +impl Emitter for Assembler { + type Label = DynamicLabel; + type Offset = AssemblyOffset; + + fn get_label(&mut self) -> DynamicLabel { + self.new_dynamic_label() + } + + fn get_offset(&self) -> AssemblyOffset { + self.offset() + } + + fn get_jmp_instr_size(&self) -> u8 { + 5 + } + + fn finalize_function(&mut self) { + dynasm!( + self + ; const_neg_one_32: + ; .dword -1 + ; const_zero_32: + ; .dword 0 + ; const_pos_one_32: + ; .dword 1 + ); + } + + fn emit_u64(&mut self, x: u64) { + self.push_u64(x); + } + + fn emit_bytes(&mut self, bytes: &[u8]) { + for &b in bytes { + self.push(b); + } + } + + fn emit_label(&mut self, label: Self::Label) { + dynasm!(self ; => label); + } + + fn emit_nop(&mut self) { + dynasm!(self ; nop); + } + + fn emit_nop_n(&mut self, mut n: usize) { + /* + 1 90H NOP + 2 66 90H 66 NOP + 3 0F 1F 00H NOP DWORD ptr [EAX] + 4 0F 1F 40 00H NOP DWORD ptr [EAX + 00H] + 5 0F 1F 44 00 00H NOP DWORD ptr [EAX + EAX*1 + 00H] + 6 66 0F 1F 44 00 00H NOP DWORD ptr [AX + AX*1 + 00H] + 7 0F 1F 80 00 00 00 00H NOP DWORD ptr [EAX + 00000000H] + 8 0F 1F 84 00 00 00 00 00H NOP DWORD ptr [AX + AX*1 + 00000000H] + 9 66 0F 1F 84 00 00 00 00 00H NOP DWORD ptr [AX + AX*1 + 00000000H] + */ + while n >= 9 { + n -= 9; + self.emit_bytes(&[0x66, 0x0f, 0x1f, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00]); + // 9-byte nop + } + let seq: &[u8] = match n { + 0 => &[], + 1 => &[0x90], + 2 => &[0x66, 0x90], + 3 => &[0x0f, 0x1f, 0x00], + 4 => &[0x0f, 0x1f, 0x40, 0x00], + 5 => &[0x0f, 0x1f, 0x44, 0x00, 0x00], + 6 => &[0x66, 0x0f, 0x1f, 0x44, 0x00, 0x00], + 7 => &[0x0f, 0x1f, 0x80, 0x00, 0x00, 0x00, 0x00], + 8 => &[0x0f, 0x1f, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00], + _ => unreachable!(), + }; + self.emit_bytes(seq); + } + + fn emit_mov(&mut self, sz: Size, src: Location, dst: Location) { + // fast path + if let (Location::Imm32(0), Location::GPR(x)) = (src, dst) { + dynasm!(self ; xor Rd(x as u8), Rd(x as u8)); + return; + } + + binop_all_nofp!(mov, self, sz, src, dst, { + binop_imm64_gpr!(mov, self, sz, src, dst, { + match (sz, src, dst) { + (Size::S8, Location::GPR(src), Location::Memory(dst, disp)) => { + dynasm!(self ; mov [Rq(dst as u8) + disp], Rb(src as u8)); + } + (Size::S8, Location::Memory(src, disp), Location::GPR(dst)) => { + dynasm!(self ; mov Rb(dst as u8), [Rq(src as u8) + disp]); + } + (Size::S8, Location::Imm32(src), Location::GPR(dst)) => { + dynasm!(self ; mov Rb(dst as u8), src as i8); + } + (Size::S8, Location::Imm64(src), Location::GPR(dst)) => { + dynasm!(self ; mov Rb(dst as u8), src as i8); + } + (Size::S8, Location::Imm32(src), Location::Memory(dst, disp)) => { + dynasm!(self ; mov BYTE [Rq(dst as u8) + disp], src as i8); + } + (Size::S8, Location::Imm64(src), Location::Memory(dst, disp)) => { + dynasm!(self ; mov BYTE [Rq(dst as u8) + disp], src as i8); + } + (Size::S16, Location::GPR(src), Location::Memory(dst, disp)) => { + dynasm!(self ; mov [Rq(dst as u8) + disp], Rw(src as u8)); + } + (Size::S16, Location::Memory(src, disp), Location::GPR(dst)) => { + dynasm!(self ; mov Rw(dst as u8), [Rq(src as u8) + disp]); + } + (Size::S16, Location::Imm32(src), Location::GPR(dst)) => { + dynasm!(self ; mov Rw(dst as u8), src as i16); + } + (Size::S16, Location::Imm64(src), Location::GPR(dst)) => { + dynasm!(self ; mov Rw(dst as u8), src as i16); + } + (Size::S16, Location::Imm32(src), Location::Memory(dst, disp)) => { + dynasm!(self ; mov WORD [Rq(dst as u8) + disp], src as i16); + } + (Size::S16, Location::Imm64(src), Location::Memory(dst, disp)) => { + dynasm!(self ; mov WORD [Rq(dst as u8) + disp], src as i16); + } + (Size::S32, Location::Imm64(src), Location::GPR(dst)) => { + dynasm!(self ; mov Rd(dst as u8), src as i32); + } + (Size::S32, Location::Imm64(src), Location::Memory(dst, disp)) => { + dynasm!(self ; mov DWORD [Rq(dst as u8) + disp], src as i32); + } + (Size::S32, Location::GPR(src), Location::XMM(dst)) => { + dynasm!(self ; movd Rx(dst as u8), Rd(src as u8)); + } + (Size::S32, Location::XMM(src), Location::GPR(dst)) => { + dynasm!(self ; movd Rd(dst as u8), Rx(src as u8)); + } + (Size::S32, Location::Memory(src, disp), Location::XMM(dst)) => { + dynasm!(self ; movd Rx(dst as u8), [Rq(src as u8) + disp]); + } + (Size::S32, Location::XMM(src), Location::Memory(dst, disp)) => { + dynasm!(self ; movd [Rq(dst as u8) + disp], Rx(src as u8)); + } + + (Size::S64, Location::GPR(src), Location::XMM(dst)) => { + dynasm!(self ; movq Rx(dst as u8), Rq(src as u8)); + } + (Size::S64, Location::XMM(src), Location::GPR(dst)) => { + dynasm!(self ; movq Rq(dst as u8), Rx(src as u8)); + } + (Size::S64, Location::Memory(src, disp), Location::XMM(dst)) => { + dynasm!(self ; movq Rx(dst as u8), [Rq(src as u8) + disp]); + } + (Size::S64, Location::XMM(src), Location::Memory(dst, disp)) => { + dynasm!(self ; movq [Rq(dst as u8) + disp], Rx(src as u8)); + } + (_, Location::XMM(src), Location::XMM(dst)) => { + dynasm!(self ; movq Rx(dst as u8), Rx(src as u8)); + } + + _ => panic!("singlepass can't emit MOV {:?} {:?} {:?}", sz, src, dst), + } + }) + }); + } + fn emit_lea(&mut self, sz: Size, src: Location, dst: Location) { + match (sz, src, dst) { + (Size::S32, Location::Memory(src, disp), Location::GPR(dst)) => { + dynasm!(self ; lea Rd(dst as u8), [Rq(src as u8) + disp]); + } + (Size::S64, Location::Memory(src, disp), Location::GPR(dst)) => { + dynasm!(self ; lea Rq(dst as u8), [Rq(src as u8) + disp]); + } + (Size::S32, Location::MemoryAddTriple(src1, src2, disp), Location::GPR(dst)) => { + dynasm!(self ; lea Rd(dst as u8), [Rq(src1 as u8) + Rq(src2 as u8) + disp]); + } + (Size::S64, Location::MemoryAddTriple(src1, src2, disp), Location::GPR(dst)) => { + dynasm!(self ; lea Rq(dst as u8), [Rq(src1 as u8) + Rq(src2 as u8) + disp]); + } + _ => panic!("singlepass can't emit LEA {:?} {:?} {:?}", sz, src, dst), + } + } + fn emit_lea_label(&mut self, label: Self::Label, dst: Location) { + match dst { + Location::GPR(x) => { + dynasm!(self ; lea Rq(x as u8), [=>label]); + } + _ => panic!("singlepass can't emit LEA label={:?} {:?}", label, dst), + } + } + fn emit_cdq(&mut self) { + dynasm!(self ; cdq); + } + fn emit_cqo(&mut self) { + dynasm!(self ; cqo); + } + fn emit_xor(&mut self, sz: Size, src: Location, dst: Location) { + binop_all_nofp!(xor, self, sz, src, dst, { + panic!("singlepass can't emit XOR {:?} {:?} {:?}", sz, src, dst) + }); + } + fn emit_jmp(&mut self, condition: Condition, label: Self::Label) { + match condition { + Condition::None => jmp_op!(jmp, self, label), + Condition::Above => jmp_op!(ja, self, label), + Condition::AboveEqual => jmp_op!(jae, self, label), + Condition::Below => jmp_op!(jb, self, label), + Condition::BelowEqual => jmp_op!(jbe, self, label), + Condition::Greater => jmp_op!(jg, self, label), + Condition::GreaterEqual => jmp_op!(jge, self, label), + Condition::Less => jmp_op!(jl, self, label), + Condition::LessEqual => jmp_op!(jle, self, label), + Condition::Equal => jmp_op!(je, self, label), + Condition::NotEqual => jmp_op!(jne, self, label), + Condition::Signed => jmp_op!(js, self, label), + Condition::Carry => jmp_op!(jc, self, label), + Condition::Overflow => jmp_op!(jo, self, label), + } + } + fn emit_jmp_location(&mut self, loc: Location) { + match loc { + Location::GPR(x) => dynasm!(self ; jmp Rq(x as u8)), + Location::Memory(base, disp) => dynasm!(self ; jmp QWORD [Rq(base as u8) + disp]), + _ => panic!("singlepass can't emit JMP {:?}", loc), + } + } + fn emit_set(&mut self, condition: Condition, dst: GPR) { + match condition { + Condition::Above => dynasm!(self ; seta Rb(dst as u8)), + Condition::AboveEqual => dynasm!(self ; setae Rb(dst as u8)), + Condition::Below => dynasm!(self ; setb Rb(dst as u8)), + Condition::BelowEqual => dynasm!(self ; setbe Rb(dst as u8)), + Condition::Greater => dynasm!(self ; setg Rb(dst as u8)), + Condition::GreaterEqual => dynasm!(self ; setge Rb(dst as u8)), + Condition::Less => dynasm!(self ; setl Rb(dst as u8)), + Condition::LessEqual => dynasm!(self ; setle Rb(dst as u8)), + Condition::Equal => dynasm!(self ; sete Rb(dst as u8)), + Condition::NotEqual => dynasm!(self ; setne Rb(dst as u8)), + Condition::Signed => dynasm!(self ; sets Rb(dst as u8)), + Condition::Carry => dynasm!(self ; setc Rb(dst as u8)), + Condition::Overflow => dynasm!(self ; seto Rb(dst as u8)), + _ => panic!("singlepass can't emit SET {:?} {:?}", condition, dst), + } + } + fn emit_push(&mut self, sz: Size, src: Location) { + match (sz, src) { + (Size::S64, Location::Imm32(src)) => dynasm!(self ; push src as i32), + (Size::S64, Location::GPR(src)) => dynasm!(self ; push Rq(src as u8)), + (Size::S64, Location::Memory(src, disp)) => { + dynasm!(self ; push QWORD [Rq(src as u8) + disp]) + } + _ => panic!("singlepass can't emit PUSH {:?} {:?}", sz, src), + } + } + fn emit_pop(&mut self, sz: Size, dst: Location) { + match (sz, dst) { + (Size::S64, Location::GPR(dst)) => dynasm!(self ; pop Rq(dst as u8)), + (Size::S64, Location::Memory(dst, disp)) => { + dynasm!(self ; pop QWORD [Rq(dst as u8) + disp]) + } + _ => panic!("singlepass can't emit POP {:?} {:?}", sz, dst), + } + } + fn emit_cmp(&mut self, sz: Size, left: Location, right: Location) { + // Constant elimination for comparision between consts. + // + // Only needed for `emit_cmp`, since other binary operators actually write to `right` and `right` must + // be a writable location for them. + let consts = match (left, right) { + (Location::Imm32(x), Location::Imm32(y)) => Some((x as i32 as i64, y as i32 as i64)), + (Location::Imm32(x), Location::Imm64(y)) => Some((x as i32 as i64, y as i64)), + (Location::Imm64(x), Location::Imm32(y)) => Some((x as i64, y as i32 as i64)), + (Location::Imm64(x), Location::Imm64(y)) => Some((x as i64, y as i64)), + _ => None, + }; + use std::cmp::Ordering; + match consts { + Some((x, y)) => match x.cmp(&y) { + Ordering::Less => dynasm!(self ; cmp DWORD [>const_neg_one_32], 0), + Ordering::Equal => dynasm!(self ; cmp DWORD [>const_zero_32], 0), + Ordering::Greater => dynasm!(self ; cmp DWORD [>const_pos_one_32], 0), + }, + None => binop_all_nofp!(cmp, self, sz, left, right, { + panic!("singlepass can't emit CMP {:?} {:?} {:?}", sz, left, right); + }), + } + } + fn emit_add(&mut self, sz: Size, src: Location, dst: Location) { + // Fast path + if let Location::Imm32(0) = src { + return; + } + binop_all_nofp!(add, self, sz, src, dst, { + panic!("singlepass can't emit ADD {:?} {:?} {:?}", sz, src, dst) + }); + } + fn emit_sub(&mut self, sz: Size, src: Location, dst: Location) { + // Fast path + if let Location::Imm32(0) = src { + return; + } + binop_all_nofp!(sub, self, sz, src, dst, { + panic!("singlepass can't emit SUB {:?} {:?} {:?}", sz, src, dst) + }); + } + fn emit_neg(&mut self, sz: Size, value: Location) { + match (sz, value) { + (Size::S8, Location::GPR(value)) => dynasm!(self ; neg Rb(value as u8)), + (Size::S8, Location::Memory(value, disp)) => { + dynasm!(self ; neg [Rq(value as u8) + disp]) + } + (Size::S16, Location::GPR(value)) => dynasm!(self ; neg Rw(value as u8)), + (Size::S16, Location::Memory(value, disp)) => { + dynasm!(self ; neg [Rq(value as u8) + disp]) + } + (Size::S32, Location::GPR(value)) => dynasm!(self ; neg Rd(value as u8)), + (Size::S32, Location::Memory(value, disp)) => { + dynasm!(self ; neg [Rq(value as u8) + disp]) + } + (Size::S64, Location::GPR(value)) => dynasm!(self ; neg Rq(value as u8)), + (Size::S64, Location::Memory(value, disp)) => { + dynasm!(self ; neg [Rq(value as u8) + disp]) + } + _ => panic!("singlepass can't emit NEG {:?} {:?}", sz, value), + } + } + fn emit_imul(&mut self, sz: Size, src: Location, dst: Location) { + binop_gpr_gpr!(imul, self, sz, src, dst, { + binop_mem_gpr!(imul, self, sz, src, dst, { + panic!("singlepass can't emit IMUL {:?} {:?} {:?}", sz, src, dst) + }) + }); + } + fn emit_imul_imm32_gpr64(&mut self, src: u32, dst: GPR) { + dynasm!(self ; imul Rq(dst as u8), Rq(dst as u8), src as i32); + } + fn emit_div(&mut self, sz: Size, divisor: Location) { + unop_gpr_or_mem!(div, self, sz, divisor, { + panic!("singlepass can't emit DIV {:?} {:?}", sz, divisor) + }); + } + fn emit_idiv(&mut self, sz: Size, divisor: Location) { + unop_gpr_or_mem!(idiv, self, sz, divisor, { + panic!("singlepass can't emit IDIV {:?} {:?}", sz, divisor) + }); + } + fn emit_shl(&mut self, sz: Size, src: Location, dst: Location) { + binop_shift!(shl, self, sz, src, dst, { + panic!("singlepass can't emit SHL {:?} {:?} {:?}", sz, src, dst) + }); + } + fn emit_shr(&mut self, sz: Size, src: Location, dst: Location) { + binop_shift!(shr, self, sz, src, dst, { + panic!("singlepass can't emit SHR {:?} {:?} {:?}", sz, src, dst) + }); + } + fn emit_sar(&mut self, sz: Size, src: Location, dst: Location) { + binop_shift!(sar, self, sz, src, dst, { + panic!("singlepass can't emit SAR {:?} {:?} {:?}", sz, src, dst) + }); + } + fn emit_rol(&mut self, sz: Size, src: Location, dst: Location) { + binop_shift!(rol, self, sz, src, dst, { + panic!("singlepass can't emit ROL {:?} {:?} {:?}", sz, src, dst) + }); + } + fn emit_ror(&mut self, sz: Size, src: Location, dst: Location) { + binop_shift!(ror, self, sz, src, dst, { + panic!("singlepass can't emit ROR {:?} {:?} {:?}", sz, src, dst) + }); + } + fn emit_and(&mut self, sz: Size, src: Location, dst: Location) { + binop_all_nofp!(and, self, sz, src, dst, { + panic!("singlepass can't emit AND {:?} {:?} {:?}", sz, src, dst) + }); + } + fn emit_or(&mut self, sz: Size, src: Location, dst: Location) { + binop_all_nofp!(or, self, sz, src, dst, { + panic!("singlepass can't emit OR {:?} {:?} {:?}", sz, src, dst) + }); + } + fn emit_bsr(&mut self, sz: Size, src: Location, dst: Location) { + binop_gpr_gpr!(bsr, self, sz, src, dst, { + binop_mem_gpr!(bsr, self, sz, src, dst, { + panic!("singlepass can't emit BSR {:?} {:?} {:?}", sz, src, dst) + }) + }); + } + fn emit_bsf(&mut self, sz: Size, src: Location, dst: Location) { + binop_gpr_gpr!(bsf, self, sz, src, dst, { + binop_mem_gpr!(bsf, self, sz, src, dst, { + panic!("singlepass can't emit BSF {:?} {:?} {:?}", sz, src, dst) + }) + }); + } + fn emit_popcnt(&mut self, sz: Size, src: Location, dst: Location) { + binop_gpr_gpr!(popcnt, self, sz, src, dst, { + binop_mem_gpr!(popcnt, self, sz, src, dst, { + panic!("singlepass can't emit POPCNT {:?} {:?} {:?}", sz, src, dst) + }) + }); + } + fn emit_movzx(&mut self, sz_src: Size, src: Location, sz_dst: Size, dst: Location) { + match (sz_src, src, sz_dst, dst) { + (Size::S8, Location::GPR(src), Size::S32, Location::GPR(dst)) => { + dynasm!(self ; movzx Rd(dst as u8), Rb(src as u8)); + } + (Size::S16, Location::GPR(src), Size::S32, Location::GPR(dst)) => { + dynasm!(self ; movzx Rd(dst as u8), Rw(src as u8)); + } + (Size::S8, Location::Memory(src, disp), Size::S32, Location::GPR(dst)) => { + dynasm!(self ; movzx Rd(dst as u8), BYTE [Rq(src as u8) + disp]); + } + (Size::S16, Location::Memory(src, disp), Size::S32, Location::GPR(dst)) => { + dynasm!(self ; movzx Rd(dst as u8), WORD [Rq(src as u8) + disp]); + } + (Size::S8, Location::GPR(src), Size::S64, Location::GPR(dst)) => { + dynasm!(self ; movzx Rq(dst as u8), Rb(src as u8)); + } + (Size::S16, Location::GPR(src), Size::S64, Location::GPR(dst)) => { + dynasm!(self ; movzx Rq(dst as u8), Rw(src as u8)); + } + (Size::S8, Location::Memory(src, disp), Size::S64, Location::GPR(dst)) => { + dynasm!(self ; movzx Rq(dst as u8), BYTE [Rq(src as u8) + disp]); + } + (Size::S16, Location::Memory(src, disp), Size::S64, Location::GPR(dst)) => { + dynasm!(self ; movzx Rq(dst as u8), WORD [Rq(src as u8) + disp]); + } + _ => { + panic!( + "singlepass can't emit MOVZX {:?} {:?} {:?} {:?}", + sz_src, src, sz_dst, dst + ) + } + } + } + fn emit_movsx(&mut self, sz_src: Size, src: Location, sz_dst: Size, dst: Location) { + match (sz_src, src, sz_dst, dst) { + (Size::S8, Location::GPR(src), Size::S32, Location::GPR(dst)) => { + dynasm!(self ; movsx Rd(dst as u8), Rb(src as u8)); + } + (Size::S16, Location::GPR(src), Size::S32, Location::GPR(dst)) => { + dynasm!(self ; movsx Rd(dst as u8), Rw(src as u8)); + } + (Size::S8, Location::Memory(src, disp), Size::S32, Location::GPR(dst)) => { + dynasm!(self ; movsx Rd(dst as u8), BYTE [Rq(src as u8) + disp]); + } + (Size::S16, Location::Memory(src, disp), Size::S32, Location::GPR(dst)) => { + dynasm!(self ; movsx Rd(dst as u8), WORD [Rq(src as u8) + disp]); + } + (Size::S8, Location::GPR(src), Size::S64, Location::GPR(dst)) => { + dynasm!(self ; movsx Rq(dst as u8), Rb(src as u8)); + } + (Size::S16, Location::GPR(src), Size::S64, Location::GPR(dst)) => { + dynasm!(self ; movsx Rq(dst as u8), Rw(src as u8)); + } + (Size::S32, Location::GPR(src), Size::S64, Location::GPR(dst)) => { + dynasm!(self ; movsx Rq(dst as u8), Rd(src as u8)); + } + (Size::S8, Location::Memory(src, disp), Size::S64, Location::GPR(dst)) => { + dynasm!(self ; movsx Rq(dst as u8), BYTE [Rq(src as u8) + disp]); + } + (Size::S16, Location::Memory(src, disp), Size::S64, Location::GPR(dst)) => { + dynasm!(self ; movsx Rq(dst as u8), WORD [Rq(src as u8) + disp]); + } + (Size::S32, Location::Memory(src, disp), Size::S64, Location::GPR(dst)) => { + dynasm!(self ; movsx Rq(dst as u8), DWORD [Rq(src as u8) + disp]); + } + _ => { + panic!( + "singlepass can't emit MOVSX {:?} {:?} {:?} {:?}", + sz_src, src, sz_dst, dst + ) + } + } + } + + fn emit_xchg(&mut self, sz: Size, src: Location, dst: Location) { + match (sz, src, dst) { + (Size::S8, Location::GPR(src), Location::GPR(dst)) => { + dynasm!(self ; xchg Rb(dst as u8), Rb(src as u8)); + } + (Size::S16, Location::GPR(src), Location::GPR(dst)) => { + dynasm!(self ; xchg Rw(dst as u8), Rw(src as u8)); + } + (Size::S32, Location::GPR(src), Location::GPR(dst)) => { + dynasm!(self ; xchg Rd(dst as u8), Rd(src as u8)); + } + (Size::S64, Location::GPR(src), Location::GPR(dst)) => { + dynasm!(self ; xchg Rq(dst as u8), Rq(src as u8)); + } + (Size::S8, Location::Memory(src, disp), Location::GPR(dst)) => { + dynasm!(self ; xchg Rb(dst as u8), [Rq(src as u8) + disp]); + } + (Size::S8, Location::GPR(src), Location::Memory(dst, disp)) => { + dynasm!(self ; xchg [Rq(dst as u8) + disp], Rb(src as u8)); + } + (Size::S16, Location::Memory(src, disp), Location::GPR(dst)) => { + dynasm!(self ; xchg Rw(dst as u8), [Rq(src as u8) + disp]); + } + (Size::S16, Location::GPR(src), Location::Memory(dst, disp)) => { + dynasm!(self ; xchg [Rq(dst as u8) + disp], Rw(src as u8)); + } + (Size::S32, Location::Memory(src, disp), Location::GPR(dst)) => { + dynasm!(self ; xchg Rd(dst as u8), [Rq(src as u8) + disp]); + } + (Size::S32, Location::GPR(src), Location::Memory(dst, disp)) => { + dynasm!(self ; xchg [Rq(dst as u8) + disp], Rd(src as u8)); + } + (Size::S64, Location::Memory(src, disp), Location::GPR(dst)) => { + dynasm!(self ; xchg Rq(dst as u8), [Rq(src as u8) + disp]); + } + (Size::S64, Location::GPR(src), Location::Memory(dst, disp)) => { + dynasm!(self ; xchg [Rq(dst as u8) + disp], Rq(src as u8)); + } + _ => panic!("singlepass can't emit XCHG {:?} {:?} {:?}", sz, src, dst), + } + } + + fn emit_lock_xadd(&mut self, sz: Size, src: Location, dst: Location) { + match (sz, src, dst) { + (Size::S8, Location::GPR(src), Location::Memory(dst, disp)) => { + dynasm!(self ; lock xadd [Rq(dst as u8) + disp], Rb(src as u8)); + } + (Size::S16, Location::GPR(src), Location::Memory(dst, disp)) => { + dynasm!(self ; lock xadd [Rq(dst as u8) + disp], Rw(src as u8)); + } + (Size::S32, Location::GPR(src), Location::Memory(dst, disp)) => { + dynasm!(self ; lock xadd [Rq(dst as u8) + disp], Rd(src as u8)); + } + (Size::S64, Location::GPR(src), Location::Memory(dst, disp)) => { + dynasm!(self ; lock xadd [Rq(dst as u8) + disp], Rq(src as u8)); + } + _ => panic!( + "singlepass can't emit LOCK XADD {:?} {:?} {:?}", + sz, src, dst + ), + } + } + + fn emit_lock_cmpxchg(&mut self, sz: Size, src: Location, dst: Location) { + match (sz, src, dst) { + (Size::S8, Location::GPR(src), Location::Memory(dst, disp)) => { + dynasm!(self ; lock cmpxchg [Rq(dst as u8) + disp], Rb(src as u8)); + } + (Size::S16, Location::GPR(src), Location::Memory(dst, disp)) => { + dynasm!(self ; lock cmpxchg [Rq(dst as u8) + disp], Rw(src as u8)); + } + (Size::S32, Location::GPR(src), Location::Memory(dst, disp)) => { + dynasm!(self ; lock cmpxchg [Rq(dst as u8) + disp], Rd(src as u8)); + } + (Size::S64, Location::GPR(src), Location::Memory(dst, disp)) => { + dynasm!(self ; lock cmpxchg [Rq(dst as u8) + disp], Rq(src as u8)); + } + _ => panic!( + "singlepass can't emit LOCK CMPXCHG {:?} {:?} {:?}", + sz, src, dst + ), + } + } + + fn emit_rep_stosq(&mut self) { + dynasm!(self ; rep stosq); + } + fn emit_btc_gpr_imm8_32(&mut self, src: u8, dst: GPR) { + dynasm!(self ; btc Rd(dst as u8), BYTE src as i8); + } + + fn emit_btc_gpr_imm8_64(&mut self, src: u8, dst: GPR) { + dynasm!(self ; btc Rq(dst as u8), BYTE src as i8); + } + + fn emit_cmovae_gpr_32(&mut self, src: GPR, dst: GPR) { + dynasm!(self ; cmovae Rd(dst as u8), Rd(src as u8)); + } + + fn emit_cmovae_gpr_64(&mut self, src: GPR, dst: GPR) { + dynasm!(self ; cmovae Rq(dst as u8), Rq(src as u8)); + } + + fn emit_vmovaps(&mut self, src: XMMOrMemory, dst: XMMOrMemory) { + match (src, dst) { + (XMMOrMemory::XMM(src), XMMOrMemory::XMM(dst)) => { + dynasm!(self ; movaps Rx(dst as u8), Rx(src as u8)) + } + (XMMOrMemory::Memory(base, disp), XMMOrMemory::XMM(dst)) => { + dynasm!(self ; movaps Rx(dst as u8), [Rq(base as u8) + disp]) + } + (XMMOrMemory::XMM(src), XMMOrMemory::Memory(base, disp)) => { + dynasm!(self ; movaps [Rq(base as u8) + disp], Rx(src as u8)) + } + _ => panic!("singlepass can't emit VMOVAPS {:?} {:?}", src, dst), + }; + } + + fn emit_vmovapd(&mut self, src: XMMOrMemory, dst: XMMOrMemory) { + match (src, dst) { + (XMMOrMemory::XMM(src), XMMOrMemory::XMM(dst)) => { + dynasm!(self ; movapd Rx(dst as u8), Rx(src as u8)) + } + (XMMOrMemory::Memory(base, disp), XMMOrMemory::XMM(dst)) => { + dynasm!(self ; movapd Rx(dst as u8), [Rq(base as u8) + disp]) + } + (XMMOrMemory::XMM(src), XMMOrMemory::Memory(base, disp)) => { + dynasm!(self ; movapd [Rq(base as u8) + disp], Rx(src as u8)) + } + _ => panic!("singlepass can't emit VMOVAPD {:?} {:?}", src, dst), + }; + } + + avx_fn!(vxorps, emit_vxorps); + avx_fn!(vxorpd, emit_vxorpd); + + avx_fn!(vaddss, emit_vaddss); + avx_fn!(vaddsd, emit_vaddsd); + + avx_fn!(vsubss, emit_vsubss); + avx_fn!(vsubsd, emit_vsubsd); + + avx_fn!(vmulss, emit_vmulss); + avx_fn!(vmulsd, emit_vmulsd); + + avx_fn!(vdivss, emit_vdivss); + avx_fn!(vdivsd, emit_vdivsd); + + avx_fn!(vmaxss, emit_vmaxss); + avx_fn!(vmaxsd, emit_vmaxsd); + + avx_fn!(vminss, emit_vminss); + avx_fn!(vminsd, emit_vminsd); + + avx_fn!(vcmpeqss, emit_vcmpeqss); + avx_fn!(vcmpeqsd, emit_vcmpeqsd); + + avx_fn!(vcmpneqss, emit_vcmpneqss); + avx_fn!(vcmpneqsd, emit_vcmpneqsd); + + avx_fn!(vcmpltss, emit_vcmpltss); + avx_fn!(vcmpltsd, emit_vcmpltsd); + + avx_fn!(vcmpless, emit_vcmpless); + avx_fn!(vcmplesd, emit_vcmplesd); + + avx_fn!(vcmpgtss, emit_vcmpgtss); + avx_fn!(vcmpgtsd, emit_vcmpgtsd); + + avx_fn!(vcmpgess, emit_vcmpgess); + avx_fn!(vcmpgesd, emit_vcmpgesd); + + avx_fn!(vcmpunordss, emit_vcmpunordss); + avx_fn!(vcmpunordsd, emit_vcmpunordsd); + + avx_fn!(vcmpordss, emit_vcmpordss); + avx_fn!(vcmpordsd, emit_vcmpordsd); + + avx_fn!(vsqrtss, emit_vsqrtss); + avx_fn!(vsqrtsd, emit_vsqrtsd); + + avx_fn!(vcvtss2sd, emit_vcvtss2sd); + avx_fn!(vcvtsd2ss, emit_vcvtsd2ss); + + avx_round_fn!(vroundss, emit_vroundss_nearest, 0); + avx_round_fn!(vroundss, emit_vroundss_floor, 1); + avx_round_fn!(vroundss, emit_vroundss_ceil, 2); + avx_round_fn!(vroundss, emit_vroundss_trunc, 3); + avx_round_fn!(vroundsd, emit_vroundsd_nearest, 0); + avx_round_fn!(vroundsd, emit_vroundsd_floor, 1); + avx_round_fn!(vroundsd, emit_vroundsd_ceil, 2); + avx_round_fn!(vroundsd, emit_vroundsd_trunc, 3); + + avx_i2f_32_fn!(vcvtsi2ss, emit_vcvtsi2ss_32); + avx_i2f_32_fn!(vcvtsi2sd, emit_vcvtsi2sd_32); + avx_i2f_64_fn!(vcvtsi2ss, emit_vcvtsi2ss_64); + avx_i2f_64_fn!(vcvtsi2sd, emit_vcvtsi2sd_64); + + fn emit_vblendvps(&mut self, src1: XMM, src2: XMMOrMemory, mask: XMM, dst: XMM) { + match src2 { + XMMOrMemory::XMM(src2) => { + dynasm!(self ; vblendvps Rx(dst as u8), Rx(mask as u8), Rx(src2 as u8), Rx(src1 as u8)) + } + XMMOrMemory::Memory(base, disp) => { + dynasm!(self ; vblendvps Rx(dst as u8), Rx(mask as u8), [Rq(base as u8) + disp], Rx(src1 as u8)) + } + } + } + + fn emit_vblendvpd(&mut self, src1: XMM, src2: XMMOrMemory, mask: XMM, dst: XMM) { + match src2 { + XMMOrMemory::XMM(src2) => { + dynasm!(self ; vblendvpd Rx(dst as u8), Rx(mask as u8), Rx(src2 as u8), Rx(src1 as u8)) + } + XMMOrMemory::Memory(base, disp) => { + dynasm!(self ; vblendvpd Rx(dst as u8), Rx(mask as u8), [Rq(base as u8) + disp], Rx(src1 as u8)) + } + } + } + + fn emit_ucomiss(&mut self, src: XMMOrMemory, dst: XMM) { + match src { + XMMOrMemory::XMM(x) => dynasm!(self ; ucomiss Rx(dst as u8), Rx(x as u8)), + XMMOrMemory::Memory(base, disp) => { + dynasm!(self ; ucomiss Rx(dst as u8), [Rq(base as u8) + disp]) + } + } + } + + fn emit_ucomisd(&mut self, src: XMMOrMemory, dst: XMM) { + match src { + XMMOrMemory::XMM(x) => dynasm!(self ; ucomisd Rx(dst as u8), Rx(x as u8)), + XMMOrMemory::Memory(base, disp) => { + dynasm!(self ; ucomisd Rx(dst as u8), [Rq(base as u8) + disp]) + } + } + } + + fn emit_cvttss2si_32(&mut self, src: XMMOrMemory, dst: GPR) { + match src { + XMMOrMemory::XMM(x) => dynasm!(self ; cvttss2si Rd(dst as u8), Rx(x as u8)), + XMMOrMemory::Memory(base, disp) => { + dynasm!(self ; cvttss2si Rd(dst as u8), [Rq(base as u8) + disp]) + } + } + } + + fn emit_cvttss2si_64(&mut self, src: XMMOrMemory, dst: GPR) { + match src { + XMMOrMemory::XMM(x) => dynasm!(self ; cvttss2si Rq(dst as u8), Rx(x as u8)), + XMMOrMemory::Memory(base, disp) => { + dynasm!(self ; cvttss2si Rq(dst as u8), [Rq(base as u8) + disp]) + } + } + } + + fn emit_cvttsd2si_32(&mut self, src: XMMOrMemory, dst: GPR) { + match src { + XMMOrMemory::XMM(x) => dynasm!(self ; cvttsd2si Rd(dst as u8), Rx(x as u8)), + XMMOrMemory::Memory(base, disp) => { + dynasm!(self ; cvttsd2si Rd(dst as u8), [Rq(base as u8) + disp]) + } + } + } + + fn emit_cvttsd2si_64(&mut self, src: XMMOrMemory, dst: GPR) { + match src { + XMMOrMemory::XMM(x) => dynasm!(self ; cvttsd2si Rq(dst as u8), Rx(x as u8)), + XMMOrMemory::Memory(base, disp) => { + dynasm!(self ; cvttsd2si Rq(dst as u8), [Rq(base as u8) + disp]) + } + } + } + + fn emit_test_gpr_64(&mut self, reg: GPR) { + dynasm!(self ; test Rq(reg as u8), Rq(reg as u8)); + } + + fn emit_ud2(&mut self) { + dynasm!(self ; ud2); + } + fn emit_ret(&mut self) { + dynasm!(self ; ret); + } + + fn emit_call_label(&mut self, label: Self::Label) { + dynasm!(self ; call =>label); + } + fn emit_call_location(&mut self, loc: Location) { + match loc { + Location::GPR(x) => dynasm!(self ; call Rq(x as u8)), + Location::Memory(base, disp) => dynasm!(self ; call QWORD [Rq(base as u8) + disp]), + _ => panic!("singlepass can't emit CALL {:?}", loc), + } + } + + fn emit_call_register(&mut self, reg: GPR) { + dynasm!(self ; call Rq(reg as u8)); + } + + fn emit_bkpt(&mut self) { + dynasm!(self ; int3); + } + + fn emit_host_redirection(&mut self, target: GPR) { + self.emit_jmp_location(Location::GPR(target)); + } + + fn arch_has_xzcnt(&self, cpu: &EnumSet) -> bool { + cpu.contains(CpuFeature::BMI1) && cpu.contains(CpuFeature::LZCNT) + } + + fn arch_emit_lzcnt(&mut self, sz: Size, src: Location, dst: Location) { + binop_gpr_gpr!(lzcnt, self, sz, src, dst, { + binop_mem_gpr!(lzcnt, self, sz, src, dst, { + panic!("singlepass can't emit LZCNT {:?} {:?} {:?}", sz, src, dst) + }) + }) + } + + fn arch_emit_tzcnt(&mut self, sz: Size, src: Location, dst: Location) { + binop_gpr_gpr!(tzcnt, self, sz, src, dst, { + binop_mem_gpr!(tzcnt, self, sz, src, dst, { + panic!("singlepass can't emit TZCNT {:?} {:?} {:?}", sz, src, dst) + }) + }) + } + + fn arch_mov64_imm_offset(&self) -> usize { + 2 + } +} diff --git a/runtime/near-vm/lib/compiler-singlepass/src/lib.rs b/runtime/near-vm/lib/compiler-singlepass/src/lib.rs new file mode 100644 index 00000000000..6e3070d082b --- /dev/null +++ b/runtime/near-vm/lib/compiler-singlepass/src/lib.rs @@ -0,0 +1,20 @@ +//! A WebAssembly `Compiler` implementation using Singlepass. +//! +//! Singlepass is a super-fast assembly generator that generates +//! assembly code in just one pass. This is useful for different applications +//! including Blockchains and Edge computing where quick compilation +//! times are a must, and JIT bombs should never happen. +//! +//! Compared to Cranelift and LLVM, Singlepass compiles much faster but has worse +//! runtime performance. + +mod address_map; +mod codegen_x64; +mod compiler; +mod config; +mod emitter_x64; +mod machine; +mod x64_decl; + +pub use crate::compiler::SinglepassCompiler; +pub use crate::config::Singlepass; diff --git a/runtime/near-vm/lib/compiler-singlepass/src/machine.rs b/runtime/near-vm/lib/compiler-singlepass/src/machine.rs new file mode 100644 index 00000000000..4f112f5d62b --- /dev/null +++ b/runtime/near-vm/lib/compiler-singlepass/src/machine.rs @@ -0,0 +1,634 @@ +use crate::emitter_x64::*; +use smallvec::smallvec; +use smallvec::SmallVec; +use std::convert::TryFrom; +use wasmer_compiler::wasmparser::ValType as WpType; +use wasmer_compiler::CallingConvention; + +const NATIVE_PAGE_SIZE: usize = 4096; + +#[derive(Clone, Copy)] +struct MachineStackOffset(usize); + +pub(crate) struct Machine { + used_gprs: u32, // Bitset for the used GPRs, 1 means used + used_xmms: u32, // Bitset for the used XMMs, 1 means used + stack_offset: MachineStackOffset, + save_area_offset: Option, + /// Memory location at which local variables begin. + /// + /// Populated in `init_locals`. + locals_offset: MachineStackOffset, +} + +/// Returns an u32 that has as 1 bits the ones matching registers passed as parameters +macro_rules! bitset_of_regs { + ($( $r:expr ),*) => {{ + $( (1u32 << ($r as u32)) )|* + }} +} + +// Note: the below asserts are because we currently use u32 for used_gprs and used_xmms +// Feel free to increase the number in this assert by making them bigger if needed +#[allow(dead_code)] +const _GPRS_FIT_IN_U32: () = assert!(GPR::num_gprs() <= 32); +#[allow(dead_code)] +const _XMMS_FIT_IN_U32: () = assert!(XMM::num_xmms() <= 32); + +impl Machine { + pub(crate) fn new() -> Self { + Machine { + used_gprs: 0, + used_xmms: 0, + stack_offset: MachineStackOffset(0), + save_area_offset: None, + locals_offset: MachineStackOffset(0), + } + } + + pub(crate) fn get_stack_offset(&self) -> usize { + self.stack_offset.0 + } + + fn get_used_in(mut v: u32, to_return_type: impl Fn(u8) -> T) -> Vec { + let mut n = 0u8; + let mut res = Vec::with_capacity(v.count_ones() as usize); + while v != 0 { + n += v.trailing_zeros() as u8; + res.push(to_return_type(n)); + v >>= v.trailing_zeros() + 1; + n += 1; + } + res + } + + pub(crate) fn get_used_gprs(&self) -> Vec { + Self::get_used_in(self.used_gprs, |r| GPR::from_repr(r).unwrap()) + } + + pub(crate) fn get_used_xmms(&self) -> Vec { + Self::get_used_in(self.used_xmms, |r| XMM::from_repr(r).unwrap()) + } + + pub(crate) fn get_vmctx_reg() -> GPR { + GPR::R15 + } + + fn pick_one_in(v: u32) -> Option { + let r = v.trailing_zeros() as u8; + (r != 32).then_some(r) + } + + /// Picks an unused general purpose register for local/stack/argument use. + /// + /// This method does not mark the register as used. + pub(crate) fn pick_gpr(&self) -> Option { + use GPR::*; + const REGS: u32 = bitset_of_regs!(RSI, RDI, R8, R9, R10, R11); + Self::pick_one_in(!self.used_gprs & REGS).map(|r| GPR::from_repr(r).unwrap()) + } + + /// Picks an unused general purpose register for internal temporary use. + /// + /// This method does not mark the register as used. + pub(crate) fn pick_temp_gpr(&self) -> Option { + use GPR::*; + const REGS: u32 = bitset_of_regs!(RAX, RCX, RDX); + Self::pick_one_in(!self.used_gprs & REGS).map(|r| GPR::from_repr(r).unwrap()) + } + + fn get_gpr_used(&self, r: GPR) -> bool { + if 0 != (self.used_gprs & bitset_of_regs!(r)) { + true + } else { + false + } + } + + fn set_gpr_used(&mut self, r: GPR) { + self.used_gprs |= bitset_of_regs!(r); + } + + fn set_gpr_unused(&mut self, r: GPR) { + self.used_gprs &= !bitset_of_regs!(r); + } + + fn get_xmm_used(&self, r: XMM) -> bool { + if 0 != (self.used_xmms & bitset_of_regs!(r)) { + true + } else { + false + } + } + + fn set_xmm_used(&mut self, r: XMM) { + self.used_xmms |= bitset_of_regs!(r); + } + + fn set_xmm_unused(&mut self, r: XMM) { + self.used_xmms &= !bitset_of_regs!(r); + } + + /// Acquires a temporary GPR. + pub(crate) fn acquire_temp_gpr(&mut self) -> Option { + let gpr = self.pick_temp_gpr(); + if let Some(x) = gpr { + self.set_gpr_used(x); + } + gpr + } + + /// Releases a temporary GPR. + pub(crate) fn release_temp_gpr(&mut self, gpr: GPR) { + assert!(self.get_gpr_used(gpr)); + self.set_gpr_unused(gpr); + } + + /// Specify that a given register is in use. + pub(crate) fn reserve_unused_temp_gpr(&mut self, gpr: GPR) -> GPR { + assert!(!self.get_gpr_used(gpr)); + self.set_gpr_used(gpr); + gpr + } + + /// Picks an unused XMM register. + /// + /// This method does not mark the register as used. + pub(crate) fn pick_xmm(&self) -> Option { + use XMM::*; + const REGS: u32 = bitset_of_regs!(XMM3, XMM4, XMM5, XMM6, XMM7); + Self::pick_one_in(!self.used_xmms & REGS).map(|r| XMM::from_repr(r).unwrap()) + } + + /// Picks an unused XMM register for internal temporary use. + /// + /// This method does not mark the register as used. + pub(crate) fn pick_temp_xmm(&self) -> Option { + use XMM::*; + const REGS: u32 = bitset_of_regs!(XMM0, XMM1, XMM2); + Self::pick_one_in(!self.used_xmms & REGS).map(|r| XMM::from_repr(r).unwrap()) + } + + /// Acquires a temporary XMM register. + pub(crate) fn acquire_temp_xmm(&mut self) -> Option { + let xmm = self.pick_temp_xmm(); + if let Some(x) = xmm { + self.set_xmm_used(x); + } + xmm + } + + /// Releases a temporary XMM register. + pub(crate) fn release_temp_xmm(&mut self, xmm: XMM) { + assert!(self.get_xmm_used(xmm)); + self.set_xmm_unused(xmm); + } + + fn increase_rsp(&mut self, a: &mut impl Emitter, sz: usize) { + a.emit_add( + Size::S64, + Location::Imm32(u32::try_from(sz).unwrap()), + Location::GPR(GPR::RSP), + ); + self.stack_offset.0 -= sz; + } + + fn decrease_rsp(&mut self, a: &mut impl Emitter, sz: usize) { + a.emit_sub( + Size::S64, + Location::Imm32(u32::try_from(sz).unwrap()), + Location::GPR(GPR::RSP), + ); + self.stack_offset.0 += sz; + } + + /// Acquires locations from the machine state. + /// + /// If the returned locations are used for stack value, `release_location` needs to be called on them; + /// Otherwise, if the returned locations are used for locals, `release_location` does not need to be called on them. + pub(crate) fn acquire_locations( + &mut self, + assembler: &mut E, + tys: &[WpType], + zeroed: bool, + ) -> SmallVec<[Location; 1]> { + let mut ret = smallvec![]; + let mut delta_stack_offset: usize = 0; + + for ty in tys { + let loc = match *ty { + WpType::F32 | WpType::F64 => self.pick_xmm().map(Location::XMM), + WpType::I32 | WpType::I64 => self.pick_gpr().map(Location::GPR), + WpType::FuncRef | WpType::ExternRef => self.pick_gpr().map(Location::GPR), + _ => unreachable!("can't acquire location for type {:?}", ty), + }; + + let loc = if let Some(x) = loc { + x + } else { + delta_stack_offset += 8; + Location::Memory( + GPR::RBP, + -((self.stack_offset.0 + delta_stack_offset) as i32), + ) + }; + if let Location::GPR(x) = loc { + self.set_gpr_used(x); + } else if let Location::XMM(x) = loc { + self.set_xmm_used(x); + } + ret.push(loc); + } + + if delta_stack_offset != 0 { + self.decrease_rsp(assembler, delta_stack_offset); + } + if zeroed { + for i in 0..tys.len() { + assembler.emit_mov(Size::S64, Location::Imm32(0), ret[i]); + } + } + ret + } + + /// Releases locations used for stack value. + pub(crate) fn release_locations(&mut self, assembler: &mut E, locs: &[Location]) { + let mut delta_stack_offset: usize = 0; + + for loc in locs.iter().rev() { + match *loc { + Location::GPR(x) => { + assert!(self.get_gpr_used(x)); + self.set_gpr_unused(x); + } + Location::XMM(x) => { + assert!(self.get_xmm_used(x)); + self.set_xmm_unused(x); + } + Location::Memory(GPR::RBP, x) => { + if x >= 0 { + unreachable!(); + } + let offset = (-x) as usize; + if offset != self.stack_offset.0 - delta_stack_offset { + unreachable!(); + } + delta_stack_offset += 8; + } + _ => {} + } + } + + if delta_stack_offset != 0 { + self.increase_rsp(assembler, delta_stack_offset); + } + } + + pub(crate) fn release_locations_only_regs(&mut self, locs: &[Location]) { + for loc in locs.iter().rev() { + match *loc { + Location::GPR(x) => { + assert!(self.get_gpr_used(x)); + self.set_gpr_unused(x); + } + Location::XMM(x) => { + assert!(self.get_xmm_used(x)); + self.set_xmm_unused(x); + } + _ => {} + } + } + } + + pub(crate) fn release_locations_only_stack( + &mut self, + assembler: &mut E, + locs: &[Location], + ) { + let mut delta_stack_offset: usize = 0; + + for loc in locs.iter().rev() { + if let Location::Memory(GPR::RBP, x) = *loc { + if x >= 0 { + unreachable!(); + } + let offset = (-x) as usize; + if offset != self.stack_offset.0 - delta_stack_offset { + unreachable!(); + } + delta_stack_offset += 8; + } + } + + if delta_stack_offset != 0 { + self.increase_rsp(assembler, delta_stack_offset); + } + } + + pub(crate) fn release_locations_keep_state( + &self, + assembler: &mut E, + locs: &[Location], + ) { + let mut delta_stack_offset: usize = 0; + + for loc in locs.iter().rev() { + if let Location::Memory(GPR::RBP, x) = *loc { + if x >= 0 { + unreachable!(); + } + let offset = (-x) as usize; + if offset != self.stack_offset.0 - delta_stack_offset { + unreachable!(); + } + delta_stack_offset += 8; + } + } + + if delta_stack_offset != 0 { + // DO NOT use increase_rsp, as we don’t want to change stack_offset + assembler.emit_add( + Size::S64, + Location::Imm32(delta_stack_offset as u32), + Location::GPR(GPR::RSP), + ); + } + } + + const LOCAL_REGISTERS: &'static [GPR] = &[GPR::R12, GPR::R13, GPR::R14, GPR::RBX]; + + pub(crate) fn get_local_location(&self, idx: u32) -> Location { + // NB: This calculation cannot reasonably overflow. `self.locals_offset` will typically be + // small (< 32), and `idx` is bounded to `51000` due to limits imposed by the wasmparser + // validator. We introduce a debug_assert here to ensure that `idx` never really exceeds + // some incredibly large value. + debug_assert!( + idx <= 999_999, + "this runtime can't deal with unreasonable number of locals" + ); + Self::LOCAL_REGISTERS + .get(idx as usize) + .map(|r| Location::GPR(*r)) + .unwrap_or_else(|| { + let local_offset = idx + .checked_sub(Self::LOCAL_REGISTERS.len() as u32) + .unwrap() + .wrapping_mul(8); + Location::Memory( + GPR::RBP, + (local_offset.wrapping_add(self.locals_offset.0 as u32) as i32).wrapping_neg(), + ) + }) + } + + // `setup_registers`, `init_locals`, `finalize_locals` and `restore_registers` work together, + // the first two making up the function prologue (with a stack check and gas charge in-between), + // and the second two making up the function epilogue (with the stack height reset in-between). + // + // Together, they build the following stack, with `N = min(n, LOCAL_REGISTERS.len())`: + // +-------------------+--------+ + // | Return Pointer | 8B | + // | Saved RBP | 8B | <- RBP + // | LOCAL_REGISTERS 0 | 8B | + // | ... | | + // | LOCAL_REGISTERS N | 8B | + // | Saved R15 | 8B | + // | (Win FastC) RDI | 8B | + // | (Win FastC) RSI | 8B | <- save_area_offset + // | Local 0 | 8B | <- locals_offset + // | ... | | + // | Local n | 8B | <- RSP, stack_offset (at end of init_locals, will keep moving during fn codegen) + // +-------------------+--------+ + pub(crate) fn setup_registers( + &mut self, + a: &mut E, + n: u32, + n_params: u32, + calling_convention: CallingConvention, + ) { + // Total size (in bytes) of the pre-allocated "static area" for this function's + // locals and callee-saved registers. + let mut static_area_size: usize = 0; + + // Space to clobber registers used for locals. + static_area_size += 8 * std::cmp::min(Self::LOCAL_REGISTERS.len(), n as usize); + + // Callee-saved R15 for vmctx. + static_area_size += 8; + + // Allocate the stack + self.decrease_rsp(a, static_area_size); + + // Save callee-saved registers + for (i, local_reg) in Self::LOCAL_REGISTERS.iter().take(n as usize).enumerate() { + a.emit_mov( + Size::S64, + Location::GPR(*local_reg), + Location::Memory(GPR::RBP, -((i + 1) as i32) * 8), + ); + } + + // Save R15 for vmctx use. + a.emit_mov( + Size::S64, + Location::GPR(GPR::R15), + Location::Memory(GPR::RSP, 0), + ); + + // For Windows ABI, save RDI and RSI + if calling_convention == CallingConvention::WindowsFastcall { + self.decrease_rsp(a, 8 * 2); + for (i, reg) in [GPR::RSI, GPR::RDI].iter().enumerate() { + a.emit_mov( + Size::S64, + Location::GPR(*reg), + Location::Memory(GPR::RSP, i as i32 * 8), + ); + } + } + + // Save the offset of register save area. + self.save_area_offset = Some(MachineStackOffset(self.stack_offset.0)); + + // Load in-register parameters into the allocated locations for register parameters. + // Locals are allocated on the stack from higher address to lower address, + // so we won't skip the stack guard page here. + self.locals_offset = MachineStackOffset(self.stack_offset.0 + 8); // + 8 because locals_offset is supposed to point to 1st local + let params_size = (n_params as usize) + .saturating_sub(Self::LOCAL_REGISTERS.len()) + .checked_mul(8) + .unwrap(); + self.decrease_rsp(a, params_size); + for i in 0..n_params { + // NB: the 0th parameter is used for passing around the internal VM data (vmctx). + let loc = Self::get_param_location((i + 1) as usize, calling_convention); + let local_loc = self.get_local_location(i); + match loc { + Location::GPR(_) => { + a.emit_mov(Size::S64, loc, local_loc); + } + // TODO: move Location::Memory args init into init_locals down below so it happens after instrumentation + // Registers *must* stay here because we’re using registers between setup_registers and init_locals + Location::Memory(_, _) => match local_loc { + Location::GPR(_) => { + a.emit_mov(Size::S64, loc, local_loc); + } + Location::Memory(_, _) => { + a.emit_mov(Size::S64, loc, Location::GPR(GPR::RAX)); + a.emit_mov(Size::S64, Location::GPR(GPR::RAX), local_loc); + } + _ => unreachable!(), + }, + _ => unreachable!(), + } + } + + // Load vmctx into R15. + a.emit_mov( + Size::S64, + Self::get_param_location(0, calling_convention), + Location::GPR(GPR::R15), + ); + } + + pub(crate) fn init_locals( + &mut self, + a: &mut E, + n: u32, + n_params: u32, + _calling_convention: CallingConvention, + ) { + let registers_remaining_for_locals = Self::LOCAL_REGISTERS + .len() + .saturating_sub(n_params as usize); + let locals_to_init = (n - n_params) as usize; + let locals_size = locals_to_init + .saturating_sub(registers_remaining_for_locals) + .checked_mul(8) + .unwrap(); + + // Allocate the stack, without actually writing to it. + self.decrease_rsp(a, locals_size); + + // Stack probe. + // + // `rep stosq` writes data from low address to high address and may skip the stack guard page. + // so here we probe it explicitly when needed. + for i in (n_params..n).step_by(NATIVE_PAGE_SIZE / 8).skip(1) { + a.emit_mov(Size::S64, Location::Imm32(0), self.get_local_location(i)); + } + + // Initialize all remaining locals to zero. + // + // This is a little tricky, as we want to initialize all stack local slots, except for + // those that were already populated with function argument data. The complication is in + // the fact that we allocate some registers to the first couple local slots. + // + // First: handle the locals that are allocated to registers... + for local_reg_idx in Self::LOCAL_REGISTERS + .iter() + .skip(n_params as usize) + .take((n_params..n).len()) + { + a.emit_mov(Size::S64, Location::Imm32(0), Location::GPR(*local_reg_idx)); + } + // Second: handle the locals that are allocated to the stack. + let stack_loc_idxs = std::cmp::max(Self::LOCAL_REGISTERS.len() as u32, n_params)..n; + if stack_loc_idxs.len() > 0 { + // Since these assemblies take up to 24 bytes, if more than 2 slots are initialized, then they are smaller. + a.emit_mov( + Size::S64, + Location::Imm64(stack_loc_idxs.len() as u64), + Location::GPR(GPR::RCX), + ); + a.emit_xor(Size::S64, Location::GPR(GPR::RAX), Location::GPR(GPR::RAX)); + a.emit_lea( + Size::S64, + self.get_local_location(n - 1), + Location::GPR(GPR::RDI), + ); + a.emit_rep_stosq(); + } + } + + pub(crate) fn finalize_locals(&mut self, a: &mut E) { + // Unwind stack to the "save area". + a.emit_lea( + Size::S64, + Location::Memory( + GPR::RBP, + -(self.save_area_offset.as_ref().unwrap().0 as i32), + ), + Location::GPR(GPR::RSP), + ); + } + + pub(crate) fn restore_registers( + &mut self, + a: &mut E, + calling_convention: CallingConvention, + local_count: u32, + ) { + if calling_convention == CallingConvention::WindowsFastcall { + // Restore RSI and RDI + a.emit_pop(Size::S64, Location::GPR(GPR::RSI)); + a.emit_pop(Size::S64, Location::GPR(GPR::RDI)); + } + // Restore R15 used by vmctx. + a.emit_pop(Size::S64, Location::GPR(GPR::R15)); + + // Restore callee-saved registers that we used for locals. + for reg in Self::LOCAL_REGISTERS + .iter() + .take(local_count as usize) + .rev() + { + a.emit_pop(Size::S64, Location::GPR(*reg)); + } + } + + pub(crate) fn get_param_location( + idx: usize, + calling_convention: CallingConvention, + ) -> Location { + match calling_convention { + CallingConvention::WindowsFastcall => match idx { + 0 => Location::GPR(GPR::RCX), + 1 => Location::GPR(GPR::RDX), + 2 => Location::GPR(GPR::R8), + 3 => Location::GPR(GPR::R9), + _ => Location::Memory(GPR::RBP, (16 + 32 + (idx - 4) * 8) as i32), + }, + _ => match idx { + 0 => Location::GPR(GPR::RDI), + 1 => Location::GPR(GPR::RSI), + 2 => Location::GPR(GPR::RDX), + 3 => Location::GPR(GPR::RCX), + 4 => Location::GPR(GPR::R8), + 5 => Location::GPR(GPR::R9), + _ => Location::Memory(GPR::RBP, (16 + (idx - 6) * 8) as i32), + }, + } + } +} + +#[cfg(test)] +mod test { + use super::*; + use dynasmrt::x64::X64Relocation; + use dynasmrt::VecAssembler; + type Assembler = VecAssembler; + + #[test] + fn test_release_locations_keep_state_nopanic() { + let mut machine = Machine::new(); + let mut assembler = Assembler::new(0); + let locs = machine.acquire_locations( + &mut assembler, + &(0..10).map(|_| WpType::I32).collect::>(), + false, + ); + + machine.release_locations_keep_state(&mut assembler, &locs); + } +} diff --git a/runtime/near-vm/lib/compiler-singlepass/src/x64_decl.rs b/runtime/near-vm/lib/compiler-singlepass/src/x64_decl.rs new file mode 100644 index 00000000000..465a9f2a887 --- /dev/null +++ b/runtime/near-vm/lib/compiler-singlepass/src/x64_decl.rs @@ -0,0 +1,249 @@ +//! X64 structures. +use wasmer_compiler::CallingConvention; +use wasmer_types::Type; + +/// General-purpose registers. +#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd, strum::FromRepr)] +#[repr(u8)] +pub(crate) enum GPR { + /// RAX register + RAX, + /// RCX register + RCX, + /// RDX register + RDX, + /// RBX register + RBX, + /// RSP register + RSP, + /// RBP register + RBP, + /// RSI register + RSI, + /// RDI register + RDI, + /// R8 register + R8, + /// R9 register + R9, + /// R10 register + R10, + /// R11 register + R11, + /// R12 register + R12, + /// R13 register + R13, + /// R14 register + R14, + /// R15 register + R15, +} + +impl GPR { + pub const fn num_gprs() -> usize { + GPR::R15 as usize + 1 + } +} + +/// XMM registers. +#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd, strum::FromRepr)] +#[repr(u8)] +pub(crate) enum XMM { + /// XMM register 0 + XMM0, + /// XMM register 1 + XMM1, + /// XMM register 2 + XMM2, + /// XMM register 3 + XMM3, + /// XMM register 4 + XMM4, + /// XMM register 5 + XMM5, + /// XMM register 6 + XMM6, + /// XMM register 7 + XMM7, + /// XMM register 8 + XMM8, + /// XMM register 9 + XMM9, + /// XMM register 10 + XMM10, + /// XMM register 11 + XMM11, + /// XMM register 12 + XMM12, + /// XMM register 13 + XMM13, + /// XMM register 14 + XMM14, + /// XMM register 15 + XMM15, +} + +impl XMM { + pub const fn num_xmms() -> usize { + XMM::XMM15 as usize + 1 + } +} + +/// A machine register under the x86-64 architecture. +#[derive(Copy, Clone, Debug, Eq, PartialEq)] +pub(crate) enum X64Register { + /// General-purpose registers. + GPR(GPR), + /// XMM (floating point/SIMD) registers. + XMM(XMM), +} + +impl X64Register { + /// Converts a DWARF regnum to X64Register. + pub(crate) fn _from_dwarf_regnum(x: u16) -> Option { + Some(match x { + 0 => X64Register::GPR(GPR::RAX), + 1 => X64Register::GPR(GPR::RDX), + 2 => X64Register::GPR(GPR::RCX), + 3 => X64Register::GPR(GPR::RBX), + 4 => X64Register::GPR(GPR::RSI), + 5 => X64Register::GPR(GPR::RDI), + 6 => X64Register::GPR(GPR::RBP), + 7 => X64Register::GPR(GPR::RSP), + 8 => X64Register::GPR(GPR::R8), + 9 => X64Register::GPR(GPR::R9), + 10 => X64Register::GPR(GPR::R10), + 11 => X64Register::GPR(GPR::R11), + 12 => X64Register::GPR(GPR::R12), + 13 => X64Register::GPR(GPR::R13), + 14 => X64Register::GPR(GPR::R14), + 15 => X64Register::GPR(GPR::R15), + + 17 => X64Register::XMM(XMM::XMM0), + 18 => X64Register::XMM(XMM::XMM1), + 19 => X64Register::XMM(XMM::XMM2), + 20 => X64Register::XMM(XMM::XMM3), + 21 => X64Register::XMM(XMM::XMM4), + 22 => X64Register::XMM(XMM::XMM5), + 23 => X64Register::XMM(XMM::XMM6), + 24 => X64Register::XMM(XMM::XMM7), + _ => return None, + }) + } + + /// Returns the instruction prefix for `movq %this_reg, ?(%rsp)`. + /// + /// To build an instruction, append the memory location as a 32-bit + /// offset to the stack pointer to this prefix. + pub(crate) fn _prefix_mov_to_stack(&self) -> Option<&'static [u8]> { + Some(match *self { + X64Register::GPR(gpr) => match gpr { + GPR::RDI => &[0x48, 0x89, 0xbc, 0x24], + GPR::RSI => &[0x48, 0x89, 0xb4, 0x24], + GPR::RDX => &[0x48, 0x89, 0x94, 0x24], + GPR::RCX => &[0x48, 0x89, 0x8c, 0x24], + GPR::R8 => &[0x4c, 0x89, 0x84, 0x24], + GPR::R9 => &[0x4c, 0x89, 0x8c, 0x24], + _ => return None, + }, + X64Register::XMM(xmm) => match xmm { + XMM::XMM0 => &[0x66, 0x0f, 0xd6, 0x84, 0x24], + XMM::XMM1 => &[0x66, 0x0f, 0xd6, 0x8c, 0x24], + XMM::XMM2 => &[0x66, 0x0f, 0xd6, 0x94, 0x24], + XMM::XMM3 => &[0x66, 0x0f, 0xd6, 0x9c, 0x24], + XMM::XMM4 => &[0x66, 0x0f, 0xd6, 0xa4, 0x24], + XMM::XMM5 => &[0x66, 0x0f, 0xd6, 0xac, 0x24], + XMM::XMM6 => &[0x66, 0x0f, 0xd6, 0xb4, 0x24], + XMM::XMM7 => &[0x66, 0x0f, 0xd6, 0xbc, 0x24], + _ => return None, + }, + }) + } +} + +/// An allocator that allocates registers for function arguments according to the System V ABI. +#[derive(Default)] +pub(crate) struct ArgumentRegisterAllocator { + n_gprs: usize, + n_xmms: usize, +} + +impl ArgumentRegisterAllocator { + /// Allocates a register for argument type `ty`. Returns `None` if no register is available for this type. + pub(crate) fn next( + &mut self, + ty: Type, + calling_convention: CallingConvention, + ) -> Option { + match calling_convention { + CallingConvention::WindowsFastcall => { + static GPR_SEQ: &'static [GPR] = &[GPR::RCX, GPR::RDX, GPR::R8, GPR::R9]; + static XMM_SEQ: &'static [XMM] = &[XMM::XMM0, XMM::XMM1, XMM::XMM2, XMM::XMM3]; + let idx = self.n_gprs + self.n_xmms; + match ty { + Type::I32 | Type::I64 => { + if idx < 4 { + let gpr = GPR_SEQ[idx]; + self.n_gprs += 1; + Some(X64Register::GPR(gpr)) + } else { + None + } + } + Type::F32 | Type::F64 => { + if idx < 4 { + let xmm = XMM_SEQ[idx]; + self.n_xmms += 1; + Some(X64Register::XMM(xmm)) + } else { + None + } + } + _ => todo!( + "ArgumentRegisterAllocator::next: Unsupported type: {:?}", + ty + ), + } + } + _ => { + static GPR_SEQ: &'static [GPR] = + &[GPR::RDI, GPR::RSI, GPR::RDX, GPR::RCX, GPR::R8, GPR::R9]; + static XMM_SEQ: &'static [XMM] = &[ + XMM::XMM0, + XMM::XMM1, + XMM::XMM2, + XMM::XMM3, + XMM::XMM4, + XMM::XMM5, + XMM::XMM6, + XMM::XMM7, + ]; + match ty { + Type::I32 | Type::I64 => { + if self.n_gprs < GPR_SEQ.len() { + let gpr = GPR_SEQ[self.n_gprs]; + self.n_gprs += 1; + Some(X64Register::GPR(gpr)) + } else { + None + } + } + Type::F32 | Type::F64 => { + if self.n_xmms < XMM_SEQ.len() { + let xmm = XMM_SEQ[self.n_xmms]; + self.n_xmms += 1; + Some(X64Register::XMM(xmm)) + } else { + None + } + } + _ => todo!( + "ArgumentRegisterAllocator::next: Unsupported type: {:?}", + ty + ), + } + } + } + } +} diff --git a/runtime/near-vm/lib/compiler/Cargo.toml b/runtime/near-vm/lib/compiler/Cargo.toml new file mode 100644 index 00000000000..48dae8e1bce --- /dev/null +++ b/runtime/near-vm/lib/compiler/Cargo.toml @@ -0,0 +1,39 @@ +[package] +name = "wasmer-compiler-near" +version = "2.4.0" +description = "Base compiler abstraction for Wasmer WebAssembly runtime" +categories = ["wasm", "no-std"] +keywords = ["wasm", "webassembly", "compiler"] +authors = ["Wasmer Engineering Team "] +repository = "https://github.com/wasmerio/wasmer" +license = "MIT OR Apache-2.0 WITH LLVM-exception" +readme = "README.md" +edition = "2018" + +[lib] +name = "wasmer_compiler" + +[dependencies] +finite-wasm = "0.3.0" +wasmer-vm = { path = "../vm", package = "wasmer-vm-near", version = "=2.4.0" } +wasmer-types = { path = "../types", package = "wasmer-types-near", version = "=2.4.0", default-features = false } +wasmparser = { version = "0.99.0", optional = true, default-features = false } +target-lexicon = { version = "0.12.2", default-features = false } +enumset = "1.0" +hashbrown = { version = "0.11", optional = true } +thiserror = "1.0" +smallvec = "1.6" +rkyv = { version = "0.7.20" } +tracing = "0.1" + +[features] +default = ["std" ] +# This feature is for compiler implementors, it enables using `Compiler` and +# `CompilerConfig`, as well as the included wasmparser. +# Disable this feature if you just want a headless engine. +translator = ["wasmparser"] +std = ["wasmer-types/std"] +core = ["hashbrown", "wasmer-types/core"] + +[badges] +maintenance = { status = "experimental" } diff --git a/runtime/near-vm/lib/compiler/README.md b/runtime/near-vm/lib/compiler/README.md new file mode 100644 index 00000000000..093c6afa62d --- /dev/null +++ b/runtime/near-vm/lib/compiler/README.md @@ -0,0 +1,55 @@ +# `wasmer-compiler` [![Build Status](https://github.com/wasmerio/wasmer/workflows/build/badge.svg?style=flat-square)](https://github.com/wasmerio/wasmer/actions?query=workflow%3Abuild) [![Join Wasmer Slack](https://img.shields.io/static/v1?label=Slack&message=join%20chat&color=brighgreen&style=flat-square)](https://slack.wasmer.io) [![MIT License](https://img.shields.io/github/license/wasmerio/wasmer.svg?style=flat-square)](https://github.com/wasmerio/wasmer/blob/master/LICENSE) + +This crate is the base for Compiler implementations. + +It performs the translation from a Wasm module into a basic +`ModuleInfo`, but leaves the Wasm function bytecode translation to the +compiler implementor. + +Here are some of the Compilers provided by Wasmer: + +* [Singlepass](https://github.com/wasmerio/wasmer/tree/master/lib/compiler-singlepass), + +## How to create a compiler + +To create a compiler, one needs to implement two traits: + +1. `CompilerConfig`, that configures and creates a new compiler, +2. `Compiler`, the compiler itself that will compile a module. + +```rust +/// The compiler configuration options. +pub trait CompilerConfig { + /// Gets the custom compiler config + fn compiler(&self) -> Box; +} + +/// An implementation of a compiler from parsed WebAssembly module to compiled native code. +pub trait Compiler { + /// Compiles a parsed module. + /// + /// It returns the [`Compilation`] or a [`CompileError`]. + fn compile_module<'data, 'module>( + &self, + target: &Target, + compile_info: &'module CompileModuleInfo, + module_translation: &ModuleTranslationState, + // The list of function bodies + function_body_inputs: PrimaryMap>, + instrumentation: &finite_wasm::Module, + ) -> Result; +} +``` + +## Acknowledgments + +This project borrowed some of the code strucutre from the +[`cranelift-wasm`] crate, however it's been adapted to not depend on +any specific IR and be abstract of any compiler. + +Please check [Wasmer `ATTRIBUTIONS`] to further see licenses and other +attributions of the project. + + +[`cranelift-wasm`]: https://crates.io/crates/cranelift-wasm +[Wasmer `ATTRIBUTIONS`]: https://github.com/wasmerio/wasmer/blob/master/ATTRIBUTIONS.md diff --git a/runtime/near-vm/lib/compiler/src/address_map.rs b/runtime/near-vm/lib/compiler/src/address_map.rs new file mode 100644 index 00000000000..4f415827b7b --- /dev/null +++ b/runtime/near-vm/lib/compiler/src/address_map.rs @@ -0,0 +1,40 @@ +//! Data structures to provide transformation of the source +// addresses of a WebAssembly module into the native code. + +use crate::lib::std::vec::Vec; +use crate::sourceloc::SourceLoc; + +/// Single source location to generated address mapping. +#[derive(rkyv::Serialize, rkyv::Deserialize, rkyv::Archive, Debug, Clone, PartialEq, Eq)] +pub struct InstructionAddressMap { + /// Original source location. + pub srcloc: SourceLoc, + + /// Generated instructions offset. + pub code_offset: usize, + + /// Generated instructions length. + pub code_len: usize, +} + +/// Function and its instructions addresses mappings. +#[derive( + rkyv::Serialize, rkyv::Deserialize, rkyv::Archive, Debug, Clone, PartialEq, Eq, Default, +)] +pub struct FunctionAddressMap { + /// Instructions maps. + /// The array is sorted by the InstructionAddressMap::code_offset field. + pub instructions: Vec, + + /// Function start source location (normally declaration). + pub start_srcloc: SourceLoc, + + /// Function end source location. + pub end_srcloc: SourceLoc, + + /// Generated function body offset if applicable, otherwise 0. + pub body_offset: usize, + + /// Generated function body length. + pub body_len: usize, +} diff --git a/runtime/near-vm/lib/compiler/src/compiler.rs b/runtime/near-vm/lib/compiler/src/compiler.rs new file mode 100644 index 00000000000..2cd88f5ec0a --- /dev/null +++ b/runtime/near-vm/lib/compiler/src/compiler.rs @@ -0,0 +1,167 @@ +//! This module mainly outputs the `Compiler` trait that custom +//! compilers will need to implement. + +use crate::error::CompileError; +use crate::function::Compilation; +use crate::lib::std::boxed::Box; +use crate::module::CompileModuleInfo; +use crate::target::Target; +use crate::FunctionBodyData; +use crate::ModuleTranslationState; +use crate::SectionIndex; +use wasmer_types::entity::PrimaryMap; +use wasmer_types::{Features, FunctionIndex, LocalFunctionIndex, SignatureIndex}; +use wasmparser::{Validator, WasmFeatures}; + +/// The compiler configuration options. +pub trait CompilerConfig { + /// Enable Position Independent Code (PIC). + /// + /// This is required for shared object generation (Native Engine), + /// but will make the JIT Engine to fail, since PIC is not yet + /// supported in the JIT linking phase. + fn enable_pic(&mut self) { + // By default we do nothing, each backend will need to customize this + // in case they do something special for emitting PIC code. + } + + /// Enable compiler IR verification. + /// + /// For compilers capable of doing so, this enables internal consistency + /// checking. + fn enable_verifier(&mut self) { + // By default we do nothing, each backend will need to customize this + // in case they create an IR that they can verify. + } + + /// Enable NaN canonicalization. + /// + /// NaN canonicalization is useful when trying to run WebAssembly + /// deterministically across different architectures. + #[deprecated(note = "Please use the canonicalize_nans instead")] + fn enable_nan_canonicalization(&mut self) { + // By default we do nothing, each backend will need to customize this + // in case they create an IR that they can verify. + } + + /// Enable NaN canonicalization. + /// + /// NaN canonicalization is useful when trying to run WebAssembly + /// deterministically across different architectures. + fn canonicalize_nans(&mut self, _enable: bool) { + // By default we do nothing, each backend will need to customize this + // in case they create an IR that they can verify. + } + + /// Gets the custom compiler config + fn compiler(self: Box) -> Box; + + /// Gets the default features for this compiler in the given target + fn default_features_for_target(&self, _target: &Target) -> Features { + Features::default() + } +} + +impl From for Box +where + T: CompilerConfig + 'static, +{ + fn from(other: T) -> Self { + Box::new(other) + } +} + +/// An implementation of a Compiler from parsed WebAssembly module to Compiled native code. +pub trait Compiler: Send { + /// Validates a module. + /// + /// It returns the a succesful Result in case is valid, `CompileError` in case is not. + fn validate_module<'data>( + &self, + features: &Features, + data: &'data [u8], + ) -> Result<(), CompileError> { + let wasm_features = WasmFeatures { + bulk_memory: features.bulk_memory, + threads: features.threads, + reference_types: features.reference_types, + multi_value: features.multi_value, + simd: features.simd, + tail_call: features.tail_call, + multi_memory: features.multi_memory, + memory64: features.memory64, + exceptions: features.exceptions, + floats: true, + component_model: false, + extended_const: false, + mutable_global: features.mutable_global, + relaxed_simd: false, + saturating_float_to_int: features.saturating_float_to_int, + sign_extension: features.sign_extension, + memory_control: false, + }; + let mut validator = Validator::new_with_features(wasm_features); + validator + .validate_all(data) + .map_err(|e| CompileError::Validate(format!("{}", e)))?; + Ok(()) + } + + /// Compiles a parsed module. + /// + /// It returns the [`Compilation`] or a [`CompileError`]. + fn compile_module<'data, 'module>( + &self, + target: &Target, + module: &'module CompileModuleInfo, + module_translation: &ModuleTranslationState, + // The list of function bodies + function_body_inputs: PrimaryMap>, + tunables: &dyn wasmer_vm::Tunables, + instrumentation: &finite_wasm::AnalysisOutcome, + ) -> Result; + + /// Compiles a module into a native object file. + /// + /// It returns the bytes as a `&[u8]` or a [`CompileError`]. + fn experimental_native_compile_module<'data, 'module>( + &self, + _target: &Target, + _module: &'module CompileModuleInfo, + _module_translation: &ModuleTranslationState, + // The list of function bodies + _function_body_inputs: &PrimaryMap>, + _symbol_registry: &dyn SymbolRegistry, + // The metadata to inject into the wasmer_metadata section of the object file. + _wasmer_metadata: &[u8], + ) -> Option, CompileError>> { + None + } +} + +/// The kinds of wasmer_types objects that might be found in a native object file. +#[derive(Clone, Debug, PartialEq, Eq)] +pub enum Symbol { + /// A function defined in the wasm. + LocalFunction(LocalFunctionIndex), + + /// A wasm section. + Section(SectionIndex), + + /// The function call trampoline for a given signature. + FunctionCallTrampoline(SignatureIndex), + + /// The dynamic function trampoline for a given function. + DynamicFunctionTrampoline(FunctionIndex), +} + +/// This trait facilitates symbol name lookups in a native object file. +pub trait SymbolRegistry: Send + Sync { + /// Given a `Symbol` it returns the name for that symbol in the object file + fn symbol_to_name(&self, symbol: Symbol) -> String; + + /// Given a name it returns the `Symbol` for that name in the object file + /// + /// This function is the inverse of [`SymbolRegistry::symbol_to_name`] + fn name_to_symbol(&self, name: &str) -> Option; +} diff --git a/runtime/near-vm/lib/compiler/src/error.rs b/runtime/near-vm/lib/compiler/src/error.rs new file mode 100644 index 00000000000..6ecee735888 --- /dev/null +++ b/runtime/near-vm/lib/compiler/src/error.rs @@ -0,0 +1,166 @@ +use crate::lib::std::string::String; +#[cfg(feature = "std")] +use thiserror::Error; + +// Compilation Errors +// +// If `std` feature is enable, we can't use `thiserror` until +// https://github.com/dtolnay/thiserror/pull/64 is merged. + +/// The WebAssembly.CompileError object indicates an error during +/// WebAssembly decoding or validation. +/// +/// This is based on the [Wasm Compile Error][compile-error] API. +/// +/// [compiler-error]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/CompileError +#[derive(Debug)] +#[cfg_attr(feature = "std", derive(Error))] +pub enum CompileError { + /// A Wasm translation error occured. + #[cfg_attr(feature = "std", error("WebAssembly translation error: {0}"))] + Wasm(WasmError), + + /// A compilation error occured. + #[cfg_attr(feature = "std", error("Compilation error: {0}"))] + Codegen(String), + + /// The module did not pass validation. + #[cfg_attr(feature = "std", error("Validation error: {0}"))] + Validate(String), + + /// Finite-wasm failed to handle the module. + #[cfg_attr(feature = "std", error("Finite-wasm analysis error: {0}"))] + Analyze(finite_wasm::Error), + + /// The compiler doesn't support a Wasm feature + #[cfg_attr(feature = "std", error("Feature {0} is not yet supported"))] + UnsupportedFeature(String), + + /// The compiler cannot compile for the given target. + /// This can refer to the OS, the chipset or any other aspect of the target system. + #[cfg_attr(feature = "std", error("The target {0} is not yet supported (see https://docs.wasmer.io/ecosystem/wasmer/wasmer-features)"))] + UnsupportedTarget(String), + + /// Insufficient resources available for execution. + #[cfg_attr(feature = "std", error("Insufficient resources: {0}"))] + Resource(String), + + /// Cannot downcast the engine to a specific type. + #[cfg_attr( + feature = "std", + error("cannot downcast the engine to a specific type") + )] + EngineDowncast, +} + +impl From for CompileError { + fn from(original: WasmError) -> Self { + Self::Wasm(original) + } +} + +/// A error in the middleware. +#[derive(Debug)] +#[cfg_attr(feature = "std", derive(Error))] +#[cfg_attr(feature = "std", error("Error in middleware {name}: {message}"))] +pub struct MiddlewareError { + /// The name of the middleware where the error was created + pub name: String, + /// The error message + pub message: String, +} + +impl MiddlewareError { + /// Create a new `MiddlewareError` + pub fn new, B: Into>(name: A, message: B) -> Self { + Self { + name: name.into(), + message: message.into(), + } + } +} + +/// A WebAssembly translation error. +/// +/// When a WebAssembly function can't be translated, one of these error codes will be returned +/// to describe the failure. +#[derive(Debug)] +#[cfg_attr(feature = "std", derive(Error))] +pub enum WasmError { + /// The input WebAssembly code is invalid. + /// + /// This error code is used by a WebAssembly translator when it encounters invalid WebAssembly + /// code. This should never happen for validated WebAssembly code. + #[cfg_attr( + feature = "std", + error("Invalid input WebAssembly code at offset {offset}: {message}") + )] + InvalidWebAssembly { + /// A string describing the validation error. + message: String, + /// The bytecode offset where the error occurred. + offset: usize, + }, + + /// A feature used by the WebAssembly code is not supported by the embedding environment. + /// + /// Embedding environments may have their own limitations and feature restrictions. + #[cfg_attr(feature = "std", error("Unsupported feature: {0}"))] + Unsupported(String), + + /// An implementation limit was exceeded. + #[cfg_attr(feature = "std", error("Implementation limit exceeded"))] + ImplLimitExceeded, + + /// An error from the middleware error. + #[cfg_attr(feature = "std", error("{0}"))] + Middleware(MiddlewareError), + + /// A generic error. + #[cfg_attr(feature = "std", error("{0}"))] + Generic(String), +} + +impl From for WasmError { + fn from(original: MiddlewareError) -> Self { + Self::Middleware(original) + } +} + +/// The error that can happen while parsing a `str` +/// to retrieve a [`CpuFeature`](crate::target::CpuFeature). +#[derive(Debug)] +#[cfg_attr(feature = "std", derive(Error))] +pub enum ParseCpuFeatureError { + /// The provided string feature doesn't exist + #[cfg_attr(feature = "std", error("CpuFeature {0} not recognized"))] + Missing(String), +} + +/// A convenient alias for a `Result` that uses `WasmError` as the error type. +pub type WasmResult = Result; + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn middleware_error_can_be_created() { + let msg = String::from("Something went wrong"); + let error = MiddlewareError::new("manipulator3000", msg); + assert_eq!(error.name, "manipulator3000"); + assert_eq!(error.message, "Something went wrong"); + } + + #[test] + fn middleware_error_be_converted_to_wasm_error() { + let error = WasmError::from(MiddlewareError::new("manipulator3000", "foo")); + match error { + WasmError::Middleware(MiddlewareError { name, message }) => { + assert_eq!(name, "manipulator3000"); + assert_eq!(message, "foo"); + } + err => panic!("Unexpected error: {:?}", err), + } + } +} diff --git a/runtime/near-vm/lib/compiler/src/function.rs b/runtime/near-vm/lib/compiler/src/function.rs new file mode 100644 index 00000000000..18b05a6c654 --- /dev/null +++ b/runtime/near-vm/lib/compiler/src/function.rs @@ -0,0 +1,188 @@ +// This file contains code from external sources. +// Attributions: https://github.com/wasmerio/wasmer/blob/master/ATTRIBUTIONS.md + +//! A `Compilation` contains the compiled function bodies for a WebAssembly +//! module (`CompiledFunction`). + +use crate::lib::std::vec::Vec; +use crate::section::{CustomSection, SectionIndex}; +use crate::trap::TrapInformation; +use crate::{ + CompiledFunctionUnwindInfo, CompiledFunctionUnwindInfoRef, FunctionAddressMap, + JumpTableOffsets, Relocation, +}; +use wasmer_types::entity::PrimaryMap; +use wasmer_types::{FunctionIndex, LocalFunctionIndex, SignatureIndex}; + +/// The frame info for a Compiled function. +/// +/// This structure is only used for reconstructing +/// the frame information after a `Trap`. +#[derive( + rkyv::Serialize, rkyv::Deserialize, rkyv::Archive, Debug, Clone, PartialEq, Eq, Default, +)] +pub struct CompiledFunctionFrameInfo { + /// The traps (in the function body). + /// + /// Code offsets of the traps MUST be in ascending order. + pub traps: Vec, + + /// The address map. + pub address_map: FunctionAddressMap, +} + +/// The function body. +#[derive(rkyv::Serialize, rkyv::Deserialize, rkyv::Archive, Debug, Clone, PartialEq, Eq)] +pub struct FunctionBody { + /// The function body bytes. + pub body: Vec, + + /// The function unwind info + pub unwind_info: Option, +} + +/// See [`FunctionBody`]. +#[derive(Clone, Copy)] +pub struct FunctionBodyRef<'a> { + /// Function body bytes. + pub body: &'a [u8], + /// The function unwind info. + pub unwind_info: Option>, +} + +impl<'a> From<&'a FunctionBody> for FunctionBodyRef<'a> { + fn from(body: &'a FunctionBody) -> Self { + FunctionBodyRef { + body: &*body.body, + unwind_info: body.unwind_info.as_ref().map(Into::into), + } + } +} + +impl<'a> From<&'a ArchivedFunctionBody> for FunctionBodyRef<'a> { + fn from(body: &'a ArchivedFunctionBody) -> Self { + FunctionBodyRef { + body: &*body.body, + unwind_info: body.unwind_info.as_ref().map(Into::into), + } + } +} + +/// The result of compiling a WebAssembly function. +/// +/// This structure only have the compiled information data +/// (function bytecode body, relocations, traps, jump tables +/// and unwind information). +#[derive(rkyv::Serialize, rkyv::Deserialize, rkyv::Archive, Debug, Clone, PartialEq, Eq)] +pub struct CompiledFunction { + /// The function body. + pub body: FunctionBody, + + /// The relocations (in the body) + pub relocations: Vec, + + /// The jump tables offsets (in the body). + pub jt_offsets: JumpTableOffsets, + + /// The frame information. + pub frame_info: CompiledFunctionFrameInfo, +} + +/// The compiled functions map (index in the Wasm -> function) +pub type Functions = PrimaryMap; + +/// The custom sections for a Compilation. +pub type CustomSections = PrimaryMap; + +/// The DWARF information for this Compilation. +/// +/// It is used for retrieving the unwind information once an exception +/// happens. +/// In the future this structure may also hold other information useful +/// for debugging. +#[derive(rkyv::Serialize, rkyv::Deserialize, rkyv::Archive, Debug, PartialEq, Eq, Clone)] +pub struct Dwarf { + /// The section index in the [`Compilation`] that corresponds to the exception frames. + /// [Learn + /// more](https://refspecs.linuxfoundation.org/LSB_3.0.0/LSB-PDA/LSB-PDA/ehframechpt.html). + pub eh_frame: SectionIndex, +} + +impl Dwarf { + /// Creates a `Dwarf` struct with the corresponding indices for its sections + pub fn new(eh_frame: SectionIndex) -> Self { + Self { eh_frame } + } +} + +/// Trampolines section used by ARM short jump (26bits) +#[derive(rkyv::Serialize, rkyv::Deserialize, rkyv::Archive, Debug, PartialEq, Eq, Clone)] +pub struct TrampolinesSection { + /// SectionIndex for the actual Trampolines code + pub section_index: SectionIndex, + /// Number of jump slots in the section + pub slots: usize, + /// Slot size + pub size: usize, +} + +impl TrampolinesSection { + /// Creates a `Trampolines` struct with the indice for its section, and number of slots and size of slot + pub fn new(section_index: SectionIndex, slots: usize, size: usize) -> Self { + Self { + section_index, + slots, + size, + } + } +} + +/// The result of compiling a WebAssembly module's functions. +#[derive(Debug, PartialEq, Eq)] +pub struct Compilation { + /// Compiled code for the function bodies. + pub functions: Functions, + + /// Custom sections for the module. + /// It will hold the data, for example, for constants used in a + /// function, global variables, rodata_64, hot/cold function partitioning, ... + pub custom_sections: CustomSections, + + /// Trampolines to call a function defined locally in the wasm via a + /// provided `Vec` of values. + /// + /// This allows us to call easily Wasm functions, such as: + /// + /// ```ignore + /// let func = instance.exports.get_function("my_func"); + /// func.call(&[Value::I32(1)]); + /// ``` + pub function_call_trampolines: PrimaryMap, + + /// Trampolines to call a dynamic function defined in + /// a host, from a Wasm module. + /// + /// This allows us to create dynamic Wasm functions, such as: + /// + /// ```ignore + /// fn my_func(values: &[Val]) -> Result, RuntimeError> { + /// // do something + /// } + /// + /// let my_func_type = FunctionType::new(vec![Type::I32], vec![Type::I32]); + /// let imports = imports!{ + /// "namespace" => { + /// "my_func" => Function::new(&store, my_func_type, my_func), + /// } + /// } + /// ``` + /// + /// Note: Dynamic function trampolines are only compiled for imported function types. + pub dynamic_function_trampolines: PrimaryMap, + + /// Section ids corresponding to the Dwarf debug info + pub debug: Option, + + /// Trampolines for the arch that needs it + pub trampolines: Option, +} diff --git a/runtime/near-vm/lib/compiler/src/jump_table.rs b/runtime/near-vm/lib/compiler/src/jump_table.rs new file mode 100644 index 00000000000..5c7fb9c2c08 --- /dev/null +++ b/runtime/near-vm/lib/compiler/src/jump_table.rs @@ -0,0 +1,36 @@ +//! A jump table is a method of transferring program control (branching) +//! to another part of a program (or a different program that may have +//! been dynamically loaded) using a table of branch or jump instructions. +//! +//! [Learn more](https://en.wikipedia.org/wiki/Branch_table). + +use super::CodeOffset; +use wasmer_types::entity::{entity_impl, SecondaryMap}; + +/// An opaque reference to a [jump table](https://en.wikipedia.org/wiki/Branch_table). +/// +/// `JumpTable`s are used for indirect branching and are specialized for dense, +/// 0-based jump offsets. +#[derive(rkyv::Serialize, rkyv::Deserialize, rkyv::Archive)] +#[archive_attr(derive(Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord))] +#[derive(Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)] +pub struct JumpTable(u32); + +entity_impl!(JumpTable, "jt"); +entity_impl!(ArchivedJumpTable, "jt"); + +impl JumpTable { + /// Create a new jump table reference from its number. + /// + /// This method is for use by the parser. + pub fn with_number(n: u32) -> Option { + if n < u32::max_value() { + Some(Self(n)) + } else { + None + } + } +} + +/// Code offsets for Jump Tables. +pub type JumpTableOffsets = SecondaryMap; diff --git a/runtime/near-vm/lib/compiler/src/lib.rs b/runtime/near-vm/lib/compiler/src/lib.rs new file mode 100644 index 00000000000..3216be5f76c --- /dev/null +++ b/runtime/near-vm/lib/compiler/src/lib.rs @@ -0,0 +1,111 @@ +//! The `wasmer-compiler` crate provides the necessary abstractions +//! to create a compiler. +//! +//! It provides an universal way of parsing a module via `wasmparser`, +//! while giving the responsibility of compiling specific function +//! WebAssembly bodies to the `Compiler` implementation. + +#![deny(missing_docs, trivial_numeric_casts, unused_extern_crates)] +#![warn(unused_import_braces)] +#![cfg_attr(feature = "std", deny(unstable_features))] +#![cfg_attr(not(feature = "std"), no_std)] +#![cfg_attr(feature = "cargo-clippy", allow(clippy::new_without_default))] +#![cfg_attr( + feature = "cargo-clippy", + warn( + clippy::float_arithmetic, + clippy::mut_mut, + clippy::nonminimal_bool, + clippy::option_map_unwrap_or, + clippy::option_map_unwrap_or_else, + clippy::print_stdout, + clippy::unicode_not_nfc, + clippy::use_self + ) +)] + +#[cfg(all(feature = "std", feature = "core"))] +compile_error!( + "The `std` and `core` features are both enabled, which is an error. Please enable only once." +); + +#[cfg(all(not(feature = "std"), not(feature = "core")))] +compile_error!("Both the `std` and `core` features are disabled. Please enable one of them."); + +#[cfg(feature = "core")] +extern crate alloc; + +mod lib { + #[cfg(feature = "core")] + pub mod std { + pub use alloc::{borrow, boxed, str, string, sync, vec}; + pub use core::fmt; + pub use hashbrown as collections; + } + + #[cfg(feature = "std")] + pub mod std { + pub use std::{borrow, boxed, collections, fmt, str, string, sync, vec}; + } +} + +mod address_map; +#[cfg(feature = "translator")] +mod compiler; +mod error; +mod function; +mod jump_table; +mod module; +mod relocation; +mod target; +mod trap; +mod unwind; +#[cfg(feature = "translator")] +#[macro_use] +mod translator; +mod section; +mod sourceloc; + +pub use crate::address_map::{FunctionAddressMap, InstructionAddressMap}; +#[cfg(feature = "translator")] +pub use crate::compiler::{Compiler, CompilerConfig, Symbol, SymbolRegistry}; +pub use crate::error::{ + CompileError, MiddlewareError, ParseCpuFeatureError, WasmError, WasmResult, +}; +pub use crate::function::{ + Compilation, CompiledFunction, CompiledFunctionFrameInfo, CustomSections, Dwarf, FunctionBody, + FunctionBodyRef, Functions, TrampolinesSection, +}; +pub use crate::jump_table::{JumpTable, JumpTableOffsets}; +pub use crate::module::CompileModuleInfo; +pub use crate::relocation::{Relocation, RelocationKind, RelocationTarget, Relocations}; +pub use crate::section::{ + CustomSection, CustomSectionProtection, CustomSectionRef, SectionBody, SectionIndex, +}; +pub use crate::sourceloc::SourceLoc; +pub use crate::target::{ + Architecture, BinaryFormat, CallingConvention, CpuFeature, Endianness, OperatingSystem, + PointerWidth, Target, Triple, +}; +#[cfg(feature = "translator")] +pub use crate::translator::{ + translate_module, wptype_to_type, FunctionBodyData, FunctionReader, ModuleEnvironment, + ModuleTranslationState, +}; +pub use crate::trap::TrapInformation; +pub use crate::unwind::{CompiledFunctionUnwindInfo, CompiledFunctionUnwindInfoRef}; + +pub use wasmer_types::Features; + +#[cfg(feature = "translator")] +/// wasmparser is exported as a module to slim compiler dependencies +pub use wasmparser; + +/// Offset in bytes from the beginning of the function. +pub type CodeOffset = u32; + +/// Addend to add to the symbol value. +pub type Addend = i64; + +/// Version number of this crate. +pub const VERSION: &str = env!("CARGO_PKG_VERSION"); diff --git a/runtime/near-vm/lib/compiler/src/module.rs b/runtime/near-vm/lib/compiler/src/module.rs new file mode 100644 index 00000000000..daa642d90ab --- /dev/null +++ b/runtime/near-vm/lib/compiler/src/module.rs @@ -0,0 +1,24 @@ +use crate::lib::std::sync::Arc; +use wasmer_types::entity::PrimaryMap; +use wasmer_types::{Features, MemoryIndex, ModuleInfo, TableIndex}; +use wasmer_vm::{MemoryStyle, TableStyle}; + +/// The required info for compiling a module. +/// +/// This differs from [`ModuleInfo`] because it have extra info only +/// possible after translation (such as the features used for compiling, +/// or the `MemoryStyle` and `TableStyle`). +#[derive(Debug, PartialEq, Eq, rkyv::Serialize, rkyv::Deserialize, rkyv::Archive)] +pub struct CompileModuleInfo { + /// The features used for compiling the module + pub features: Features, + /// The module information + pub module: Arc, + /// The memory styles used for compiling. + /// + /// The compiler will emit the most optimal code based + /// on the memory style (static or dynamic) chosen. + pub memory_styles: PrimaryMap, + /// The table plans used for compiling. + pub table_styles: PrimaryMap, +} diff --git a/runtime/near-vm/lib/compiler/src/relocation.rs b/runtime/near-vm/lib/compiler/src/relocation.rs new file mode 100644 index 00000000000..ce9b008fc24 --- /dev/null +++ b/runtime/near-vm/lib/compiler/src/relocation.rs @@ -0,0 +1,171 @@ +//! Relocation is the process of assigning load addresses for position-dependent +//! code and data of a program and adjusting the code and data to reflect the +//! assigned addresses. +//! +//! [Learn more](https://en.wikipedia.org/wiki/Relocation_(computing)). +//! +//! Each time a `Compiler` compiles a WebAssembly function (into machine code), +//! it also attaches if there are any relocations that need to be patched into +//! the generated machine code, so a given frontend (JIT or native) can +//! do the corresponding work to run it. + +use crate::lib::std::fmt; +use crate::lib::std::vec::Vec; +use crate::section::SectionIndex; +use crate::{Addend, CodeOffset, JumpTable}; +use wasmer_types::entity::PrimaryMap; +use wasmer_types::LocalFunctionIndex; +use wasmer_vm::libcalls::LibCall; + +/// Relocation kinds for every ISA. +#[derive(rkyv::Serialize, rkyv::Deserialize, rkyv::Archive, Copy, Clone, Debug, PartialEq, Eq)] +pub enum RelocationKind { + /// absolute 4-byte + Abs4, + /// absolute 8-byte + Abs8, + /// x86 PC-relative 4-byte + X86PCRel4, + /// x86 PC-relative 8-byte + X86PCRel8, + /// x86 PC-relative 4-byte offset to trailing rodata + X86PCRelRodata4, + /// x86 call to PC-relative 4-byte + X86CallPCRel4, + /// x86 call to PLT-relative 4-byte + X86CallPLTRel4, + /// x86 GOT PC-relative 4-byte + X86GOTPCRel4, + /// Arm32 call target + Arm32Call, + /// Arm64 call target + Arm64Call, + /// Arm64 movk/z part 0 + Arm64Movw0, + /// Arm64 movk/z part 1 + Arm64Movw1, + /// Arm64 movk/z part 2 + Arm64Movw2, + /// Arm64 movk/z part 3 + Arm64Movw3, + // /// RISC-V call target + // RiscvCall, + /// Elf x86_64 32 bit signed PC relative offset to two GOT entries for GD symbol. + ElfX86_64TlsGd, + // /// Mach-O x86_64 32 bit signed PC relative offset to a `__thread_vars` entry. + // MachOX86_64Tlv, +} + +impl fmt::Display for RelocationKind { + /// Display trait implementation drops the arch, since its used in contexts where the arch is + /// already unambiguous, e.g. clif syntax with isa specified. In other contexts, use Debug. + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + match *self { + Self::Abs4 => write!(f, "Abs4"), + Self::Abs8 => write!(f, "Abs8"), + Self::X86PCRel4 => write!(f, "PCRel4"), + Self::X86PCRel8 => write!(f, "PCRel8"), + Self::X86PCRelRodata4 => write!(f, "PCRelRodata4"), + Self::X86CallPCRel4 => write!(f, "CallPCRel4"), + Self::X86CallPLTRel4 => write!(f, "CallPLTRel4"), + Self::X86GOTPCRel4 => write!(f, "GOTPCRel4"), + Self::Arm32Call | Self::Arm64Call => write!(f, "Call"), + Self::Arm64Movw0 => write!(f, "Arm64MovwG0"), + Self::Arm64Movw1 => write!(f, "Arm64MovwG1"), + Self::Arm64Movw2 => write!(f, "Arm64MovwG2"), + Self::Arm64Movw3 => write!(f, "Arm64MovwG3"), + Self::ElfX86_64TlsGd => write!(f, "ElfX86_64TlsGd"), + // Self::MachOX86_64Tlv => write!(f, "MachOX86_64Tlv"), + } + } +} + +/// A record of a relocation to perform. +#[derive(rkyv::Serialize, rkyv::Deserialize, rkyv::Archive, Debug, Clone, PartialEq, Eq)] +pub struct Relocation { + /// The relocation kind. + pub kind: RelocationKind, + /// Relocation target. + pub reloc_target: RelocationTarget, + /// The offset where to apply the relocation. + pub offset: CodeOffset, + /// The addend to add to the relocation value. + pub addend: Addend, +} + +/// Destination function. Can be either user function or some special one, like `memory.grow`. +#[derive(rkyv::Serialize, rkyv::Deserialize, rkyv::Archive, Debug, Copy, Clone, PartialEq, Eq)] +pub enum RelocationTarget { + /// A relocation to a function defined locally in the wasm (not an imported one). + LocalFunc(LocalFunctionIndex), + /// A compiler-generated libcall. + LibCall(LibCall), + /// Jump table index. + JumpTable(LocalFunctionIndex, JumpTable), + /// Custom sections generated by the compiler + CustomSection(SectionIndex), +} + +impl Relocation { + /// Given a function start address, provide the relocation relative + /// to that address. + /// + /// The function returns the relocation address and the delta. + pub fn for_address(&self, start: usize, target_func_address: u64) -> (usize, u64) { + match self.kind { + RelocationKind::Abs8 + | RelocationKind::Arm64Movw0 + | RelocationKind::Arm64Movw1 + | RelocationKind::Arm64Movw2 + | RelocationKind::Arm64Movw3 => { + let reloc_address = start + self.offset as usize; + let reloc_addend = self.addend as isize; + let reloc_abs = target_func_address + .checked_add(reloc_addend as u64) + .unwrap(); + (reloc_address, reloc_abs) + } + RelocationKind::X86PCRel4 => { + let reloc_address = start + self.offset as usize; + let reloc_addend = self.addend as isize; + let reloc_delta_u32 = (target_func_address as u32) + .wrapping_sub(reloc_address as u32) + .checked_add(reloc_addend as u32) + .unwrap(); + (reloc_address, reloc_delta_u32 as u64) + } + RelocationKind::X86PCRel8 => { + let reloc_address = start + self.offset as usize; + let reloc_addend = self.addend as isize; + let reloc_delta = target_func_address + .wrapping_sub(reloc_address as u64) + .checked_add(reloc_addend as u64) + .unwrap(); + (reloc_address, reloc_delta) + } + RelocationKind::X86CallPCRel4 | RelocationKind::X86CallPLTRel4 => { + let reloc_address = start + self.offset as usize; + let reloc_addend = self.addend as isize; + let reloc_delta_u32 = (target_func_address as u32) + .wrapping_sub(reloc_address as u32) + .wrapping_add(reloc_addend as u32); + (reloc_address, reloc_delta_u32 as u64) + } + RelocationKind::Arm64Call => { + let reloc_address = start + self.offset as usize; + let reloc_addend = self.addend as isize; + let reloc_delta_u32 = target_func_address + .wrapping_sub(reloc_address as u64) + .wrapping_add(reloc_addend as u64); + (reloc_address, reloc_delta_u32) + } + // RelocationKind::X86PCRelRodata4 => { + // (start, target_func_address) + // } + _ => panic!("Relocation kind unsupported"), + } + } +} + +/// Relocations to apply to function bodies. +pub type Relocations = PrimaryMap>; diff --git a/runtime/near-vm/lib/compiler/src/section.rs b/runtime/near-vm/lib/compiler/src/section.rs new file mode 100644 index 00000000000..339d367f6fb --- /dev/null +++ b/runtime/near-vm/lib/compiler/src/section.rs @@ -0,0 +1,118 @@ +//! This module define the required structures to emit custom +//! Sections in a `Compilation`. +//! +//! The functions that access a custom [`CustomSection`] would need +//! to emit a custom relocation: `RelocationTarget::CustomSection`, so +//! it can be patched later by the engine (native or JIT). + +use crate::lib::std::vec::Vec; +use crate::Relocation; +use wasmer_types::entity::entity_impl; + +/// Index type of a Section defined inside a WebAssembly `Compilation`. +#[derive(rkyv::Serialize, rkyv::Deserialize, rkyv::Archive)] +#[archive_attr(derive(Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord, Debug))] +#[derive(Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord, Debug)] +pub struct SectionIndex(u32); + +entity_impl!(SectionIndex); + +entity_impl!(ArchivedSectionIndex); + +/// Custom section Protection. +/// +/// Determines how a custom section may be used. +#[derive(rkyv::Serialize, rkyv::Deserialize, rkyv::Archive, Debug, Copy, Clone, PartialEq, Eq)] +pub enum CustomSectionProtection { + /// A custom section with read permission. + Read, + + /// A custom section with read and execute permissions. + ReadExecute, +} + +/// A Section for a `Compilation`. +/// +/// This is used so compilers can store arbitrary information +/// in the emitted module. +#[derive(rkyv::Serialize, rkyv::Deserialize, rkyv::Archive, Debug, Clone, PartialEq, Eq)] +pub struct CustomSection { + /// Memory protection that applies to this section. + pub protection: CustomSectionProtection, + + /// The bytes corresponding to this section. + /// + /// > Note: These bytes have to be at-least 8-byte aligned + /// > (the start of the memory pointer). + /// > We might need to create another field for alignment in case it's + /// > needed in the future. + pub bytes: SectionBody, + + /// Relocations that apply to this custom section. + pub relocations: Vec, +} + +/// See [`CustomSection`]. +/// +/// Note that this does not reference the relocation data. +#[derive(Clone, Copy)] +pub struct CustomSectionRef<'a> { + /// See [`CustomSection::protection`]. + pub protection: CustomSectionProtection, + + /// See [`CustomSection::bytes`]. + pub bytes: &'a [u8], +} + +impl<'a> From<&'a CustomSection> for CustomSectionRef<'a> { + fn from(section: &'a CustomSection) -> Self { + CustomSectionRef { + protection: section.protection.clone(), + bytes: section.bytes.as_slice(), + } + } +} + +impl<'a> From<&'a ArchivedCustomSection> for CustomSectionRef<'a> { + fn from(section: &'a ArchivedCustomSection) -> Self { + CustomSectionRef { + protection: Result::<_, std::convert::Infallible>::unwrap( + rkyv::Deserialize::deserialize(§ion.protection, &mut rkyv::Infallible), + ), + bytes: §ion.bytes.0[..], + } + } +} + +/// The bytes in the section. +#[derive( + rkyv::Serialize, rkyv::Deserialize, rkyv::Archive, Debug, Clone, PartialEq, Eq, Default, +)] +pub struct SectionBody(Vec); + +impl SectionBody { + /// Create a new section body with the given contents. + pub fn new_with_vec(contents: Vec) -> Self { + Self(contents) + } + + /// Returns a raw pointer to the section's buffer. + pub fn as_ptr(&self) -> *const u8 { + self.0.as_ptr() + } + + /// Returns the length of this section in bytes. + pub fn len(&self) -> usize { + self.0.len() + } + + /// Dereferences into the section's buffer. + pub fn as_slice(&self) -> &[u8] { + self.0.as_slice() + } + + /// Returns whether or not the section body is empty. + pub fn is_empty(&self) -> bool { + self.0.is_empty() + } +} diff --git a/runtime/near-vm/lib/compiler/src/sourceloc.rs b/runtime/near-vm/lib/compiler/src/sourceloc.rs new file mode 100644 index 00000000000..b2b091e5d95 --- /dev/null +++ b/runtime/near-vm/lib/compiler/src/sourceloc.rs @@ -0,0 +1,66 @@ +// This file contains code from external sources. +// Attributions: https://github.com/wasmerio/wasmer/blob/master/ATTRIBUTIONS.md + +//! Source locations. +//! +//! A [`SourceLoc`] determines the position of a certain instruction +//! relative to the WebAssembly module. This is used mainly for debugging +//! and tracing errors. + +use crate::lib::std::fmt; + +/// A source location. +/// +/// The default source location uses the all-ones bit pattern `!0`. It is used for instructions +/// that can't be given a real source location. +#[derive(rkyv::Serialize, rkyv::Deserialize, rkyv::Archive, Debug, Clone, Copy, PartialEq, Eq)] +#[archive(as = "Self")] +#[repr(transparent)] +pub struct SourceLoc(u32); + +impl SourceLoc { + /// Create a new source location with the given bits. + pub fn new(bits: u32) -> Self { + Self(bits) + } + + /// Is this the default source location? + pub fn is_default(self) -> bool { + self == Default::default() + } + + /// Read the bits of this source location. + pub fn bits(self) -> u32 { + self.0 + } +} + +impl Default for SourceLoc { + fn default() -> Self { + Self(!0) + } +} + +impl fmt::Display for SourceLoc { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + if self.is_default() { + write!(f, "0x-") + } else { + write!(f, "0x{:04x}", self.0) + } + } +} + +#[cfg(test)] +mod tests { + use super::SourceLoc; + use crate::lib::std::string::ToString; + + #[test] + fn display() { + assert_eq!(SourceLoc::default().to_string(), "0x-"); + assert_eq!(SourceLoc::new(0).to_string(), "0x0000"); + assert_eq!(SourceLoc::new(16).to_string(), "0x0010"); + assert_eq!(SourceLoc::new(0xabcdef).to_string(), "0xabcdef"); + } +} diff --git a/runtime/near-vm/lib/compiler/src/target.rs b/runtime/near-vm/lib/compiler/src/target.rs new file mode 100644 index 00000000000..9d18d79e87d --- /dev/null +++ b/runtime/near-vm/lib/compiler/src/target.rs @@ -0,0 +1,197 @@ +//! Target configuration +use crate::error::ParseCpuFeatureError; +use crate::lib::std::str::FromStr; +use crate::lib::std::string::{String, ToString}; +use enumset::{EnumSet, EnumSetType}; +pub use target_lexicon::{ + Architecture, BinaryFormat, CallingConvention, Endianness, OperatingSystem, PointerWidth, + Triple, +}; + +/// The nomenclature is inspired by the [`cpuid` crate]. +/// The list of supported features was initially retrieved from +/// [`cranelift-native`]. +/// +/// The `CpuFeature` enum values are likely to grow closer to the +/// original `cpuid`. However, we prefer to start small and grow from there. +/// +/// If you would like to use a flag that doesn't exist yet here, please +/// open a PR. +/// +/// [`cpuid` crate]: https://docs.rs/cpuid/0.1.1/cpuid/enum.CpuFeature.html +/// [`cranelift-native`]: https://github.com/bytecodealliance/cranelift/blob/6988545fd20249b084c53f4761b8c861266f5d31/cranelift-native/src/lib.rs#L51-L92 +#[allow(missing_docs, clippy::derive_hash_xor_eq)] +#[derive(EnumSetType, Debug, Hash)] +pub enum CpuFeature { + // X86 features + SSE2, + SSE3, + SSSE3, + SSE41, + SSE42, + POPCNT, + AVX, + BMI1, + BMI2, + AVX2, + AVX512DQ, + AVX512VL, + AVX512F, + LZCNT, + // ARM features + // Risc-V features +} + +impl CpuFeature { + #[cfg(any(target_arch = "x86", target_arch = "x86_64"))] + /// Retrieves the features for the current Host + pub fn for_host() -> EnumSet { + let mut features = EnumSet::new(); + + if std::is_x86_feature_detected!("sse2") { + features.insert(Self::SSE2); + } + if std::is_x86_feature_detected!("sse3") { + features.insert(Self::SSE3); + } + if std::is_x86_feature_detected!("ssse3") { + features.insert(Self::SSSE3); + } + if std::is_x86_feature_detected!("sse4.1") { + features.insert(Self::SSE41); + } + if std::is_x86_feature_detected!("sse4.2") { + features.insert(Self::SSE42); + } + if std::is_x86_feature_detected!("popcnt") { + features.insert(Self::POPCNT); + } + if std::is_x86_feature_detected!("avx") { + features.insert(Self::AVX); + } + if std::is_x86_feature_detected!("bmi1") { + features.insert(Self::BMI1); + } + if std::is_x86_feature_detected!("bmi2") { + features.insert(Self::BMI2); + } + if std::is_x86_feature_detected!("avx2") { + features.insert(Self::AVX2); + } + if std::is_x86_feature_detected!("avx512dq") { + features.insert(Self::AVX512DQ); + } + if std::is_x86_feature_detected!("avx512vl") { + features.insert(Self::AVX512VL); + } + if std::is_x86_feature_detected!("avx512f") { + features.insert(Self::AVX512F); + } + if std::is_x86_feature_detected!("lzcnt") { + features.insert(Self::LZCNT); + } + features + } + #[cfg(not(any(target_arch = "x86", target_arch = "x86_64")))] + /// Retrieves the features for the current Host + pub fn for_host() -> EnumSet { + // We default to an empty hash set + EnumSet::new() + } + + /// Retrieves an empty set of `CpuFeature`s. + pub fn set() -> EnumSet { + // We default to an empty hash set + EnumSet::new() + } +} + +// This options should map exactly the GCC options indicated +// here by architectures: +// +// X86: https://gcc.gnu.org/onlinedocs/gcc/x86-Options.html +// ARM: https://gcc.gnu.org/onlinedocs/gcc/ARM-Options.html +// Aarch64: https://gcc.gnu.org/onlinedocs/gcc/AArch64-Options.html +impl FromStr for CpuFeature { + type Err = ParseCpuFeatureError; + + fn from_str(s: &str) -> Result { + match s { + "sse2" => Ok(Self::SSE2), + "sse3" => Ok(Self::SSE3), + "ssse3" => Ok(Self::SSSE3), + "sse4.1" => Ok(Self::SSE41), + "sse4.2" => Ok(Self::SSE42), + "popcnt" => Ok(Self::POPCNT), + "avx" => Ok(Self::AVX), + "bmi" => Ok(Self::BMI1), + "bmi2" => Ok(Self::BMI2), + "avx2" => Ok(Self::AVX2), + "avx512dq" => Ok(Self::AVX512DQ), + "avx512vl" => Ok(Self::AVX512VL), + "avx512f" => Ok(Self::AVX512F), + "lzcnt" => Ok(Self::LZCNT), + _ => Err(ParseCpuFeatureError::Missing(s.to_string())), + } + } +} + +impl ToString for CpuFeature { + fn to_string(&self) -> String { + match self { + Self::SSE2 => "sse2", + Self::SSE3 => "sse3", + Self::SSSE3 => "ssse3", + Self::SSE41 => "sse4.1", + Self::SSE42 => "sse4.2", + Self::POPCNT => "popcnt", + Self::AVX => "avx", + Self::BMI1 => "bmi", + Self::BMI2 => "bmi2", + Self::AVX2 => "avx2", + Self::AVX512DQ => "avx512dq", + Self::AVX512VL => "avx512vl", + Self::AVX512F => "avx512f", + Self::LZCNT => "lzcnt", + } + .to_string() + } +} + +/// This is the target that we will use for compiling +/// the WebAssembly ModuleInfo, and then run it. +#[derive(Clone, Debug, PartialEq, Eq, Hash)] +pub struct Target { + triple: Triple, + cpu_features: EnumSet, +} + +impl Target { + /// Creates a new target given a triple + pub fn new(triple: Triple, cpu_features: EnumSet) -> Self { + Self { + triple, + cpu_features, + } + } + + /// The triple associated for the target. + pub fn triple(&self) -> &Triple { + &self.triple + } + + /// The triple associated for the target. + pub fn cpu_features(&self) -> &EnumSet { + &self.cpu_features + } +} + +/// The default for the Target will use the HOST as the triple +impl Default for Target { + fn default() -> Self { + Self { + triple: Triple::host(), + cpu_features: CpuFeature::for_host(), + } + } +} diff --git a/runtime/near-vm/lib/compiler/src/translator/environ.rs b/runtime/near-vm/lib/compiler/src/translator/environ.rs new file mode 100644 index 00000000000..529b8007769 --- /dev/null +++ b/runtime/near-vm/lib/compiler/src/translator/environ.rs @@ -0,0 +1,426 @@ +// This file contains code from external sources. +// Attributions: https://github.com/wasmerio/wasmer/blob/master/ATTRIBUTIONS.md +use super::state::ModuleTranslationState; +use crate::lib::std::borrow::ToOwned; +use crate::lib::std::string::ToString; +use crate::lib::std::{boxed::Box, string::String, vec::Vec}; +use crate::translate_module; +use crate::{WasmError, WasmResult}; +use std::convert::{TryFrom, TryInto}; +use std::sync::Arc; +use wasmer_types::entity::PrimaryMap; +use wasmer_types::FunctionType; +use wasmer_types::{ + CustomSectionIndex, DataIndex, DataInitializer, DataInitializerLocation, ElemIndex, + ExportIndex, FunctionIndex, GlobalIndex, GlobalInit, GlobalType, ImportIndex, + LocalFunctionIndex, MemoryIndex, MemoryType, ModuleInfo, OwnedTableInitializer, SignatureIndex, + TableIndex, TableType, +}; +pub use wasmparser::FunctionBody as FunctionReader; + +/// Contains function data: bytecode and its offset in the module. +#[derive(Hash)] +pub struct FunctionBodyData<'a> { + /// Function body bytecode. + pub data: &'a [u8], + + /// Body offset relative to the module file. + pub module_offset: usize, +} + +/// The result of translating via `ModuleEnvironment`. Function bodies are not +/// yet translated, and data initializers have not yet been copied out of the +/// original buffer. +/// The function bodies will be translated by a specific compiler backend. +pub struct ModuleEnvironment<'data> { + /// ModuleInfo information. + pub module: ModuleInfo, + + /// References to the function bodies. + pub function_body_inputs: PrimaryMap>, + + /// References to the data initializers. + pub data_initializers: Vec>, + + /// The decoded Wasm types for the module. + pub module_translation_state: Option, +} + +impl<'data> ModuleEnvironment<'data> { + /// Allocates the environment data structures. + pub fn new() -> Self { + Self { + module: ModuleInfo::new(), + function_body_inputs: PrimaryMap::new(), + data_initializers: Vec::new(), + module_translation_state: None, + } + } + + /// Translate a wasm module using this environment. This consumes the + /// `ModuleEnvironment` and produces a `ModuleInfoTranslation`. + #[tracing::instrument(skip_all)] + pub fn translate(mut self, data: &'data [u8]) -> WasmResult> { + assert!(self.module_translation_state.is_none()); + let module_translation_state = translate_module(data, &mut self)?; + self.module_translation_state = Some(module_translation_state); + Ok(self) + } + + pub(crate) fn declare_export(&mut self, export: ExportIndex, name: &str) -> WasmResult<()> { + self.module.exports.insert(String::from(name), export); + Ok(()) + } + + pub(crate) fn declare_import( + &mut self, + import: ImportIndex, + module: &str, + field: &str, + ) -> WasmResult<()> { + self.module.imports.insert( + ( + String::from(module), + String::from(field), + self.module.imports.len().try_into().unwrap(), + ), + import, + ); + Ok(()) + } + + pub(crate) fn reserve_signatures(&mut self, num: u32) -> WasmResult<()> { + self.module + .signatures + .reserve_exact(usize::try_from(num).unwrap()); + Ok(()) + } + + pub(crate) fn declare_signature(&mut self, sig: FunctionType) -> WasmResult<()> { + // TODO: Deduplicate signatures. + self.module.signatures.push(sig); + Ok(()) + } + + pub(crate) fn declare_func_import( + &mut self, + sig_index: SignatureIndex, + module: &str, + field: &str, + ) -> WasmResult<()> { + debug_assert_eq!( + self.module.functions.len(), + self.module.import_counts.functions as usize, + "Imported functions must be declared first" + ); + self.declare_import( + ImportIndex::Function(FunctionIndex::from_u32(self.module.import_counts.functions)), + module, + field, + )?; + self.module.functions.push(sig_index); + self.module.import_counts.functions += 1; + Ok(()) + } + + pub(crate) fn declare_table_import( + &mut self, + table: TableType, + module: &str, + field: &str, + ) -> WasmResult<()> { + debug_assert_eq!( + self.module.tables.len(), + self.module.import_counts.tables as usize, + "Imported tables must be declared first" + ); + self.declare_import( + ImportIndex::Table(TableIndex::from_u32(self.module.import_counts.tables)), + module, + field, + )?; + self.module.tables.push(table); + self.module.import_counts.tables += 1; + Ok(()) + } + + pub(crate) fn declare_memory_import( + &mut self, + memory: MemoryType, + module: &str, + field: &str, + ) -> WasmResult<()> { + debug_assert_eq!( + self.module.memories.len(), + self.module.import_counts.memories as usize, + "Imported memories must be declared first" + ); + self.declare_import( + ImportIndex::Memory(MemoryIndex::from_u32(self.module.import_counts.memories)), + module, + field, + )?; + self.module.memories.push(memory); + self.module.import_counts.memories += 1; + Ok(()) + } + + pub(crate) fn declare_global_import( + &mut self, + global: GlobalType, + module: &str, + field: &str, + ) -> WasmResult<()> { + debug_assert_eq!( + self.module.globals.len(), + self.module.import_counts.globals as usize, + "Imported globals must be declared first" + ); + self.declare_import( + ImportIndex::Global(GlobalIndex::from_u32(self.module.import_counts.globals)), + module, + field, + )?; + self.module.globals.push(global); + self.module.import_counts.globals += 1; + Ok(()) + } + + pub(crate) fn finish_imports(&mut self) -> WasmResult<()> { + Ok(()) + } + + pub(crate) fn reserve_func_types(&mut self, num: u32) -> WasmResult<()> { + self.module + .functions + .reserve_exact(usize::try_from(num).unwrap()); + self.function_body_inputs + .reserve_exact(usize::try_from(num).unwrap()); + Ok(()) + } + + pub(crate) fn declare_func_type(&mut self, sig_index: SignatureIndex) -> WasmResult<()> { + self.module.functions.push(sig_index); + Ok(()) + } + + pub(crate) fn reserve_tables(&mut self, num: u32) -> WasmResult<()> { + self.module + .tables + .reserve_exact(usize::try_from(num).unwrap()); + Ok(()) + } + + pub(crate) fn declare_table(&mut self, table: TableType) -> WasmResult<()> { + self.module.tables.push(table); + Ok(()) + } + + pub(crate) fn reserve_memories(&mut self, num: u32) -> WasmResult<()> { + self.module + .memories + .reserve_exact(usize::try_from(num).unwrap()); + Ok(()) + } + + pub(crate) fn declare_memory(&mut self, memory: MemoryType) -> WasmResult<()> { + if memory.shared { + return Err(WasmError::Unsupported( + "shared memories are not supported yet".to_owned(), + )); + } + self.module.memories.push(memory); + Ok(()) + } + + pub(crate) fn reserve_globals(&mut self, num: u32) -> WasmResult<()> { + self.module + .globals + .reserve_exact(usize::try_from(num).unwrap()); + Ok(()) + } + + pub(crate) fn declare_global( + &mut self, + global: GlobalType, + initializer: GlobalInit, + ) -> WasmResult<()> { + self.module.globals.push(global); + self.module.global_initializers.push(initializer); + Ok(()) + } + + pub(crate) fn reserve_exports(&mut self, num: u32) -> WasmResult<()> { + self.module.exports.reserve(usize::try_from(num).unwrap()); + Ok(()) + } + + pub(crate) fn declare_func_export( + &mut self, + func_index: FunctionIndex, + name: &str, + ) -> WasmResult<()> { + self.declare_export(ExportIndex::Function(func_index), name) + } + + pub(crate) fn declare_table_export( + &mut self, + table_index: TableIndex, + name: &str, + ) -> WasmResult<()> { + self.declare_export(ExportIndex::Table(table_index), name) + } + + pub(crate) fn declare_memory_export( + &mut self, + memory_index: MemoryIndex, + name: &str, + ) -> WasmResult<()> { + self.declare_export(ExportIndex::Memory(memory_index), name) + } + + pub(crate) fn declare_global_export( + &mut self, + global_index: GlobalIndex, + name: &str, + ) -> WasmResult<()> { + self.declare_export(ExportIndex::Global(global_index), name) + } + + pub(crate) fn declare_start_function(&mut self, func_index: FunctionIndex) -> WasmResult<()> { + debug_assert!(self.module.start_function.is_none()); + self.module.start_function = Some(func_index); + Ok(()) + } + + pub(crate) fn reserve_table_initializers(&mut self, num: u32) -> WasmResult<()> { + self.module + .table_initializers + .reserve_exact(usize::try_from(num).unwrap()); + Ok(()) + } + + pub(crate) fn declare_table_initializers( + &mut self, + table_index: TableIndex, + base: Option, + offset: usize, + elements: Box<[FunctionIndex]>, + ) -> WasmResult<()> { + self.module.table_initializers.push(OwnedTableInitializer { + table_index, + base, + offset, + elements, + }); + Ok(()) + } + + pub(crate) fn declare_passive_element( + &mut self, + elem_index: ElemIndex, + segments: Box<[FunctionIndex]>, + ) -> WasmResult<()> { + let old = self.module.passive_elements.insert(elem_index, segments); + debug_assert!( + old.is_none(), + "should never get duplicate element indices, that would be a bug in `wasmer_compiler`'s \ + translation" + ); + Ok(()) + } + + pub(crate) fn define_function_body( + &mut self, + _module_translation_state: &ModuleTranslationState, + body_bytes: &'data [u8], + body_offset: usize, + ) -> WasmResult<()> { + self.function_body_inputs.push(FunctionBodyData { + data: body_bytes, + module_offset: body_offset, + }); + Ok(()) + } + + pub(crate) fn reserve_data_initializers(&mut self, num: u32) -> WasmResult<()> { + self.data_initializers + .reserve_exact(usize::try_from(num).unwrap()); + Ok(()) + } + + pub(crate) fn declare_data_initialization( + &mut self, + memory_index: MemoryIndex, + base: Option, + offset: usize, + data: &'data [u8], + ) -> WasmResult<()> { + self.data_initializers.push(DataInitializer { + location: DataInitializerLocation { + memory_index, + base, + offset, + }, + data, + }); + Ok(()) + } + + pub(crate) fn reserve_passive_data(&mut self, _count: u32) -> WasmResult<()> { + // TODO(0-copy): consider finding a more appropriate data structure for this? + Ok(()) + } + + pub(crate) fn declare_passive_data( + &mut self, + data_index: DataIndex, + data: &'data [u8], + ) -> WasmResult<()> { + let old = self.module.passive_data.insert(data_index, Arc::from(data)); + debug_assert!( + old.is_none(), + "a module can't have duplicate indices, this would be a wasmer-compiler bug" + ); + Ok(()) + } + + pub(crate) fn declare_module_name(&mut self, name: &'data str) -> WasmResult<()> { + self.module.name = Some(name.to_string()); + Ok(()) + } + + pub(crate) fn declare_function_name( + &mut self, + func_index: FunctionIndex, + name: &'data str, + ) -> WasmResult<()> { + self.module + .function_names + .insert(func_index, name.to_string()); + Ok(()) + } + + /// Provides the number of imports up front. By default this does nothing, but + /// implementations can use this to preallocate memory if desired. + pub(crate) fn reserve_imports(&mut self, _num: u32) -> WasmResult<()> { + Ok(()) + } + + /// Notifies the implementation that all exports have been declared. + pub(crate) fn finish_exports(&mut self) -> WasmResult<()> { + Ok(()) + } + + /// Indicates that a custom section has been found in the wasm file + pub(crate) fn custom_section(&mut self, name: &'data str, data: &'data [u8]) -> WasmResult<()> { + let custom_section = CustomSectionIndex::from_u32( + self.module.custom_sections_data.len().try_into().unwrap(), + ); + self.module + .custom_sections + .insert(String::from(name), custom_section); + self.module.custom_sections_data.push(Arc::from(data)); + Ok(()) + } +} diff --git a/runtime/near-vm/lib/compiler/src/translator/error.rs b/runtime/near-vm/lib/compiler/src/translator/error.rs new file mode 100644 index 00000000000..e61e88c3883 --- /dev/null +++ b/runtime/near-vm/lib/compiler/src/translator/error.rs @@ -0,0 +1,58 @@ +use crate::{CompileError, WasmError}; +use wasmparser::BinaryReaderError; + +/// Return an `Err(WasmError::Unsupported(msg))` where `msg` the string built by calling `format!` +/// on the arguments to this macro. +#[macro_export] +macro_rules! wasm_unsupported { + ($($arg:tt)*) => { $crate::WasmError::Unsupported(format!($($arg)*)) } +} + +impl From for WasmError { + fn from(original: BinaryReaderError) -> Self { + Self::InvalidWebAssembly { + message: original.message().into(), + offset: original.offset(), + } + } +} + +impl From for CompileError { + fn from(original: BinaryReaderError) -> Self { + // `From` does not seem to be transitive by default, so we convert + // BinaryReaderError -> WasmError -> CompileError + Self::from(WasmError::from(original)) + } +} + +#[cfg(test)] +mod tests { + use super::*; + use wasmparser::BinaryReader; + + #[test] + fn can_convert_binary_reader_error_to_wasm_error() { + let mut reader = BinaryReader::new(b"\0\0\0\0"); + let binary_reader_error = reader.read_bytes(10).unwrap_err(); + match WasmError::from(binary_reader_error) { + WasmError::InvalidWebAssembly { message, offset } => { + assert_eq!(message, "unexpected end-of-file"); + assert_eq!(offset, 0); + } + err => panic!("Unexpected error: {:?}", err), + } + } + + #[test] + fn can_convert_binary_reader_error_to_compile_error() { + let mut reader = BinaryReader::new(b"\0\0\0\0"); + let binary_reader_error = reader.read_bytes(10).unwrap_err(); + match CompileError::from(binary_reader_error) { + CompileError::Wasm(WasmError::InvalidWebAssembly { message, offset }) => { + assert_eq!(message, "unexpected end-of-file"); + assert_eq!(offset, 0); + } + err => panic!("Unexpected error: {:?}", err), + } + } +} diff --git a/runtime/near-vm/lib/compiler/src/translator/mod.rs b/runtime/near-vm/lib/compiler/src/translator/mod.rs new file mode 100644 index 00000000000..186ef97e334 --- /dev/null +++ b/runtime/near-vm/lib/compiler/src/translator/mod.rs @@ -0,0 +1,18 @@ +//! This module defines the parser and translator from wasmparser +//! to a common structure `ModuleInfo`. +//! +//! It's derived from [cranelift-wasm] but architected for multiple +//! compilers rather than just Cranelift. +//! +//! [cranelift-wasm]: https://crates.io/crates/cranelift-wasm/ +mod environ; +mod module; +mod state; +#[macro_use] +mod error; +mod sections; + +pub use self::environ::{FunctionBodyData, FunctionReader, ModuleEnvironment}; +pub use self::module::translate_module; +pub use self::sections::wptype_to_type; +pub use self::state::ModuleTranslationState; diff --git a/runtime/near-vm/lib/compiler/src/translator/module.rs b/runtime/near-vm/lib/compiler/src/translator/module.rs new file mode 100644 index 00000000000..84ba7968385 --- /dev/null +++ b/runtime/near-vm/lib/compiler/src/translator/module.rs @@ -0,0 +1,140 @@ +// This file contains code from external sources. +// Attributions: https://github.com/wasmerio/wasmer/blob/master/ATTRIBUTIONS.md + +//! Translation skeleton that traverses the whole WebAssembly module and call helper functions +//! to deal with each part of it. +use super::environ::ModuleEnvironment; +use super::sections::{ + parse_data_section, parse_element_section, parse_export_section, parse_function_section, + parse_global_section, parse_import_section, parse_memory_section, parse_name_section, + parse_start_section, parse_table_section, parse_type_section, +}; +use super::state::ModuleTranslationState; +use crate::WasmResult; +use wasmparser::{NameSectionReader, Parser, Payload}; + +/// Translate a sequence of bytes forming a valid Wasm binary into a +/// parsed ModuleInfo `ModuleTranslationState`. +#[tracing::instrument(skip_all)] +pub fn translate_module<'data>( + data: &'data [u8], + environ: &mut ModuleEnvironment<'data>, +) -> WasmResult { + let mut module_translation_state = ModuleTranslationState::new(); + + for payload in Parser::new(0).parse_all(data) { + match payload? { + Payload::Version { .. } | Payload::End(_) => {} + + Payload::TypeSection(types) => { + parse_type_section(types, &mut module_translation_state, environ)?; + } + + Payload::ImportSection(imports) => { + parse_import_section(imports, environ)?; + } + + Payload::FunctionSection(functions) => { + parse_function_section(functions, environ)?; + } + + Payload::TableSection(tables) => { + parse_table_section(tables, environ)?; + } + + Payload::MemorySection(memories) => { + parse_memory_section(memories, environ)?; + } + + Payload::GlobalSection(globals) => { + parse_global_section(globals, environ)?; + } + + Payload::ExportSection(exports) => { + parse_export_section(exports, environ)?; + } + + Payload::StartSection { func, .. } => { + parse_start_section(func, environ)?; + } + + Payload::ElementSection(elements) => { + parse_element_section(elements, environ)?; + } + + Payload::CodeSectionStart { .. } => {} + Payload::CodeSectionEntry(code) => { + let mut code = code.get_binary_reader(); + let size = code.bytes_remaining(); + let offset = code.original_position(); + environ.define_function_body( + &module_translation_state, + code.read_bytes(size)?, + offset, + )?; + } + + Payload::DataSection(data) => { + parse_data_section(data, environ)?; + } + + Payload::DataCountSection { count, .. } => { + environ.reserve_passive_data(count)?; + } + + Payload::InstanceSection(_) => { + unimplemented!("module linking not implemented yet") + } + + Payload::TagSection(_) => { + unimplemented!("exception handling proposal is not implemented yet") + } + + Payload::CustomSection(reader) => { + if reader.name() == "name" { + parse_name_section( + NameSectionReader::new(reader.data(), reader.data_offset()), + environ, + )?; + } else { + environ.custom_section(reader.name(), reader.data())?; + } + } + + Payload::ModuleSection { .. } => unimplemented!("module sections not supported yet"), // which proposal is this coming from? + Payload::CoreTypeSection { .. } => { + unimplemented!("component proposal is not implemented yet") + } + Payload::ComponentSection { .. } => { + unimplemented!("component proposal is not implemented yet") + } + Payload::ComponentInstanceSection { .. } => { + unimplemented!("component proposal is not implemented yet") + } + Payload::ComponentAliasSection { .. } => { + unimplemented!("component proposal is not implemented yet") + } + Payload::ComponentTypeSection { .. } => { + unimplemented!("component proposal is not implemented yet") + } + Payload::ComponentCanonicalSection { .. } => { + unimplemented!("component proposal is not implemented yet") + } + Payload::ComponentStartSection { .. } => { + unimplemented!("component proposal is not implemented yet") + } + Payload::ComponentImportSection { .. } => { + unimplemented!("component proposal is not implemented yet") + } + Payload::ComponentExportSection { .. } => { + unimplemented!("component proposal is not implemented yet") + } + + Payload::UnknownSection { .. } => unreachable!(), + } + } + + module_translation_state.build_import_map(&environ.module); + + Ok(module_translation_state) +} diff --git a/runtime/near-vm/lib/compiler/src/translator/sections.rs b/runtime/near-vm/lib/compiler/src/translator/sections.rs new file mode 100644 index 00000000000..c0324b1a4ce --- /dev/null +++ b/runtime/near-vm/lib/compiler/src/translator/sections.rs @@ -0,0 +1,480 @@ +// This file contains code from external sources. +// Attributions: https://github.com/wasmerio/wasmer/blob/master/ATTRIBUTIONS.md + +//! Helper functions to gather information for each of the non-function sections of a +//! WebAssembly module. +//! +//! The code of these helper functions is straightforward since they only read metadata +//! about linear memories, tables, globals, etc. and store them for later use. +//! +//! The special case of the initialize expressions for table elements offsets or global variables +//! is handled, according to the semantics of WebAssembly, to only specific expressions that are +//! interpreted on the fly. +use super::environ::ModuleEnvironment; +use super::state::ModuleTranslationState; +use crate::wasm_unsupported; +use crate::{WasmError, WasmResult}; +use core::convert::TryFrom; +use std::boxed::Box; +use std::collections::HashMap; +use std::convert::TryInto; +use std::sync::Arc; +use std::vec::Vec; +use wasmer_types::entity::packed_option::ReservedValue; +use wasmer_types::entity::EntityRef; +use wasmer_types::{ + DataIndex, ElemIndex, FunctionIndex, FunctionType, GlobalIndex, GlobalInit, GlobalType, + MemoryIndex, MemoryType, Mutability, Pages, SignatureIndex, TableIndex, TableType, Type, V128, +}; +use wasmparser::{ + self, Data, DataKind, DataSectionReader, Element, ElementItems, ElementKind, + ElementSectionReader, Export, ExportSectionReader, ExternalKind, FunctionSectionReader, + GlobalSectionReader, GlobalType as WPGlobalType, ImportSectionReader, MemorySectionReader, + NameMap, NameSectionReader, Naming, Operator, TableSectionReader, Type as WPType, TypeRef, + TypeSectionReader, ValType as WPValType, +}; + +/// Helper function translating wasmparser types to Wasm Type. +pub fn wptype_to_type(ty: WPValType) -> WasmResult { + match ty { + WPValType::I32 => Ok(Type::I32), + WPValType::I64 => Ok(Type::I64), + WPValType::F32 => Ok(Type::F32), + WPValType::F64 => Ok(Type::F64), + WPValType::V128 => Ok(Type::V128), + WPValType::ExternRef => Ok(Type::ExternRef), + WPValType::FuncRef => Ok(Type::FuncRef), + } +} + +/// Parses the Type section of the wasm module. +pub fn parse_type_section( + types: TypeSectionReader, + module_translation_state: &mut ModuleTranslationState, + environ: &mut ModuleEnvironment, +) -> WasmResult<()> { + let count = types.count(); + environ.reserve_signatures(count)?; + + for entry in types { + if let Ok(WPType::Func(t)) = entry { + let params: Box<[WPValType]> = t.params().into(); + let results: Box<[WPValType]> = t.results().into(); + let sig_params: Arc<[Type]> = params + .iter() + .map(|ty| { + wptype_to_type(*ty) + .expect("only numeric types are supported in function signatures") + }) + .collect(); + let sig_results: Arc<[Type]> = results + .iter() + .map(|ty| { + wptype_to_type(*ty) + .expect("only numeric types are supported in function signatures") + }) + .collect(); + let sig = FunctionType::new(sig_params, sig_results); + environ.declare_signature(sig)?; + module_translation_state.wasm_types.push((params, results)); + } else { + unimplemented!("module linking not implemented yet") + } + } + + Ok(()) +} + +/// Parses the Import section of the wasm module. +pub fn parse_import_section<'data>( + imports: ImportSectionReader<'data>, + environ: &mut ModuleEnvironment<'data>, +) -> WasmResult<()> { + environ.reserve_imports(imports.count())?; + + for entry in imports { + let import = entry?; + let module_name = import.module; + let field_name = import.name; + + match import.ty { + TypeRef::Func(sig) => { + environ.declare_func_import( + SignatureIndex::from_u32(sig), + module_name, + field_name, + )?; + } + TypeRef::Memory(mem) => { + assert!(!mem.memory64, "64bit memory not implemented yet"); + environ.declare_memory_import( + MemoryType { + minimum: Pages(mem.initial.try_into().unwrap()), + maximum: mem.maximum.map(|m| Pages(m.try_into().unwrap())), + shared: mem.shared, + }, + module_name, + field_name, + )?; + } + TypeRef::Global(ref ty) => { + environ.declare_global_import( + GlobalType { + ty: wptype_to_type(ty.content_type).unwrap(), + mutability: if ty.mutable { + Mutability::Var + } else { + Mutability::Const + }, + }, + module_name, + field_name, + )?; + } + TypeRef::Table(ref tab) => { + environ.declare_table_import( + TableType { + ty: wptype_to_type(tab.element_type).unwrap(), + minimum: tab.initial, + maximum: tab.maximum, + }, + module_name, + field_name, + )?; + } + TypeRef::Tag(_) => panic!("exception handling proposal is not implemented yet"), + } + } + + environ.finish_imports()?; + Ok(()) +} + +/// Parses the Function section of the wasm module. +pub fn parse_function_section( + functions: FunctionSectionReader, + environ: &mut ModuleEnvironment, +) -> WasmResult<()> { + let num_functions = functions.count(); + if num_functions == std::u32::MAX { + // We reserve `u32::MAX` for our own use. + return Err(WasmError::ImplLimitExceeded); + } + + environ.reserve_func_types(num_functions)?; + + for entry in functions { + let sigindex = entry?; + environ.declare_func_type(SignatureIndex::from_u32(sigindex))?; + } + + Ok(()) +} + +/// Parses the Table section of the wasm module. +pub fn parse_table_section( + tables: TableSectionReader, + environ: &mut ModuleEnvironment, +) -> WasmResult<()> { + environ.reserve_tables(tables.count())?; + + for entry in tables { + let table = entry?; + environ.declare_table(TableType { + ty: wptype_to_type(table.element_type).unwrap(), + minimum: table.initial, + maximum: table.maximum, + })?; + } + + Ok(()) +} + +/// Parses the Memory section of the wasm module. +pub fn parse_memory_section( + memories: MemorySectionReader, + environ: &mut ModuleEnvironment, +) -> WasmResult<()> { + environ.reserve_memories(memories.count())?; + + for entry in memories { + let mem = entry?; + assert!(!mem.memory64, "64bit memory not implemented yet"); + + environ.declare_memory(MemoryType { + minimum: Pages(mem.initial.try_into().unwrap()), + maximum: mem.maximum.map(|m| Pages(m.try_into().unwrap())), + shared: mem.shared, + })?; + } + + Ok(()) +} + +/// Parses the Global section of the wasm module. +pub fn parse_global_section( + globals: GlobalSectionReader, + environ: &mut ModuleEnvironment, +) -> WasmResult<()> { + environ.reserve_globals(globals.count())?; + + for entry in globals { + let wasmparser::Global { + ty: WPGlobalType { + content_type, + mutable, + }, + init_expr, + } = entry?; + let mut init_expr_reader = init_expr.get_binary_reader(); + let initializer = match init_expr_reader.read_operator()? { + Operator::I32Const { value } => GlobalInit::I32Const(value), + Operator::I64Const { value } => GlobalInit::I64Const(value), + Operator::F32Const { value } => GlobalInit::F32Const(f32::from_bits(value.bits())), + Operator::F64Const { value } => GlobalInit::F64Const(f64::from_bits(value.bits())), + Operator::V128Const { value } => GlobalInit::V128Const(V128::from(*value.bytes())), + Operator::RefNull { ty: _ } => GlobalInit::RefNullConst, + Operator::RefFunc { function_index } => { + GlobalInit::RefFunc(FunctionIndex::from_u32(function_index)) + } + Operator::GlobalGet { global_index } => { + GlobalInit::GetGlobal(GlobalIndex::from_u32(global_index)) + } + ref s => { + return Err(wasm_unsupported!( + "unsupported init expr in global section: {:?}", + s + )); + } + }; + let global = GlobalType { + ty: wptype_to_type(content_type).unwrap(), + mutability: if mutable { + Mutability::Var + } else { + Mutability::Const + }, + }; + environ.declare_global(global, initializer)?; + } + + Ok(()) +} + +/// Parses the Export section of the wasm module. +pub fn parse_export_section<'data>( + exports: ExportSectionReader<'data>, + environ: &mut ModuleEnvironment<'data>, +) -> WasmResult<()> { + environ.reserve_exports(exports.count())?; + + for entry in exports { + let Export { + name, + ref kind, + index, + } = entry?; + + // The input has already been validated, so we should be able to + // assume valid UTF-8 and use `from_utf8_unchecked` if performance + // becomes a concern here. + let index = index as usize; + match *kind { + ExternalKind::Func => environ.declare_func_export(FunctionIndex::new(index), name)?, + ExternalKind::Table => environ.declare_table_export(TableIndex::new(index), name)?, + ExternalKind::Memory => environ.declare_memory_export(MemoryIndex::new(index), name)?, + ExternalKind::Global => environ.declare_global_export(GlobalIndex::new(index), name)?, + ExternalKind::Tag => panic!("exception handling proposal is not implemented yet"), + } + } + + environ.finish_exports()?; + Ok(()) +} + +/// Parses the Start section of the wasm module. +pub fn parse_start_section(index: u32, environ: &mut ModuleEnvironment) -> WasmResult<()> { + environ.declare_start_function(FunctionIndex::from_u32(index))?; + Ok(()) +} + +fn read_elems(items: &ElementItems) -> WasmResult> { + match items.clone() { + ElementItems::Functions(items) => items + .into_iter() + .map(|v| v.map(FunctionIndex::from_u32).map_err(WasmError::from)) + .collect(), + ElementItems::Expressions(items) => { + let mut elems = Vec::with_capacity(usize::try_from(items.count()).unwrap()); + for item in items.into_iter() { + let mut reader = item?.get_operators_reader(); + let op = reader.read()?; + let end = reader.read()?; + reader.ensure_end()?; + use Operator::*; + match (op, end) { + (RefFunc { function_index }, End) => { + elems.push(FunctionIndex::from_u32(function_index)) + } + (RefNull { .. }, End) => elems.push(FunctionIndex::reserved_value()), + _ => todo!("unexpected syntax for elems item initializer"), + } + } + Ok(elems.into_boxed_slice()) + } + } +} + +/// Parses the Element section of the wasm module. +pub fn parse_element_section<'data>( + elements: ElementSectionReader<'data>, + environ: &mut ModuleEnvironment, +) -> WasmResult<()> { + environ.reserve_table_initializers(elements.count())?; + + for (index, entry) in elements.into_iter().enumerate() { + let Element { + kind, items, ty, .. + } = entry?; + if ty != WPValType::FuncRef { + return Err(wasm_unsupported!( + "unsupported table element type: {:?}", + ty + )); + } + let segments = read_elems(&items)?; + match kind { + ElementKind::Active { + table_index, + offset_expr, + } => { + let mut offset_expr_reader = offset_expr.get_binary_reader(); + let (base, offset) = match offset_expr_reader.read_operator()? { + Operator::I32Const { value } => (None, value as u32 as usize), + Operator::GlobalGet { global_index } => { + (Some(GlobalIndex::from_u32(global_index)), 0) + } + ref s => { + return Err(wasm_unsupported!( + "unsupported init expr in element section: {:?}", + s + )); + } + }; + environ.declare_table_initializers( + TableIndex::from_u32(table_index), + base, + offset, + segments, + )? + } + ElementKind::Passive => { + let index = ElemIndex::from_u32(index as u32); + environ.declare_passive_element(index, segments)?; + } + ElementKind::Declared => (), + } + } + Ok(()) +} + +/// Parses the Data section of the wasm module. +pub fn parse_data_section<'data>( + data: DataSectionReader<'data>, + environ: &mut ModuleEnvironment<'data>, +) -> WasmResult<()> { + environ.reserve_data_initializers(data.count())?; + + for (index, entry) in data.into_iter().enumerate() { + let Data { kind, data, .. } = entry?; + match kind { + DataKind::Active { + memory_index, + offset_expr, + } => { + let mut offset_expr_reader = offset_expr.get_binary_reader(); + let (base, offset) = match offset_expr_reader.read_operator()? { + Operator::I32Const { value } => (None, value as u32 as usize), + Operator::GlobalGet { global_index } => { + (Some(GlobalIndex::from_u32(global_index)), 0) + } + ref s => { + return Err(wasm_unsupported!( + "unsupported init expr in data section: {:?}", + s + )) + } + }; + environ.declare_data_initialization( + MemoryIndex::from_u32(memory_index), + base, + offset, + data, + )?; + } + DataKind::Passive => { + let index = DataIndex::from_u32(index as u32); + environ.declare_passive_data(index, data)?; + } + } + } + + Ok(()) +} + +/// Parses the Name section of the wasm module. +pub fn parse_name_section<'data>( + mut names: NameSectionReader<'data>, + environ: &mut ModuleEnvironment<'data>, +) -> WasmResult<()> { + use wasmparser::Name; + while let Some(subsection) = names.next() { + let subsection = subsection?; + match subsection { + Name::Function(function_subsection) => { + if let Some(function_names) = parse_function_name_subsection(function_subsection) { + for (index, name) in function_names { + environ.declare_function_name(index, name)?; + } + } + } + Name::Module { name, .. } => { + environ.declare_module_name(name)?; + } + Name::Local(_) => {} + Name::Label(_) => {} + Name::Type(_) => {} + Name::Table(_) => {} + Name::Memory(_) => {} + Name::Global(_) => {} + Name::Element(_) => {} + Name::Data(_) => {} + Name::Unknown { .. } => {} + }; + } + Ok(()) +} + +fn parse_function_name_subsection( + naming_reader: NameMap<'_>, +) -> Option> { + let mut function_names = HashMap::new(); + for name in naming_reader.into_iter() { + let Naming { index, name } = name.ok()?; + if index == std::u32::MAX { + // We reserve `u32::MAX` for our own use. + return None; + } + + if function_names + .insert(FunctionIndex::from_u32(index), name) + .is_some() + { + // If the function index has been previously seen, then we + // break out of the loop and early return `None`, because these + // should be unique. + return None; + } + } + Some(function_names) +} diff --git a/runtime/near-vm/lib/compiler/src/translator/state.rs b/runtime/near-vm/lib/compiler/src/translator/state.rs new file mode 100644 index 00000000000..032627e6c18 --- /dev/null +++ b/runtime/near-vm/lib/compiler/src/translator/state.rs @@ -0,0 +1,55 @@ +// This file contains code from external sources. +// Attributions: https://github.com/wasmerio/wasmer/blob/master/ATTRIBUTIONS.md + +use std::boxed::Box; +use std::collections::HashMap; +use wasmer_types::entity::PrimaryMap; +use wasmer_types::{FunctionIndex, ImportIndex, ModuleInfo, SignatureIndex}; + +/// Map of signatures to a function's parameter and return types. +pub(crate) type WasmTypes = + PrimaryMap, Box<[wasmparser::ValType]>)>; + +/// Contains information decoded from the Wasm module that must be referenced +/// during each Wasm function's translation. +/// +/// This is only for data that is maintained by `wasmer-compiler` itself, as +/// opposed to being maintained by the embedder. Data that is maintained by the +/// embedder is represented with `ModuleEnvironment`. +#[derive(Debug)] +pub struct ModuleTranslationState { + /// A map containing a Wasm module's original, raw signatures. + /// + /// This is used for translating multi-value Wasm blocks inside functions, + /// which are encoded to refer to their type signature via index. + pub(crate) wasm_types: WasmTypes, + + /// Imported functions names map. + pub import_map: HashMap, +} + +impl ModuleTranslationState { + /// Creates a new empty ModuleTranslationState. + pub fn new() -> Self { + Self { + wasm_types: PrimaryMap::new(), + import_map: HashMap::new(), + } + } + + /// Build map of imported functions names for intrinsification. + #[tracing::instrument(skip_all)] + pub fn build_import_map(&mut self, module: &ModuleInfo) { + for key in module.imports.keys() { + let value = &module.imports[key]; + match value { + ImportIndex::Function(index) => { + self.import_map.insert(*index, key.1.clone()); + } + _ => { + // Non-function import. + } + } + } + } +} diff --git a/runtime/near-vm/lib/compiler/src/trap.rs b/runtime/near-vm/lib/compiler/src/trap.rs new file mode 100644 index 00000000000..7b0f1ae9a58 --- /dev/null +++ b/runtime/near-vm/lib/compiler/src/trap.rs @@ -0,0 +1,11 @@ +use crate::CodeOffset; +use wasmer_vm::TrapCode; + +/// Information about trap. +#[derive(rkyv::Serialize, rkyv::Deserialize, rkyv::Archive, Clone, Debug, PartialEq, Eq)] +pub struct TrapInformation { + /// The offset of the trapping instruction in native code. It is relative to the beginning of the function. + pub code_offset: CodeOffset, + /// Code of the trap. + pub trap_code: TrapCode, +} diff --git a/runtime/near-vm/lib/compiler/src/unwind.rs b/runtime/near-vm/lib/compiler/src/unwind.rs new file mode 100644 index 00000000000..903cfd4bd6c --- /dev/null +++ b/runtime/near-vm/lib/compiler/src/unwind.rs @@ -0,0 +1,55 @@ +//! A `CompiledFunctionUnwindInfo` contains the function unwind information. +//! +//! The unwind information is used to determine which function +//! called the function that threw the exception, and which +//! function called that one, and so forth. +//! +//! [Learn more](https://en.wikipedia.org/wiki/Call_stack). +use crate::lib::std::vec::Vec; + +/// Compiled function unwind information. +/// +/// > Note: Windows OS have a different way of representing the [unwind info], +/// > That's why we keep the Windows data and the Unix frame layout in different +/// > fields. +/// +/// [unwind info]: https://docs.microsoft.com/en-us/cpp/build/exception-handling-x64?view=vs-2019 +#[derive(rkyv::Serialize, rkyv::Deserialize, rkyv::Archive, Debug, Clone, PartialEq, Eq)] +pub enum CompiledFunctionUnwindInfo { + /// Windows UNWIND_INFO. + WindowsX64(Vec), + + /// The unwind info is added to the Dwarf section in `Compilation`. + Dwarf, +} + +/// See [`CompiledFunctionUnwindInfo`]. +#[derive(Clone, Copy)] +pub enum CompiledFunctionUnwindInfoRef<'a> { + /// Windows UNWIND_INFO. + WindowsX64(&'a [u8]), + /// Unwind info is added to the Dwarf section in `Compilation`. + Dwarf, +} + +impl<'a> From<&'a CompiledFunctionUnwindInfo> for CompiledFunctionUnwindInfoRef<'a> { + fn from(uw: &'a CompiledFunctionUnwindInfo) -> Self { + match uw { + CompiledFunctionUnwindInfo::WindowsX64(d) => { + CompiledFunctionUnwindInfoRef::WindowsX64(d) + } + CompiledFunctionUnwindInfo::Dwarf => CompiledFunctionUnwindInfoRef::Dwarf, + } + } +} + +impl<'a> From<&'a ArchivedCompiledFunctionUnwindInfo> for CompiledFunctionUnwindInfoRef<'a> { + fn from(uw: &'a ArchivedCompiledFunctionUnwindInfo) -> Self { + match uw { + ArchivedCompiledFunctionUnwindInfo::WindowsX64(d) => { + CompiledFunctionUnwindInfoRef::WindowsX64(d) + } + ArchivedCompiledFunctionUnwindInfo::Dwarf => CompiledFunctionUnwindInfoRef::Dwarf, + } + } +} diff --git a/runtime/near-vm/lib/engine-universal/Cargo.toml b/runtime/near-vm/lib/engine-universal/Cargo.toml new file mode 100644 index 00000000000..6b11aa667d9 --- /dev/null +++ b/runtime/near-vm/lib/engine-universal/Cargo.toml @@ -0,0 +1,43 @@ +[package] +name = "wasmer-engine-universal-near" +version = "2.4.0" +description = "Wasmer Universal Engine" +categories = ["wasm"] +keywords = ["wasm", "webassembly", "engine", "universal"] +authors = ["Wasmer Engineering Team "] +repository = "https://github.com/wasmerio/wasmer" +license = "MIT OR Apache-2.0 WITH LLVM-exception " +readme = "README.md" +edition = "2018" + +[lib] +name = "wasmer_engine_universal" + +[dependencies] +finite-wasm = "0.3.0" +wasmer-compiler = { path = "../compiler", version = "=2.4.0", package = "wasmer-compiler-near", features = ["translator"] } +wasmer-engine = { path = "../engine", package = "wasmer-engine-near", version = "=2.4.0" } +wasmer-types = { path = "../types", version = "=2.4.0", package = "wasmer-types-near" } +wasmer-vm = { path = "../vm", version = "=2.4.0", package = "wasmer-vm-near" } + +cfg-if = "1.0" +enumset = "1.0" +# flexbuffers = { path = "../../../flatbuffers/rust/flexbuffers", version = "0.1.0" } +leb128 = "0.2" +prefix-sum-vec = "0.1.1" +region = "3.0" +rkyv = "0.7.31" +thiserror = "1" +tracing = "0.1" +wasmparser = "0.99.0" + +[target.'cfg(target_os = "windows")'.dependencies] +winapi = { version = "0.3", features = ["winnt", "impl-default"] } + +[features] +# Enable the `compiler` feature if you want the engine to compile +# and not be only on headless mode. +compiler = ["wasmer-compiler/translator"] + +[badges] +maintenance = { status = "actively-developed" } diff --git a/runtime/near-vm/lib/engine-universal/README.md b/runtime/near-vm/lib/engine-universal/README.md new file mode 100644 index 00000000000..93d9ac321f5 --- /dev/null +++ b/runtime/near-vm/lib/engine-universal/README.md @@ -0,0 +1,25 @@ +# `wasmer-engine-universal` [![Build Status](https://github.com/wasmerio/wasmer/workflows/build/badge.svg?style=flat-square)](https://github.com/wasmerio/wasmer/actions?query=workflow%3Abuild) [![Join Wasmer Slack](https://img.shields.io/static/v1?label=Slack&message=join%20chat&color=brighgreen&style=flat-square)](https://slack.wasmer.io) [![MIT License](https://img.shields.io/github/license/wasmerio/wasmer.svg?style=flat-square)](https://github.com/wasmerio/wasmer/blob/master/LICENSE) + +The Wasmer Universal engine is usable with any compiler implementation based +on [`wasmer-compiler`]. After the compiler process the result, the Universal +pushes it into memory and links its contents so it can be usable by +the [`wasmer`] API. + +*Note: you can find a [full working example using the Universal engine +here][example].* + +### Acknowledgments + +This project borrowed some of the code of the code memory and unwind +tables from the [`wasmtime-jit`], the code since then has evolved +significantly. + +Please check [Wasmer `ATTRIBUTIONS`] to further see licenses and other +attributions of the project. + + +[`wasmer-compiler`]: https://github.com/wasmerio/wasmer/tree/master/lib/compiler +[`wasmer`]: https://github.com/wasmerio/wasmer/tree/master/lib/api +[example]: https://github.com/wasmerio/wasmer/blob/master/examples/engine_universal.rs +[`wasmtime-jit`]: https://crates.io/crates/wasmtime-jit +[Wasmer `ATTRIBUTIONS`]: https://github.com/wasmerio/wasmer/blob/master/ATTRIBUTIONS.md diff --git a/runtime/near-vm/lib/engine-universal/src/artifact.rs b/runtime/near-vm/lib/engine-universal/src/artifact.rs new file mode 100644 index 00000000000..045eb4c8904 --- /dev/null +++ b/runtime/near-vm/lib/engine-universal/src/artifact.rs @@ -0,0 +1,193 @@ +//! Define `UniversalArtifact` to allow compiling and instantiating to be +//! done as separate steps. + +use std::collections::BTreeMap; +use std::convert::TryFrom; +use std::sync::Arc; +use wasmer_engine::InstantiationError; +use wasmer_types::entity::{BoxedSlice, EntityRef, PrimaryMap}; +use wasmer_types::{ + DataIndex, ElemIndex, FunctionIndex, GlobalInit, GlobalType, ImportCounts, LocalFunctionIndex, + LocalGlobalIndex, MemoryType, OwnedDataInitializer, OwnedTableInitializer, SignatureIndex, + TableType, +}; +use wasmer_vm::{ + Artifact, FunctionBodyPtr, FunctionExtent, InstanceHandle, Instantiatable, MemoryStyle, + Resolver, TableStyle, Tunables, VMImport, VMImportType, VMLocalFunction, VMOffsets, + VMSharedSignatureIndex, +}; + +/// A compiled wasm module, containing everything necessary for instantiation. +pub struct UniversalArtifact { + // TODO: figure out how to allocate fewer distinct structures onto heap. Maybe have an arena…? + pub(crate) engine: crate::UniversalEngine, + pub(crate) import_counts: ImportCounts, + pub(crate) start_function: Option, + pub(crate) vmoffsets: VMOffsets, + pub(crate) imports: Vec, + pub(crate) dynamic_function_trampolines: BoxedSlice, + pub(crate) functions: BoxedSlice, + pub(crate) exports: BTreeMap, + pub(crate) signatures: BoxedSlice, + pub(crate) local_memories: Vec<(MemoryType, MemoryStyle)>, + pub(crate) data_segments: Vec, + pub(crate) passive_data: BTreeMap>, + pub(crate) local_tables: Vec<(TableType, TableStyle)>, + pub(crate) element_segments: Vec, + // TODO: does this need to be a BTreeMap? Can it be a plain vector? + pub(crate) passive_elements: BTreeMap>, + pub(crate) local_globals: Vec<(GlobalType, GlobalInit)>, +} + +impl UniversalArtifact { + /// Return the extents of the specified local function. + pub fn function_extent(&self, index: LocalFunctionIndex) -> Option { + let func = self.functions.get(index)?; + Some(FunctionExtent { + address: func.body, + length: usize::try_from(func.length).unwrap(), + }) + } + + /// Return the engine instance this artifact is loaded into. + pub fn engine(&self) -> &crate::UniversalEngine { + &self.engine + } +} + +impl Instantiatable for UniversalArtifact { + type Error = InstantiationError; + + unsafe fn instantiate( + self: Arc, + tunables: &dyn Tunables, + resolver: &dyn Resolver, + host_state: Box, + config: wasmer_types::InstanceConfig, + ) -> Result { + let (imports, import_function_envs) = { + let mut imports = wasmer_engine::resolve_imports( + &self.engine, + resolver, + &self.import_counts, + &self.imports, + &self.dynamic_function_trampolines, + ) + .map_err(InstantiationError::Link)?; + + // Get the `WasmerEnv::init_with_instance` function pointers and the pointers + // to the envs to call it on. + let import_function_envs = imports.get_imported_function_envs(); + + (imports, import_function_envs) + }; + + let (allocator, memory_definition_locations, table_definition_locations) = + wasmer_vm::InstanceAllocator::new(self.vmoffsets.clone()); + + // Memories + let mut memories: PrimaryMap = + PrimaryMap::with_capacity(self.local_memories.len()); + for (idx, (ty, style)) in (self.import_counts.memories..).zip(self.local_memories.iter()) { + let memory = tunables + .create_vm_memory(&ty, &style, memory_definition_locations[idx as usize]) + .map_err(|e| { + InstantiationError::Link(wasmer_engine::LinkError::Resource(format!( + "Failed to create memory: {}", + e + ))) + })?; + memories.push(memory); + } + + // Tables + let mut tables: PrimaryMap = + PrimaryMap::with_capacity(self.local_tables.len()); + for (idx, (ty, style)) in (self.import_counts.tables..).zip(self.local_tables.iter()) { + let table = tunables + .create_vm_table(ty, style, table_definition_locations[idx as usize]) + .map_err(|e| InstantiationError::Link(wasmer_engine::LinkError::Resource(e)))?; + tables.push(table); + } + + // Globals + let mut globals = + PrimaryMap::::with_capacity(self.local_globals.len()); + for (ty, _) in self.local_globals.iter() { + globals.push(Arc::new(wasmer_vm::Global::new(*ty))); + } + + let passive_data = self.passive_data.clone(); + Ok(InstanceHandle::new( + self, + allocator, + memories.into_boxed_slice(), + tables.into_boxed_slice(), + globals.into_boxed_slice(), + imports, + passive_data, + host_state, + import_function_envs, + config, + )) + } +} + +impl Artifact for UniversalArtifact { + fn offsets(&self) -> &wasmer_vm::VMOffsets { + &self.vmoffsets + } + + fn import_counts(&self) -> &ImportCounts { + &self.import_counts + } + + fn functions(&self) -> &BoxedSlice { + &self.functions + } + + fn passive_elements(&self) -> &BTreeMap> { + &self.passive_elements + } + + fn element_segments(&self) -> &[OwnedTableInitializer] { + &self.element_segments[..] + } + + fn data_segments(&self) -> &[OwnedDataInitializer] { + &self.data_segments[..] + } + + fn globals(&self) -> &[(GlobalType, GlobalInit)] { + &self.local_globals[..] + } + + fn start_function(&self) -> Option { + self.start_function + } + + fn export_field(&self, name: &str) -> Option { + self.exports.get(name).cloned() + } + + fn signatures(&self) -> &[wasmer_vm::VMSharedSignatureIndex] { + self.signatures.values().as_slice() + } + + fn function_signature(&self, index: FunctionIndex) -> Option { + match self.import_counts().local_function_index(index) { + Ok(local) => Some(self.functions[local].signature), + Err(import) => self + .imports + .iter() + .filter_map(|im| { + if let VMImportType::Function { sig, .. } = im.ty { + Some(sig) + } else { + None + } + }) + .nth(import.index()), + } + } +} diff --git a/runtime/near-vm/lib/engine-universal/src/builder.rs b/runtime/near-vm/lib/engine-universal/src/builder.rs new file mode 100644 index 00000000000..0dd9fc0ef87 --- /dev/null +++ b/runtime/near-vm/lib/engine-universal/src/builder.rs @@ -0,0 +1,66 @@ +use crate::UniversalEngine; +use wasmer_compiler::{CompilerConfig, Features, Target}; + +/// The Universal builder +pub struct Universal { + #[allow(dead_code)] + compiler_config: Option>, + target: Option, + features: Option, +} + +impl Universal { + /// Create a new Universal + pub fn new(compiler_config: T) -> Self + where + T: Into>, + { + Self { + compiler_config: Some(compiler_config.into()), + target: None, + features: None, + } + } + + /// Create a new headless Universal + pub fn headless() -> Self { + Self { + compiler_config: None, + target: None, + features: None, + } + } + + /// Set the target + pub fn target(mut self, target: Target) -> Self { + self.target = Some(target); + self + } + + /// Set the features + pub fn features(mut self, features: Features) -> Self { + self.features = Some(features); + self + } + + /// Build the `UniversalEngine` for this configuration + #[cfg(feature = "compiler")] + pub fn engine(self) -> UniversalEngine { + let target = self.target.unwrap_or_default(); + if let Some(compiler_config) = self.compiler_config { + let features = self + .features + .unwrap_or_else(|| compiler_config.default_features_for_target(&target)); + let compiler = compiler_config.compiler(); + UniversalEngine::new(compiler, target, features) + } else { + UniversalEngine::headless() + } + } + + /// Build the `UniversalEngine` for this configuration + #[cfg(not(feature = "compiler"))] + pub fn engine(self) -> UniversalEngine { + UniversalEngine::headless() + } +} diff --git a/runtime/near-vm/lib/engine-universal/src/code_memory.rs b/runtime/near-vm/lib/engine-universal/src/code_memory.rs new file mode 100644 index 00000000000..148f69eb18d --- /dev/null +++ b/runtime/near-vm/lib/engine-universal/src/code_memory.rs @@ -0,0 +1,223 @@ +// This file contains code from external sources. +// Attributions: https://github.com/wasmerio/wasmer/blob/master/ATTRIBUTIONS.md + +//! Memory management for executable code. +use crate::unwind::UnwindRegistry; +use wasmer_compiler::{CompiledFunctionUnwindInfoRef, CustomSectionRef, FunctionBodyRef}; +use wasmer_vm::{Mmap, VMFunctionBody}; + +/// The optimal alignment for functions. +/// +/// On x86-64, this is 16 since it's what the optimizations assume. +/// When we add support for other architectures, we should also figure out their +/// optimal alignment values. +const ARCH_FUNCTION_ALIGNMENT: usize = 16; + +/// The optimal alignment for data. +/// +const DATA_SECTION_ALIGNMENT: usize = 64; + +/// Memory manager for executable code. +pub struct CodeMemory { + unwind_registry: UnwindRegistry, + mmap: Mmap, + start_of_nonexecutable_pages: usize, +} + +impl CodeMemory { + /// Create a new `CodeMemory` instance. + pub fn new() -> Self { + Self { + unwind_registry: UnwindRegistry::new(), + mmap: Mmap::new(), + start_of_nonexecutable_pages: 0, + } + } + + /// Mutably get the UnwindRegistry. + pub fn unwind_registry_mut(&mut self) -> &mut UnwindRegistry { + &mut self.unwind_registry + } + + /// Allocate a single contiguous block of memory for the functions and custom sections, and copy the data in place. + pub fn allocate( + &mut self, + functions: &[FunctionBodyRef<'_>], + executable_sections: &[CustomSectionRef<'_>], + data_sections: &[CustomSectionRef<'_>], + ) -> Result<(Vec<&mut [VMFunctionBody]>, Vec<&mut [u8]>, Vec<&mut [u8]>), String> { + let mut function_result = vec![]; + let mut data_section_result = vec![]; + let mut executable_section_result = vec![]; + + let page_size = region::page::size(); + + // 1. Calculate the total size, that is: + // - function body size, including all trampolines + // -- windows unwind info + // -- padding between functions + // - executable section body + // -- padding between executable sections + // - padding until a new page to change page permissions + // - data section body size + // -- padding between data sections + + let total_len = round_up( + functions.iter().fold(0, |acc, func| { + round_up( + acc + Self::function_allocation_size(*func), + ARCH_FUNCTION_ALIGNMENT, + ) + }) + executable_sections.iter().fold(0, |acc, exec| { + round_up(acc + exec.bytes.len(), ARCH_FUNCTION_ALIGNMENT) + }), + page_size, + ) + data_sections.iter().fold(0, |acc, data| { + round_up(acc + data.bytes.len(), DATA_SECTION_ALIGNMENT) + }); + + // 2. Allocate the pages. Mark them all read-write. + + self.mmap = Mmap::with_at_least(total_len)?; + + // 3. Determine where the pointers to each function, executable section + // or data section are. Copy the functions. Collect the addresses of each and return them. + + let mut bytes = 0; + let mut buf = self.mmap.as_mut_slice(); + for func in functions { + let len = round_up( + Self::function_allocation_size(*func), + ARCH_FUNCTION_ALIGNMENT, + ); + let (func_buf, next_buf) = buf.split_at_mut(len); + buf = next_buf; + bytes += len; + + let vmfunc = Self::copy_function(&mut self.unwind_registry, *func, func_buf); + assert_eq!(vmfunc.as_ptr() as usize % ARCH_FUNCTION_ALIGNMENT, 0); + function_result.push(vmfunc); + } + for section in executable_sections { + let section = §ion.bytes; + assert_eq!(buf.as_mut_ptr() as usize % ARCH_FUNCTION_ALIGNMENT, 0); + let len = round_up(section.len(), ARCH_FUNCTION_ALIGNMENT); + let (s, next_buf) = buf.split_at_mut(len); + buf = next_buf; + bytes += len; + s[..section.len()].copy_from_slice(*section); + executable_section_result.push(s); + } + + self.start_of_nonexecutable_pages = bytes; + + if !data_sections.is_empty() { + // Data sections have different page permissions from the executable + // code that came before it, so they need to be on different pages. + let padding = round_up(bytes, page_size) - bytes; + buf = buf.split_at_mut(padding).1; + + for section in data_sections { + let section = §ion.bytes; + assert_eq!(buf.as_mut_ptr() as usize % DATA_SECTION_ALIGNMENT, 0); + let len = round_up(section.len(), DATA_SECTION_ALIGNMENT); + let (s, next_buf) = buf.split_at_mut(len); + buf = next_buf; + s[..section.len()].copy_from_slice(*section); + data_section_result.push(s); + } + } + + Ok(( + function_result, + executable_section_result, + data_section_result, + )) + } + + /// Apply the page permissions. + pub fn publish(&mut self) { + if self.mmap.is_empty() || self.start_of_nonexecutable_pages == 0 { + return; + } + assert!(self.mmap.len() >= self.start_of_nonexecutable_pages); + unsafe { + region::protect( + self.mmap.as_mut_ptr(), + self.start_of_nonexecutable_pages, + region::Protection::READ_EXECUTE, + ) + } + .expect("unable to make memory readonly and executable"); + } + + /// Calculates the allocation size of the given compiled function. + fn function_allocation_size(func: FunctionBodyRef<'_>) -> usize { + match &func.unwind_info { + Some(CompiledFunctionUnwindInfoRef::WindowsX64(info)) => { + // Windows unwind information is required to be emitted into code memory + // This is because it must be a positive relative offset from the start of the memory + // Account for necessary unwind information alignment padding (32-bit alignment) + ((func.body.len() + 3) & !3) + info.len() + } + _ => func.body.len(), + } + } + + /// Copies the data of the compiled function to the given buffer. + /// + /// This will also add the function to the current function table. + fn copy_function<'a>( + registry: &mut UnwindRegistry, + func: FunctionBodyRef<'_>, + buf: &'a mut [u8], + ) -> &'a mut [VMFunctionBody] { + assert_eq!(buf.as_ptr() as usize % ARCH_FUNCTION_ALIGNMENT, 0); + + let func_len = func.body.len(); + + let (body, remainder) = buf.split_at_mut(func_len); + body.copy_from_slice(&func.body); + let vmfunc = Self::view_as_mut_vmfunc_slice(body); + + if let Some(CompiledFunctionUnwindInfoRef::WindowsX64(info)) = &func.unwind_info { + // Windows unwind information is written following the function body + // Keep unwind information 32-bit aligned (round up to the nearest 4 byte boundary) + let unwind_start = (func_len + 3) & !3; + let unwind_size = info.len(); + let padding = unwind_start - func_len; + assert_eq!((func_len + padding) % 4, 0); + let slice = remainder.split_at_mut(padding + unwind_size).0; + slice[padding..].copy_from_slice(&info); + } + + if let Some(info) = &func.unwind_info { + registry + .register(vmfunc.as_ptr() as usize, 0, func_len as u32, *info) + .expect("failed to register unwind information"); + } + + vmfunc + } + + /// Convert mut a slice from u8 to VMFunctionBody. + fn view_as_mut_vmfunc_slice(slice: &mut [u8]) -> &mut [VMFunctionBody] { + let byte_ptr: *mut [u8] = slice; + let body_ptr = byte_ptr as *mut [VMFunctionBody]; + unsafe { &mut *body_ptr } + } +} + +fn round_up(size: usize, multiple: usize) -> usize { + debug_assert!(multiple.is_power_of_two()); + (size + (multiple - 1)) & !(multiple - 1) +} + +#[cfg(test)] +mod tests { + use super::CodeMemory; + fn _assert() { + fn _assert_send_sync() {} + _assert_send_sync::(); + } +} diff --git a/runtime/near-vm/lib/engine-universal/src/engine.rs b/runtime/near-vm/lib/engine-universal/src/engine.rs new file mode 100644 index 00000000000..cc096537299 --- /dev/null +++ b/runtime/near-vm/lib/engine-universal/src/engine.rs @@ -0,0 +1,716 @@ +//! Universal compilation. + +use crate::executable::{unrkyv, UniversalExecutableRef}; +use crate::{CodeMemory, UniversalArtifact, UniversalExecutable}; +use rkyv::de::deserializers::SharedDeserializeMap; +use std::collections::BTreeMap; +use std::convert::TryFrom; +use std::sync::{Arc, Mutex}; +#[cfg(feature = "compiler")] +use wasmer_compiler::Compiler; +use wasmer_compiler::{ + CompileError, CustomSectionProtection, CustomSectionRef, FunctionBodyRef, JumpTable, + SectionIndex, Target, +}; +use wasmer_engine::{Engine, EngineId}; +use wasmer_types::entity::{EntityRef, PrimaryMap}; +use wasmer_types::{ + DataInitializer, ExportIndex, Features, FunctionIndex, FunctionType, FunctionTypeRef, + GlobalInit, GlobalType, ImportCounts, ImportIndex, LocalFunctionIndex, LocalGlobalIndex, + MemoryIndex, SignatureIndex, TableIndex, +}; +use wasmer_vm::{ + FuncDataRegistry, FunctionBodyPtr, SectionBodyPtr, SignatureRegistry, Tunables, + VMCallerCheckedAnyfunc, VMFuncRef, VMFunctionBody, VMImportType, VMLocalFunction, VMOffsets, + VMSharedSignatureIndex, VMTrampoline, +}; + +/// A WebAssembly `Universal` Engine. +#[derive(Clone)] +pub struct UniversalEngine { + inner: Arc>, + /// The target for the compiler + target: Arc, + engine_id: EngineId, +} + +impl UniversalEngine { + /// Create a new `UniversalEngine` with the given config + #[cfg(feature = "compiler")] + pub fn new(compiler: Box, target: Target, features: Features) -> Self { + Self { + inner: Arc::new(Mutex::new(UniversalEngineInner { + compiler: Some(compiler), + code_memory: vec![], + signatures: SignatureRegistry::new(), + func_data: Arc::new(FuncDataRegistry::new()), + features, + })), + target: Arc::new(target), + engine_id: EngineId::default(), + } + } + + /// Create a headless `UniversalEngine` + /// + /// A headless engine is an engine without any compiler attached. + /// This is useful for assuring a minimal runtime for running + /// WebAssembly modules. + /// + /// For example, for running in IoT devices where compilers are very + /// expensive, or also to optimize startup speed. + /// + /// # Important + /// + /// Headless engines can't compile or validate any modules, + /// they just take already processed Modules (via `Module::serialize`). + pub fn headless() -> Self { + Self { + inner: Arc::new(Mutex::new(UniversalEngineInner { + #[cfg(feature = "compiler")] + compiler: None, + code_memory: vec![], + signatures: SignatureRegistry::new(), + func_data: Arc::new(FuncDataRegistry::new()), + features: Features::default(), + })), + target: Arc::new(Target::default()), + engine_id: EngineId::default(), + } + } + + pub(crate) fn inner(&self) -> std::sync::MutexGuard<'_, UniversalEngineInner> { + self.inner.lock().unwrap() + } + + pub(crate) fn inner_mut(&self) -> std::sync::MutexGuard<'_, UniversalEngineInner> { + self.inner.lock().unwrap() + } + + /// Compile a WebAssembly binary + #[cfg(feature = "compiler")] + #[tracing::instrument(skip_all)] + pub fn compile_universal( + &self, + binary: &[u8], + tunables: &dyn Tunables, + ) -> Result { + // Compute the needed instrumentation + let instrumentation = finite_wasm::Analysis::new() + .with_stack(tunables.stack_limiter_cfg()) + .with_gas(tunables.gas_cfg()) + .analyze(binary) + .map_err(CompileError::Analyze)?; + + let inner_engine = self.inner_mut(); + let features = inner_engine.features(); + let compiler = inner_engine.compiler()?; + let environ = wasmer_compiler::ModuleEnvironment::new(); + let translation = environ.translate(binary).map_err(CompileError::Wasm)?; + + let memory_styles: PrimaryMap = translation + .module + .memories + .values() + .map(|memory_type| tunables.memory_style(memory_type)) + .collect(); + let table_styles: PrimaryMap = translation + .module + .tables + .values() + .map(|table_type| tunables.table_style(table_type)) + .collect(); + + // Compile the Module + let compile_info = wasmer_compiler::CompileModuleInfo { + module: Arc::new(translation.module), + features: features.clone(), + memory_styles, + table_styles, + }; + let wasmer_compiler::Compilation { + functions, + custom_sections, + function_call_trampolines, + dynamic_function_trampolines, + debug, + trampolines, + } = compiler.compile_module( + &self.target(), + &compile_info, + // SAFETY: Calling `unwrap` is correct since + // `environ.translate()` above will write some data into + // `module_translation_state`. + translation.module_translation_state.as_ref().unwrap(), + translation.function_body_inputs, + tunables, + &instrumentation, + )?; + let data_initializers = translation + .data_initializers + .iter() + .map(wasmer_types::OwnedDataInitializer::new) + .collect(); + let mut function_frame_info = PrimaryMap::with_capacity(functions.len()); + let mut function_bodies = PrimaryMap::with_capacity(functions.len()); + let mut function_relocations = PrimaryMap::with_capacity(functions.len()); + let mut function_jt_offsets = PrimaryMap::with_capacity(functions.len()); + for (_, func) in functions.into_iter() { + function_bodies.push(func.body); + function_relocations.push(func.relocations); + function_jt_offsets.push(func.jt_offsets); + function_frame_info.push(func.frame_info); + } + let custom_section_relocations = custom_sections + .iter() + .map(|(_, section)| section.relocations.clone()) + .collect::>(); + Ok(crate::UniversalExecutable { + function_bodies, + function_relocations, + function_jt_offsets, + function_frame_info, + function_call_trampolines, + dynamic_function_trampolines, + custom_sections, + custom_section_relocations, + debug, + trampolines, + compile_info, + data_initializers, + cpu_features: self.target().cpu_features().as_u64(), + }) + } + + /// Load a [`UniversalExecutable`](crate::UniversalExecutable) with this engine. + #[tracing::instrument(skip_all)] + pub fn load_universal_executable( + &self, + executable: &UniversalExecutable, + ) -> Result { + let info = &executable.compile_info; + let module = &info.module; + let local_memories = (module.import_counts.memories as usize..module.memories.len()) + .map(|idx| { + let idx = MemoryIndex::new(idx); + (module.memories[idx], info.memory_styles[idx].clone()) + }) + .collect(); + let local_tables = (module.import_counts.tables as usize..module.tables.len()) + .map(|idx| { + let idx = TableIndex::new(idx); + (module.tables[idx], info.table_styles[idx].clone()) + }) + .collect(); + let local_globals: Vec<(GlobalType, GlobalInit)> = module + .globals + .iter() + .skip(module.import_counts.globals as usize) + .enumerate() + .map(|(idx, (_, t))| { + let init = module.global_initializers[LocalGlobalIndex::new(idx)]; + (*t, init) + }) + .collect(); + let mut inner_engine = self.inner_mut(); + + let local_functions = executable.function_bodies.iter().map(|(_, b)| b.into()); + let function_call_trampolines = &executable.function_call_trampolines; + let dynamic_function_trampolines = &executable.dynamic_function_trampolines; + let signatures = module + .signatures + .iter() + .map(|(_, sig)| inner_engine.signatures.register(sig.clone())) + .collect::>() + .into_boxed_slice(); + let (functions, trampolines, dynamic_trampolines, custom_sections) = inner_engine + .allocate( + local_functions, + function_call_trampolines.iter().map(|(_, b)| b.into()), + dynamic_function_trampolines.iter().map(|(_, b)| b.into()), + executable.custom_sections.iter().map(|(_, s)| s.into()), + |idx: LocalFunctionIndex| { + let func_idx = module.import_counts.function_index(idx); + let sig_idx = module.functions[func_idx]; + (sig_idx, signatures[sig_idx]) + }, + )?; + let imports = module + .imports + .iter() + .map(|((module_name, field, idx), entity)| wasmer_vm::VMImport { + module: String::from(module_name), + field: String::from(field), + import_no: *idx, + ty: match entity { + ImportIndex::Function(i) => { + let sig_idx = module.functions[*i]; + VMImportType::Function { + sig: signatures[sig_idx], + static_trampoline: trampolines[sig_idx], + } + } + ImportIndex::Table(i) => VMImportType::Table(module.tables[*i]), + &ImportIndex::Memory(i) => { + let ty = module.memories[i]; + VMImportType::Memory(ty, info.memory_styles[i].clone()) + } + ImportIndex::Global(i) => VMImportType::Global(module.globals[*i]), + }, + }) + .collect(); + + let function_relocations = executable.function_relocations.iter(); + let section_relocations = executable.custom_section_relocations.iter(); + crate::link_module( + &functions, + |func_idx, jt_idx| executable.function_jt_offsets[func_idx][jt_idx], + function_relocations.map(|(i, rs)| (i, rs.iter().cloned())), + &custom_sections, + section_relocations.map(|(i, rs)| (i, rs.iter().cloned())), + &executable.trampolines, + ); + + // Make all code loaded executable. + inner_engine.publish_compiled_code(); + if let Some(ref d) = executable.debug { + unsafe { + // TODO: safety comment + inner_engine.publish_eh_frame(std::slice::from_raw_parts( + *custom_sections[d.eh_frame], + executable.custom_sections[d.eh_frame].bytes.len(), + ))?; + } + } + let exports = module + .exports + .iter() + .map(|(s, i)| (s.clone(), i.clone())) + .collect::>(); + + Ok(UniversalArtifact { + engine: self.clone(), + import_counts: module.import_counts, + start_function: module.start_function, + vmoffsets: VMOffsets::for_host().with_module_info(&*module), + imports, + dynamic_function_trampolines: dynamic_trampolines.into_boxed_slice(), + functions: functions.into_boxed_slice(), + exports, + signatures, + local_memories, + data_segments: executable.data_initializers.clone(), + passive_data: module.passive_data.clone(), + local_tables, + element_segments: module.table_initializers.clone(), + passive_elements: module.passive_elements.clone(), + local_globals, + }) + } + + /// Load a [`UniversalExecutableRef`](crate::UniversalExecutableRef) with this engine. + pub fn load_universal_executable_ref( + &self, + executable: &UniversalExecutableRef, + ) -> Result { + let info = &executable.compile_info; + let module = &info.module; + let import_counts: ImportCounts = unrkyv(&module.import_counts); + let local_memories = (import_counts.memories as usize..module.memories.len()) + .map(|idx| { + let idx = MemoryIndex::new(idx); + let mty = &module.memories[&idx]; + (unrkyv(mty), unrkyv(&info.memory_styles[&idx])) + }) + .collect(); + let local_tables = (import_counts.tables as usize..module.tables.len()) + .map(|idx| { + let idx = TableIndex::new(idx); + let tty = &module.tables[&idx]; + (unrkyv(tty), unrkyv(&info.table_styles[&idx])) + }) + .collect(); + let local_globals: Vec<(GlobalType, GlobalInit)> = module + .globals + .iter() + .skip(import_counts.globals as _) + .enumerate() + .map(|(idx, (_, t))| { + let init = unrkyv(&module.global_initializers[&LocalGlobalIndex::new(idx)]); + (*t, init) + }) + .collect(); + + let passive_data = + rkyv::Deserialize::deserialize(&module.passive_data, &mut SharedDeserializeMap::new()) + .map_err(|_| CompileError::Validate("could not deserialize passive data".into()))?; + let data_segments = executable.data_initializers.iter(); + let data_segments = data_segments + .map(|s| DataInitializer::from(s).into()) + .collect(); + let element_segments = unrkyv(&module.table_initializers); + let passive_elements: BTreeMap> = + unrkyv(&module.passive_elements); + + let import_counts: ImportCounts = unrkyv(&module.import_counts); + let mut inner_engine = self.inner_mut(); + + let local_functions = executable.function_bodies.iter().map(|(_, b)| b.into()); + let call_trampolines = executable.function_call_trampolines.iter(); + let dynamic_trampolines = executable.dynamic_function_trampolines.iter(); + let signatures = module + .signatures + .values() + .map(|sig| { + let sig_ref = FunctionTypeRef::from(sig); + inner_engine + .signatures + .register(FunctionType::new(sig_ref.params(), sig_ref.results())) + }) + .collect::>() + .into_boxed_slice(); + let (functions, trampolines, dynamic_trampolines, custom_sections) = inner_engine + .allocate( + local_functions, + call_trampolines.map(|(_, b)| b.into()), + dynamic_trampolines.map(|(_, b)| b.into()), + executable.custom_sections.iter().map(|(_, s)| s.into()), + |idx: LocalFunctionIndex| { + let func_idx = import_counts.function_index(idx); + let sig_idx = module.functions[&func_idx]; + (sig_idx, signatures[sig_idx]) + }, + )?; + let imports = { + module + .imports + .iter() + .map(|((module_name, field, idx), entity)| wasmer_vm::VMImport { + module: String::from(module_name.as_str()), + field: String::from(field.as_str()), + import_no: *idx, + ty: match entity { + ImportIndex::Function(i) => { + let sig_idx = module.functions[i]; + VMImportType::Function { + sig: signatures[sig_idx], + static_trampoline: trampolines[sig_idx], + } + } + ImportIndex::Table(i) => VMImportType::Table(unrkyv(&module.tables[i])), + ImportIndex::Memory(i) => { + let ty = unrkyv(&module.memories[i]); + VMImportType::Memory(ty, unrkyv(&info.memory_styles[i])) + } + ImportIndex::Global(i) => VMImportType::Global(unrkyv(&module.globals[i])), + }, + }) + .collect() + }; + + let function_relocations = executable.function_relocations.iter(); + let section_relocations = executable.custom_section_relocations.iter(); + crate::link_module( + &functions, + |func_idx, jt_idx| { + let func_idx = rkyv::Archived::::new(func_idx.index()); + let jt_idx = rkyv::Archived::::new(jt_idx.index()); + executable.function_jt_offsets[&func_idx][&jt_idx] + }, + function_relocations.map(|(i, r)| (i, r.iter().map(unrkyv))), + &custom_sections, + section_relocations.map(|(i, r)| (i, r.iter().map(unrkyv))), + &unrkyv(&executable.trampolines), + ); + + // Make all code compiled thus far executable. + inner_engine.publish_compiled_code(); + if let rkyv::option::ArchivedOption::Some(ref d) = executable.debug { + unsafe { + // TODO: safety comment + let s = CustomSectionRef::from(&executable.custom_sections[&d.eh_frame]); + inner_engine.publish_eh_frame(std::slice::from_raw_parts( + *custom_sections[unrkyv(&d.eh_frame)], + s.bytes.len(), + ))?; + } + } + let exports = module + .exports + .iter() + .map(|(s, i)| (unrkyv(s), unrkyv(i))) + .collect::>(); + Ok(UniversalArtifact { + engine: self.clone(), + import_counts, + start_function: unrkyv(&module.start_function), + vmoffsets: VMOffsets::for_host().with_archived_module_info(&*module), + imports, + dynamic_function_trampolines: dynamic_trampolines.into_boxed_slice(), + functions: functions.into_boxed_slice(), + exports, + signatures, + local_memories, + data_segments, + passive_data, + local_tables, + element_segments, + passive_elements, + local_globals, + }) + } +} + +impl Engine for UniversalEngine { + /// The target + fn target(&self) -> &Target { + &self.target + } + + /// Register a signature + fn register_signature(&self, func_type: FunctionType) -> VMSharedSignatureIndex { + self.inner().signatures.register(func_type) + } + + fn register_function_metadata(&self, func_data: VMCallerCheckedAnyfunc) -> VMFuncRef { + self.inner().func_data().register(func_data) + } + + /// Lookup a signature + fn lookup_signature(&self, sig: VMSharedSignatureIndex) -> Option { + self.inner().signatures.lookup(sig).cloned() + } + + /// Validates a WebAssembly module + #[tracing::instrument(skip_all)] + fn validate(&self, binary: &[u8]) -> Result<(), CompileError> { + self.inner().validate(binary) + } + + #[cfg(not(feature = "compiler"))] + fn compile( + &self, + binary: &[u8], + tunables: &dyn Tunables, + ) -> Result, CompileError> { + return Err(CompileError::Codegen( + "The UniversalEngine is operating in headless mode, so it can not compile Modules." + .to_string(), + )); + } + + /// Compile a WebAssembly binary + #[cfg(feature = "compiler")] + #[tracing::instrument(skip_all)] + fn compile( + &self, + binary: &[u8], + tunables: &dyn Tunables, + ) -> Result, CompileError> { + self.compile_universal(binary, tunables) + .map(|ex| Box::new(ex) as _) + } + + #[tracing::instrument(skip_all)] + fn load( + &self, + executable: &(dyn wasmer_engine::Executable), + ) -> Result, CompileError> { + executable.load(self) + } + + fn id(&self) -> &EngineId { + &self.engine_id + } + + fn cloned(&self) -> Arc { + Arc::new(self.clone()) + } +} + +/// The inner contents of `UniversalEngine` +pub struct UniversalEngineInner { + /// The compiler + #[cfg(feature = "compiler")] + compiler: Option>, + /// The features to compile the Wasm module with + features: Features, + /// The code memory is responsible of publishing the compiled + /// functions to memory. + code_memory: Vec, + /// The signature registry is used mainly to operate with trampolines + /// performantly. + pub(crate) signatures: SignatureRegistry, + /// The backing storage of `VMFuncRef`s. This centralized store ensures that 2 + /// functions with the same `VMCallerCheckedAnyfunc` will have the same `VMFuncRef`. + /// It also guarantees that the `VMFuncRef`s stay valid until the engine is dropped. + func_data: Arc, +} + +impl UniversalEngineInner { + /// Gets the compiler associated to this engine. + #[cfg(feature = "compiler")] + pub fn compiler(&self) -> Result<&dyn Compiler, CompileError> { + if self.compiler.is_none() { + return Err(CompileError::Codegen("The UniversalEngine is operating in headless mode, so it can only execute already compiled Modules.".to_string())); + } + Ok(&**self.compiler.as_ref().unwrap()) + } + + /// Validate the module + #[cfg(feature = "compiler")] + pub fn validate<'data>(&self, data: &'data [u8]) -> Result<(), CompileError> { + self.compiler()?.validate_module(self.features(), data) + } + + /// Validate the module + #[cfg(not(feature = "compiler"))] + pub fn validate<'data>(&self, _data: &'data [u8]) -> Result<(), CompileError> { + Err(CompileError::Validate( + "The UniversalEngine is not compiled with compiler support, which is required for validating" + .to_string(), + )) + } + + /// The Wasm features + pub fn features(&self) -> &Features { + &self.features + } + + /// Allocate compiled functions into memory + #[allow(clippy::type_complexity)] + pub(crate) fn allocate<'a>( + &mut self, + local_functions: impl ExactSizeIterator>, + call_trampolines: impl ExactSizeIterator>, + dynamic_trampolines: impl ExactSizeIterator>, + custom_sections: impl ExactSizeIterator>, + function_signature: impl Fn(LocalFunctionIndex) -> (SignatureIndex, VMSharedSignatureIndex), + ) -> Result< + ( + PrimaryMap, + PrimaryMap, + PrimaryMap, + PrimaryMap, + ), + CompileError, + > { + let code_memory = &mut self.code_memory; + let function_count = local_functions.len(); + let call_trampoline_count = call_trampolines.len(); + let function_bodies = call_trampolines + .chain(local_functions) + .chain(dynamic_trampolines) + .collect::>(); + + // TOOD: this shouldn't be necessary.... + let mut section_types = Vec::with_capacity(custom_sections.len()); + let mut executable_sections = Vec::new(); + let mut data_sections = Vec::new(); + for section in custom_sections { + if let CustomSectionProtection::ReadExecute = section.protection { + executable_sections.push(section); + } else { + data_sections.push(section); + } + section_types.push(section.protection); + } + code_memory.push(CodeMemory::new()); + let code_memory = self.code_memory.last_mut().expect("infallible"); + + let (mut allocated_functions, allocated_executable_sections, allocated_data_sections) = + code_memory + .allocate( + function_bodies.as_slice(), + executable_sections.as_slice(), + data_sections.as_slice(), + ) + .map_err(|message| { + CompileError::Resource(format!( + "failed to allocate memory for functions: {}", + message + )) + })?; + + let mut allocated_function_call_trampolines: PrimaryMap = + PrimaryMap::new(); + for ptr in allocated_functions + .drain(0..call_trampoline_count) + .map(|slice| slice.as_ptr()) + { + // TODO: What in damnation have you done?! – Bannon + let trampoline = + unsafe { std::mem::transmute::<*const VMFunctionBody, VMTrampoline>(ptr) }; + allocated_function_call_trampolines.push(trampoline); + } + + let allocated_functions_result = allocated_functions + .drain(0..function_count) + .enumerate() + .map(|(index, slice)| -> Result<_, CompileError> { + let index = LocalFunctionIndex::new(index); + let (sig_idx, sig) = function_signature(index); + Ok(VMLocalFunction { + body: FunctionBodyPtr(slice.as_ptr()), + length: u32::try_from(slice.len()).map_err(|_| { + CompileError::Codegen("function body length exceeds 4GiB".into()) + })?, + signature: sig, + trampoline: allocated_function_call_trampolines[sig_idx], + }) + }) + .collect::, _>>()?; + + let allocated_dynamic_function_trampolines = allocated_functions + .drain(..) + .map(|slice| FunctionBodyPtr(slice.as_ptr())) + .collect::>(); + + let mut exec_iter = allocated_executable_sections.iter(); + let mut data_iter = allocated_data_sections.iter(); + let allocated_custom_sections = section_types + .into_iter() + .map(|protection| { + SectionBodyPtr( + if protection == CustomSectionProtection::ReadExecute { + exec_iter.next() + } else { + data_iter.next() + } + .unwrap() + .as_ptr(), + ) + }) + .collect::>(); + + Ok(( + allocated_functions_result, + allocated_function_call_trampolines, + allocated_dynamic_function_trampolines, + allocated_custom_sections, + )) + } + + /// Make memory containing compiled code executable. + pub(crate) fn publish_compiled_code(&mut self) { + self.code_memory.last_mut().unwrap().publish(); + } + + /// Register DWARF-type exception handling information associated with the code. + pub(crate) fn publish_eh_frame(&mut self, eh_frame: &[u8]) -> Result<(), CompileError> { + self.code_memory + .last_mut() + .unwrap() + .unwind_registry_mut() + .publish(eh_frame) + .map_err(|e| { + CompileError::Resource(format!("Error while publishing the unwind code: {}", e)) + })?; + Ok(()) + } + + /// Shared func metadata registry. + pub(crate) fn func_data(&self) -> &Arc { + &self.func_data + } +} diff --git a/runtime/near-vm/lib/engine-universal/src/executable.rs b/runtime/near-vm/lib/engine-universal/src/executable.rs new file mode 100644 index 00000000000..3e04ce1ab3c --- /dev/null +++ b/runtime/near-vm/lib/engine-universal/src/executable.rs @@ -0,0 +1,246 @@ +use std::sync::Arc; + +use enumset::EnumSet; +use rkyv::de::deserializers::SharedDeserializeMap; +use rkyv::ser::serializers::{ + AllocScratchError, AllocSerializer, CompositeSerializerError, SharedSerializeMapError, +}; +use wasmer_compiler::{ + CompileError, CompileModuleInfo, CompiledFunctionFrameInfo, CpuFeature, CustomSection, Dwarf, + Features, FunctionBody, JumpTableOffsets, Relocation, SectionIndex, TrampolinesSection, +}; +use wasmer_engine::{DeserializeError, Engine}; +use wasmer_types::entity::PrimaryMap; +use wasmer_types::{ + ExportIndex, FunctionIndex, ImportIndex, LocalFunctionIndex, OwnedDataInitializer, + SignatureIndex, +}; +use wasmer_vm::Artifact; + +const MAGIC_HEADER: [u8; 32] = { + let value = *b"\0wasmer-universal\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"; + let _length_must_be_multiple_of_16: bool = [true][value.len() % 16]; + value +}; + +/// A 0-copy view of the encoded `UniversalExecutable` payload. +#[derive(Clone, Copy)] +pub struct UniversalExecutableRef<'a> { + buffer: &'a [u8], + archive: &'a ArchivedUniversalExecutable, +} + +impl<'a> std::ops::Deref for UniversalExecutableRef<'a> { + type Target = ArchivedUniversalExecutable; + fn deref(&self) -> &Self::Target { + self.archive + } +} + +impl<'a> UniversalExecutableRef<'a> { + /// Verify the buffer for whether it is a valid `UniversalExecutable`. + pub fn verify_serialized(data: &[u8]) -> Result<(), &'static str> { + if !data.starts_with(&MAGIC_HEADER) { + return Err("the provided bytes are not wasmer-universal"); + } + if data.len() < MAGIC_HEADER.len() + 8 { + return Err("the data buffer is too small to be valid"); + } + let (remaining, position) = data.split_at(data.len() - 8); + let mut position_value = [0u8; 8]; + position_value.copy_from_slice(position); + if u64::from_le_bytes(position_value) > remaining.len() as u64 { + return Err("the buffer is malformed"); + } + // TODO(0-copy): bytecheck too. + Ok(()) + } + + /// # Safety + /// + /// This method is unsafe since it deserializes data directly + /// from memory. + /// Right now we are not doing any extra work for validation, but + /// `rkyv` has an option to do bytecheck on the serialized data before + /// serializing (via `rkyv::check_archived_value`). + pub unsafe fn deserialize( + data: &'a [u8], + ) -> Result, DeserializeError> { + Self::verify_serialized(data).map_err(|e| DeserializeError::Incompatible(e.to_string()))?; + let (archive, position) = data.split_at(data.len() - 8); + let mut position_value = [0u8; 8]; + position_value.copy_from_slice(position); + let (_, data) = archive.split_at(MAGIC_HEADER.len()); + Ok(UniversalExecutableRef { + buffer: data, + archive: rkyv::archived_value::( + data, + u64::from_le_bytes(position_value) as usize, + ), + }) + } + + // TODO(0-copy): this should never fail. + /// Convert this reference to an owned `UniversalExecutable` value. + pub fn to_owned(self) -> Result { + let mut deserializer = SharedDeserializeMap::new(); + rkyv::Deserialize::deserialize(self.archive, &mut deserializer) + .map_err(|e| DeserializeError::CorruptedBinary(format!("{:?}", e))) + } +} + +/// A wasm module compiled to some shape, ready to be loaded with `UniversalEngine` to produce an +/// `UniversalArtifact`. +/// +/// This is the result obtained after validating and compiling a WASM module with any of the +/// supported compilers. This type falls in-between a module and [`Artifact`](crate::Artifact). +#[derive(rkyv::Archive, rkyv::Deserialize, rkyv::Serialize)] +pub struct UniversalExecutable { + pub(crate) function_bodies: PrimaryMap, + pub(crate) function_relocations: PrimaryMap>, + pub(crate) function_jt_offsets: PrimaryMap, + pub(crate) function_frame_info: PrimaryMap, + pub(crate) function_call_trampolines: PrimaryMap, + pub(crate) dynamic_function_trampolines: PrimaryMap, + pub(crate) custom_sections: PrimaryMap, + pub(crate) custom_section_relocations: PrimaryMap>, + // The section indices corresponding to the Dwarf debug info + pub(crate) debug: Option, + // the Trampoline for Arm arch + pub(crate) trampolines: Option, + pub(crate) compile_info: CompileModuleInfo, + pub(crate) data_initializers: Vec, + pub(crate) cpu_features: u64, +} + +#[derive(thiserror::Error, Debug)] +pub enum ExecutableSerializeError { + #[error("could not serialize the executable data")] + Executable( + #[source] + CompositeSerializerError< + std::convert::Infallible, + AllocScratchError, + SharedSerializeMapError, + >, + ), +} + +impl wasmer_engine::Executable for UniversalExecutable { + fn load( + &self, + engine: &(dyn Engine + 'static), + ) -> Result, CompileError> { + engine + .downcast_ref::() + .ok_or(CompileError::EngineDowncast)? + .load_universal_executable(self) + .map(|a| Arc::new(a) as _) + } + + fn features(&self) -> Features { + self.compile_info.features.clone() + } + + fn cpu_features(&self) -> EnumSet { + EnumSet::from_u64(self.cpu_features) + } + + fn serialize(&self) -> Result, Box<(dyn std::error::Error + Send + Sync + 'static)>> { + // The format is as thus: + // + // HEADER + // RKYV PAYLOAD + // RKYV POSITION + // + // It is expected that any framing for message length is handled by the caller. + let mut serializer = AllocSerializer::<1024>::default(); + let pos = rkyv::ser::Serializer::serialize_value(&mut serializer, self) + .map_err(ExecutableSerializeError::Executable)? as u64; + let pos_bytes = pos.to_le_bytes(); + let data = serializer.into_serializer().into_inner(); + let mut out = Vec::with_capacity(MAGIC_HEADER.len() + pos_bytes.len() + data.len()); + out.extend(&MAGIC_HEADER); + out.extend(data.as_slice()); + out.extend(&pos_bytes); + Ok(out) + } + + fn function_name(&self, index: FunctionIndex) -> Option<&str> { + let module = &self.compile_info.module; + // First, lets see if there's a name by which this function is exported. + for (name, idx) in module.exports.iter() { + match idx { + &ExportIndex::Function(fi) if fi == index => return Some(&*name), + _ => continue, + } + } + if let Some(r) = module.function_names.get(&index) { + return Some(&**r); + } + for ((_, field, _), idx) in module.imports.iter() { + match idx { + &ImportIndex::Function(fi) if fi == index => return Some(&*field), + _ => continue, + } + } + None + } +} + +impl<'a> wasmer_engine::Executable for UniversalExecutableRef<'a> { + fn load( + &self, + engine: &(dyn Engine + 'static), + ) -> Result, CompileError> { + engine + .downcast_ref::() + .ok_or_else(|| CompileError::Codegen("can't downcast TODO FIXME".into()))? + .load_universal_executable_ref(self) + .map(|a| Arc::new(a) as _) + } + + fn features(&self) -> Features { + unrkyv(&self.archive.compile_info.features) + } + + fn cpu_features(&self) -> EnumSet { + EnumSet::from_u64(unrkyv(&self.archive.cpu_features)) + } + + fn serialize(&self) -> Result, Box> { + Ok(self.buffer.to_vec()) + } + + fn function_name(&self, index: FunctionIndex) -> Option<&str> { + let module = &self.compile_info.module; + // First, lets see if there's a name by which this function is exported. + for (name, idx) in module.exports.iter() { + match idx { + &ExportIndex::Function(fi) if fi == index => return Some(&*name), + _ => continue, + } + } + if let Some(r) = module.function_names.get(&index) { + return Some(&**r); + } + for ((_, field, _), idx) in module.imports.iter() { + match idx { + &ImportIndex::Function(fi) if fi == index => return Some(&*field), + _ => continue, + } + } + None + } +} + +pub(crate) fn unrkyv(archive: &T::Archived) -> T +where + T: rkyv::Archive, + T::Archived: rkyv::Deserialize, +{ + Result::<_, std::convert::Infallible>::unwrap(rkyv::Deserialize::deserialize( + archive, + &mut rkyv::Infallible, + )) +} diff --git a/runtime/near-vm/lib/engine-universal/src/lib.rs b/runtime/near-vm/lib/engine-universal/src/lib.rs new file mode 100644 index 00000000000..2a2d41f4341 --- /dev/null +++ b/runtime/near-vm/lib/engine-universal/src/lib.rs @@ -0,0 +1,43 @@ +//! Universal backend for Wasmer compilers. +//! +//! Given a compiler (such as `CraneliftCompiler` or `LLVMCompiler`) +//! it generates the compiled machine code, and publishes it into +//! memory so it can be used externally. + +#![deny(missing_docs, trivial_numeric_casts, unused_extern_crates)] +#![warn(unused_import_braces)] +#![cfg_attr( + feature = "cargo-clippy", + allow(clippy::new_without_default, clippy::new_without_default) +)] +#![cfg_attr( + feature = "cargo-clippy", + warn( + clippy::float_arithmetic, + clippy::mut_mut, + clippy::nonminimal_bool, + clippy::option_map_unwrap_or, + clippy::option_map_unwrap_or_else, + clippy::print_stdout, + clippy::unicode_not_nfc, + clippy::use_self + ) +)] + +mod artifact; +mod builder; +mod code_memory; +mod engine; +mod executable; +mod link; +mod unwind; + +pub use crate::artifact::UniversalArtifact; +pub use crate::builder::Universal; +pub use crate::code_memory::CodeMemory; +pub use crate::engine::UniversalEngine; +pub use crate::executable::{UniversalExecutable, UniversalExecutableRef}; +pub use crate::link::link_module; + +/// Version number of this crate. +pub const VERSION: &str = env!("CARGO_PKG_VERSION"); diff --git a/runtime/near-vm/lib/engine-universal/src/link.rs b/runtime/near-vm/lib/engine-universal/src/link.rs new file mode 100644 index 00000000000..e4d96ec44b1 --- /dev/null +++ b/runtime/near-vm/lib/engine-universal/src/link.rs @@ -0,0 +1,209 @@ +//! Linking for Universal-compiled code. + +use std::collections::HashMap; +use std::ptr::{read_unaligned, write_unaligned}; +use wasmer_compiler::{ + JumpTable, Relocation, RelocationKind, RelocationTarget, SectionIndex, TrampolinesSection, +}; +use wasmer_types::entity::PrimaryMap; +use wasmer_types::LocalFunctionIndex; +use wasmer_vm::{SectionBodyPtr, VMLocalFunction}; + +/// Add a new trampoline address, given the base adress of the Section. Return the address of the jump +/// The trampoline itself still have to be writen +fn trampolines_add( + map: &mut HashMap, + trampoline: &TrampolinesSection, + address: usize, + baseaddress: usize, +) -> usize { + if let Some(target) = map.get(&address) { + return *target; + } + let ret = map.len(); + if ret == trampoline.slots { + panic!("No more slot in Trampolines"); + } + map.insert(address, baseaddress + ret * trampoline.size); + baseaddress + ret * trampoline.size +} + +fn use_trampoline( + address: usize, + allocated_sections: &PrimaryMap, + trampolines: &Option, + map: &mut HashMap, +) -> Option { + match trampolines { + Some(trampolines) => Some(trampolines_add( + map, + trampolines, + address, + *allocated_sections[trampolines.section_index] as usize, + )), + _ => None, + } +} + +fn fill_trampoline_map( + allocated_sections: &PrimaryMap, + trampolines: &Option, +) -> HashMap { + let mut map: HashMap = HashMap::new(); + match trampolines { + Some(trampolines) => { + let baseaddress = *allocated_sections[trampolines.section_index] as usize; + for i in 0..trampolines.size { + let jmpslot: usize = unsafe { + read_unaligned((baseaddress + i * trampolines.size + 8) as *mut usize) + }; + if jmpslot != 0 { + map.insert(jmpslot, baseaddress + i * trampolines.size); + } + } + } + _ => {} + }; + map +} + +fn apply_relocation( + body: usize, + r: &Relocation, + allocated_functions: &PrimaryMap, + jt_offsets: impl Fn(LocalFunctionIndex, JumpTable) -> wasmer_compiler::CodeOffset, + allocated_sections: &PrimaryMap, + trampolines: &Option, + trampolines_map: &mut HashMap, +) { + let target_func_address: usize = match r.reloc_target { + RelocationTarget::LocalFunc(index) => *allocated_functions[index].body as usize, + RelocationTarget::LibCall(libcall) => libcall.function_pointer(), + RelocationTarget::CustomSection(custom_section) => { + *allocated_sections[custom_section] as usize + } + RelocationTarget::JumpTable(func_index, jt) => { + let offset = jt_offsets(func_index, jt); + *allocated_functions[func_index].body as usize + offset as usize + } + }; + + match r.kind { + #[cfg(target_pointer_width = "64")] + RelocationKind::Abs8 => unsafe { + let (reloc_address, reloc_delta) = r.for_address(body, target_func_address as u64); + write_unaligned(reloc_address as *mut u64, reloc_delta); + }, + #[cfg(target_pointer_width = "32")] + RelocationKind::X86PCRel4 => unsafe { + let (reloc_address, reloc_delta) = r.for_address(body, target_func_address as u64); + write_unaligned(reloc_address as *mut u32, reloc_delta as _); + }, + #[cfg(target_pointer_width = "64")] + RelocationKind::X86PCRel8 => unsafe { + let (reloc_address, reloc_delta) = r.for_address(body, target_func_address as u64); + write_unaligned(reloc_address as *mut u64, reloc_delta); + }, + RelocationKind::X86CallPCRel4 => unsafe { + let (reloc_address, reloc_delta) = r.for_address(body, target_func_address as u64); + write_unaligned(reloc_address as *mut u32, reloc_delta as _); + }, + RelocationKind::X86PCRelRodata4 => {} + RelocationKind::Arm64Call => unsafe { + let (reloc_address, mut reloc_delta) = r.for_address(body, target_func_address as u64); + if (reloc_delta as i64).abs() >= 0x1000_0000 { + let new_address = match use_trampoline( + target_func_address, + allocated_sections, + trampolines, + trampolines_map, + ) { + Some(new_address) => new_address, + _ => panic!( + "Relocation to big for {:?} for {:?} with {:x}, current val {:x}", + r.kind, + r.reloc_target, + reloc_delta, + read_unaligned(reloc_address as *mut u32) + ), + }; + write_unaligned((new_address + 8) as *mut u64, target_func_address as u64); // write the jump address + let (_, new_delta) = r.for_address(body, new_address as u64); + reloc_delta = new_delta; + } + let reloc_delta = (((reloc_delta / 4) as u32) & 0x3ff_ffff) + | read_unaligned(reloc_address as *mut u32); + write_unaligned(reloc_address as *mut u32, reloc_delta); + }, + RelocationKind::Arm64Movw0 => unsafe { + let (reloc_address, reloc_delta) = r.for_address(body, target_func_address as u64); + let reloc_delta = + (((reloc_delta & 0xffff) as u32) << 5) | read_unaligned(reloc_address as *mut u32); + write_unaligned(reloc_address as *mut u32, reloc_delta); + }, + RelocationKind::Arm64Movw1 => unsafe { + let (reloc_address, reloc_delta) = r.for_address(body, target_func_address as u64); + let reloc_delta = ((((reloc_delta >> 16) & 0xffff) as u32) << 5) + | read_unaligned(reloc_address as *mut u32); + write_unaligned(reloc_address as *mut u32, reloc_delta); + }, + RelocationKind::Arm64Movw2 => unsafe { + let (reloc_address, reloc_delta) = r.for_address(body, target_func_address as u64); + let reloc_delta = ((((reloc_delta >> 32) & 0xffff) as u32) << 5) + | read_unaligned(reloc_address as *mut u32); + write_unaligned(reloc_address as *mut u32, reloc_delta); + }, + RelocationKind::Arm64Movw3 => unsafe { + let (reloc_address, reloc_delta) = r.for_address(body, target_func_address as u64); + let reloc_delta = ((((reloc_delta >> 48) & 0xffff) as u32) << 5) + | read_unaligned(reloc_address as *mut u32); + write_unaligned(reloc_address as *mut u32, reloc_delta); + }, + kind => panic!( + "Relocation kind unsupported in the current architecture {}", + kind + ), + } +} + +/// Links a module, patching the allocated functions with the +/// required relocations and jump tables. +#[tracing::instrument(skip_all)] +pub fn link_module( + allocated_functions: &PrimaryMap, + jt_offsets: impl Fn(LocalFunctionIndex, JumpTable) -> wasmer_compiler::CodeOffset, + function_relocations: impl Iterator)>, + allocated_sections: &PrimaryMap, + section_relocations: impl Iterator)>, + trampolines: &Option, +) { + let mut trampolines_map = fill_trampoline_map(allocated_sections, trampolines); + for (i, section_relocs) in section_relocations { + let body = *allocated_sections[i] as usize; + for r in section_relocs { + apply_relocation( + body, + &r, + allocated_functions, + &jt_offsets, + allocated_sections, + trampolines, + &mut trampolines_map, + ); + } + } + for (i, function_relocs) in function_relocations { + let body = *allocated_functions[i].body as usize; + for r in function_relocs { + apply_relocation( + body, + &r, + allocated_functions, + &jt_offsets, + allocated_sections, + trampolines, + &mut trampolines_map, + ); + } + } +} diff --git a/runtime/near-vm/lib/engine-universal/src/unwind/dummy.rs b/runtime/near-vm/lib/engine-universal/src/unwind/dummy.rs new file mode 100644 index 00000000000..3d029ecd981 --- /dev/null +++ b/runtime/near-vm/lib/engine-universal/src/unwind/dummy.rs @@ -0,0 +1,32 @@ +//! Module for Dummy unwind registry. + +use wasmer_compiler::CompiledFunctionUnwindInfo; + +/// Represents a registry of function unwind information when the host system +/// support any one in specific. +pub struct DummyUnwindRegistry {} + +impl DummyUnwindRegistry { + /// Creates a new unwind registry with the given base address. + pub fn new() -> Self { + DummyUnwindRegistry {} + } + + /// Registers a function given the start offset, length, and unwind information. + pub fn register( + &mut self, + _base_address: usize, + _func_start: u32, + _func_len: u32, + _info: &CompiledFunctionUnwindInfo, + ) -> Result<(), String> { + // Do nothing + Ok(()) + } + + /// Publishes all registered functions. + pub fn publish(&mut self, eh_frame: Option<&[u8]>) -> Result<(), String> { + // Do nothing + Ok(()) + } +} diff --git a/runtime/near-vm/lib/engine-universal/src/unwind/mod.rs b/runtime/near-vm/lib/engine-universal/src/unwind/mod.rs new file mode 100644 index 00000000000..7d61694a210 --- /dev/null +++ b/runtime/near-vm/lib/engine-universal/src/unwind/mod.rs @@ -0,0 +1,13 @@ +cfg_if::cfg_if! { + if #[cfg(all(windows, target_arch = "x86_64"))] { + mod windows_x64; + pub use self::windows_x64::*; + } else if #[cfg(unix)] { + mod systemv; + pub use self::systemv::*; + } else { + // Otherwise, we provide a dummy fallback without unwinding + mod dummy; + pub use self::dummy::DummyUnwindRegistry as UnwindRegistry; + } +} diff --git a/runtime/near-vm/lib/engine-universal/src/unwind/systemv.rs b/runtime/near-vm/lib/engine-universal/src/unwind/systemv.rs new file mode 100644 index 00000000000..b4c4ebe8101 --- /dev/null +++ b/runtime/near-vm/lib/engine-universal/src/unwind/systemv.rs @@ -0,0 +1,119 @@ +// This file contains code from external sources. +// Attributions: https://github.com/wasmerio/wasmer/blob/master/ATTRIBUTIONS.md + +//! Module for System V ABI unwind registry. + +use wasmer_compiler::CompiledFunctionUnwindInfoRef; + +/// Represents a registry of function unwind information for System V ABI. +pub struct UnwindRegistry { + registrations: Vec, + published: bool, +} + +extern "C" { + // libunwind import + fn __register_frame(fde: *const u8); + fn __deregister_frame(fde: *const u8); +} + +impl UnwindRegistry { + /// Creates a new unwind registry with the given base address. + pub fn new() -> Self { + Self { + registrations: Vec::new(), + published: false, + } + } + + /// Registers a function given the start offset, length, and unwind information. + pub fn register( + &mut self, + _base_address: usize, + _func_start: u32, + _func_len: u32, + info: CompiledFunctionUnwindInfoRef<'_>, + ) -> Result<(), String> { + match info { + CompiledFunctionUnwindInfoRef::Dwarf => {} + _ => return Err("unsupported unwind information".to_string()), + }; + Ok(()) + } + + /// Publishes all registered functions. + pub fn publish(&mut self, eh_frame: &[u8]) -> Result<(), String> { + if self.published { + return Err("unwind registry has already been published".to_string()); + } + + unsafe { + self.register_frames(eh_frame); + } + + self.published = true; + + Ok(()) + } + + #[allow(clippy::cast_ptr_alignment)] + unsafe fn register_frames(&mut self, eh_frame: &[u8]) { + if cfg!(all(target_os = "linux", target_env = "gnu")) { + // Registering an empty `eh_frame` (i.e. which + // contains empty FDEs) cause problems on Linux when + // deregistering it. We must avoid this + // scenario. Usually, this is handled upstream by the + // compilers. + debug_assert_ne!( + eh_frame, + &[0, 0, 0, 0], + "`eh_frame` seems to contain empty FDEs" + ); + + // On gnu (libgcc), `__register_frame` will walk the FDEs until an entry of length 0 + let ptr = eh_frame.as_ptr(); + __register_frame(ptr); + self.registrations.push(ptr as usize); + } else { + // For libunwind, `__register_frame` takes a pointer to a single FDE + let start = eh_frame.as_ptr(); + let end = start.add(eh_frame.len()); + let mut current = start; + + // Walk all of the entries in the frame table and register them + while current < end { + let len = std::ptr::read::(current as *const u32) as usize; + + // Skip over the CIE and zero-length FDEs. + // LLVM's libunwind emits a warning on zero-length FDEs. + if current != start && len != 0 { + __register_frame(current); + self.registrations.push(current as usize); + } + + // Move to the next table entry (+4 because the length itself is not inclusive) + current = current.add(len + 4); + } + } + } +} + +impl Drop for UnwindRegistry { + fn drop(&mut self) { + if self.published { + unsafe { + // libgcc stores the frame entries as a linked list in decreasing sort order + // based on the PC value of the registered entry. + // + // As we store the registrations in increasing order, it would be O(N^2) to + // deregister in that order. + // + // To ensure that we just pop off the first element in the list upon every + // deregistration, walk our list of registrations backwards. + for fde in self.registrations.iter().rev() { + __deregister_frame(*fde as *const _); + } + } + } + } +} diff --git a/runtime/near-vm/lib/engine-universal/src/unwind/windows_x64.rs b/runtime/near-vm/lib/engine-universal/src/unwind/windows_x64.rs new file mode 100644 index 00000000000..8ee3903b32f --- /dev/null +++ b/runtime/near-vm/lib/engine-universal/src/unwind/windows_x64.rs @@ -0,0 +1,105 @@ +// This file contains code from external sources. +// Attributions: https://github.com/wasmerio/wasmer/blob/master/ATTRIBUTIONS.md + +//! Module for Windows x64 ABI unwind registry. +use std::collections::HashMap; +use wasmer_compiler::CompiledFunctionUnwindInfo; +use winapi::um::winnt; + +/// Represents a registry of function unwind information for Windows x64 ABI. +pub struct UnwindRegistry { + // A hashmap mapping the baseaddress with the registered runtime functions + functions: HashMap>, + published: bool, +} + +impl UnwindRegistry { + /// Creates a new unwind registry with the given base address. + pub fn new() -> Self { + Self { + functions: HashMap::new(), + published: false, + } + } + + /// Registers a function given the start offset, length, and unwind information. + pub fn register( + &mut self, + base_address: usize, + func_start: u32, + func_len: u32, + info: &CompiledFunctionUnwindInfo, + ) -> Result<(), String> { + if self.published { + return Err("unwind registry has already been published".to_string()); + } + + match info { + CompiledFunctionUnwindInfo::WindowsX64(_) => {} + _ => return Err("unsupported unwind information".to_string()), + }; + + let mut entry = winnt::RUNTIME_FUNCTION::default(); + + entry.BeginAddress = func_start; + entry.EndAddress = func_start + func_len; + + // The unwind information should be immediately following the function + // with padding for 4 byte alignment + unsafe { + *entry.u.UnwindInfoAddress_mut() = (entry.EndAddress + 3) & !3; + } + let entries = self + .functions + .entry(base_address) + .or_insert_with(|| Vec::new()); + + entries.push(entry); + + Ok(()) + } + + /// Publishes all registered functions. + pub fn publish(&mut self, _eh_frame: Option<&[u8]>) -> Result<(), String> { + if self.published { + return Err("unwind registry has already been published".to_string()); + } + + self.published = true; + + if !self.functions.is_empty() { + for (base_address, functions) in self.functions.iter_mut() { + // Windows heap allocations are 32-bit aligned, but assert just in case + assert_eq!( + (functions.as_mut_ptr() as u64) % 4, + 0, + "function table allocation was not aligned" + ); + unsafe { + if winnt::RtlAddFunctionTable( + functions.as_mut_ptr(), + functions.len() as u32, + *base_address as u64, + ) == 0 + { + return Err("failed to register function tables".to_string()); + } + } + } + } + + Ok(()) + } +} + +impl Drop for UnwindRegistry { + fn drop(&mut self) { + if self.published { + unsafe { + for functions in self.functions.values_mut() { + winnt::RtlDeleteFunctionTable(functions.as_mut_ptr()); + } + } + } + } +} diff --git a/runtime/near-vm/lib/engine/Cargo.toml b/runtime/near-vm/lib/engine/Cargo.toml new file mode 100644 index 00000000000..e7d4e65b5b2 --- /dev/null +++ b/runtime/near-vm/lib/engine/Cargo.toml @@ -0,0 +1,32 @@ +[package] +name = "wasmer-engine-near" +version = "2.4.0" +description = "Wasmer Engine abstraction" +categories = ["wasm"] +keywords = ["wasm", "webassembly", "engine"] +authors = ["Wasmer Engineering Team "] +repository = "https://github.com/wasmerio/wasmer" +license = "MIT OR Apache-2.0 WITH LLVM-exception " +readme = "README.md" +edition = "2018" + +[lib] +name = "wasmer_engine" + +[dependencies] +finite-wasm = "0.3.0" +wasmer-types = { path = "../types", version = "=2.4.0", package = "wasmer-types-near" } +wasmer-compiler = { path = "../compiler", version = "=2.4.0", package = "wasmer-compiler-near" } +wasmer-vm = { path = "../vm", version = "=2.4.0", package = "wasmer-vm-near" } +target-lexicon = { version = "0.12.2", default-features = false } +# flexbuffers = { path = "../../../flatbuffers/rust/flexbuffers", version = "0.1.0" } +backtrace = "0.3" +rustc-demangle = "0.1" +memmap2 = "0.5" +more-asserts = "0.2" +thiserror = "1.0" +lazy_static = "1.4" +enumset = "1.0" + +[badges] +maintenance = { status = "actively-developed" } diff --git a/runtime/near-vm/lib/engine/README.md b/runtime/near-vm/lib/engine/README.md new file mode 100644 index 00000000000..c4de85c25dc --- /dev/null +++ b/runtime/near-vm/lib/engine/README.md @@ -0,0 +1,36 @@ +# `wasmer-engine` [![Build Status](https://github.com/wasmerio/wasmer/workflows/build/badge.svg?style=flat-square)](https://github.com/wasmerio/wasmer/actions?query=workflow%3Abuild) [![Join Wasmer Slack](https://img.shields.io/static/v1?label=Slack&message=join%20chat&color=brighgreen&style=flat-square)](https://slack.wasmer.io) [![MIT License](https://img.shields.io/github/license/wasmerio/wasmer.svg?style=flat-square)](https://github.com/wasmerio/wasmer/blob/master/LICENSE) + +This crate is the general abstraction for creating Engines in Wasmer. + +Wasmer Engines are mainly responsible for two things: +* Transform the compilation code (from any Wasmer Compiler) to + **create** an `Artifact`, +* **Load** an`Artifact` so it can be used by the user (normally, + pushing the code into executable memory and so on). + +It currently has three implementations: + +1. Universal with [`wasmer-engine-universal`], +2. Native with [`wasmer-engine-dylib`], +3. Object with [`wasmer-engine-staticlib`]. + +## Example Implementation + +Please check [`wasmer-engine-dummy`] for an example implementation for +an `Engine`. + +### Acknowledgments + +This project borrowed some of the code of the trap implementation from +the [`wasmtime-api`], the code since then has evolved significantly. + +Please check [Wasmer `ATTRIBUTIONS`] to further see licenses and other +attributions of the project. + + +[`wasmer-engine-universal`]: https://github.com/wasmerio/wasmer/tree/master/lib/engine-universal +[`wasmer-engine-dylib`]: https://github.com/wasmerio/wasmer/tree/master/lib/engine-dylib +[`wasmer-engine-staticlib`]: https://github.com/wasmerio/wasmer/tree/master/lib/engine-staticlib +[`wasmer-engine-dummy`]: https://github.com/wasmerio/wasmer/tree/master/tests/lib/engine-dummy +[`wasmtime-api`]: https://crates.io/crates/wasmtime +[Wasmer `ATTRIBUTIONS`]: https://github.com/wasmerio/wasmer/blob/master/ATTRIBUTIONS.md diff --git a/runtime/near-vm/lib/engine/src/engine.rs b/runtime/near-vm/lib/engine/src/engine.rs new file mode 100644 index 00000000000..dfa3570db25 --- /dev/null +++ b/runtime/near-vm/lib/engine/src/engine.rs @@ -0,0 +1,104 @@ +//! Engine trait and associated types. + +use std::sync::atomic::{AtomicUsize, Ordering::SeqCst}; +use std::sync::Arc; +use wasmer_compiler::{CompileError, Target}; +use wasmer_types::FunctionType; +use wasmer_vm::{Artifact, Tunables, VMCallerCheckedAnyfunc, VMFuncRef, VMSharedSignatureIndex}; + +mod private { + pub struct Internal(pub(super) ()); +} + +/// A unimplemented Wasmer `Engine`. +/// +/// This trait is used by implementors to implement custom engines +/// such as: Universal or Native. +/// +/// The product that an `Engine` produces and consumes is the [`Artifact`]. +pub trait Engine { + /// Gets the target + fn target(&self) -> &Target; + + /// Register a signature + fn register_signature(&self, func_type: FunctionType) -> VMSharedSignatureIndex; + + /// Register a function's data. + fn register_function_metadata(&self, func_data: VMCallerCheckedAnyfunc) -> VMFuncRef; + + /// Lookup a signature + fn lookup_signature(&self, sig: VMSharedSignatureIndex) -> Option; + + /// Validates a WebAssembly module + fn validate(&self, binary: &[u8]) -> Result<(), CompileError>; + + /// Compile a WebAssembly binary + fn compile( + &self, + binary: &[u8], + tunables: &dyn Tunables, + ) -> Result, CompileError>; + + /// Load a compiled executable with this engine. + fn load(&self, executable: &(dyn crate::Executable)) + -> Result, CompileError>; + + /// A unique identifier for this object. + /// + /// This exists to allow us to compare two Engines for equality. Otherwise, + /// comparing two trait objects unsafely relies on implementation details + /// of trait representation. + fn id(&self) -> &EngineId; + + /// Clone the engine + fn cloned(&self) -> Arc; + + /// Internal: support for downcasting `Engine`s. + #[doc(hidden)] + fn type_id(&self, _: private::Internal) -> std::any::TypeId + where + Self: 'static, + { + std::any::TypeId::of::() + } +} + +#[derive(Debug, PartialEq, Eq, PartialOrd, Ord)] +#[repr(transparent)] +/// A unique identifier for an Engine. +pub struct EngineId { + id: usize, +} + +impl EngineId { + /// Format this identifier as a string. + pub fn id(&self) -> String { + format!("{}", &self.id) + } +} + +impl Clone for EngineId { + fn clone(&self) -> Self { + Self::default() + } +} + +impl Default for EngineId { + fn default() -> Self { + static NEXT_ID: AtomicUsize = AtomicUsize::new(0); + Self { + id: NEXT_ID.fetch_add(1, SeqCst), + } + } +} + +impl dyn Engine { + /// Downcast a dynamic Executable object to a concrete implementation of the trait. + pub fn downcast_ref(&self) -> Option<&T> { + if std::any::TypeId::of::() == self.type_id(private::Internal(())) { + unsafe { Some(&*(self as *const dyn Engine as *const T)) } + } else { + None + } + } +} diff --git a/runtime/near-vm/lib/engine/src/error.rs b/runtime/near-vm/lib/engine/src/error.rs new file mode 100644 index 00000000000..534e44a0b89 --- /dev/null +++ b/runtime/near-vm/lib/engine/src/error.rs @@ -0,0 +1,90 @@ +//! The WebAssembly possible errors +use crate::trap::RuntimeError; +use std::io; +use thiserror::Error; +use wasmer_compiler::CompileError; +use wasmer_types::ExternType; + +/// The Deserialize error can occur when loading a +/// compiled Module from a binary. +#[derive(Error, Debug)] +pub enum DeserializeError { + /// An IO error + #[error(transparent)] + Io(#[from] io::Error), + /// A generic deserialization error + #[error("{0}")] + Generic(String), + /// Incompatible serialized binary + #[error("incompatible binary: {0}")] + Incompatible(String), + /// The provided binary is corrupted + #[error("corrupted binary: {0}")] + CorruptedBinary(String), + /// The binary was valid, but we got an error when + /// trying to allocate the required resources. + #[error(transparent)] + Compiler(CompileError), +} + +/// An ImportError. +/// +/// Note: this error is not standard to WebAssembly, but it's +/// useful to determine the import issue on the API side. +#[derive(Error, Debug)] +pub enum ImportError { + /// Incompatible Import Type. + /// This error occurs when the import types mismatch. + #[error("incompatible import type. Expected {0:?} but received {1:?}")] + IncompatibleType(ExternType, ExternType), + + /// Unknown Import. + /// This error occurs when an import was expected but not provided. + #[error("unknown import. Expected {0:?}")] + UnknownImport(ExternType), +} + +/// The WebAssembly.LinkError object indicates an error during +/// module instantiation (besides traps from the start function). +/// +/// This is based on the [link error][link-error] API. +/// +/// [link-error]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/LinkError +#[derive(Error, Debug)] +#[error("Link error: {0}")] +pub enum LinkError { + /// An error occurred when checking the import types. + #[error("Error while importing {0:?}.{1:?}: {2}")] + Import(String, String, ImportError), + + /// A trap ocurred during linking. + #[error("RuntimeError occurred during linking: {0}")] + Trap(#[source] RuntimeError), + + /// Insufficient resources available for linking. + #[error("Insufficient resources: {0}")] + Resource(String), +} + +/// An error while instantiating a module. +/// +/// This is not a common WebAssembly error, however +/// we need to differentiate from a `LinkError` (an error +/// that happens while linking, on instantiation) and a +/// Trap that occurs when calling the WebAssembly module +/// start function. +#[derive(Error, Debug)] +pub enum InstantiationError { + /// A linking ocurred during instantiation. + #[error(transparent)] + Link(LinkError), + + /// The module was compiled with a CPU feature that is not available on + /// the current host. + #[error("module compiled with CPU feature that is missing from host")] + CpuFeature(String), + + /// A runtime error occured while invoking the start function + #[error(transparent)] + Start(RuntimeError), +} diff --git a/runtime/near-vm/lib/engine/src/executable.rs b/runtime/near-vm/lib/engine/src/executable.rs new file mode 100644 index 00000000000..9b5c17761ee --- /dev/null +++ b/runtime/near-vm/lib/engine/src/executable.rs @@ -0,0 +1,57 @@ +use crate::Engine; +use enumset::EnumSet; +use wasmer_compiler::{CompileError, CpuFeature, Features}; +use wasmer_types::FunctionIndex; +use wasmer_vm::Artifact; + +mod private { + pub struct Internal(pub(super) ()); +} + +/// A WASM module built by some [`Engine`](crate::Engine). +/// +/// Types implementing this trait are ready to be saved (to e.g. disk) for later use or loaded with +/// the `Engine` to in order to produce an [`Artifact`](crate::Artifact). +pub trait Executable { + /// Load this executable with the specified engine. + /// + /// TODO(0-copy): change error type here. + fn load( + &self, + engine: &(dyn Engine + 'static), + ) -> Result, CompileError>; + + /// The features with which this `Executable` was built. + fn features(&self) -> Features; + + /// The CPU features this `Executable` requires. + fn cpu_features(&self) -> EnumSet; + + /// Serializes the artifact into bytes + fn serialize(&self) -> Result, Box>; + + /// Obtain a best effort description for the function at the given function index. + /// + /// Implementations are not required to maintain symbol names, so this may always return None. + fn function_name(&self, index: FunctionIndex) -> Option<&str>; + + /// Internal: support for downcasting `Executable`s. + #[doc(hidden)] + fn type_id(&self, _: private::Internal) -> std::any::TypeId + where + Self: 'static, + { + std::any::TypeId::of::() + } +} + +impl dyn Executable { + /// Downcast a dynamic Executable object to a concrete implementation of the trait. + pub fn downcast_ref(&self) -> Option<&T> { + if std::any::TypeId::of::() == self.type_id(private::Internal(())) { + unsafe { Some(&*(self as *const dyn Executable as *const T)) } + } else { + None + } + } +} diff --git a/runtime/near-vm/lib/engine/src/export.rs b/runtime/near-vm/lib/engine/src/export.rs new file mode 100644 index 00000000000..5bb83ac645e --- /dev/null +++ b/runtime/near-vm/lib/engine/src/export.rs @@ -0,0 +1,3 @@ +use std::sync::Arc; +use wasmer_vm::{ImportInitializerFuncPtr, VMExtern, VMFunction, VMGlobal, VMMemory, VMTable}; + diff --git a/runtime/near-vm/lib/engine/src/lib.rs b/runtime/near-vm/lib/engine/src/lib.rs new file mode 100644 index 00000000000..9746f1013fc --- /dev/null +++ b/runtime/near-vm/lib/engine/src/lib.rs @@ -0,0 +1,36 @@ +//! Generic Engine abstraction for Wasmer Engines. + +#![deny(missing_docs, trivial_numeric_casts, unused_extern_crates)] +#![warn(unused_import_braces)] +#![cfg_attr( + feature = "cargo-clippy", + allow(clippy::new_without_default, clippy::new_without_default) +)] +#![cfg_attr( + feature = "cargo-clippy", + warn( + clippy::float_arithmetic, + clippy::mut_mut, + clippy::nonminimal_bool, + clippy::option_map_unwrap_or, + clippy::option_map_unwrap_or_else, + clippy::print_stdout, + clippy::unicode_not_nfc, + clippy::use_self + ) +)] + +mod engine; +mod error; +mod executable; +mod resolver; +mod trap; + +pub use crate::engine::{Engine, EngineId}; +pub use crate::error::{DeserializeError, ImportError, InstantiationError, LinkError}; +pub use crate::executable::Executable; +pub use crate::resolver::resolve_imports; +pub use crate::trap::*; + +/// Version number of this crate. +pub const VERSION: &str = env!("CARGO_PKG_VERSION"); diff --git a/runtime/near-vm/lib/engine/src/resolver.rs b/runtime/near-vm/lib/engine/src/resolver.rs new file mode 100644 index 00000000000..2f6208729cf --- /dev/null +++ b/runtime/near-vm/lib/engine/src/resolver.rs @@ -0,0 +1,232 @@ +//! Define the `Resolver` trait, allowing custom resolution for external +//! references. + +use crate::{Engine, ImportError, LinkError}; +use more_asserts::assert_ge; +use wasmer_types::entity::{BoxedSlice, EntityRef, PrimaryMap}; +use wasmer_types::{ExternType, FunctionIndex, ImportCounts, MemoryType, TableType}; + +use wasmer_vm::{ + Export, ExportFunctionMetadata, FunctionBodyPtr, ImportFunctionEnv, Imports, MemoryStyle, + Resolver, VMFunctionBody, VMFunctionEnvironment, VMFunctionImport, VMFunctionKind, + VMGlobalImport, VMImport, VMImportType, VMMemoryImport, VMTableImport, +}; + +fn is_compatible_table(ex: &TableType, im: &TableType) -> bool { + (ex.ty == wasmer_types::Type::FuncRef || ex.ty == im.ty) + && im.minimum <= ex.minimum + && (im.maximum.is_none() + || (!ex.maximum.is_none() && im.maximum.unwrap() >= ex.maximum.unwrap())) +} + +fn is_compatible_memory(ex: &MemoryType, im: &MemoryType) -> bool { + im.minimum <= ex.minimum + && (im.maximum.is_none() + || (!ex.maximum.is_none() && im.maximum.unwrap() >= ex.maximum.unwrap())) + && ex.shared == im.shared +} + +/// This function allows to match all imports of a `ModuleInfo` with concrete definitions provided by +/// a `Resolver`. +/// +/// If all imports are satisfied returns an `Imports` instance required for a module instantiation. +pub fn resolve_imports( + engine: &dyn Engine, + resolver: &dyn Resolver, + import_counts: &ImportCounts, + imports: &[VMImport], + finished_dynamic_function_trampolines: &BoxedSlice, +) -> Result { + let mut function_imports = PrimaryMap::with_capacity(import_counts.functions as _); + let mut host_function_env_initializers = + PrimaryMap::with_capacity(import_counts.functions as _); + let mut table_imports = PrimaryMap::with_capacity(import_counts.tables as _); + let mut memory_imports = PrimaryMap::with_capacity(import_counts.memories as _); + let mut global_imports = PrimaryMap::with_capacity(import_counts.globals as _); + for VMImport { + import_no, + module, + field, + ty, + } in imports + { + let resolved = resolver.resolve(*import_no, module, field); + let import_extern = || match ty { + &VMImportType::Table(t) => ExternType::Table(t), + &VMImportType::Memory(t, _) => ExternType::Memory(t), + &VMImportType::Global(t) => ExternType::Global(t), + &VMImportType::Function { + sig, + static_trampoline: _, + } => ExternType::Function( + engine + .lookup_signature(sig) + .expect("VMSharedSignatureIndex is not valid?"), + ), + }; + let resolved = match resolved { + Some(r) => r, + None => { + return Err(LinkError::Import( + module.to_string(), + field.to_string(), + ImportError::UnknownImport(import_extern()), + )); + } + }; + let export_extern = || match resolved { + Export::Function(ref f) => ExternType::Function( + engine + .lookup_signature(f.vm_function.signature) + .expect("VMSharedSignatureIndex not registered with engine (wrong engine?)") + .clone(), + ), + Export::Table(ref t) => ExternType::Table(*t.ty()), + Export::Memory(ref m) => ExternType::Memory(m.ty()), + Export::Global(ref g) => { + let global = g.from.ty(); + ExternType::Global(*global) + } + }; + match (&resolved, ty) { + ( + Export::Function(ex), + VMImportType::Function { + sig, + static_trampoline, + }, + ) if ex.vm_function.signature == *sig => { + let address = match ex.vm_function.kind { + VMFunctionKind::Dynamic => { + // If this is a dynamic imported function, + // the address of the function is the address of the + // reverse trampoline. + let index = FunctionIndex::new(function_imports.len()); + finished_dynamic_function_trampolines[index].0 as *mut VMFunctionBody as _ + + // TODO: We should check that the f.vmctx actually matches + // the shape of `VMDynamicFunctionImportContext` + } + VMFunctionKind::Static => ex.vm_function.address, + }; + + // Clone the host env for this `Instance`. + let env = if let Some(ExportFunctionMetadata { + host_env_clone_fn: clone, + .. + }) = ex.metadata.as_deref() + { + // TODO: maybe start adding asserts in all these + // unsafe blocks to prevent future changes from + // horribly breaking things. + unsafe { + assert!(!ex.vm_function.vmctx.host_env.is_null()); + (clone)(ex.vm_function.vmctx.host_env) + } + } else { + // No `clone` function means we're dealing with some + // other kind of `vmctx`, not a host env of any + // kind. + unsafe { ex.vm_function.vmctx.host_env } + }; + + let trampoline = if let Some(t) = ex.vm_function.call_trampoline { + Some(t) + } else if let VMFunctionKind::Static = ex.vm_function.kind { + // Look up a trampoline by finding one by the signature and fill it in. + Some(*static_trampoline) + } else { + // FIXME: remove this possibility entirely. + None + }; + + function_imports.push(VMFunctionImport { + body: FunctionBodyPtr(address), + signature: *sig, + environment: VMFunctionEnvironment { host_env: env }, + trampoline, + }); + + let initializer = ex + .metadata + .as_ref() + .and_then(|m| m.import_init_function_ptr); + let clone = ex.metadata.as_ref().map(|m| m.host_env_clone_fn); + let destructor = ex.metadata.as_ref().map(|m| m.host_env_drop_fn); + let import_function_env = + if let (Some(clone), Some(destructor)) = (clone, destructor) { + ImportFunctionEnv::Env { + env, + clone, + initializer, + destructor, + } + } else { + ImportFunctionEnv::NoEnv + }; + + host_function_env_initializers.push(import_function_env); + } + (Export::Table(ex), VMImportType::Table(im)) if is_compatible_table(ex.ty(), im) => { + let import_table_ty = ex.from.ty(); + if import_table_ty.ty != im.ty { + return Err(LinkError::Import( + module.to_string(), + field.to_string(), + ImportError::IncompatibleType(import_extern(), export_extern()), + )); + } + table_imports.push(VMTableImport { + definition: ex.from.vmtable(), + from: ex.from.clone(), + }); + } + (Export::Memory(ex), VMImportType::Memory(im, import_memory_style)) + if is_compatible_memory(&ex.ty(), im) => + { + // Sanity-check: Ensure that the imported memory has at least + // guard-page protections the importing module expects it to have. + let export_memory_style = ex.style(); + if let ( + MemoryStyle::Static { bound, .. }, + MemoryStyle::Static { + bound: import_bound, + .. + }, + ) = (export_memory_style.clone(), &import_memory_style) + { + assert_ge!(bound, *import_bound); + } + assert_ge!( + export_memory_style.offset_guard_size(), + import_memory_style.offset_guard_size() + ); + memory_imports.push(VMMemoryImport { + definition: ex.from.vmmemory(), + from: ex.from.clone(), + }); + } + + (Export::Global(ex), VMImportType::Global(im)) if ex.from.ty() == im => { + global_imports.push(VMGlobalImport { + definition: ex.from.vmglobal(), + from: ex.from.clone(), + }); + } + _ => { + return Err(LinkError::Import( + module.to_string(), + field.to_string(), + ImportError::IncompatibleType(import_extern(), export_extern()), + )); + } + } + } + Ok(Imports::new( + function_imports, + host_function_env_initializers, + table_imports, + memory_imports, + global_imports, + )) +} diff --git a/runtime/near-vm/lib/engine/src/trap/error.rs b/runtime/near-vm/lib/engine/src/trap/error.rs new file mode 100644 index 00000000000..9615dfe2590 --- /dev/null +++ b/runtime/near-vm/lib/engine/src/trap/error.rs @@ -0,0 +1,258 @@ +use super::frame_info::{FrameInfo, GlobalFrameInfo, FRAME_INFO}; +use backtrace::Backtrace; +use std::error::Error; +use std::fmt; +use std::sync::Arc; +use wasmer_vm::{raise_user_trap, Trap, TrapCode}; + +/// A struct representing an aborted instruction execution, with a message +/// indicating the cause. +#[derive(Clone)] +pub struct RuntimeError { + inner: Arc, +} + +/// The source of the `RuntimeError`. +#[derive(Debug)] +enum RuntimeErrorSource { + Generic(String), + OOM, + User(Box), + Trap(TrapCode), +} + +impl fmt::Display for RuntimeErrorSource { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + match self { + Self::Generic(s) => write!(f, "{}", s), + Self::User(s) => write!(f, "{}", s), + Self::OOM => write!(f, "Wasmer VM out of memory"), + Self::Trap(s) => write!(f, "{}", s.message()), + } + } +} + +struct RuntimeErrorInner { + /// The source error (this can be a custom user `Error` or a [`TrapCode`]) + source: RuntimeErrorSource, + /// The reconstructed Wasm trace (from the native trace and the `GlobalFrameInfo`). + wasm_trace: Vec, + /// The native backtrace + native_trace: Backtrace, +} + +fn _assert_trap_is_sync_and_send(t: &Trap) -> (&dyn Sync, &dyn Send) { + (t, t) +} + +impl RuntimeError { + /// Creates a new generic `RuntimeError` with the given `message`. + /// + /// # Example + /// ``` + /// let trap = wasmer_engine::RuntimeError::new("unexpected error"); + /// assert_eq!("unexpected error", trap.message()); + /// ``` + pub fn new>(message: I) -> Self { + let info = FRAME_INFO.read().unwrap(); + let msg = message.into(); + Self::new_with_trace( + &info, + None, + RuntimeErrorSource::Generic(msg), + Backtrace::new_unresolved(), + ) + } + + /// Create a new RuntimeError from a Trap. + pub fn from_trap(trap: Trap) -> Self { + let info = FRAME_INFO.read().unwrap(); + match trap { + // A user error + Trap::User(error) => { + match error.downcast::() { + // The error is already a RuntimeError, we return it directly + Ok(runtime_error) => *runtime_error, + Err(e) => Self::new_with_trace( + &info, + None, + RuntimeErrorSource::User(e), + Backtrace::new_unresolved(), + ), + } + } + // A trap caused by the VM being Out of Memory + Trap::OOM { backtrace } => { + Self::new_with_trace(&info, None, RuntimeErrorSource::OOM, backtrace) + } + // A trap caused by an error on the generated machine code for a Wasm function + Trap::Wasm { + pc, + signal_trap, + backtrace, + } => { + let code = info + .lookup_trap_info(pc) + .map_or(signal_trap.unwrap_or(TrapCode::StackOverflow), |info| { + info.trap_code + }); + Self::new_with_trace(&info, Some(pc), RuntimeErrorSource::Trap(code), backtrace) + } + // A trap triggered manually from the Wasmer runtime + Trap::Lib { + trap_code, + backtrace, + } => Self::new_with_trace(&info, None, RuntimeErrorSource::Trap(trap_code), backtrace), + } + } + + /// Raises a custom user Error + pub fn raise(error: Box) -> ! { + unsafe { raise_user_trap(error) } + } + + fn new_with_trace( + info: &GlobalFrameInfo, + trap_pc: Option, + source: RuntimeErrorSource, + native_trace: Backtrace, + ) -> Self { + let frames: Vec = native_trace + .frames() + .iter() + .filter_map(|frame| { + let pc = frame.ip() as usize; + if pc == 0 { + None + } else { + // Note that we need to be careful about the pc we pass in here to + // lookup frame information. This program counter is used to + // translate back to an original source location in the origin wasm + // module. If this pc is the exact pc that the trap happened at, + // then we look up that pc precisely. Otherwise backtrace + // information typically points at the pc *after* the call + // instruction (because otherwise it's likely a call instruction on + // the stack). In that case we want to lookup information for the + // previous instruction (the call instruction) so we subtract one as + // the lookup. + let pc_to_lookup = if Some(pc) == trap_pc { pc } else { pc - 1 }; + Some(pc_to_lookup) + } + }) + .collect(); + + // Let's construct the trace + let wasm_trace = frames + .into_iter() + .filter_map(|pc| info.lookup_frame_info(pc)) + .collect::>(); + + Self { + inner: Arc::new(RuntimeErrorInner { + source, + wasm_trace, + native_trace, + }), + } + } + + /// Returns a reference the `message` stored in `Trap`. + pub fn message(&self) -> String { + self.inner.source.to_string() + } + + /// Returns a list of function frames in WebAssembly code that led to this + /// trap happening. + pub fn trace(&self) -> &[FrameInfo] { + &self.inner.wasm_trace + } + + /// Attempts to downcast the `RuntimeError` to a concrete type. + pub fn downcast(self) -> Result { + match Arc::try_unwrap(self.inner) { + // We only try to downcast user errors + Ok(RuntimeErrorInner { + source: RuntimeErrorSource::User(err), + .. + }) if err.is::() => Ok(*err.downcast::().unwrap()), + Ok(inner) => Err(Self { + inner: Arc::new(inner), + }), + Err(inner) => Err(Self { inner }), + } + } + + /// Returns trap code, if it's a Trap + pub fn to_trap(self) -> Option { + if let RuntimeErrorSource::Trap(trap_code) = self.inner.source { + Some(trap_code) + } else { + None + } + } + + /// Returns true if the `RuntimeError` is the same as T + pub fn is(&self) -> bool { + match &self.inner.source { + RuntimeErrorSource::User(err) => err.is::(), + _ => false, + } + } +} + +impl fmt::Debug for RuntimeError { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.debug_struct("RuntimeError") + .field("source", &self.inner.source) + .field("wasm_trace", &self.inner.wasm_trace) + .field("native_trace", &self.inner.native_trace) + .finish() + } +} + +impl fmt::Display for RuntimeError { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + write!(f, "RuntimeError: {}", self.message())?; + let trace = self.trace(); + if trace.is_empty() { + return Ok(()); + } + for frame in self.trace().iter() { + let name = frame.module_name(); + let func_index = frame.func_index(); + writeln!(f)?; + write!(f, " at ")?; + match frame.function_name() { + Some(name) => match rustc_demangle::try_demangle(name) { + Ok(name) => write!(f, "{}", name)?, + Err(_) => write!(f, "{}", name)?, + }, + None => write!(f, "")?, + } + write!( + f, + " ({}[{}]:0x{:x})", + name, + func_index, + frame.module_offset() + )?; + } + Ok(()) + } +} + +impl std::error::Error for RuntimeError { + fn source(&self) -> Option<&(dyn std::error::Error + 'static)> { + match &self.inner.source { + RuntimeErrorSource::User(err) => Some(&**err), + RuntimeErrorSource::Trap(err) => Some(err), + _ => None, + } + } +} + +impl From for RuntimeError { + fn from(trap: Trap) -> Self { + Self::from_trap(trap) + } +} diff --git a/runtime/near-vm/lib/engine/src/trap/frame_info.rs b/runtime/near-vm/lib/engine/src/trap/frame_info.rs new file mode 100644 index 00000000000..10a6c4f89c9 --- /dev/null +++ b/runtime/near-vm/lib/engine/src/trap/frame_info.rs @@ -0,0 +1,244 @@ +//! This module is used for having backtraces in the Wasm runtime. +//! Once the Compiler has compiled the ModuleInfo, and we have a set of +//! compiled functions (addresses and function index) and a module, +//! then we can use this to set a backtrace for that module. +//! +//! # Example +//! ```ignore +//! use wasmer_vm::{FRAME_INFO}; +//! use wasmer_types::ModuleInfo; +//! +//! let module: ModuleInfo = ...; +//! FRAME_INFO.register(module, compiled_functions); +//! ``` +use std::collections::BTreeMap; +use std::sync::{Arc, RwLock}; +use wasmer_compiler::{CompiledFunctionFrameInfo, SourceLoc, TrapInformation}; +use wasmer_types::entity::{EntityRef, PrimaryMap}; +use wasmer_types::{LocalFunctionIndex, ModuleInfo}; + +lazy_static::lazy_static! { + /// This is a global cache of backtrace frame information for all active + /// + /// This global cache is used during `Trap` creation to symbolicate frames. + /// This is populated on module compilation, and it is cleared out whenever + /// all references to a module are dropped. + pub static ref FRAME_INFO: RwLock = Default::default(); +} + +#[derive(Default)] +pub struct GlobalFrameInfo { + /// An internal map that keeps track of backtrace frame information for + /// each module. + /// + /// This map is morally a map of ranges to a map of information for that + /// module. Each module is expected to reside in a disjoint section of + /// contiguous memory. No modules can overlap. + /// + /// The key of this map is the highest address in the module and the value + /// is the module's information, which also contains the start address. + ranges: BTreeMap, +} + +/// An RAII structure used to unregister a module's frame information when the +/// module is destroyed. +pub struct GlobalFrameInfoRegistration { + /// The key that will be removed from the global `ranges` map when this is + /// dropped. + key: usize, +} + +#[derive(Debug)] +struct ModuleInfoFrameInfo { + start: usize, + functions: BTreeMap, + module: Arc, + frame_infos: PrimaryMap, +} + +impl ModuleInfoFrameInfo { + fn function_debug_info(&self, local_index: LocalFunctionIndex) -> &CompiledFunctionFrameInfo { + &self.frame_infos.get(local_index).unwrap() + } + + /// Gets a function given a pc + fn function_info(&self, pc: usize) -> Option<&FunctionInfo> { + let (end, func) = self.functions.range(pc..).next()?; + if func.start <= pc && pc <= *end { + return Some(func); + } else { + None + } + } +} + +#[derive(Debug)] +struct FunctionInfo { + start: usize, + local_index: LocalFunctionIndex, +} + +impl GlobalFrameInfo { + /// Fetches frame information about a program counter in a backtrace. + /// + /// Returns an object if this `pc` is known to some previously registered + /// module, or returns `None` if no information can be found. + pub fn lookup_frame_info(&self, pc: usize) -> Option { + let module = self.module_info(pc)?; + let func = module.function_info(pc)?; + + // Use our relative position from the start of the function to find the + // machine instruction that corresponds to `pc`, which then allows us to + // map that to a wasm original source location. + let rel_pos = pc - func.start; + let instr_map = &module.function_debug_info(func.local_index).address_map; + let pos = match instr_map + .instructions + .binary_search_by_key(&rel_pos, |map| map.code_offset) + { + // Exact hit! + Ok(pos) => Some(pos), + + // This *would* be at the first slot in the array, so no + // instructions cover `pc`. + Err(0) => None, + + // This would be at the `nth` slot, so check `n-1` to see if we're + // part of that instruction. This happens due to the minus one when + // this function is called form trap symbolication, where we don't + // always get called with a `pc` that's an exact instruction + // boundary. + Err(n) => { + let instr = &instr_map.instructions[n - 1]; + if instr.code_offset <= rel_pos && rel_pos < instr.code_offset + instr.code_len { + Some(n - 1) + } else { + None + } + } + }; + + let instr = match pos { + Some(pos) => instr_map.instructions[pos].srcloc, + // Some compilers don't emit yet the full trap information for each of + // the instructions (such as LLVM). + // In case no specific instruction is found, we return by default the + // start offset of the function. + None => instr_map.start_srcloc, + }; + let func_index = module.module.func_index(func.local_index); + Some(FrameInfo { + module_name: module.module.name(), + func_index: func_index.index() as u32, + function_name: module.module.function_names.get(&func_index).cloned(), + instr, + func_start: instr_map.start_srcloc, + }) + } + + /// Fetches trap information about a program counter in a backtrace. + pub fn lookup_trap_info(&self, pc: usize) -> Option<&TrapInformation> { + let module = self.module_info(pc)?; + let func = module.function_info(pc)?; + let traps = &module.function_debug_info(func.local_index).traps; + let idx = traps + .binary_search_by_key(&((pc - func.start) as u32), |info| info.code_offset) + .ok()?; + Some(&traps[idx]) + } + + /// Gets a module given a pc + fn module_info(&self, pc: usize) -> Option<&ModuleInfoFrameInfo> { + let (end, module_info) = self.ranges.range(pc..).next()?; + if module_info.start <= pc && pc <= *end { + Some(module_info) + } else { + None + } + } +} + +impl Drop for GlobalFrameInfoRegistration { + fn drop(&mut self) { + if let Ok(mut info) = FRAME_INFO.write() { + info.ranges.remove(&self.key); + } + } +} + +/// Description of a frame in a backtrace for a [`RuntimeError::trace`](crate::RuntimeError::trace). +/// +/// Whenever a WebAssembly trap occurs an instance of [`RuntimeError`] +/// is created. Each [`RuntimeError`] has a backtrace of the +/// WebAssembly frames that led to the trap, and each frame is +/// described by this structure. +/// +/// [`RuntimeError`]: crate::RuntimeError +#[derive(Debug, Clone)] +pub struct FrameInfo { + module_name: String, + func_index: u32, + function_name: Option, + func_start: SourceLoc, + instr: SourceLoc, +} + +impl FrameInfo { + /// Returns the WebAssembly function index for this frame. + /// + /// This function index is the index in the function index space of the + /// WebAssembly module that this frame comes from. + pub fn func_index(&self) -> u32 { + self.func_index + } + + /// Returns the identifer of the module that this frame is for. + /// + /// ModuleInfo identifiers are present in the `name` section of a WebAssembly + /// binary, but this may not return the exact item in the `name` section. + /// ModuleInfo names can be overwritten at construction time or perhaps inferred + /// from file names. The primary purpose of this function is to assist in + /// debugging and therefore may be tweaked over time. + /// + /// This function returns `None` when no name can be found or inferred. + pub fn module_name(&self) -> &str { + &self.module_name + } + + /// Returns a descriptive name of the function for this frame, if one is + /// available. + /// + /// The name of this function may come from the `name` section of the + /// WebAssembly binary, or wasmer may try to infer a better name for it if + /// not available, for example the name of the export if it's exported. + /// + /// This return value is primarily used for debugging and human-readable + /// purposes for things like traps. Note that the exact return value may be + /// tweaked over time here and isn't guaranteed to be something in + /// particular about a wasm module due to its primary purpose of assisting + /// in debugging. + /// + /// This function returns `None` when no name could be inferred. + pub fn function_name(&self) -> Option<&str> { + self.function_name.as_deref() + } + + /// Returns the offset within the original wasm module this frame's program + /// counter was at. + /// + /// The offset here is the offset from the beginning of the original wasm + /// module to the instruction that this frame points to. + pub fn module_offset(&self) -> usize { + self.instr.bits() as usize + } + + /// Returns the offset from the original wasm module's function to this + /// frame's program counter. + /// + /// The offset here is the offset from the beginning of the defining + /// function of this frame (within the wasm module) to the instruction this + /// frame points to. + pub fn func_offset(&self) -> usize { + (self.instr.bits() - self.func_start.bits()) as usize + } +} diff --git a/runtime/near-vm/lib/engine/src/trap/mod.rs b/runtime/near-vm/lib/engine/src/trap/mod.rs new file mode 100644 index 00000000000..3144b41cff2 --- /dev/null +++ b/runtime/near-vm/lib/engine/src/trap/mod.rs @@ -0,0 +1,4 @@ +mod error; +mod frame_info; +pub use error::RuntimeError; +pub use frame_info::{FrameInfo, GlobalFrameInfoRegistration}; diff --git a/runtime/near-vm/lib/types/Cargo.toml b/runtime/near-vm/lib/types/Cargo.toml new file mode 100644 index 00000000000..36132ecc8b1 --- /dev/null +++ b/runtime/near-vm/lib/types/Cargo.toml @@ -0,0 +1,32 @@ +[package] +name = "wasmer-types-near" +version = "2.4.0" +description = "Wasmer Common Types" +categories = ["wasm", "no-std", "data-structures"] +keywords = ["wasm", "webassembly", "types"] +authors = ["Wasmer Engineering Team "] +repository = "https://github.com/wasmerio/wasmer" +license = "MIT OR Apache-2.0 WITH LLVM-exception" +readme = "README.md" +edition = "2018" + +[lib] +name = "wasmer_types" + +[dependencies] +thiserror = "1.0" +indexmap = { version = "1.6" } +num-traits = "0.2.15" +rkyv = { version = "0.7.20" } + +[dev-dependencies] +bolero = "0.6.0" + +[features] +default = ["std"] +std = [] +core = [] + +[[test]] +name = "partial-sum-map" +harness = false diff --git a/runtime/near-vm/lib/types/README.md b/runtime/near-vm/lib/types/README.md new file mode 100644 index 00000000000..799c1bcb4cc --- /dev/null +++ b/runtime/near-vm/lib/types/README.md @@ -0,0 +1,28 @@ +# `wasmer-types` [![Build Status](https://github.com/wasmerio/wasmer/workflows/build/badge.svg?style=flat-square)](https://github.com/wasmerio/wasmer/actions?query=workflow%3Abuild) [![Join Wasmer Slack](https://img.shields.io/static/v1?label=Slack&message=join%20chat&color=brighgreen&style=flat-square)](https://slack.wasmer.io) [![MIT License](https://img.shields.io/github/license/wasmerio/wasmer.svg?style=flat-square)](https://github.com/wasmerio/wasmer/blob/master/LICENSE) + +This library provides all the types and traits necessary to use +WebAssembly easily anywhere. + +Among other things, it defines the following _types_: + +* `units` like `Pages` or `Bytes` +* `types` and `values` like `I32`, `I64`, `F32`, `F64`, `ExternRef`, + `FuncRef`, `V128`, value conversions, `ExternType`, `FunctionType` + etc. +* `native` contains a set of trait and implementations to deal with + WebAssembly types that have a direct representation on the host, +* `memory_view`, an API to read/write memories when bytes are + interpreted as particular types (`i8`, `i16`, `i32` etc.) +* `indexes` contains all the possible WebAssembly module indexes for + various types +* `initializers` for tables, data etc. +* `features` to enable or disable some WebAssembly features inside the + Wasmer runtime + + +### Acknowledgments + +This project borrowed some of the code for the entity structure from [cranelift-entity](https://crates.io/crates/cranelift-entity). +We decided to move it here to help on serialization/deserialization and also to ease the integration with other tools like `loupe`. + +Please check [Wasmer ATTRIBUTIONS](https://github.com/wasmerio/wasmer/blob/master/ATTRIBUTIONS.md) to further see licenses and other attributions of the project. diff --git a/runtime/near-vm/lib/types/src/archives.rs b/runtime/near-vm/lib/types/src/archives.rs new file mode 100644 index 00000000000..f2c26d64321 --- /dev/null +++ b/runtime/near-vm/lib/types/src/archives.rs @@ -0,0 +1,44 @@ +#[cfg(feature = "core")] +use core::hash::Hash; +use indexmap::IndexMap; +use rkyv::Archive; +#[cfg(feature = "std")] +use std::hash::Hash; + +#[derive(rkyv::Serialize, rkyv::Deserialize, rkyv::Archive)] +/// See [`IndexMap`] +pub struct ArchivableIndexMap { + entries: Vec<(K, V)>, +} + +impl ArchivedArchivableIndexMap { + pub fn iter(&self) -> core::slice::Iter<'_, (K::Archived, V::Archived)> { + self.entries.iter() + } +} + +impl From> + for ArchivableIndexMap +{ + fn from(it: IndexMap) -> ArchivableIndexMap { + let mut r = ArchivableIndexMap { + entries: Vec::new(), + }; + for (k, v) in it.into_iter() { + r.entries.push((k, v)); + } + r + } +} + +impl Into> + for ArchivableIndexMap +{ + fn into(self) -> IndexMap { + let mut r = IndexMap::new(); + for (k, v) in self.entries.into_iter() { + r.insert(k, v); + } + r + } +} diff --git a/runtime/near-vm/lib/types/src/entity/boxed_slice.rs b/runtime/near-vm/lib/types/src/entity/boxed_slice.rs new file mode 100644 index 00000000000..4f9aa95eaf8 --- /dev/null +++ b/runtime/near-vm/lib/types/src/entity/boxed_slice.rs @@ -0,0 +1,319 @@ +// This file contains code from external sources. +// Attributions: https://github.com/wasmerio/wasmer/blob/master/ATTRIBUTIONS.md + +//! Boxed slices for `PrimaryMap`. + +use crate::entity::iter::{Iter, IterMut}; +use crate::entity::keys::Keys; +use crate::entity::EntityRef; +use crate::lib::std::boxed::Box; +use crate::lib::std::marker::PhantomData; +use crate::lib::std::ops::{Index, IndexMut}; +use crate::lib::std::slice; + +/// A slice mapping `K -> V` allocating dense entity references. +/// +/// The `BoxedSlice` data structure uses the dense index space to implement a map with a boxed +/// slice. +#[derive(Debug, Clone)] +pub struct BoxedSlice +where + K: EntityRef, +{ + elems: Box<[V]>, + unused: PhantomData, +} + +impl BoxedSlice +where + K: EntityRef, +{ + /// Create a new slice from a raw pointer. A safer way to create slices is + /// to use `PrimaryMap::into_boxed_slice()`. + /// + /// # Safety + /// + /// This relies on `raw` pointing to a valid slice of `V`s. + pub unsafe fn from_raw(raw: *mut [V]) -> Self { + Self { + elems: Box::from_raw(raw), + unused: PhantomData, + } + } + + /// Check if `k` is a valid key in the map. + pub fn is_valid(&self, k: K) -> bool { + k.index() < self.elems.len() + } + + /// Get the element at `k` if it exists. + pub fn get(&self, k: K) -> Option<&V> { + self.elems.get(k.index()) + } + + /// Get the element at `k` if it exists, mutable version. + pub fn get_mut(&mut self, k: K) -> Option<&mut V> { + self.elems.get_mut(k.index()) + } + + /// Is this map completely empty? + pub fn is_empty(&self) -> bool { + self.elems.is_empty() + } + + /// Get the total number of entity references created. + pub fn len(&self) -> usize { + self.elems.len() + } + + /// Iterate over all the keys in this map. + pub fn keys(&self) -> Keys { + Keys::with_len(self.elems.len()) + } + + /// Iterate over all the values in this map. + pub fn values(&self) -> slice::Iter { + self.elems.iter() + } + + /// Iterate over all the values in this map, mutable edition. + pub fn values_mut(&mut self) -> slice::IterMut { + self.elems.iter_mut() + } + + /// Iterate over all the keys and values in this map. + pub fn iter(&self) -> Iter { + Iter::new(self.elems.iter()) + } + + /// Iterate over all the keys and values in this map, mutable edition. + pub fn iter_mut(&mut self) -> IterMut { + IterMut::new(self.elems.iter_mut()) + } + + /// Returns the last element that was inserted in the map. + pub fn last(&self) -> Option<&V> { + self.elems.last() + } +} + +/// Immutable indexing into a `BoxedSlice`. +/// The indexed value must be in the map. +impl Index for BoxedSlice +where + K: EntityRef, +{ + type Output = V; + + fn index(&self, k: K) -> &V { + &self.elems[k.index()] + } +} + +/// Mutable indexing into a `BoxedSlice`. +impl IndexMut for BoxedSlice +where + K: EntityRef, +{ + fn index_mut(&mut self, k: K) -> &mut V { + &mut self.elems[k.index()] + } +} + +impl<'a, K, V> IntoIterator for &'a BoxedSlice +where + K: EntityRef, +{ + type Item = (K, &'a V); + type IntoIter = Iter<'a, K, V>; + + fn into_iter(self) -> Self::IntoIter { + Iter::new(self.elems.iter()) + } +} + +impl<'a, K, V> IntoIterator for &'a mut BoxedSlice +where + K: EntityRef, +{ + type Item = (K, &'a mut V); + type IntoIter = IterMut<'a, K, V>; + + fn into_iter(self) -> Self::IntoIter { + IterMut::new(self.elems.iter_mut()) + } +} + +#[cfg(test)] +mod tests { + use super::*; + use crate::entity::PrimaryMap; + use crate::lib::std::vec::Vec; + + // `EntityRef` impl for testing. + #[derive(Clone, Copy, Debug, PartialEq, Eq)] + struct E(u32); + + impl EntityRef for E { + fn new(i: usize) -> Self { + E(i as u32) + } + fn index(self) -> usize { + self.0 as usize + } + } + + #[test] + fn basic() { + let r0 = E(0); + let r1 = E(1); + let p = PrimaryMap::::new(); + let m = p.into_boxed_slice(); + + let v: Vec = m.keys().collect(); + assert_eq!(v, []); + + assert!(!m.is_valid(r0)); + assert!(!m.is_valid(r1)); + } + + #[test] + fn iter() { + let mut p: PrimaryMap = PrimaryMap::new(); + p.push(12); + p.push(33); + let mut m = p.into_boxed_slice(); + + let mut i = 0; + for (key, value) in &m { + assert_eq!(key.index(), i); + match i { + 0 => assert_eq!(*value, 12), + 1 => assert_eq!(*value, 33), + _ => panic!(), + } + i += 1; + } + i = 0; + for (key_mut, value_mut) in m.iter_mut() { + assert_eq!(key_mut.index(), i); + match i { + 0 => assert_eq!(*value_mut, 12), + 1 => assert_eq!(*value_mut, 33), + _ => panic!(), + } + i += 1; + } + } + + #[test] + fn iter_rev() { + let mut p: PrimaryMap = PrimaryMap::new(); + p.push(12); + p.push(33); + let mut m = p.into_boxed_slice(); + + let mut i = 2; + for (key, value) in m.iter().rev() { + i -= 1; + assert_eq!(key.index(), i); + match i { + 0 => assert_eq!(*value, 12), + 1 => assert_eq!(*value, 33), + _ => panic!(), + } + } + + i = 2; + for (key, value) in m.iter_mut().rev() { + i -= 1; + assert_eq!(key.index(), i); + match i { + 0 => assert_eq!(*value, 12), + 1 => assert_eq!(*value, 33), + _ => panic!(), + } + } + } + #[test] + fn keys() { + let mut p: PrimaryMap = PrimaryMap::new(); + p.push(12); + p.push(33); + let m = p.into_boxed_slice(); + + let mut i = 0; + for key in m.keys() { + assert_eq!(key.index(), i); + i += 1; + } + } + + #[test] + fn keys_rev() { + let mut p: PrimaryMap = PrimaryMap::new(); + p.push(12); + p.push(33); + let m = p.into_boxed_slice(); + + let mut i = 2; + for key in m.keys().rev() { + i -= 1; + assert_eq!(key.index(), i); + } + } + + #[test] + fn values() { + let mut p: PrimaryMap = PrimaryMap::new(); + p.push(12); + p.push(33); + let mut m = p.into_boxed_slice(); + + let mut i = 0; + for value in m.values() { + match i { + 0 => assert_eq!(*value, 12), + 1 => assert_eq!(*value, 33), + _ => panic!(), + } + i += 1; + } + i = 0; + for value_mut in m.values_mut() { + match i { + 0 => assert_eq!(*value_mut, 12), + 1 => assert_eq!(*value_mut, 33), + _ => panic!(), + } + i += 1; + } + } + + #[test] + fn values_rev() { + let mut p: PrimaryMap = PrimaryMap::new(); + p.push(12); + p.push(33); + let mut m = p.into_boxed_slice(); + + let mut i = 2; + for value in m.values().rev() { + i -= 1; + match i { + 0 => assert_eq!(*value, 12), + 1 => assert_eq!(*value, 33), + _ => panic!(), + } + } + i = 2; + for value_mut in m.values_mut().rev() { + i -= 1; + match i { + 0 => assert_eq!(*value_mut, 12), + 1 => assert_eq!(*value_mut, 33), + _ => panic!(), + } + } + } +} diff --git a/runtime/near-vm/lib/types/src/entity/iter.rs b/runtime/near-vm/lib/types/src/entity/iter.rs new file mode 100644 index 00000000000..a157abef8f1 --- /dev/null +++ b/runtime/near-vm/lib/types/src/entity/iter.rs @@ -0,0 +1,127 @@ +// This file contains code from external sources. +// Attributions: https://github.com/wasmerio/wasmer/blob/master/ATTRIBUTIONS.md + +//! A double-ended iterator over entity references and entities. + +use crate::entity::EntityRef; +use crate::lib::std::iter::Enumerate; +use crate::lib::std::marker::PhantomData; +use crate::lib::std::slice; +use crate::lib::std::vec; + +/// Iterate over all keys in order. +pub struct Iter<'a, K: EntityRef, V> +where + V: 'a, +{ + enumerate: Enumerate>, + unused: PhantomData, +} + +impl<'a, K: EntityRef, V> Iter<'a, K, V> { + /// Create an `Iter` iterator that visits the `PrimaryMap` keys and values + /// of `iter`. + pub fn new(iter: slice::Iter<'a, V>) -> Self { + Self { + enumerate: iter.enumerate(), + unused: PhantomData, + } + } +} + +impl<'a, K: EntityRef, V> Iterator for Iter<'a, K, V> { + type Item = (K, &'a V); + + fn next(&mut self) -> Option { + self.enumerate.next().map(|(i, v)| (K::new(i), v)) + } + + fn size_hint(&self) -> (usize, Option) { + self.enumerate.size_hint() + } +} + +impl<'a, K: EntityRef, V> DoubleEndedIterator for Iter<'a, K, V> { + fn next_back(&mut self) -> Option { + self.enumerate.next_back().map(|(i, v)| (K::new(i), v)) + } +} + +impl<'a, K: EntityRef, V> ExactSizeIterator for Iter<'a, K, V> {} + +/// Iterate over all keys in order. +pub struct IterMut<'a, K: EntityRef, V> +where + V: 'a, +{ + enumerate: Enumerate>, + unused: PhantomData, +} + +impl<'a, K: EntityRef, V> IterMut<'a, K, V> { + /// Create an `IterMut` iterator that visits the `PrimaryMap` keys and values + /// of `iter`. + pub fn new(iter: slice::IterMut<'a, V>) -> Self { + Self { + enumerate: iter.enumerate(), + unused: PhantomData, + } + } +} + +impl<'a, K: EntityRef, V> Iterator for IterMut<'a, K, V> { + type Item = (K, &'a mut V); + + fn next(&mut self) -> Option { + self.enumerate.next().map(|(i, v)| (K::new(i), v)) + } + + fn size_hint(&self) -> (usize, Option) { + self.enumerate.size_hint() + } +} + +impl<'a, K: EntityRef, V> DoubleEndedIterator for IterMut<'a, K, V> { + fn next_back(&mut self) -> Option { + self.enumerate.next_back().map(|(i, v)| (K::new(i), v)) + } +} + +impl<'a, K: EntityRef, V> ExactSizeIterator for IterMut<'a, K, V> {} + +/// Iterate over all keys in order. +pub struct IntoIter { + enumerate: Enumerate>, + unused: PhantomData, +} + +impl IntoIter { + /// Create an `IntoIter` iterator that visits the `PrimaryMap` keys and values + /// of `iter`. + pub fn new(iter: vec::IntoIter) -> Self { + Self { + enumerate: iter.enumerate(), + unused: PhantomData, + } + } +} + +impl Iterator for IntoIter { + type Item = (K, V); + + fn next(&mut self) -> Option { + self.enumerate.next().map(|(i, v)| (K::new(i), v)) + } + + fn size_hint(&self) -> (usize, Option) { + self.enumerate.size_hint() + } +} + +impl DoubleEndedIterator for IntoIter { + fn next_back(&mut self) -> Option { + self.enumerate.next_back().map(|(i, v)| (K::new(i), v)) + } +} + +impl ExactSizeIterator for IntoIter {} diff --git a/runtime/near-vm/lib/types/src/entity/keys.rs b/runtime/near-vm/lib/types/src/entity/keys.rs new file mode 100644 index 00000000000..08d5a225c18 --- /dev/null +++ b/runtime/near-vm/lib/types/src/entity/keys.rs @@ -0,0 +1,61 @@ +// This file contains code from external sources. +// Attributions: https://github.com/wasmerio/wasmer/blob/master/ATTRIBUTIONS.md + +//! A double-ended iterator over entity references. +//! +//! When `core::iter::Step` is stabilized, `Keys` could be implemented as a wrapper around +//! `core::ops::Range`, but for now, we implement it manually. + +use crate::entity::EntityRef; +use crate::lib::std::marker::PhantomData; + +/// Iterate over all keys in order. +pub struct Keys { + pos: usize, + rev_pos: usize, + unused: PhantomData, +} + +impl Keys { + /// Create a `Keys` iterator that visits `len` entities starting from 0. + pub fn with_len(len: usize) -> Self { + Self { + pos: 0, + rev_pos: len, + unused: PhantomData, + } + } +} + +impl Iterator for Keys { + type Item = K; + + fn next(&mut self) -> Option { + if self.pos < self.rev_pos { + let k = K::new(self.pos); + self.pos += 1; + Some(k) + } else { + None + } + } + + fn size_hint(&self) -> (usize, Option) { + let size = self.rev_pos - self.pos; + (size, Some(size)) + } +} + +impl DoubleEndedIterator for Keys { + fn next_back(&mut self) -> Option { + if self.rev_pos > self.pos { + let k = K::new(self.rev_pos - 1); + self.rev_pos -= 1; + Some(k) + } else { + None + } + } +} + +impl ExactSizeIterator for Keys {} diff --git a/runtime/near-vm/lib/types/src/entity/mod.rs b/runtime/near-vm/lib/types/src/entity/mod.rs new file mode 100644 index 00000000000..f654bdaff21 --- /dev/null +++ b/runtime/near-vm/lib/types/src/entity/mod.rs @@ -0,0 +1,95 @@ +// This file contains code from external sources. +// Attributions: https://github.com/wasmerio/wasmer/blob/master/ATTRIBUTIONS.md + +/// A type wrapping a small integer index should implement `EntityRef` so it can be used as the key +/// of an `SecondaryMap` or `SparseMap`. +pub trait EntityRef: Copy + Eq { + /// Create a new entity reference from a small integer. + /// This should crash if the requested index is not representable. + fn new(_: usize) -> Self; + + /// Get the index that was used to create this entity reference. + fn index(self) -> usize; +} + +/// Macro which provides the common implementation of a 32-bit entity reference. +#[macro_export] +macro_rules! entity_impl { + // Basic traits. + ($entity:ident) => { + impl $crate::entity::EntityRef for $entity { + fn new(index: usize) -> Self { + debug_assert!(index < ($crate::lib::std::u32::MAX as usize)); + $entity(index as u32) + } + + fn index(self) -> usize { + self.0 as usize + } + } + + impl $crate::entity::packed_option::ReservedValue for $entity { + fn reserved_value() -> $entity { + $entity($crate::lib::std::u32::MAX) + } + + fn is_reserved_value(&self) -> bool { + self.0 == $crate::lib::std::u32::MAX + } + } + + impl $entity { + /// Create a new instance from a `u32`. + #[allow(dead_code)] + pub fn from_u32(x: u32) -> Self { + debug_assert!(x < $crate::lib::std::u32::MAX); + $entity(x) + } + + /// Return the underlying index value as a `u32`. + #[allow(dead_code)] + pub fn as_u32(self) -> u32 { + self.0 + } + } + }; + + // Include basic `Display` impl using the given display prefix. + // Display a `Block` reference as "block12". + ($entity:ident, $display_prefix:expr) => { + entity_impl!($entity); + + impl $crate::lib::std::fmt::Display for $entity { + fn fmt( + &self, + f: &mut $crate::lib::std::fmt::Formatter, + ) -> $crate::lib::std::fmt::Result { + write!(f, concat!($display_prefix, "{}"), self.0) + } + } + + impl $crate::lib::std::fmt::Debug for $entity { + fn fmt( + &self, + f: &mut $crate::lib::std::fmt::Formatter, + ) -> $crate::lib::std::fmt::Result { + (self as &dyn $crate::lib::std::fmt::Display).fmt(f) + } + } + }; +} + +pub mod packed_option; + +mod boxed_slice; +mod iter; +mod keys; +mod primary_map; +mod secondary_map; + +pub use crate::entity_impl; +pub use boxed_slice::BoxedSlice; +pub use iter::{Iter, IterMut}; +pub use keys::Keys; +pub use primary_map::PrimaryMap; +pub use secondary_map::SecondaryMap; diff --git a/runtime/near-vm/lib/types/src/entity/packed_option.rs b/runtime/near-vm/lib/types/src/entity/packed_option.rs new file mode 100644 index 00000000000..60dd208f0bb --- /dev/null +++ b/runtime/near-vm/lib/types/src/entity/packed_option.rs @@ -0,0 +1,171 @@ +// This file contains code from external sources. +// Attributions: https://github.com/wasmerio/wasmer/blob/master/ATTRIBUTIONS.md + +//! Compact representation of `Option` for types with a reserved value. +//! +//! Small types are often used in tables and linked lists where an +//! `Option` is needed. Unfortunately, that would double the size of the tables +//! because `Option` is twice as big as `T`. +//! +//! This module provides a `PackedOption` for types that have a reserved value that can be used +//! to represent `None`. + +use crate::lib::std::fmt; +use crate::lib::std::mem; + +/// Types that have a reserved value which can't be created any other way. +pub trait ReservedValue { + /// Create an instance of the reserved value. + fn reserved_value() -> Self; + /// Checks whether value is the reserved one. + fn is_reserved_value(&self) -> bool; +} + +/// Packed representation of `Option`. +#[derive(Clone, Copy, PartialEq, PartialOrd, Eq, Ord, Hash)] +pub struct PackedOption(T); + +impl PackedOption { + /// Returns `true` if the packed option is a `None` value. + pub fn is_none(&self) -> bool { + self.0.is_reserved_value() + } + + /// Returns `true` if the packed option is a `Some` value. + pub fn is_some(&self) -> bool { + !self.0.is_reserved_value() + } + + /// Expand the packed option into a normal `Option`. + pub fn expand(self) -> Option { + if self.is_none() { + None + } else { + Some(self.0) + } + } + + /// Maps a `PackedOption` to `Option` by applying a function to a contained value. + pub fn map(self, f: F) -> Option + where + F: FnOnce(T) -> U, + { + self.expand().map(f) + } + + /// Unwrap a packed `Some` value or panic. + pub fn unwrap(self) -> T { + self.expand().unwrap() + } + + /// Unwrap a packed `Some` value or panic. + pub fn expect(self, msg: &str) -> T { + self.expand().expect(msg) + } + + /// Takes the value out of the packed option, leaving a `None` in its place. + pub fn take(&mut self) -> Option { + mem::replace(self, None.into()).expand() + } +} + +impl Default for PackedOption { + /// Create a default packed option representing `None`. + fn default() -> Self { + Self(T::reserved_value()) + } +} + +impl From for PackedOption { + /// Convert `t` into a packed `Some(x)`. + fn from(t: T) -> Self { + debug_assert!( + !t.is_reserved_value(), + "Can't make a PackedOption from the reserved value." + ); + Self(t) + } +} + +impl From> for PackedOption { + /// Convert an option into its packed equivalent. + fn from(opt: Option) -> Self { + match opt { + None => Self::default(), + Some(t) => t.into(), + } + } +} + +impl Into> for PackedOption { + fn into(self) -> Option { + self.expand() + } +} + +impl fmt::Debug for PackedOption +where + T: ReservedValue + fmt::Debug, +{ + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + if self.is_none() { + write!(f, "None") + } else { + write!(f, "Some({:?})", self.0) + } + } +} + +#[cfg(test)] +mod tests { + use super::*; + + // Dummy entity class, with no Copy or Clone. + #[derive(Debug, PartialEq, Eq)] + struct NoC(u32); + + impl ReservedValue for NoC { + fn reserved_value() -> Self { + NoC(13) + } + + fn is_reserved_value(&self) -> bool { + self.0 == 13 + } + } + + #[test] + fn moves() { + let x = NoC(3); + let somex: PackedOption = x.into(); + assert!(!somex.is_none()); + assert_eq!(somex.expand(), Some(NoC(3))); + + let none: PackedOption = None.into(); + assert!(none.is_none()); + assert_eq!(none.expand(), None); + } + + // Dummy entity class, with Copy. + #[derive(Clone, Copy, Debug, PartialEq, Eq)] + struct Ent(u32); + + impl ReservedValue for Ent { + fn reserved_value() -> Self { + Ent(13) + } + + fn is_reserved_value(&self) -> bool { + self.0 == 13 + } + } + + #[test] + fn copies() { + let x = Ent(2); + let some: PackedOption = x.into(); + let some2: Option = x.into(); + assert_eq!(some.expand(), some2); + assert_eq!(some, x.into()); + } +} diff --git a/runtime/near-vm/lib/types/src/entity/primary_map.rs b/runtime/near-vm/lib/types/src/entity/primary_map.rs new file mode 100644 index 00000000000..afe4ab1c25c --- /dev/null +++ b/runtime/near-vm/lib/types/src/entity/primary_map.rs @@ -0,0 +1,463 @@ +// This file contains code from external sources. +// Attributions: https://github.com/wasmerio/wasmer/blob/master/ATTRIBUTIONS.md + +//! Densely numbered entity references as mapping keys. +use rkyv::Archive; + +use crate::entity::boxed_slice::BoxedSlice; +use crate::entity::iter::{IntoIter, Iter, IterMut}; +use crate::entity::keys::Keys; +use crate::entity::EntityRef; +use crate::lib::std::boxed::Box; +use crate::lib::std::iter::FromIterator; +use crate::lib::std::marker::PhantomData; +use crate::lib::std::ops::{Index, IndexMut}; +use crate::lib::std::slice; +use crate::lib::std::vec::Vec; + +/// A primary mapping `K -> V` allocating dense entity references. +/// +/// The `PrimaryMap` data structure uses the dense index space to implement a map with a vector. +/// +/// A primary map contains the main definition of an entity, and it can be used to allocate new +/// entity references with the `push` method. +/// +/// There should only be a single `PrimaryMap` instance for a given `EntityRef` type, otherwise +/// conflicting references will be created. Using unknown keys for indexing will cause a panic. +/// +/// Note that `PrimaryMap` doesn't implement `Deref` or `DerefMut`, which would allow +/// `&PrimaryMap` to convert to `&[V]`. One of the main advantages of `PrimaryMap` is +/// that it only allows indexing with the distinct `EntityRef` key type, so converting to a +/// plain slice would make it easier to use incorrectly. To make a slice of a `PrimaryMap`, use +/// `into_boxed_slice`. +#[derive(Debug, Clone, Hash, PartialEq, Eq, rkyv::Serialize, rkyv::Deserialize, rkyv::Archive)] +pub struct PrimaryMap +where + K: EntityRef, +{ + pub(crate) elems: Vec, + pub(crate) unused: PhantomData, +} + +impl PrimaryMap +where + K: EntityRef, +{ + /// Create a new empty map. + pub fn new() -> Self { + Self { + elems: Vec::new(), + unused: PhantomData, + } + } + + /// Create a new empty map with the given capacity. + pub fn with_capacity(capacity: usize) -> Self { + Self { + elems: Vec::with_capacity(capacity), + unused: PhantomData, + } + } + + /// Check if `k` is a valid key in the map. + pub fn is_valid(&self, k: K) -> bool { + k.index() < self.elems.len() + } + + /// Get the element at `k` if it exists. + pub fn get(&self, k: K) -> Option<&V> { + self.elems.get(k.index()) + } + + /// Get the element at `k` if it exists, mutable version. + pub fn get_mut(&mut self, k: K) -> Option<&mut V> { + self.elems.get_mut(k.index()) + } + + /// Is this map completely empty? + pub fn is_empty(&self) -> bool { + self.elems.is_empty() + } + + /// Get the total number of entity references created. + pub fn len(&self) -> usize { + self.elems.len() + } + + /// Iterate over all the keys in this map. + pub fn keys(&self) -> Keys { + Keys::with_len(self.elems.len()) + } + + /// Iterate over all the values in this map. + pub fn values(&self) -> slice::Iter { + self.elems.iter() + } + + /// Iterate over all the values in this map, mutable edition. + pub fn values_mut(&mut self) -> slice::IterMut { + self.elems.iter_mut() + } + + /// Iterate over all the keys and values in this map. + pub fn iter(&self) -> Iter { + Iter::new(self.elems.iter()) + } + + /// Iterate over all the keys and values in this map, mutable edition. + pub fn iter_mut(&mut self) -> IterMut { + IterMut::new(self.elems.iter_mut()) + } + + /// Remove all entries from this map. + pub fn clear(&mut self) { + self.elems.clear() + } + + /// Get the key that will be assigned to the next pushed value. + pub fn next_key(&self) -> K { + K::new(self.elems.len()) + } + + /// Append `v` to the mapping, assigning a new key which is returned. + pub fn push(&mut self, v: V) -> K { + let k = self.next_key(); + self.elems.push(v); + k + } + + /// Returns the last element that was inserted in the map. + pub fn last(&self) -> Option<&V> { + self.elems.last() + } + + /// Reserves capacity for at least `additional` more elements to be inserted. + pub fn reserve(&mut self, additional: usize) { + self.elems.reserve(additional) + } + + /// Reserves the minimum capacity for exactly `additional` more elements to be inserted. + pub fn reserve_exact(&mut self, additional: usize) { + self.elems.reserve_exact(additional) + } + + /// Shrinks the capacity of the `PrimaryMap` as much as possible. + pub fn shrink_to_fit(&mut self) { + self.elems.shrink_to_fit() + } + + /// Consumes this `PrimaryMap` and produces a `BoxedSlice`. + pub fn into_boxed_slice(self) -> BoxedSlice { + unsafe { BoxedSlice::::from_raw(Box::<[V]>::into_raw(self.elems.into_boxed_slice())) } + } +} + +impl Default for PrimaryMap +where + K: EntityRef, +{ + fn default() -> PrimaryMap { + PrimaryMap::new() + } +} + +/// Immutable indexing into an `PrimaryMap`. +/// The indexed value must be in the map. +impl Index for PrimaryMap +where + K: EntityRef, +{ + type Output = V; + + fn index(&self, k: K) -> &V { + &self.elems[k.index()] + } +} + +/// Mutable indexing into an `PrimaryMap`. +impl IndexMut for PrimaryMap +where + K: EntityRef, +{ + fn index_mut(&mut self, k: K) -> &mut V { + &mut self.elems[k.index()] + } +} + +impl IntoIterator for PrimaryMap +where + K: EntityRef, +{ + type Item = (K, V); + type IntoIter = IntoIter; + + fn into_iter(self) -> Self::IntoIter { + IntoIter::new(self.elems.into_iter()) + } +} + +impl<'a, K, V> IntoIterator for &'a PrimaryMap +where + K: EntityRef, +{ + type Item = (K, &'a V); + type IntoIter = Iter<'a, K, V>; + + fn into_iter(self) -> Self::IntoIter { + Iter::new(self.elems.iter()) + } +} + +impl<'a, K, V> IntoIterator for &'a mut PrimaryMap +where + K: EntityRef, +{ + type Item = (K, &'a mut V); + type IntoIter = IterMut<'a, K, V>; + + fn into_iter(self) -> Self::IntoIter { + IterMut::new(self.elems.iter_mut()) + } +} + +impl FromIterator for PrimaryMap +where + K: EntityRef, +{ + fn from_iter(iter: T) -> Self + where + T: IntoIterator, + { + Self { + elems: Vec::from_iter(iter), + unused: PhantomData, + } + } +} + +impl ArchivedPrimaryMap +where + K: Archive + EntityRef, + V: Archive, +{ + /// Get the total number of entity references created. + pub fn len(&self) -> usize { + self.elems.len() + } + + /// Iterate over all the values in this map. + pub fn values(&self) -> slice::Iter> { + self.elems.iter() + } + + /// Iterate over all the keys and values in this map. + pub fn iter(&self) -> Iter> { + Iter::new(self.elems.iter()) + } +} + +/// Immutable indexing into an `PrimaryMap`. +/// The indexed value must be in the map. +impl Index<&K::Archived> for ArchivedPrimaryMap +where + K: EntityRef + Archive, + K::Archived: EntityRef, + V: Archive, +{ + type Output = ::Archived; + + fn index(&self, k: &K::Archived) -> &Self::Output { + &self.elems[k.index()] + } +} + +#[cfg(test)] +mod tests { + use super::*; + + // `EntityRef` impl for testing. + #[derive(Clone, Copy, Debug, PartialEq, Eq)] + struct E(u32); + + impl EntityRef for E { + fn new(i: usize) -> Self { + E(i as u32) + } + fn index(self) -> usize { + self.0 as usize + } + } + + #[test] + fn basic() { + let r0 = E(0); + let r1 = E(1); + let m = PrimaryMap::::new(); + + let v: Vec = m.keys().collect(); + assert_eq!(v, []); + + assert!(!m.is_valid(r0)); + assert!(!m.is_valid(r1)); + } + + #[test] + fn push() { + let mut m = PrimaryMap::new(); + let k0: E = m.push(12); + let k1 = m.push(33); + + assert_eq!(m[k0], 12); + assert_eq!(m[k1], 33); + + let v: Vec = m.keys().collect(); + assert_eq!(v, [k0, k1]); + } + + #[test] + fn iter() { + let mut m: PrimaryMap = PrimaryMap::new(); + m.push(12); + m.push(33); + + let mut i = 0; + for (key, value) in &m { + assert_eq!(key.index(), i); + match i { + 0 => assert_eq!(*value, 12), + 1 => assert_eq!(*value, 33), + _ => panic!(), + } + i += 1; + } + i = 0; + for (key_mut, value_mut) in m.iter_mut() { + assert_eq!(key_mut.index(), i); + match i { + 0 => assert_eq!(*value_mut, 12), + 1 => assert_eq!(*value_mut, 33), + _ => panic!(), + } + i += 1; + } + } + + #[test] + fn iter_rev() { + let mut m: PrimaryMap = PrimaryMap::new(); + m.push(12); + m.push(33); + + let mut i = 2; + for (key, value) in m.iter().rev() { + i -= 1; + assert_eq!(key.index(), i); + match i { + 0 => assert_eq!(*value, 12), + 1 => assert_eq!(*value, 33), + _ => panic!(), + } + } + + i = 2; + for (key, value) in m.iter_mut().rev() { + i -= 1; + assert_eq!(key.index(), i); + match i { + 0 => assert_eq!(*value, 12), + 1 => assert_eq!(*value, 33), + _ => panic!(), + } + } + } + #[test] + fn keys() { + let mut m: PrimaryMap = PrimaryMap::new(); + m.push(12); + m.push(33); + + let mut i = 0; + for key in m.keys() { + assert_eq!(key.index(), i); + i += 1; + } + } + + #[test] + fn keys_rev() { + let mut m: PrimaryMap = PrimaryMap::new(); + m.push(12); + m.push(33); + + let mut i = 2; + for key in m.keys().rev() { + i -= 1; + assert_eq!(key.index(), i); + } + } + + #[test] + fn values() { + let mut m: PrimaryMap = PrimaryMap::new(); + m.push(12); + m.push(33); + + let mut i = 0; + for value in m.values() { + match i { + 0 => assert_eq!(*value, 12), + 1 => assert_eq!(*value, 33), + _ => panic!(), + } + i += 1; + } + i = 0; + for value_mut in m.values_mut() { + match i { + 0 => assert_eq!(*value_mut, 12), + 1 => assert_eq!(*value_mut, 33), + _ => panic!(), + } + i += 1; + } + } + + #[test] + fn values_rev() { + let mut m: PrimaryMap = PrimaryMap::new(); + m.push(12); + m.push(33); + + let mut i = 2; + for value in m.values().rev() { + i -= 1; + match i { + 0 => assert_eq!(*value, 12), + 1 => assert_eq!(*value, 33), + _ => panic!(), + } + } + i = 2; + for value_mut in m.values_mut().rev() { + i -= 1; + match i { + 0 => assert_eq!(*value_mut, 12), + 1 => assert_eq!(*value_mut, 33), + _ => panic!(), + } + } + } + + #[test] + fn from_iter() { + let mut m: PrimaryMap = PrimaryMap::new(); + m.push(12); + m.push(33); + + let n = m.values().collect::>(); + assert!(m.len() == n.len()); + for (me, ne) in m.values().zip(n.values()) { + assert!(*me == **ne); + } + } +} diff --git a/runtime/near-vm/lib/types/src/entity/secondary_map.rs b/runtime/near-vm/lib/types/src/entity/secondary_map.rs new file mode 100644 index 00000000000..2365dcc1a63 --- /dev/null +++ b/runtime/near-vm/lib/types/src/entity/secondary_map.rs @@ -0,0 +1,254 @@ +// This file contains code from external sources. +// Attributions: https://github.com/wasmerio/wasmer/blob/master/ATTRIBUTIONS.md + +//! Densely numbered entity references as mapping keys. + +use crate::entity::iter::{Iter, IterMut}; +use crate::entity::keys::Keys; +use crate::entity::EntityRef; +use crate::lib::std::cmp::min; +use crate::lib::std::marker::PhantomData; +use crate::lib::std::ops::{Index, IndexMut}; +use crate::lib::std::slice; +use crate::lib::std::vec::Vec; +use rkyv::Archive; + +/// A mapping `K -> V` for densely indexed entity references. +/// +/// The `SecondaryMap` data structure uses the dense index space to implement a map with a vector. +/// Unlike `PrimaryMap`, an `SecondaryMap` can't be used to allocate entity references. It is used +/// to associate secondary information with entities. +/// +/// The map does not track if an entry for a key has been inserted or not. Instead it behaves as if +/// all keys have a default entry from the beginning. +#[derive(Debug, Clone, rkyv::Serialize, rkyv::Deserialize, rkyv::Archive)] +pub struct SecondaryMap +where + K: EntityRef, + V: Clone, +{ + pub(crate) elems: Vec, + pub(crate) default: V, + pub(crate) unused: PhantomData, +} + +/// Shared `SecondaryMap` implementation for all value types. +impl SecondaryMap +where + K: EntityRef, + V: Clone, +{ + /// Create a new empty map. + pub fn new() -> Self + where + V: Default, + { + Self { + elems: Vec::new(), + default: Default::default(), + unused: PhantomData, + } + } + + /// Create a new, empty map with the specified capacity. + /// + /// The map will be able to hold exactly `capacity` elements without reallocating. + pub fn with_capacity(capacity: usize) -> Self + where + V: Default, + { + Self { + elems: Vec::with_capacity(capacity), + default: Default::default(), + unused: PhantomData, + } + } + + /// Create a new empty map with a specified default value. + /// + /// This constructor does not require V to implement Default. + pub fn with_default(default: V) -> Self { + Self { + elems: Vec::new(), + default, + unused: PhantomData, + } + } + + /// Returns the number of elements the map can hold without reallocating. + pub fn capacity(&self) -> usize { + self.elems.capacity() + } + + /// Get the element at `k` if it exists. + #[inline(always)] + pub fn get(&self, k: K) -> Option<&V> { + self.elems.get(k.index()) + } + + /// Is this map completely empty? + #[inline(always)] + pub fn is_empty(&self) -> bool { + self.elems.is_empty() + } + + /// Remove all entries from this map. + #[inline(always)] + pub fn clear(&mut self) { + self.elems.clear() + } + + /// Iterate over all the keys and values in this map. + pub fn iter(&self) -> Iter { + Iter::new(self.elems.iter()) + } + + /// Iterate over all the keys and values in this map, mutable edition. + pub fn iter_mut(&mut self) -> IterMut { + IterMut::new(self.elems.iter_mut()) + } + + /// Iterate over all the keys in this map. + pub fn keys(&self) -> Keys { + Keys::with_len(self.elems.len()) + } + + /// Iterate over all the values in this map. + pub fn values(&self) -> slice::Iter { + self.elems.iter() + } + + /// Iterate over all the values in this map, mutable edition. + pub fn values_mut(&mut self) -> slice::IterMut { + self.elems.iter_mut() + } + + /// Resize the map to have `n` entries by adding default entries as needed. + pub fn resize(&mut self, n: usize) { + self.elems.resize(n, self.default.clone()); + } +} + +impl Default for SecondaryMap +where + K: EntityRef, + V: Clone + Default, +{ + fn default() -> SecondaryMap { + SecondaryMap::new() + } +} + +/// Immutable indexing into an `SecondaryMap`. +/// +/// All keys are permitted. Untouched entries have the default value. +impl Index for SecondaryMap +where + K: EntityRef, + V: Clone, +{ + type Output = V; + + #[inline(always)] + fn index(&self, k: K) -> &V { + self.elems.get(k.index()).unwrap_or(&self.default) + } +} + +/// Immutable indexing into an `SecondaryMap`. +/// +/// All keys are permitted. Untouched entries have the default value. +impl Index<&K::Archived> for ArchivedSecondaryMap +where + K: EntityRef + Archive, + K::Archived: EntityRef, + V: Archive + Clone, +{ + type Output = ::Archived; + + fn index(&self, k: &K::Archived) -> &Self::Output { + &self.elems.get(k.index()).unwrap_or(&self.default) + } +} + +/// Mutable indexing into an `SecondaryMap`. +/// +/// The map grows as needed to accommodate new keys. +impl IndexMut for SecondaryMap +where + K: EntityRef, + V: Clone, +{ + #[inline(always)] + fn index_mut(&mut self, k: K) -> &mut V { + let i = k.index(); + if i >= self.elems.len() { + self.elems.resize(i + 1, self.default.clone()); + } + &mut self.elems[i] + } +} + +impl PartialEq for SecondaryMap +where + K: EntityRef, + V: Clone + PartialEq, +{ + fn eq(&self, other: &Self) -> bool { + let min_size = min(self.elems.len(), other.elems.len()); + self.default == other.default + && self.elems[..min_size] == other.elems[..min_size] + && self.elems[min_size..].iter().all(|e| *e == self.default) + && other.elems[min_size..].iter().all(|e| *e == other.default) + } +} + +impl Eq for SecondaryMap +where + K: EntityRef, + V: Clone + PartialEq + Eq, +{ +} + +#[cfg(test)] +mod tests { + use super::*; + + // `EntityRef` impl for testing. + #[derive(Clone, Copy, Debug, PartialEq, Eq)] + struct E(u32); + + impl EntityRef for E { + fn new(i: usize) -> Self { + E(i as u32) + } + fn index(self) -> usize { + self.0 as usize + } + } + + #[test] + fn basic() { + let r0 = E(0); + let r1 = E(1); + let r2 = E(2); + let mut m = SecondaryMap::new(); + + let v: Vec = m.keys().collect(); + assert_eq!(v, []); + + m[r2] = 3; + m[r1] = 5; + + assert_eq!(m[r1], 5); + assert_eq!(m[r2], 3); + + let v: Vec = m.keys().collect(); + assert_eq!(v, [r0, r1, r2]); + + let shared = &m; + assert_eq!(shared[r0], 0); + assert_eq!(shared[r1], 5); + assert_eq!(shared[r2], 3); + } +} diff --git a/runtime/near-vm/lib/types/src/extern_ref.rs b/runtime/near-vm/lib/types/src/extern_ref.rs new file mode 100644 index 00000000000..fc14459fa3b --- /dev/null +++ b/runtime/near-vm/lib/types/src/extern_ref.rs @@ -0,0 +1,279 @@ +use std::any::Any; +use std::ptr; +use std::sync::atomic; + +/// This type does not do reference counting automatically, reference counting can be done with +/// [`Self::ref_clone`] and [`Self::ref_drop`]. +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +#[repr(transparent)] +pub struct VMExternRef(*const VMExternRefInner); + +impl VMExternRef { + /// The maximum number of references allowed to this data. + const MAX_REFCOUNT: usize = std::usize::MAX - 1; + + /// Checks if the given ExternRef is null. + pub fn is_null(&self) -> bool { + self.0.is_null() + } + + /// New null extern ref + pub const fn null() -> Self { + Self(ptr::null()) + } + + /// Get a bit-level representation of an externref. + /// For internal use for packing / unpacking it for calling functions. + pub(crate) fn to_binary(self) -> i128 { + self.0 as i128 + } + + /// Create an externref from bit-level representation. + /// For internal use for packing / unpacking it for calling functions. + /// + /// # Safety + /// The pointer is assumed valid or null. Passing arbitrary data to this function will + /// result in undefined behavior. It is the caller's responsibility to verify that only + /// valid externref bit patterns are passed to this function. + pub(crate) unsafe fn from_binary(bits: i128) -> Self { + Self(bits as usize as *const _) + } + + /// Make a new extern reference + pub fn new(value: T) -> Self + where + T: Any + Send + Sync + 'static + Sized, + { + Self(Box::into_raw(Box::new(VMExternRefInner::new::(value)))) + } + + /// Try to downcast to the given value + pub fn downcast(&self) -> Option<&T> + where + T: Any + Send + Sync + 'static + Sized, + { + if self.is_null() { + return None; + } + unsafe { + let inner = &*self.0; + + inner.data.downcast_ref::() + } + } + + /// Panic if the ref count gets too high. + #[track_caller] + fn sanity_check_ref_count(old_size: usize, growth_amount: usize) { + // If we exceed 18_446_744_073_709_551_614 references on a 64bit system (or + // 2_147_483_646 references on a 32bit system) then we either live in a future with + // magic technology or we have a bug in our ref counting logic (i.e. a leak). + // Either way, the best course of action is to terminate the program and update + // some code on our side. + // + // Note to future readers: exceeding `usize` ref count is trivially provable as a + // bug on systems that can address `usize` sized memory blocks or smaller because + // the reference itself is at least `usize` in size and all virtual memory would be + // taken by references to the data leaving no room for the data itself. + if old_size + .checked_add(growth_amount) + .map(|v| v > Self::MAX_REFCOUNT) + .unwrap_or(true) + { + panic!("Too many references to `ExternRef`"); + } + } + + /// A low-level function to increment the strong-count a given number of times. + /// + /// This is used as an optimization when implementing some low-level VM primitives. + /// If you're using this type directly for whatever reason, you probably want + /// [`Self::ref_clone`] instead. + pub fn ref_inc_by(&self, val: usize) { + if self.0.is_null() { + return; + } + + let old_size = unsafe { + let ref_inner = &*self.0; + ref_inner.increment_ref_count(val) + }; + + Self::sanity_check_ref_count(old_size, val); + } + + /// A deep copy of the reference, increments the strong count. + pub fn ref_clone(&self) -> Self { + if self.0.is_null() { + return Self(self.0); + } + + let old_size = unsafe { + let ref_inner = &*self.0; + ref_inner.increment_ref_count(1) + }; + + // See comments in [`Self::sanity_check_ref_count`] for more information. + if old_size > Self::MAX_REFCOUNT { + panic!("Too many references to `ExternRef`"); + } + + Self(self.0) + } + + /// Does an inner drop, decrementing the strong count + pub fn ref_drop(&mut self) { + if !self.0.is_null() { + unsafe { + let should_drop = { + let ref_inner: &VMExternRefInner = &*self.0; + ref_inner.decrement_and_drop() + }; + if should_drop { + let _ = Box::from_raw(self.0 as *mut VMExternRefInner); + } + } + } + } + + #[allow(dead_code)] + /// Get the number of strong references to this data. + fn strong_count(&self) -> usize { + if self.0.is_null() { + 0 + } else { + unsafe { (&*self.0).strong.load(atomic::Ordering::SeqCst) } + } + } +} + +#[derive(Debug)] +#[repr(C)] +pub(crate) struct VMExternRefInner { + strong: atomic::AtomicUsize, + /// Do something obviously correct to get started. This can "easily" be improved + /// to be an inline allocation later as the logic is fully encapsulated. + data: Box, +} + +impl VMExternRefInner { + fn new(value: T) -> Self + where + T: Any + Send + Sync + Sized + 'static, + { + Self { + strong: atomic::AtomicUsize::new(1), + data: Box::new(value), + } + } + + /// Increments the reference count. + /// Returns the old value. + fn increment_ref_count(&self, val: usize) -> usize { + // Using a relaxed ordering is alright here, as knowledge of + // the original reference prevents other threads from + // erroneously deleting the object. + // + // As explained in the [Boost documentation][1]: + // + // > Increasing the reference counter can always be done with + // > `memory_order_relaxed`: New references to an object can + // > only be formed from an existing reference, and passing an + // > existing reference from one thread to another must already + // > provide any required synchronization. + // + // [1]: https://www.boost.org/doc/libs/1_55_0/doc/html/atomic/usage_examples.html + self.strong.fetch_add(val, atomic::Ordering::Relaxed) + } + + /// Decrement the count and drop the data if the count hits 0 + /// returns `true` if the containing allocation should be dropped + fn decrement_and_drop(&self) -> bool { + // Because `fetch_sub` is already atomic, we do not need to + // synchronize with other thread. + if self.strong.fetch_sub(1, atomic::Ordering::Release) != 1 { + return false; + } + + // This fence is needed to prevent reordering of use of the data and + // deletion of the data. Because it is marked `Release`, the decreasing + // of the reference count synchronizes with this `Acquire` fence. This + // means that use of the data happens before decreasing the reference + // count, which happens before this fence, which happens before the + // deletion of the data. + // + // As explained in the [Boost documentation][1]: + // + // > It is important to enforce any possible access to the object in one + // > thread (through an existing reference) to *happen before* deleting + // > the object in a different thread. This is achieved by a "release" + // > operation after dropping a reference (any access to the object + // > through this reference must obviously happened before), and an + // > "acquire" operation before deleting the object. + // + // [1]: https://www.boost.org/doc/libs/1_55_0/doc/html/atomic/usage_examples.html + atomic::fence(atomic::Ordering::Acquire); + + return true; + } +} + +#[derive(Debug, PartialEq, Eq)] +#[repr(transparent)] +/// An opaque reference to some data. This reference can be passed through Wasm. +pub struct ExternRef { + inner: VMExternRef, +} + +impl Clone for ExternRef { + fn clone(&self) -> Self { + Self { + inner: self.inner.ref_clone(), + } + } +} + +impl Drop for ExternRef { + fn drop(&mut self) { + self.inner.ref_drop() + } +} + +impl ExternRef { + /// Checks if the given ExternRef is null. + pub fn is_null(&self) -> bool { + self.inner.is_null() + } + + /// New null extern ref + pub fn null() -> Self { + Self { + inner: VMExternRef::null(), + } + } + + /// Make a new extern reference + pub fn new(value: T) -> Self + where + T: Any + Send + Sync + 'static + Sized, + { + Self { + inner: VMExternRef::new(value), + } + } +} + +impl From for ExternRef { + fn from(other: VMExternRef) -> Self { + Self { inner: other } + } +} + +impl From for VMExternRef { + fn from(other: ExternRef) -> Self { + let out = other.inner; + // We want to make this transformation without decrementing the count. + std::mem::forget(other); + out + } +} diff --git a/runtime/near-vm/lib/types/src/features.rs b/runtime/near-vm/lib/types/src/features.rs new file mode 100644 index 00000000000..9a6de02813a --- /dev/null +++ b/runtime/near-vm/lib/types/src/features.rs @@ -0,0 +1,311 @@ +/// Controls which experimental features will be enabled. +/// Features usually have a corresponding [WebAssembly proposal]. +/// +/// [WebAssembly proposal]: https://github.com/WebAssembly/proposals +#[derive(Clone, Debug, Eq, PartialEq, rkyv::Serialize, rkyv::Deserialize, rkyv::Archive)] +pub struct Features { + /// Threads proposal should be enabled + pub threads: bool, + /// Reference Types proposal should be enabled + pub reference_types: bool, + /// SIMD proposal should be enabled + pub simd: bool, + /// Bulk Memory proposal should be enabled + pub bulk_memory: bool, + /// Multi Value proposal should be enabled + pub multi_value: bool, + /// Tail call proposal should be enabled + pub tail_call: bool, + /// Multi Memory proposal should be enabled + pub multi_memory: bool, + /// 64-bit Memory proposal should be enabled + pub memory64: bool, + /// Wasm exceptions proposal should be enabled + pub exceptions: bool, + /// Mutable global proposal should be enabled + pub mutable_global: bool, + /// Non-trapping float-to-int proposal should be enabled + pub saturating_float_to_int: bool, + /// Sign-extension operators should be enabled + pub sign_extension: bool, +} + +impl Features { + /// Create a new feature + pub fn new() -> Self { + Self { + threads: false, + // Reference types should be on by default + reference_types: true, + // SIMD should be on by default + simd: true, + // Bulk Memory should be on by default + bulk_memory: true, + // Multivalue should be on by default + multi_value: true, + tail_call: false, + multi_memory: false, + memory64: false, + exceptions: false, + // these were once defaulting to true in wasmparser, we now set them to true here + mutable_global: true, + saturating_float_to_int: true, + sign_extension: true, + } + } + + /// Configures whether the WebAssembly threads proposal will be enabled. + /// + /// The [WebAssembly threads proposal][threads] is not currently fully + /// standardized and is undergoing development. Support for this feature can + /// be enabled through this method for appropriate WebAssembly modules. + /// + /// This feature gates items such as shared memories and atomic + /// instructions. + /// + /// This is `false` by default. + /// + /// [threads]: https://github.com/webassembly/threads + pub fn threads(&mut self, enable: bool) -> &mut Self { + self.threads = enable; + self + } + + /// Configures whether the WebAssembly reference types proposal will be + /// enabled. + /// + /// The [WebAssembly reference types proposal][proposal] is now + /// fully standardized and enabled by default. + /// + /// This feature gates items such as the `externref` type and multiple tables + /// being in a module. Note that enabling the reference types feature will + /// also enable the bulk memory feature. + /// + /// This is `true` by default. + /// + /// [proposal]: https://github.com/webassembly/reference-types + pub fn reference_types(&mut self, enable: bool) -> &mut Self { + self.reference_types = enable; + // The reference types proposal depends on the bulk memory proposal + if enable { + self.bulk_memory(true); + } + self + } + + /// Configures whether the WebAssembly SIMD proposal will be + /// enabled. + /// + /// The [WebAssembly SIMD proposal][proposal] is not currently + /// fully standardized and is undergoing development. Support for this + /// feature can be enabled through this method for appropriate WebAssembly + /// modules. + /// + /// This feature gates items such as the `v128` type and all of its + /// operators being in a module. + /// + /// This is `false` by default. + /// + /// [proposal]: https://github.com/webassembly/simd + pub fn simd(&mut self, enable: bool) -> &mut Self { + self.simd = enable; + self + } + + /// Configures whether the WebAssembly bulk memory operations proposal will + /// be enabled. + /// + /// The [WebAssembly bulk memory operations proposal][proposal] is now + /// fully standardized and enabled by default. + /// + /// This feature gates items such as the `memory.copy` instruction, passive + /// data/table segments, etc, being in a module. + /// + /// This is `true` by default. + /// + /// [proposal]: https://github.com/webassembly/bulk-memory-operations + pub fn bulk_memory(&mut self, enable: bool) -> &mut Self { + self.bulk_memory = enable; + // In case is false, we disable both threads and reference types + // since they both depend on bulk memory + if !enable { + self.reference_types(false); + } + self + } + + /// Configures whether the WebAssembly multi-value proposal will + /// be enabled. + /// + /// The [WebAssembly multi-value proposal][proposal] is now fully + /// standardized and enabled by default, except with the singlepass + /// compiler which does not support it. + /// + /// This feature gates functions and blocks returning multiple values in a + /// module, for example. + /// + /// This is `true` by default. + /// + /// [proposal]: https://github.com/webassembly/multi-value + pub fn multi_value(&mut self, enable: bool) -> &mut Self { + self.multi_value = enable; + self + } + + /// Configures whether the WebAssembly tail-call proposal will + /// be enabled. + /// + /// The [WebAssembly tail-call proposal][proposal] is not + /// currently fully standardized and is undergoing development. + /// Support for this feature can be enabled through this method for + /// appropriate WebAssembly modules. + /// + /// This feature gates tail-call functions in WebAssembly. + /// + /// This is `false` by default. + /// + /// [proposal]: https://github.com/webassembly/tail-call + pub fn tail_call(&mut self, enable: bool) -> &mut Self { + self.tail_call = enable; + self + } + + /// Configures whether the WebAssembly multi-memory proposal will + /// be enabled. + /// + /// The [WebAssembly multi-memory proposal][proposal] is not + /// currently fully standardized and is undergoing development. + /// Support for this feature can be enabled through this method for + /// appropriate WebAssembly modules. + /// + /// This feature adds the ability to use multiple memories within a + /// single Wasm module. + /// + /// This is `false` by default. + /// + /// [proposal]: https://github.com/WebAssembly/multi-memory + pub fn multi_memory(&mut self, enable: bool) -> &mut Self { + self.multi_memory = enable; + self + } + + /// Configures whether the WebAssembly 64-bit memory proposal will + /// be enabled. + /// + /// The [WebAssembly 64-bit memory proposal][proposal] is not + /// currently fully standardized and is undergoing development. + /// Support for this feature can be enabled through this method for + /// appropriate WebAssembly modules. + /// + /// This feature gates support for linear memory of sizes larger than + /// 2^32 bits. + /// + /// This is `false` by default. + /// + /// [proposal]: https://github.com/WebAssembly/memory64 + pub fn memory64(&mut self, enable: bool) -> &mut Self { + self.memory64 = enable; + self + } +} + +impl Default for Features { + fn default() -> Self { + Self::new() + } +} + +#[cfg(test)] +mod test_features { + use super::*; + #[test] + fn default_features() { + let default = Features::default(); + assert_eq!( + default, + Features { + threads: false, + reference_types: true, + simd: true, + bulk_memory: true, + multi_value: true, + tail_call: false, + multi_memory: false, + memory64: false, + exceptions: false, + mutable_global: true, + saturating_float_to_int: true, + sign_extension: true, + } + ); + } + + #[test] + fn enable_threads() { + let mut features = Features::new(); + features.bulk_memory(false).threads(true); + + assert!(features.threads); + } + + #[test] + fn enable_reference_types() { + let mut features = Features::new(); + features.bulk_memory(false).reference_types(true); + assert!(features.reference_types); + assert!(features.bulk_memory); + } + + #[test] + fn enable_simd() { + let mut features = Features::new(); + features.simd(true); + assert!(features.simd); + } + + #[test] + fn enable_multi_value() { + let mut features = Features::new(); + features.multi_value(true); + assert!(features.multi_value); + } + + #[test] + fn enable_bulk_memory() { + let mut features = Features::new(); + features.bulk_memory(true); + assert!(features.bulk_memory); + } + + #[test] + fn disable_bulk_memory() { + let mut features = Features::new(); + features + .threads(true) + .reference_types(true) + .bulk_memory(false); + assert!(!features.bulk_memory); + assert!(!features.reference_types); + } + + #[test] + fn enable_tail_call() { + let mut features = Features::new(); + features.tail_call(true); + assert!(features.tail_call); + } + + #[test] + fn enable_multi_memory() { + let mut features = Features::new(); + features.multi_memory(true); + assert!(features.multi_memory); + } + + #[test] + fn enable_memory64() { + let mut features = Features::new(); + features.memory64(true); + assert!(features.memory64); + } +} diff --git a/runtime/near-vm/lib/types/src/indexes.rs b/runtime/near-vm/lib/types/src/indexes.rs new file mode 100644 index 00000000000..09412dc8065 --- /dev/null +++ b/runtime/near-vm/lib/types/src/indexes.rs @@ -0,0 +1,255 @@ +//! Helper functions and structures for the translation. +use crate::entity::entity_impl; +use core::u32; + +/// Index type of a function defined locally inside the WebAssembly module. +#[derive( + Copy, + Clone, + PartialEq, + Eq, + Hash, + PartialOrd, + Ord, + Debug, + rkyv::Serialize, + rkyv::Deserialize, + rkyv::Archive, +)] +#[archive(as = "Self")] +#[repr(transparent)] +pub struct LocalFunctionIndex(u32); +entity_impl!(LocalFunctionIndex); + +/// Index type of a table defined locally inside the WebAssembly module. +#[derive(Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord, Debug)] +pub struct LocalTableIndex(u32); +entity_impl!(LocalTableIndex); + +/// Index type of a memory defined locally inside the WebAssembly module. +#[derive(Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord, Debug)] +pub struct LocalMemoryIndex(u32); +entity_impl!(LocalMemoryIndex); + +/// Index type of a global defined locally inside the WebAssembly module. +#[derive( + Copy, + Clone, + PartialEq, + Eq, + Hash, + PartialOrd, + Ord, + Debug, + rkyv::Serialize, + rkyv::Deserialize, + rkyv::Archive, +)] +#[archive(as = "Self")] +#[repr(transparent)] +pub struct LocalGlobalIndex(u32); +entity_impl!(LocalGlobalIndex); + +/// Index type of a function (imported or local) inside the WebAssembly module. +#[derive( + Copy, + Clone, + PartialEq, + Eq, + Hash, + PartialOrd, + Ord, + Debug, + rkyv::Serialize, + rkyv::Deserialize, + rkyv::Archive, +)] +#[archive(as = "Self")] +#[repr(transparent)] +pub struct FunctionIndex(u32); +entity_impl!(FunctionIndex); + +/// Index type of a table (imported or local) inside the WebAssembly module. +#[derive( + Copy, + Clone, + PartialEq, + Eq, + Hash, + PartialOrd, + Ord, + Debug, + rkyv::Serialize, + rkyv::Deserialize, + rkyv::Archive, +)] +#[archive(as = "Self")] +#[repr(transparent)] +pub struct TableIndex(u32); +entity_impl!(TableIndex); + +/// Index type of a global variable (imported or local) inside the WebAssembly module. +#[derive( + Copy, + Clone, + PartialEq, + Eq, + Hash, + PartialOrd, + Ord, + Debug, + rkyv::Serialize, + rkyv::Deserialize, + rkyv::Archive, +)] +#[archive(as = "Self")] +#[repr(transparent)] +pub struct GlobalIndex(u32); +entity_impl!(GlobalIndex); + +/// Index type of a linear memory (imported or local) inside the WebAssembly module. +#[derive( + Copy, + Clone, + PartialEq, + Eq, + Hash, + PartialOrd, + Ord, + Debug, + rkyv::Serialize, + rkyv::Deserialize, + rkyv::Archive, +)] +#[archive(as = "Self")] +#[repr(transparent)] +pub struct MemoryIndex(u32); +entity_impl!(MemoryIndex); + +/// Index type of a signature (imported or local) inside the WebAssembly module. +#[derive( + Copy, + Clone, + PartialEq, + Eq, + Hash, + PartialOrd, + Ord, + Debug, + rkyv::Serialize, + rkyv::Deserialize, + rkyv::Archive, +)] +#[archive(as = "Self")] +#[repr(transparent)] +pub struct SignatureIndex(u32); +entity_impl!(SignatureIndex); + +/// Index type of a passive data segment inside the WebAssembly module. +#[derive( + Copy, + Clone, + PartialEq, + Eq, + Hash, + PartialOrd, + Ord, + Debug, + rkyv::Serialize, + rkyv::Deserialize, + rkyv::Archive, +)] +#[archive(as = "Self")] +#[repr(transparent)] +pub struct DataIndex(u32); +entity_impl!(DataIndex); + +/// Index type of a passive element segment inside the WebAssembly module. +#[derive( + Copy, + Clone, + PartialEq, + Eq, + Hash, + PartialOrd, + Ord, + Debug, + rkyv::Serialize, + rkyv::Deserialize, + rkyv::Archive, +)] +#[archive(as = "Self")] +#[repr(transparent)] +pub struct ElemIndex(u32); +entity_impl!(ElemIndex); + +/// Index type of a custom section inside a WebAssembly module. +#[derive( + Copy, + Clone, + PartialEq, + Eq, + Hash, + PartialOrd, + Ord, + Debug, + rkyv::Serialize, + rkyv::Deserialize, + rkyv::Archive, +)] +#[archive(as = "Self")] +#[repr(transparent)] +pub struct CustomSectionIndex(u32); +entity_impl!(CustomSectionIndex); + +/// An entity to export. +#[derive( + Clone, + Debug, + Hash, + PartialEq, + Eq, + PartialOrd, + Ord, + rkyv::Serialize, + rkyv::Deserialize, + rkyv::Archive, +)] +#[archive(as = "Self")] +#[repr(u8)] +pub enum ExportIndex { + /// Function export. + Function(FunctionIndex), + /// Table export. + Table(TableIndex), + /// Memory export. + Memory(MemoryIndex), + /// Global export. + Global(GlobalIndex), +} + +/// An entity to import. +#[derive( + Clone, + Debug, + Hash, + PartialEq, + Eq, + PartialOrd, + Ord, + rkyv::Serialize, + rkyv::Deserialize, + rkyv::Archive, +)] +#[archive(as = "Self")] +#[repr(u8)] +pub enum ImportIndex { + /// Function import. + Function(FunctionIndex), + /// Table import. + Table(TableIndex), + /// Memory import. + Memory(MemoryIndex), + /// Global import. + Global(GlobalIndex), +} diff --git a/runtime/near-vm/lib/types/src/initializers.rs b/runtime/near-vm/lib/types/src/initializers.rs new file mode 100644 index 00000000000..9df1f9f2588 --- /dev/null +++ b/runtime/near-vm/lib/types/src/initializers.rs @@ -0,0 +1,88 @@ +use crate::indexes::{FunctionIndex, GlobalIndex, MemoryIndex, TableIndex}; +use crate::lib::std::boxed::Box; + +/// A WebAssembly table initializer. +#[derive(Clone, Debug, Hash, PartialEq, Eq, rkyv::Serialize, rkyv::Deserialize, rkyv::Archive)] +pub struct OwnedTableInitializer { + /// The index of a table to initialize. + pub table_index: TableIndex, + /// Optionally, a global variable giving a base index. + pub base: Option, + /// The offset to add to the base. + pub offset: usize, + /// The values to write into the table elements. + pub elements: Box<[FunctionIndex]>, +} + +/// A memory index and offset within that memory where a data initialization +/// should be performed. +#[derive(Clone, Debug, PartialEq, Eq, rkyv::Serialize, rkyv::Deserialize, rkyv::Archive)] +pub struct DataInitializerLocation { + /// The index of the memory to initialize. + pub memory_index: MemoryIndex, + + /// Optionally a Global variable base to initialize at. + pub base: Option, + + /// A constant offset to initialize at. + pub offset: usize, +} + +/// A data initializer for linear memory. +#[derive(Debug)] +pub struct DataInitializer<'data> { + /// The location where the initialization is to be performed. + pub location: DataInitializerLocation, + + /// The initialization data. + pub data: &'data [u8], +} + +/// As `DataInitializer` but owning the data rather than +/// holding a reference to it +#[derive(Debug, Clone, PartialEq, Eq, rkyv::Serialize, rkyv::Deserialize, rkyv::Archive)] +pub struct OwnedDataInitializer { + /// The location where the initialization is to be performed. + pub location: DataInitializerLocation, + + /// The initialization owned data. + pub data: Vec, +} + +impl OwnedDataInitializer { + /// Creates a new `OwnedDataInitializer` from a `DataInitializer`. + pub fn new(borrowed: &DataInitializer<'_>) -> Self { + Self { + location: borrowed.location.clone(), + data: borrowed.data.to_vec(), + } + } +} + +impl<'a> From<&'a OwnedDataInitializer> for DataInitializer<'a> { + fn from(init: &'a OwnedDataInitializer) -> Self { + DataInitializer { + location: init.location.clone(), + data: &*init.data, + } + } +} + +impl<'a> From<&'a ArchivedOwnedDataInitializer> for DataInitializer<'a> { + fn from(init: &'a ArchivedOwnedDataInitializer) -> Self { + DataInitializer { + location: rkyv::Deserialize::deserialize(&init.location, &mut rkyv::Infallible) + .expect("deserialization cannot fail"), + data: &*init.data, + } + } +} + +impl<'a> From> for OwnedDataInitializer { + fn from(init: DataInitializer<'a>) -> Self { + OwnedDataInitializer { + location: init.location.clone(), + data: init.data.to_vec(), + } + } +} diff --git a/runtime/near-vm/lib/types/src/lib.rs b/runtime/near-vm/lib/types/src/lib.rs new file mode 100644 index 00000000000..75f82604240 --- /dev/null +++ b/runtime/near-vm/lib/types/src/lib.rs @@ -0,0 +1,97 @@ +//! This are the common types and utility tools for using WebAssembly +//! in a Rust environment. +//! +//! This crate provides common structures such as `Type` or `Value`, type indexes +//! and native function wrappers with `Func`. + +#![deny(missing_docs, unused_extern_crates)] +#![warn(unused_import_braces)] +#![cfg_attr(feature = "std", deny(unstable_features))] +#![cfg_attr(not(feature = "std"), no_std)] +#![cfg_attr(feature = "cargo-clippy", allow(clippy::new_without_default))] +#![cfg_attr( + feature = "cargo-clippy", + warn( + clippy::float_arithmetic, + clippy::mut_mut, + clippy::nonminimal_bool, + clippy::option_map_unwrap_or, + clippy::option_map_unwrap_or_else, + clippy::print_stdout, + clippy::unicode_not_nfc, + clippy::use_self + ) +)] + +#[cfg(all(feature = "std", feature = "core"))] +compile_error!( + "The `std` and `core` features are both enabled, which is an error. Please enable only once." +); + +#[cfg(all(not(feature = "std"), not(feature = "core")))] +compile_error!("Both the `std` and `core` features are disabled. Please enable one of them."); + +#[cfg(feature = "core")] +extern crate alloc; + +/// The `lib` module defines a `std` module that is identical whether +/// the `core` or the `std` feature is enabled. +pub mod lib { + /// Custom `std` module. + #[cfg(feature = "core")] + pub mod std { + pub use alloc::{borrow, boxed, format, iter, rc, slice, string, vec}; + pub use core::{any, cell, cmp, convert, fmt, hash, marker, mem, ops, ptr, sync, u32}; + } + + /// Custom `std` module. + #[cfg(feature = "std")] + pub mod std { + pub use std::{ + any, borrow, boxed, cell, cmp, convert, fmt, format, hash, iter, marker, mem, ops, ptr, + rc, slice, string, sync, u32, vec, + }; + } +} + +mod archives; +mod extern_ref; +mod features; +mod indexes; +mod initializers; +mod memory_view; +mod module; +mod native; +pub mod partial_sum_map; +mod types; +mod units; +mod values; + +/// The entity module, with common helpers for Rust structures +pub mod entity; +pub use crate::extern_ref::{ExternRef, VMExternRef}; +pub use crate::features::Features; +pub use crate::indexes::{ + CustomSectionIndex, DataIndex, ElemIndex, ExportIndex, FunctionIndex, GlobalIndex, ImportIndex, + LocalFunctionIndex, LocalGlobalIndex, LocalMemoryIndex, LocalTableIndex, MemoryIndex, + SignatureIndex, TableIndex, +}; +pub use crate::initializers::{ + DataInitializer, DataInitializerLocation, OwnedDataInitializer, OwnedTableInitializer, +}; +pub use crate::memory_view::{Atomically, MemoryView}; +pub use crate::module::{ImportCounts, ModuleInfo}; +pub use crate::native::{NativeWasmType, ValueType}; +pub use crate::units::{ + Bytes, PageCountOutOfRange, Pages, WASM_MAX_PAGES, WASM_MIN_PAGES, WASM_PAGE_SIZE, +}; +pub use crate::values::{Value, WasmValueType}; +pub use types::{ + ExportType, ExternType, FastGasCounter, FunctionType, FunctionTypeRef, GlobalInit, GlobalType, + Import, InstanceConfig, MemoryType, Mutability, TableType, Type, V128, +}; + +pub use archives::ArchivableIndexMap; + +/// Version number of this crate. +pub const VERSION: &str = env!("CARGO_PKG_VERSION"); diff --git a/runtime/near-vm/lib/types/src/memory_view.rs b/runtime/near-vm/lib/types/src/memory_view.rs new file mode 100644 index 00000000000..732e687319f --- /dev/null +++ b/runtime/near-vm/lib/types/src/memory_view.rs @@ -0,0 +1,132 @@ +use crate::lib::std::cell::Cell; +use crate::lib::std::marker::PhantomData; +use crate::lib::std::ops::Deref; +// use crate::lib::std::ops::{Bound, RangeBounds}; +use crate::lib::std::slice; +use crate::lib::std::sync::atomic::{ + AtomicI16, AtomicI32, AtomicI64, AtomicI8, AtomicU16, AtomicU32, AtomicU64, AtomicU8, +}; +use crate::native::ValueType; + +pub trait Atomic { + type Output; +} + +macro_rules! atomic { + ( $($for:ty => $output:ty),+ ) => { + $( + impl Atomic for $for { + type Output = $output; + } + )+ + } +} + +atomic!( + i8 => AtomicI8, + i16 => AtomicI16, + i32 => AtomicI32, + i64 => AtomicI64, + u8 => AtomicU8, + u16 => AtomicU16, + u32 => AtomicU32, + u64 => AtomicU64, + f32 => AtomicU32, + f64 => AtomicU64 +); + +/// A trait that represants an atomic type. +pub trait Atomicity {} + +/// Atomically. +pub struct Atomically; +impl Atomicity for Atomically {} + +/// Non-atomically. +pub struct NonAtomically; +impl Atomicity for NonAtomically {} + +/// A view into a memory. +pub struct MemoryView<'a, T: 'a, A = NonAtomically> { + ptr: *mut T, + // Note: the length is in the terms of `size::()`. + // The total length in memory is `size::() * length`. + length: usize, + _phantom: PhantomData<(&'a [Cell], A)>, +} + +impl<'a, T> MemoryView<'a, T, NonAtomically> +where + T: ValueType, +{ + /// Creates a new MemoryView given a `pointer` and `length`. + pub unsafe fn new(ptr: *mut T, length: u32) -> Self { + Self { + ptr, + length: length as usize, + _phantom: PhantomData, + } + } + + /// Creates a subarray view from this `MemoryView`. + pub fn subarray(&self, start: u32, end: u32) -> Self { + assert!( + (start as usize) < self.length, + "The range start is bigger than current length" + ); + assert!( + (end as usize) < self.length, + "The range end is bigger than current length" + ); + + Self { + ptr: unsafe { self.ptr.add(start as usize) }, + length: (end - start) as usize, + _phantom: PhantomData, + } + } + + /// Copy the contents of the source slice into this `MemoryView`. + /// + /// This function will efficiently copy the memory from within the wasm + /// module’s own linear memory to this typed array. + /// + /// # Safety + /// + /// This method is unsafe because the caller will need to make sure + /// there are no data races when copying memory into the view. + pub unsafe fn copy_from(&self, src: &[T]) { + // We cap at a max length + let sliced_src = &src[..self.length]; + for (i, byte) in sliced_src.iter().enumerate() { + *self.ptr.offset(i as isize) = *byte; + } + } +} + +impl<'a, T: Atomic> MemoryView<'a, T> { + /// Get atomic access to a memory view. + pub fn atomically(&self) -> MemoryView<'a, T::Output, Atomically> { + MemoryView { + ptr: self.ptr as *mut T::Output, + length: self.length, + _phantom: PhantomData, + } + } +} + +impl<'a, T> Deref for MemoryView<'a, T, NonAtomically> { + type Target = [Cell]; + fn deref(&self) -> &[Cell] { + let mut_slice: &mut [T] = unsafe { slice::from_raw_parts_mut(self.ptr, self.length) }; + let cell_slice: &Cell<[T]> = Cell::from_mut(mut_slice); + cell_slice.as_slice_of_cells() + } +} + +impl<'a, T> Deref for MemoryView<'a, T, Atomically> { + type Target = [T]; + fn deref(&self) -> &[T] { + unsafe { slice::from_raw_parts(self.ptr as *const T, self.length) } + } +} diff --git a/runtime/near-vm/lib/types/src/module.rs b/runtime/near-vm/lib/types/src/module.rs new file mode 100644 index 00000000000..e8da8e0de0a --- /dev/null +++ b/runtime/near-vm/lib/types/src/module.rs @@ -0,0 +1,444 @@ +// This file contains code from external sources. +// Attributions: https://github.com/wasmerio/wasmer/blob/master/ATTRIBUTIONS.md + +//! Data structure for representing WebAssembly modules in a +//! `wasmer::Module`. + +use crate::entity::{EntityRef, PrimaryMap}; +use crate::ArchivableIndexMap; +use crate::{ + CustomSectionIndex, DataIndex, ElemIndex, ExportIndex, FunctionIndex, FunctionType, + GlobalIndex, GlobalInit, GlobalType, ImportIndex, LocalFunctionIndex, LocalGlobalIndex, + LocalMemoryIndex, LocalTableIndex, MemoryIndex, MemoryType, OwnedTableInitializer, + SignatureIndex, TableIndex, TableType, +}; +use indexmap::IndexMap; +use rkyv::{ + de::SharedDeserializeRegistry, ser::ScratchSpace, ser::Serializer, + ser::SharedSerializeRegistry, Archive, Archived, Fallible, +}; +use std::collections::BTreeMap; +use std::collections::HashMap; +use std::fmt; +use std::sync::atomic::{AtomicUsize, Ordering::SeqCst}; +use std::sync::Arc; + +#[derive(Debug, Clone, rkyv::Serialize, rkyv::Deserialize, rkyv::Archive)] +pub struct ModuleId { + id: usize, +} + +impl ModuleId { + pub fn id(&self) -> String { + format!("{}", &self.id) + } +} + +impl Default for ModuleId { + fn default() -> Self { + static NEXT_ID: AtomicUsize = AtomicUsize::new(0); + Self { + id: NEXT_ID.fetch_add(1, SeqCst), + } + } +} + +/// The counts of imported entities in a WebAssembly module. +#[derive( + Debug, Copy, Clone, Default, PartialEq, Eq, rkyv::Serialize, rkyv::Deserialize, rkyv::Archive, +)] +#[archive(as = "Self")] +pub struct ImportCounts { + /// Number of imported functions in the module. + pub functions: u32, + + /// Number of imported tables in the module. + pub tables: u32, + + /// Number of imported memories in the module. + pub memories: u32, + + /// Number of imported globals in the module. + pub globals: u32, +} + +impl ImportCounts { + fn make_local(idx: I, imports: u32) -> Result { + EntityRef::index(idx) + .checked_sub(imports as _) + .map(R::new) + .ok_or(idx) + } + + /// Convert the `FunctionIndex` to a `LocalFunctionIndex`. + pub fn local_function_index( + &self, + idx: FunctionIndex, + ) -> Result { + Self::make_local(idx, self.functions) + } + + /// Convert the `TableIndex` to a `LocalTableIndex`. + pub fn local_table_index(&self, idx: TableIndex) -> Result { + Self::make_local(idx, self.tables) + } + + /// Convert the `MemoryIndex` to a `LocalMemoryIndex`. + pub fn local_memory_index(&self, idx: MemoryIndex) -> Result { + Self::make_local(idx, self.memories) + } + + /// Convert the `GlobalIndex` to a `LocalGlobalIndex`. + pub fn local_global_index(&self, idx: GlobalIndex) -> Result { + Self::make_local(idx, self.globals) + } + + fn make_index(idx: I, imports: u32) -> R { + let imports = imports as usize; + R::new(idx.index() + imports) + } + + /// Convert the `LocalFunctionIndex` to a `FunctionIndex`. + pub fn function_index(&self, idx: LocalFunctionIndex) -> FunctionIndex { + Self::make_index(idx, self.functions) + } + + /// Convert the `LocalTableIndex` to a `TableIndex`. + pub fn table_index(&self, idx: LocalTableIndex) -> TableIndex { + Self::make_index(idx, self.tables) + } + + /// Convert the `LocalMemoryIndex` to a `MemoryIndex`. + pub fn memory_index(&self, idx: LocalMemoryIndex) -> MemoryIndex { + Self::make_index(idx, self.memories) + } + + /// Convert the `LocalGlobalIndex` to a `GlobalIndex`. + pub fn global_index(&self, idx: LocalGlobalIndex) -> GlobalIndex { + Self::make_index(idx, self.globals) + } +} + +/// A translated WebAssembly module, excluding the function bodies and +/// memory initializers. +#[derive(Debug, Clone, Default)] +pub struct ModuleInfo { + /// A unique identifier (within this process) for this module. + /// + /// We skip serialization/deserialization of this field, as it + /// should be computed by the process. + /// + /// It's not skipped in rkyv, but that is okay, because even though it's skipped in + /// bincode/serde it's still deserialized back as a garbage number, and later override from + /// computed by the process + pub id: ModuleId, + + /// The name of this wasm module, often found in the wasm file. + pub name: Option, + + /// Imported entities with the (module, field, index_of_the_import) + /// + /// Keeping the `index_of_the_import` is important, as there can be + /// two same references to the same import, and we don't want to confuse + /// them. + pub imports: IndexMap<(String, String, u32), ImportIndex>, + + /// Exported entities. + pub exports: IndexMap, + + /// The module "start" function, if present. + pub start_function: Option, + + /// WebAssembly table initializers. + pub table_initializers: Vec, + + /// WebAssembly passive elements. + pub passive_elements: BTreeMap>, + + /// WebAssembly passive data segments. + pub passive_data: BTreeMap>, + + /// WebAssembly global initializers. + pub global_initializers: PrimaryMap, + + /// WebAssembly function names. + pub function_names: HashMap, + + /// WebAssembly function signatures. + pub signatures: PrimaryMap, + + /// WebAssembly functions (imported and local). + pub functions: PrimaryMap, + + /// WebAssembly tables (imported and local). + pub tables: PrimaryMap, + + /// WebAssembly linear memories (imported and local). + pub memories: PrimaryMap, + + /// WebAssembly global variables (imported and local). + pub globals: PrimaryMap, + + /// Custom sections in the module. + pub custom_sections: IndexMap, + + /// The data for each CustomSection in the module. + pub custom_sections_data: PrimaryMap>, + + /// The counts of imported entities. + pub import_counts: ImportCounts, +} + +/// Mirror version of ModuleInfo that can derive rkyv traits +#[derive(rkyv::Serialize, rkyv::Deserialize, rkyv::Archive)] +pub struct ArchivableModuleInfo { + pub name: Option, + pub imports: ArchivableIndexMap<(String, String, u32), ImportIndex>, + pub exports: ArchivableIndexMap, + pub start_function: Option, + pub table_initializers: Vec, + pub passive_elements: BTreeMap>, + pub passive_data: BTreeMap>, + pub global_initializers: PrimaryMap, + pub function_names: BTreeMap, + pub signatures: PrimaryMap, + pub functions: PrimaryMap, + pub tables: PrimaryMap, + pub memories: PrimaryMap, + pub globals: PrimaryMap, + pub custom_sections: ArchivableIndexMap, + pub custom_sections_data: PrimaryMap>, + pub import_counts: ImportCounts, +} + +impl From for ArchivableModuleInfo { + fn from(it: ModuleInfo) -> ArchivableModuleInfo { + ArchivableModuleInfo { + name: it.name, + imports: ArchivableIndexMap::from(it.imports), + exports: ArchivableIndexMap::from(it.exports), + start_function: it.start_function, + table_initializers: it.table_initializers, + passive_elements: it.passive_elements.into_iter().collect(), + passive_data: it.passive_data.into_iter().collect(), + global_initializers: it.global_initializers, + function_names: it.function_names.into_iter().collect(), + signatures: it.signatures, + functions: it.functions, + tables: it.tables, + memories: it.memories, + globals: it.globals, + custom_sections: ArchivableIndexMap::from(it.custom_sections), + custom_sections_data: it.custom_sections_data, + import_counts: it.import_counts, + } + } +} + +impl From for ModuleInfo { + fn from(it: ArchivableModuleInfo) -> ModuleInfo { + ModuleInfo { + id: Default::default(), + name: it.name, + imports: it.imports.into(), + exports: it.exports.into(), + start_function: it.start_function, + table_initializers: it.table_initializers, + passive_elements: it.passive_elements.into_iter().collect(), + passive_data: it.passive_data.into_iter().collect(), + global_initializers: it.global_initializers, + function_names: it.function_names.into_iter().collect(), + signatures: it.signatures, + functions: it.functions, + tables: it.tables, + memories: it.memories, + globals: it.globals, + custom_sections: it.custom_sections.into(), + custom_sections_data: it.custom_sections_data, + import_counts: it.import_counts, + } + } +} + +impl From<&ModuleInfo> for ArchivableModuleInfo { + fn from(it: &ModuleInfo) -> ArchivableModuleInfo { + ArchivableModuleInfo::from(it.clone()) + } +} + +impl Archive for ModuleInfo { + type Archived = ::Archived; + type Resolver = ::Resolver; + + unsafe fn resolve(&self, pos: usize, resolver: Self::Resolver, out: *mut Self::Archived) { + ArchivableModuleInfo::from(self).resolve(pos, resolver, out) + } +} + +impl rkyv::Serialize + for ModuleInfo +{ + fn serialize(&self, serializer: &mut S) -> Result { + ArchivableModuleInfo::from(self).serialize(serializer) + } +} + +impl rkyv::Deserialize + for Archived +{ + fn deserialize(&self, deserializer: &mut D) -> Result { + let r: ArchivableModuleInfo = + rkyv::Deserialize::::deserialize(self, deserializer)?; + Ok(ModuleInfo::from(r)) + } +} + +// For test serialization correctness, everything except module id should be same +impl PartialEq for ModuleInfo { + fn eq(&self, other: &ModuleInfo) -> bool { + self.name == other.name + && self.imports == other.imports + && self.exports == other.exports + && self.start_function == other.start_function + && self.table_initializers == other.table_initializers + && self.passive_elements == other.passive_elements + && self.passive_data == other.passive_data + && self.global_initializers == other.global_initializers + && self.function_names == other.function_names + && self.signatures == other.signatures + && self.functions == other.functions + && self.tables == other.tables + && self.memories == other.memories + && self.globals == other.globals + && self.custom_sections == other.custom_sections + && self.custom_sections_data == other.custom_sections_data + && self.import_counts == other.import_counts + } +} + +impl Eq for ModuleInfo {} + +impl ModuleInfo { + /// Allocates the module data structures. + pub fn new() -> Self { + Default::default() + } + + /// Get the given passive element, if it exists. + pub fn get_passive_element(&self, index: ElemIndex) -> Option<&[FunctionIndex]> { + self.passive_elements.get(&index).map(|es| &**es) + } + + /// Get the exported signatures of the module + pub fn exported_signatures(&self) -> Vec { + self.exports + .iter() + .filter_map(|(_name, export_index)| match export_index { + ExportIndex::Function(i) => { + let signature = self.functions.get(*i).unwrap(); + let func_type = self.signatures.get(*signature).unwrap(); + Some(func_type.clone()) + } + _ => None, + }) + .collect::>() + } + + /// Get the custom sections of the module given a `name`. + pub fn custom_sections<'a>(&'a self, name: &'a str) -> impl Iterator> + 'a { + self.custom_sections + .iter() + .filter_map(move |(section_name, section_index)| { + if name != section_name { + return None; + } + Some(self.custom_sections_data[*section_index].clone()) + }) + } + + /// Convert a `LocalFunctionIndex` into a `FunctionIndex`. + pub fn func_index(&self, local_func: LocalFunctionIndex) -> FunctionIndex { + self.import_counts.function_index(local_func) + } + + /// Convert a `FunctionIndex` into a `LocalFunctionIndex`. Returns None if the + /// index is an imported function. + pub fn local_func_index(&self, func: FunctionIndex) -> Option { + self.import_counts.local_function_index(func).ok() + } + + /// Test whether the given function index is for an imported function. + pub fn is_imported_function(&self, index: FunctionIndex) -> bool { + self.local_func_index(index).is_none() + } + + /// Convert a `LocalTableIndex` into a `TableIndex`. + pub fn table_index(&self, local_table: LocalTableIndex) -> TableIndex { + self.import_counts.table_index(local_table) + } + + /// Convert a `TableIndex` into a `LocalTableIndex`. Returns None if the + /// index is an imported table. + pub fn local_table_index(&self, table: TableIndex) -> Option { + self.import_counts.local_table_index(table).ok() + } + + /// Test whether the given table index is for an imported table. + pub fn is_imported_table(&self, index: TableIndex) -> bool { + self.local_table_index(index).is_none() + } + + /// Convert a `LocalMemoryIndex` into a `MemoryIndex`. + pub fn memory_index(&self, local_memory: LocalMemoryIndex) -> MemoryIndex { + self.import_counts.memory_index(local_memory) + } + + /// Convert a `MemoryIndex` into a `LocalMemoryIndex`. Returns None if the + /// index is an imported memory. + pub fn local_memory_index(&self, memory: MemoryIndex) -> Option { + self.import_counts.local_memory_index(memory).ok() + } + + /// Test whether the given memory index is for an imported memory. + pub fn is_imported_memory(&self, index: MemoryIndex) -> bool { + self.local_memory_index(index).is_none() + } + + /// Convert a `LocalGlobalIndex` into a `GlobalIndex`. + pub fn global_index(&self, local_global: LocalGlobalIndex) -> GlobalIndex { + self.import_counts.global_index(local_global) + } + + /// Convert a `GlobalIndex` into a `LocalGlobalIndex`. Returns None if the + /// index is an imported global. + pub fn local_global_index(&self, global: GlobalIndex) -> Option { + self.import_counts.local_global_index(global).ok() + } + + /// Test whether the given global index is for an imported global. + pub fn is_imported_global(&self, index: GlobalIndex) -> bool { + self.local_global_index(index).is_none() + } + + /// Get the Module name + pub fn name(&self) -> String { + match self.name { + Some(ref name) => name.to_string(), + None => "".to_string(), + } + } + + /// Get the imported function types of the module. + pub fn imported_function_types<'a>(&'a self) -> impl Iterator + 'a { + self.functions + .values() + .take(self.import_counts.functions as usize) + .map(move |sig_index| self.signatures[*sig_index].clone()) + } +} + +impl fmt::Display for ModuleInfo { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + write!(f, "{}", self.name()) + } +} diff --git a/runtime/near-vm/lib/types/src/native.rs b/runtime/near-vm/lib/types/src/native.rs new file mode 100644 index 00000000000..f5759b3645b --- /dev/null +++ b/runtime/near-vm/lib/types/src/native.rs @@ -0,0 +1,270 @@ +//! This module permits to create native functions +//! easily in Rust, thanks to its advanced typing system. + +use crate::extern_ref::VMExternRef; +use crate::lib::std::fmt; +use crate::types::Type; +use crate::values::{Value, WasmValueType}; + +/// `NativeWasmType` represents a Wasm type that has a direct +/// representation on the host (hence the “native” term). +/// +/// It uses the Rust Type system to automatically detect the +/// Wasm type associated with a native Rust type. +/// +/// ``` +/// use wasmer_types::{NativeWasmType, Type}; +/// +/// let wasm_type = i32::WASM_TYPE; +/// assert_eq!(wasm_type, Type::I32); +/// ``` +/// +/// > Note: This strategy will be needed later to +/// > automatically detect the signature of a Rust function. +pub trait NativeWasmType: Sized { + /// The ABI for this type (i32, i64, f32, f64) + type Abi: Copy + fmt::Debug; + + /// Type for this `NativeWasmType`. + const WASM_TYPE: Type; + + #[doc(hidden)] + fn from_abi(abi: Self::Abi) -> Self; + + #[doc(hidden)] + fn into_abi(self) -> Self::Abi; + + /// Convert self to i128 binary representation. + fn to_binary(self) -> i128; + + /// Convert self to a `Value`. + fn to_value(self) -> Value { + let binary = self.to_binary(); + // we need a store, we're just hoping we don't actually use it via funcref + // TODO(reftypes): we need an actual solution here + let hack = 3; + + unsafe { Value::read_value_from(&hack, &binary, Self::WASM_TYPE) } + } + + /// Convert to self from i128 binary representation. + fn from_binary(binary: i128) -> Self; +} + +impl NativeWasmType for i32 { + const WASM_TYPE: Type = Type::I32; + type Abi = Self; + + #[inline] + fn from_abi(abi: Self::Abi) -> Self { + abi + } + + #[inline] + fn into_abi(self) -> Self::Abi { + self + } + + #[inline] + fn to_binary(self) -> i128 { + self as _ + } + + #[inline] + fn from_binary(bits: i128) -> Self { + bits as _ + } +} + +impl NativeWasmType for i64 { + const WASM_TYPE: Type = Type::I64; + type Abi = Self; + + #[inline] + fn from_abi(abi: Self::Abi) -> Self { + abi + } + + #[inline] + fn into_abi(self) -> Self::Abi { + self + } + + #[inline] + fn to_binary(self) -> i128 { + self as _ + } + + #[inline] + fn from_binary(bits: i128) -> Self { + bits as _ + } +} + +impl NativeWasmType for f32 { + const WASM_TYPE: Type = Type::F32; + type Abi = Self; + + #[inline] + fn from_abi(abi: Self::Abi) -> Self { + abi + } + + #[inline] + fn into_abi(self) -> Self::Abi { + self + } + + #[inline] + fn to_binary(self) -> i128 { + self.to_bits() as _ + } + + #[inline] + fn from_binary(bits: i128) -> Self { + Self::from_bits(bits as _) + } +} + +impl NativeWasmType for f64 { + const WASM_TYPE: Type = Type::F64; + type Abi = Self; + + #[inline] + fn from_abi(abi: Self::Abi) -> Self { + abi + } + + #[inline] + fn into_abi(self) -> Self::Abi { + self + } + + #[inline] + fn to_binary(self) -> i128 { + self.to_bits() as _ + } + + #[inline] + fn from_binary(bits: i128) -> Self { + Self::from_bits(bits as _) + } +} + +impl NativeWasmType for u128 { + const WASM_TYPE: Type = Type::V128; + type Abi = Self; + + #[inline] + fn from_abi(abi: Self::Abi) -> Self { + abi + } + + #[inline] + fn into_abi(self) -> Self::Abi { + self + } + + #[inline] + fn to_binary(self) -> i128 { + self as _ + } + + #[inline] + fn from_binary(bits: i128) -> Self { + bits as _ + } +} + +impl NativeWasmType for VMExternRef { + const WASM_TYPE: Type = Type::ExternRef; + type Abi = Self; + + #[inline] + fn from_abi(abi: Self::Abi) -> Self { + abi + } + + #[inline] + fn into_abi(self) -> Self::Abi { + self + } + + #[inline] + fn to_binary(self) -> i128 { + self.to_binary() + } + + #[inline] + fn from_binary(bits: i128) -> Self { + // TODO(reftypes): ensure that the safety invariants are actually upheld here + unsafe { Self::from_binary(bits) } + } +} + +#[cfg(test)] +mod test_native_type { + use super::*; + use crate::types::Type; + + #[test] + fn test_wasm_types() { + assert_eq!(i32::WASM_TYPE, Type::I32); + assert_eq!(i64::WASM_TYPE, Type::I64); + assert_eq!(f32::WASM_TYPE, Type::F32); + assert_eq!(f64::WASM_TYPE, Type::F64); + assert_eq!(u128::WASM_TYPE, Type::V128); + } + + #[test] + fn test_roundtrip() { + assert_eq!(i32::from_binary(42i32.to_binary()), 42i32); + assert_eq!(i64::from_binary(42i64.to_binary()), 42i64); + assert_eq!(f32::from_binary(42f32.to_binary()), 42f32); + assert_eq!(f64::from_binary(42f64.to_binary()), 42f64); + assert_eq!(u128::from_binary(42u128.to_binary()), 42u128); + } +} + +// pub trait IntegerAtomic +// where +// Self: Sized +// { +// type Primitive; + +// fn add(&self, other: Self::Primitive) -> Self::Primitive; +// fn sub(&self, other: Self::Primitive) -> Self::Primitive; +// fn and(&self, other: Self::Primitive) -> Self::Primitive; +// fn or(&self, other: Self::Primitive) -> Self::Primitive; +// fn xor(&self, other: Self::Primitive) -> Self::Primitive; +// fn load(&self) -> Self::Primitive; +// fn store(&self, other: Self::Primitive) -> Self::Primitive; +// fn compare_exchange(&self, expected: Self::Primitive, new: Self::Primitive) -> Self::Primitive; +// fn swap(&self, other: Self::Primitive) -> Self::Primitive; +// } + +/// Trait for a Value type. A Value type is a type that is always valid and may +/// be safely copied. +/// +/// That is, for all possible bit patterns a valid Value type can be constructed +/// from those bits. +/// +/// Concretely a `u32` is a Value type because every combination of 32 bits is +/// a valid `u32`. However a `bool` is _not_ a Value type because any bit patterns +/// other than `0` and `1` are invalid in Rust and may cause undefined behavior if +/// a `bool` is constructed from those bytes. +pub unsafe trait ValueType: Copy +where + Self: Sized, +{ +} + +macro_rules! impl_value_type_for { + ( $($type:ty),* ) => { + $( + unsafe impl ValueType for $type {} + )* + }; +} + +impl_value_type_for!(u8, i8, u16, i16, u32, i32, u64, i64, f32, f64); diff --git a/runtime/near-vm/lib/types/src/partial_sum_map.rs b/runtime/near-vm/lib/types/src/partial_sum_map.rs new file mode 100644 index 00000000000..be8695c0062 --- /dev/null +++ b/runtime/near-vm/lib/types/src/partial_sum_map.rs @@ -0,0 +1,167 @@ +//! Partial sum maps +//! +//! These maps allow you to efficiently store repeating sequences of a value. An example of such +//! sequence could be the list of locals for a webassembly function. +//! +//! Considering the locals example above, it might be represented as a `u32` partial sum of the +//! local’s index. The locals between the index of the previous element and the current element +//! have the `WpType` type. So, given +//! +//! (0, u32), (10, u64), (15, f64) +//! +//! then 0th local would be a u32, locals `1..=10` – u64 and locals `11..=15` – f64. +//! +//! The type of a given index can be quickly found with a binary search over the partial sum +//! field. + +/// A Map from keys to values that is able to efficiently store repeating occurences of the value. +/// +/// This map can only be appended to. +#[derive(Debug)] +pub struct PartialSumMap { + /// Keys between ((keys[n-1] + 1) or 0) and keys[n] (both included) have value values[n] + keys: Vec, + values: Vec, + size: K, +} + +impl PartialSumMap { + /// Create a new `PartialSumMap`. + /// + /// Does not allocate. + pub fn new() -> Self { + Self { + keys: vec![], + values: vec![], + size: K::zero(), + } + } + + /// Push `count` number of `value`s. + /// + /// `O(1)` amortized. + pub fn push(&mut self, count: K, value: V) -> Result<(), Error> { + if count != K::zero() { + self.size = self.size.checked_add(&count).ok_or(Error::Overflow)?; + self.keys.push(self.size.clone() - K::one()); + self.values.push(value); + } + Ok(()) + } + + /// Get the current maximum index that can be used with `find` for this map. + /// + /// Will return `None` if there are no elements in this map yet. + /// + /// `O(1)` + pub fn max_index(&self) -> Option { + self.keys.last().cloned() + } + + /// Get the current (virtual) size of this map. This is the sum of all `count` arguments passed to `push` until now. + /// + /// Note that the result can be greater than `usize::MAX` if eg. `K` is a BigInt type. Cast at your own risk. + /// + /// `O(1)` + pub fn size(&self) -> &K { + &self.size + } + + /// Find the value by the index. + /// + /// This is a `O(n log n)` operation. + pub fn find(&self, index: K) -> Option<&V> { + match self.keys.binary_search(&index) { + // If this index would be inserted at the end of the list, then the + // index is out of bounds and we return a None. + // + // If `Ok` is returned we found the index exactly, or if `Err` is + // returned the position is the one which is the least index + // greater than `idx`, which is still the type of `idx` according + // to our "compressed" representation. In both cases we access the + // list at index `i`. + Ok(i) | Err(i) => self.values.get(i), + } + } +} + +/// Errors that occur when using PartialSumMap. +#[derive(Debug, PartialEq, Eq)] +pub enum Error { + /// The partial sum has overflowed. + Overflow, +} + +impl std::error::Error for Error {} +impl std::fmt::Display for Error { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + f.write_str(match self { + Self::Overflow => "partial sum overflow", + }) + } +} + +#[cfg(test)] +mod tests { + use super::{Error, PartialSumMap}; + + #[test] + fn empty_partial_map() { + let map = PartialSumMap::::new(); + assert_eq!(None, map.find(0)); + assert_eq!(0, *map.size()); + } + + #[test] + fn basic_function() { + let mut map = PartialSumMap::::new(); + assert_eq!(None, map.max_index()); + assert_eq!(0, *map.size()); + for i in 0..10 { + map.push(1, i).unwrap(); + assert_eq!(Some(i), map.max_index()); + assert_eq!(i + 1, *map.size()); + } + for i in 0..10 { + assert_eq!(Some(&i), map.find(i)); + } + assert_eq!(None, map.find(10)); + assert_eq!(None, map.find(0xFFFF_FFFF)); + } + + #[test] + fn zero_count() { + let mut map = PartialSumMap::::new(); + assert_eq!(Ok(()), map.push(0, 0)); + assert_eq!(None, map.max_index()); + assert_eq!(0, *map.size()); + assert_eq!(Ok(()), map.push(10, 42)); + assert_eq!(Some(9), map.max_index()); + assert_eq!(10, *map.size()); + assert_eq!(Ok(()), map.push(0, 43)); + assert_eq!(Some(9), map.max_index()); + assert_eq!(10, *map.size()); + } + + #[test] + fn close_to_limit() { + let mut map = PartialSumMap::::new(); + assert_eq!(Ok(()), map.push(0xFFFF_FFFE, 42)); // we added values 0..=0xFFFF_FFFD + assert_eq!(Some(&42), map.find(0xFFFF_FFFD)); + assert_eq!(None, map.find(0xFFFF_FFFE)); + + assert_eq!(Err(Error::Overflow), map.push(100, 93)); // overflowing does not change the map + assert_eq!(Some(&42), map.find(0xFFFF_FFFD)); + assert_eq!(None, map.find(0xFFFF_FFFE)); + + assert_eq!(Ok(()), map.push(1, 322)); // we added value at index 0xFFFF_FFFE (which is the 0xFFFF_FFFFth value) + assert_eq!(Some(&42), map.find(0xFFFF_FFFD)); + assert_eq!(Some(&322), map.find(0xFFFF_FFFE)); + assert_eq!(None, map.find(0xFFFF_FFFF)); + + assert_eq!(Err(Error::Overflow), map.push(1, 1234)); // can't add any more stuff... + assert_eq!(Some(&42), map.find(0xFFFF_FFFD)); + assert_eq!(Some(&322), map.find(0xFFFF_FFFE)); + assert_eq!(None, map.find(0xFFFF_FFFF)); + } +} diff --git a/runtime/near-vm/lib/types/src/types.rs b/runtime/near-vm/lib/types/src/types.rs new file mode 100644 index 00000000000..f645156cede --- /dev/null +++ b/runtime/near-vm/lib/types/src/types.rs @@ -0,0 +1,685 @@ +use crate::indexes::{FunctionIndex, GlobalIndex}; +use crate::lib::std::fmt; +use crate::lib::std::format; +use crate::lib::std::string::{String, ToString}; +use crate::lib::std::vec::Vec; +use crate::units::Pages; +use crate::values::{Value, WasmValueType}; +use std::cell::UnsafeCell; +use std::rc::Rc; +use std::sync::Arc; + +// Type Representations + +// Value Types + +/// A list of all possible value types in WebAssembly. +#[derive( + Copy, Debug, Clone, Eq, PartialEq, Hash, rkyv::Serialize, rkyv::Deserialize, rkyv::Archive, +)] +#[archive(as = "Self")] +pub enum Type { + /// Signed 32 bit integer. + I32, + /// Signed 64 bit integer. + I64, + /// Floating point 32 bit integer. + F32, + /// Floating point 64 bit integer. + F64, + /// A 128 bit number. + V128, + /// A reference to opaque data in the Wasm instance. + ExternRef, /* = 128 */ + /// A reference to a Wasm function. + FuncRef, +} + +impl Type { + /// Returns true if `Type` matches any of the numeric types. (e.g. `I32`, + /// `I64`, `F32`, `F64`, `V128`). + pub fn is_num(self) -> bool { + matches!( + self, + Self::I32 | Self::I64 | Self::F32 | Self::F64 | Self::V128 + ) + } + + /// Returns true if `Type` matches either of the reference types. + pub fn is_ref(self) -> bool { + matches!(self, Self::ExternRef | Self::FuncRef) + } +} + +impl fmt::Display for Type { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + write!(f, "{:?}", self) + } +} + +#[derive( + Copy, Clone, Debug, Eq, PartialEq, Hash, rkyv::Serialize, rkyv::Deserialize, rkyv::Archive, +)] +#[archive(as = "Self")] +/// The WebAssembly V128 type +pub struct V128(pub(crate) [u8; 16]); + +impl V128 { + /// Get the bytes corresponding to the V128 value + pub fn bytes(&self) -> &[u8; 16] { + &self.0 + } + /// Iterate over the bytes in the constant. + pub fn iter(&self) -> impl Iterator { + self.0.iter() + } + + /// Convert the immediate into a vector. + pub fn to_vec(self) -> Vec { + self.0.to_vec() + } + + /// Convert the immediate into a slice. + pub fn as_slice(&self) -> &[u8] { + &self.0[..] + } +} + +impl From<[u8; 16]> for V128 { + fn from(array: [u8; 16]) -> Self { + Self(array) + } +} + +impl From<&[u8]> for V128 { + fn from(slice: &[u8]) -> Self { + assert_eq!(slice.len(), 16); + let mut buffer = [0; 16]; + buffer.copy_from_slice(slice); + Self(buffer) + } +} + +// External Types + +/// A list of all possible types which can be externally referenced from a +/// WebAssembly module. +/// +/// This list can be found in [`ImportType`] or [`ExportType`], so these types +/// can either be imported or exported. +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub enum ExternType { + /// This external type is the type of a WebAssembly function. + Function(FunctionType), + /// This external type is the type of a WebAssembly global. + Global(GlobalType), + /// This external type is the type of a WebAssembly table. + Table(TableType), + /// This external type is the type of a WebAssembly memory. + Memory(MemoryType), +} + +macro_rules! accessors { + ($(($variant:ident($ty:ty) $get:ident $unwrap:ident))*) => ($( + /// Attempt to return the underlying type of this external type, + /// returning `None` if it is a different type. + pub fn $get(&self) -> Option<&$ty> { + if let Self::$variant(e) = self { + Some(e) + } else { + None + } + } + + /// Returns the underlying descriptor of this [`ExternType`], panicking + /// if it is a different type. + /// + /// # Panics + /// + /// Panics if `self` is not of the right type. + pub fn $unwrap(&self) -> &$ty { + self.$get().expect(concat!("expected ", stringify!($ty))) + } + )*) +} + +impl ExternType { + accessors! { + (Function(FunctionType) func unwrap_func) + (Global(GlobalType) global unwrap_global) + (Table(TableType) table unwrap_table) + (Memory(MemoryType) memory unwrap_memory) + } +} + +// TODO: `shrink_to_fit` these or change it to `Box<[Type]>` if not using +// Cow or something else +/// The signature of a function that is either implemented +/// in a Wasm module or exposed to Wasm by the host. +/// +/// WebAssembly functions can have 0 or more parameters and results. +#[derive(Debug, Clone, PartialEq, Eq, Hash, rkyv::Serialize, rkyv::Deserialize, rkyv::Archive)] +pub struct FunctionType { + /// The parameters of the function + params: Arc<[Type]>, + /// The return values of the function + results: Arc<[Type]>, +} + +impl FunctionType { + /// Creates a new Function Type with the given parameter and return types. + pub fn new(params: Params, returns: Returns) -> Self + where + Params: Into>, + Returns: Into>, + { + Self { + params: params.into(), + results: returns.into(), + } + } + + /// Parameter types. + pub fn params(&self) -> &[Type] { + &self.params + } + + /// Return types. + pub fn results(&self) -> &[Type] { + &self.results + } +} + +impl fmt::Display for FunctionType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let params = self + .params + .iter() + .map(|p| format!("{:?}", p)) + .collect::>() + .join(", "); + let results = self + .results + .iter() + .map(|p| format!("{:?}", p)) + .collect::>() + .join(", "); + write!(f, "[{}] -> [{}]", params, results) + } +} + +// Macro needed until https://rust-lang.github.io/rfcs/2000-const-generics.html is stable. +// See https://users.rust-lang.org/t/how-to-implement-trait-for-fixed-size-array-of-any-size/31494 +macro_rules! implement_from_pair_to_functiontype { + ($($N:literal,$M:literal)+) => { + $( + impl From<([Type; $N], [Type; $M])> for FunctionType { + fn from(pair: ([Type; $N], [Type; $M])) -> Self { + Self::new(&pair.0[..], &pair.1[..]) + } + } + )+ + } +} + +implement_from_pair_to_functiontype! { + 0,0 0,1 0,2 0,3 0,4 0,5 0,6 0,7 0,8 0,9 + 1,0 1,1 1,2 1,3 1,4 1,5 1,6 1,7 1,8 1,9 + 2,0 2,1 2,2 2,3 2,4 2,5 2,6 2,7 2,8 2,9 + 3,0 3,1 3,2 3,3 3,4 3,5 3,6 3,7 3,8 3,9 + 4,0 4,1 4,2 4,3 4,4 4,5 4,6 4,7 4,8 4,9 + 5,0 5,1 5,2 5,3 5,4 5,5 5,6 5,7 5,8 5,9 + 6,0 6,1 6,2 6,3 6,4 6,5 6,6 6,7 6,8 6,9 + 7,0 7,1 7,2 7,3 7,4 7,5 7,6 7,7 7,8 7,9 + 8,0 8,1 8,2 8,3 8,4 8,5 8,6 8,7 8,8 8,9 + 9,0 9,1 9,2 9,3 9,4 9,5 9,6 9,7 9,8 9,9 +} + +impl From<&FunctionType> for FunctionType { + fn from(as_ref: &FunctionType) -> Self { + as_ref.clone() + } +} + +/// Borrowed version of [`FunctionType`]. +pub struct FunctionTypeRef<'a> { + /// The parameters of the function + params: &'a [Type], + /// The return values of the function + results: &'a [Type], +} + +impl<'a> FunctionTypeRef<'a> { + /// Create a new temporary function type. + pub fn new(params: &'a [Type], results: &'a [Type]) -> Self { + Self { params, results } + } + + /// Parameter types. + pub fn params(&self) -> &[Type] { + self.params + } + + /// Return types. + pub fn results(&self) -> &[Type] { + self.results + } +} + +impl<'a> From<&'a FunctionType> for FunctionTypeRef<'a> { + fn from(FunctionType { params, results }: &'a FunctionType) -> Self { + Self { params, results } + } +} + +impl<'a> From<&'a ArchivedFunctionType> for FunctionTypeRef<'a> { + fn from(ArchivedFunctionType { params, results }: &'a ArchivedFunctionType) -> Self { + Self { + params: &**params, + results: &**results, + } + } +} + +/// Indicator of whether a global is mutable or not +#[derive( + Debug, Clone, Copy, PartialEq, Eq, Hash, rkyv::Serialize, rkyv::Deserialize, rkyv::Archive, +)] +#[archive(as = "Self")] +pub enum Mutability { + /// The global is constant and its value does not change + Const, + /// The value of the global can change over time + Var, +} + +impl Mutability { + /// Returns a boolean indicating if the enum is set to mutable. + pub fn is_mutable(self) -> bool { + match self { + Self::Const => false, + Self::Var => true, + } + } +} + +/// WebAssembly global. +#[derive( + Debug, Clone, Copy, PartialEq, Eq, Hash, rkyv::Serialize, rkyv::Deserialize, rkyv::Archive, +)] +#[archive(as = "Self")] +pub struct GlobalType { + /// The type of the value stored in the global. + pub ty: Type, + /// A flag indicating whether the value may change at runtime. + pub mutability: Mutability, +} + +// Global Types + +/// A WebAssembly global descriptor. +/// +/// This type describes an instance of a global in a WebAssembly +/// module. Globals are local to an `Instance` and are either +/// immutable or mutable. +impl GlobalType { + /// Create a new Global variable + /// # Usage: + /// ``` + /// use wasmer_types::{GlobalType, Type, Mutability, Value}; + /// + /// // An I32 constant global + /// let global = GlobalType::new(Type::I32, Mutability::Const); + /// // An I64 mutable global + /// let global = GlobalType::new(Type::I64, Mutability::Var); + /// ``` + pub fn new(ty: Type, mutability: Mutability) -> Self { + Self { ty, mutability } + } +} + +impl fmt::Display for GlobalType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let mutability = match self.mutability { + Mutability::Const => "constant", + Mutability::Var => "mutable", + }; + write!(f, "{} ({})", self.ty, mutability) + } +} + +/// Globals are initialized via the `const` operators or by referring to another import. +#[derive(Debug, Clone, Copy, PartialEq, rkyv::Serialize, rkyv::Deserialize, rkyv::Archive)] +#[archive(as = "Self")] +pub enum GlobalInit { + /// An `i32.const`. + I32Const(i32), + /// An `i64.const`. + I64Const(i64), + /// An `f32.const`. + F32Const(f32), + /// An `f64.const`. + F64Const(f64), + /// A `v128.const`. + V128Const(V128), + /// A `global.get` of another global. + GetGlobal(GlobalIndex), + // TODO(reftypes): `ref.null func` and `ref.null extern` seem to be 2 different + // things: we need to handle both. Perhaps this handled in context by the + // global knowing its own type? + /// A `ref.null`. + RefNullConst, + /// A `ref.func `. + RefFunc(FunctionIndex), +} + +impl Eq for GlobalInit {} + +impl GlobalInit { + /// Get the `GlobalInit` from a given `Value` + pub fn from_value(value: Value) -> Self { + match value { + Value::I32(i) => Self::I32Const(i), + Value::I64(i) => Self::I64Const(i), + Value::F32(f) => Self::F32Const(f), + Value::F64(f) => Self::F64Const(f), + _ => unimplemented!("GlobalInit from_value for {:?}", value), + } + } + /// Get the `Value` from the Global init value + pub fn to_value(&self) -> Value { + match self { + Self::I32Const(i) => Value::I32(*i), + Self::I64Const(i) => Value::I64(*i), + Self::F32Const(f) => Value::F32(*f), + Self::F64Const(f) => Value::F64(*f), + _ => unimplemented!("GlobalInit to_value for {:?}", self), + } + } +} + +// Table Types + +/// A descriptor for a table in a WebAssembly module. +/// +/// Tables are contiguous chunks of a specific element, typically a `funcref` or +/// an `externref`. The most common use for tables is a function table through +/// which `call_indirect` can invoke other functions. +#[derive( + Debug, Clone, Copy, PartialEq, Eq, Hash, rkyv::Serialize, rkyv::Deserialize, rkyv::Archive, +)] +pub struct TableType { + /// The type of data stored in elements of the table. + pub ty: Type, + /// The minimum number of elements in the table. + pub minimum: u32, + /// The maximum number of elements in the table. + pub maximum: Option, +} + +impl TableType { + /// Creates a new table descriptor which will contain the specified + /// `element` and have the `limits` applied to its length. + pub fn new(ty: Type, minimum: u32, maximum: Option) -> Self { + Self { + ty, + minimum, + maximum, + } + } +} + +impl fmt::Display for TableType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + if let Some(maximum) = self.maximum { + write!(f, "{} ({}..{})", self.ty, self.minimum, maximum) + } else { + write!(f, "{} ({}..)", self.ty, self.minimum) + } + } +} + +// Memory Types + +/// A descriptor for a WebAssembly memory type. +/// +/// Memories are described in units of pages (64KB) and represent contiguous +/// chunks of addressable memory. +#[derive( + Debug, Clone, Copy, PartialEq, Eq, Hash, rkyv::Serialize, rkyv::Deserialize, rkyv::Archive, +)] +pub struct MemoryType { + /// The minimum number of pages in the memory. + pub minimum: Pages, + /// The maximum number of pages in the memory. + pub maximum: Option, + /// Whether the memory may be shared between multiple threads. + pub shared: bool, +} + +impl MemoryType { + /// Creates a new descriptor for a WebAssembly memory given the specified + /// limits of the memory. + pub fn new(minimum: IntoPages, maximum: Option, shared: bool) -> Self + where + IntoPages: Into, + { + Self { + minimum: minimum.into(), + maximum: maximum.map(Into::into), + shared, + } + } +} + +impl fmt::Display for MemoryType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let shared = if self.shared { "shared" } else { "not shared" }; + if let Some(maximum) = self.maximum { + write!(f, "{} ({:?}..{:?})", shared, self.minimum, maximum) + } else { + write!(f, "{} ({:?}..)", shared, self.minimum) + } + } +} + +// Import Types + +/// A descriptor for an imported value into a wasm module. +/// +/// This type is primarily accessed from the `Module::imports` +/// API. Each `ImportType` describes an import into the wasm module +/// with the module/name that it's imported from as well as the type +/// of item that's being imported. +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct Import { + module: S, + name: S, + index: u32, + ty: T, +} + +impl, T> Import { + /// Creates a new import descriptor which comes from `module` and `name` and + /// is of type `ty`. + pub fn new(module: S, name: S, index: u32, ty: T) -> Self { + Self { + module, + name, + index, + ty, + } + } + + /// Returns the module name that this import is expected to come from. + pub fn module(&self) -> &str { + self.module.as_ref() + } + + /// Returns the field name of the module that this import is expected to + /// come from. + pub fn name(&self) -> &str { + self.name.as_ref() + } + + /// The index of the import in the module. + pub fn index(&self) -> u32 { + self.index + } + + /// Returns the expected type of this import. + pub fn ty(&self) -> &T { + &self.ty + } +} + +// Export Types + +/// A descriptor for an exported WebAssembly value. +/// +/// This type is primarily accessed from the `Module::exports` +/// accessor and describes what names are exported from a wasm module +/// and the type of the item that is exported. +/// +/// The `` refefers to `ExternType`, however it can also refer to use +/// `MemoryType`, `TableType`, `FunctionType` and `GlobalType` for ease of +/// use. +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct ExportType { + name: String, + ty: T, +} + +impl ExportType { + /// Creates a new export which is exported with the given `name` and has the + /// given `ty`. + pub fn new(name: &str, ty: T) -> Self { + Self { + name: name.to_string(), + ty, + } + } + + /// Returns the name by which this export is known by. + pub fn name(&self) -> &str { + &self.name + } + + /// Returns the type of this export. + pub fn ty(&self) -> &T { + &self.ty + } +} + +/// Fast gas counter with very simple structure, could be exposed to compiled code in the VM. +#[repr(C)] +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct FastGasCounter { + /// The following three fields must be put next to another to make sure + /// generated gas counting code can use and adjust them. + /// We will share counter to ensure we never miss synchronization. + /// This could change and in such a case synchronization required between compiled WASM code + /// and the host code. + + /// The amount of gas that was irreversibly used for contract execution. + pub burnt_gas: u64, + /// Hard gas limit for execution + pub gas_limit: u64, +} + +impl FastGasCounter { + /// New fast gas counter. + pub fn new(limit: u64) -> Self { + FastGasCounter { + burnt_gas: 0, + gas_limit: limit, + } + } + /// Amount of gas burnt, maybe load as atomic to avoid aliasing issues. + pub fn burnt(&self) -> u64 { + self.burnt_gas + } +} + +impl fmt::Display for FastGasCounter { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + write!(f, "burnt: {} limit: {} ", self.burnt(), self.gas_limit,) + } +} + +/// External configuration of execution environment for Instance. +#[derive(Clone)] +pub struct InstanceConfig { + /// External gas counter pointer. + pub gas_counter: *mut FastGasCounter, + default_gas_counter: Option>>, + /// Stack limit, in 8-byte slots. + pub stack_limit: i32, +} + +// Default stack limit, in bytes. +const DEFAULT_STACK_LIMIT: i32 = 1024 * 1024; + +impl InstanceConfig { + /// Create default instance configuration. + pub fn default() -> Self { + let result = Rc::new(UnsafeCell::new(FastGasCounter { + burnt_gas: 0, + gas_limit: u64::MAX, + })); + Self { + gas_counter: result.get(), + default_gas_counter: Some(result), + stack_limit: DEFAULT_STACK_LIMIT, + } + } + + /// Create instance configuration with an external gas counter, unsafe as it creates + /// an alias on raw memory of gas_counter. This memory could be accessed until + /// instance configured with this `InstanceConfig` exists. + pub unsafe fn with_counter(mut self, gas_counter: *mut FastGasCounter) -> Self { + self.gas_counter = gas_counter; + self.default_gas_counter = None; + self + } + + /// Create instance configuration with given stack limit. + pub unsafe fn with_stack_limit(mut self, stack_limit: i32) -> Self { + self.stack_limit = stack_limit; + self + } +} + +#[cfg(test)] +mod tests { + use super::*; + + const VOID_TO_VOID: ([Type; 0], [Type; 0]) = ([], []); + const I32_I32_TO_VOID: ([Type; 2], [Type; 0]) = ([Type::I32, Type::I32], []); + const V128_I64_TO_I32: ([Type; 2], [Type; 1]) = ([Type::V128, Type::I64], [Type::I32]); + const NINE_V128_TO_NINE_I32: ([Type; 9], [Type; 9]) = ([Type::V128; 9], [Type::I32; 9]); + + #[test] + fn convert_tuple_to_functiontype() { + let ty: FunctionType = VOID_TO_VOID.into(); + assert_eq!(ty.params().len(), 0); + assert_eq!(ty.results().len(), 0); + + let ty: FunctionType = I32_I32_TO_VOID.into(); + assert_eq!(ty.params().len(), 2); + assert_eq!(ty.params()[0], Type::I32); + assert_eq!(ty.params()[1], Type::I32); + assert_eq!(ty.results().len(), 0); + + let ty: FunctionType = V128_I64_TO_I32.into(); + assert_eq!(ty.params().len(), 2); + assert_eq!(ty.params()[0], Type::V128); + assert_eq!(ty.params()[1], Type::I64); + assert_eq!(ty.results().len(), 1); + assert_eq!(ty.results()[0], Type::I32); + + let ty: FunctionType = NINE_V128_TO_NINE_I32.into(); + assert_eq!(ty.params().len(), 9); + assert_eq!(ty.results().len(), 9); + } +} diff --git a/runtime/near-vm/lib/types/src/units.rs b/runtime/near-vm/lib/types/src/units.rs new file mode 100644 index 00000000000..4303a5b5d77 --- /dev/null +++ b/runtime/near-vm/lib/types/src/units.rs @@ -0,0 +1,188 @@ +use crate::lib::std::convert::TryFrom; +use crate::lib::std::fmt; +use crate::lib::std::ops::{Add, Sub}; +use std::convert::TryInto; +use thiserror::Error; + +/// WebAssembly page sizes are fixed to be 64KiB. +/// Note: large page support may be added in an opt-in manner in the [future]. +/// +/// [future]: https://webassembly.org/docs/future-features/#large-page-support +pub const WASM_PAGE_SIZE: usize = 0x10000; + +/// The number of pages we can have before we run out of byte index space. +pub const WASM_MAX_PAGES: u32 = 0x10000; + +/// The minimum number of pages allowed. +pub const WASM_MIN_PAGES: u32 = 0x100; + +/// Units of WebAssembly pages (as specified to be 65,536 bytes). +#[derive( + Copy, + Clone, + PartialEq, + Eq, + PartialOrd, + Ord, + Hash, + rkyv::Serialize, + rkyv::Deserialize, + rkyv::Archive, +)] +#[archive(as = "Self")] +#[repr(transparent)] +pub struct Pages(pub u32); + +impl Pages { + /// Returns the largest value that can be represented by the Pages type. + /// + /// This is defined by the WebAssembly standard as 65,536 pages. + #[inline(always)] + pub const fn max_value() -> Self { + Self(WASM_MAX_PAGES) + } + + /// Checked addition. Computes `self + rhs`, + /// returning `None` if overflow occurred. + pub fn checked_add(self, rhs: Self) -> Option { + let added = (self.0 as usize) + (rhs.0 as usize); + if added <= (WASM_MAX_PAGES as usize) { + Some(Self(added as u32)) + } else { + None + } + } + + /// Calculate number of bytes from pages. + pub fn bytes(self) -> Bytes { + self.into() + } +} + +impl fmt::Debug for Pages { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + write!(f, "{} pages", self.0) + } +} + +impl From for Pages { + fn from(other: u32) -> Self { + Self(other) + } +} + +/// Units of WebAssembly memory in terms of 8-bit bytes. +#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct Bytes(pub usize); + +impl fmt::Debug for Bytes { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + write!(f, "{} bytes", self.0) + } +} + +impl From for Bytes { + fn from(pages: Pages) -> Self { + Self((pages.0 as usize) * WASM_PAGE_SIZE) + } +} + +impl From for Bytes { + fn from(other: usize) -> Self { + Self(other) + } +} + +impl From for Bytes { + fn from(other: u32) -> Self { + Self(other.try_into().unwrap()) + } +} + +impl Sub for Pages +where + T: Into, +{ + type Output = Self; + fn sub(self, rhs: T) -> Self { + Self(self.0 - rhs.into().0) + } +} + +impl Add for Pages +where + T: Into, +{ + type Output = Self; + fn add(self, rhs: T) -> Self { + Self(self.0 + rhs.into().0) + } +} + +/// The only error that can happen when converting `Bytes` to `Pages` +#[derive(Debug, Clone, Copy, PartialEq, Error)] +#[error("Number of pages exceeds uint32 range")] +pub struct PageCountOutOfRange; + +impl TryFrom for Pages { + type Error = PageCountOutOfRange; + + fn try_from(bytes: Bytes) -> Result { + let pages: u32 = (bytes.0 / WASM_PAGE_SIZE) + .try_into() + .or(Err(PageCountOutOfRange))?; + Ok(Self(pages)) + } +} + +impl Sub for Bytes +where + T: Into, +{ + type Output = Self; + fn sub(self, rhs: T) -> Self { + Self(self.0 - rhs.into().0) + } +} + +impl Add for Bytes +where + T: Into, +{ + type Output = Self; + fn add(self, rhs: T) -> Self { + Self(self.0 + rhs.into().0) + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn convert_bytes_to_pages() { + // rounds down + let pages = Pages::try_from(Bytes(0)).unwrap(); + assert_eq!(pages, Pages(0)); + let pages = Pages::try_from(Bytes(1)).unwrap(); + assert_eq!(pages, Pages(0)); + let pages = Pages::try_from(Bytes(WASM_PAGE_SIZE - 1)).unwrap(); + assert_eq!(pages, Pages(0)); + let pages = Pages::try_from(Bytes(WASM_PAGE_SIZE)).unwrap(); + assert_eq!(pages, Pages(1)); + let pages = Pages::try_from(Bytes(WASM_PAGE_SIZE + 1)).unwrap(); + assert_eq!(pages, Pages(1)); + let pages = Pages::try_from(Bytes(28 * WASM_PAGE_SIZE + 42)).unwrap(); + assert_eq!(pages, Pages(28)); + let pages = Pages::try_from(Bytes((u32::MAX as usize) * WASM_PAGE_SIZE)).unwrap(); + assert_eq!(pages, Pages(u32::MAX)); + let pages = Pages::try_from(Bytes((u32::MAX as usize) * WASM_PAGE_SIZE + 1)).unwrap(); + assert_eq!(pages, Pages(u32::MAX)); + + // Errors when page count cannot be represented as u32 + let result = Pages::try_from(Bytes((u32::MAX as usize + 1) * WASM_PAGE_SIZE)); + assert_eq!(result.unwrap_err(), PageCountOutOfRange); + let result = Pages::try_from(Bytes(usize::MAX)); + assert_eq!(result.unwrap_err(), PageCountOutOfRange); + } +} diff --git a/runtime/near-vm/lib/types/src/values.rs b/runtime/near-vm/lib/types/src/values.rs new file mode 100644 index 00000000000..36772ae1bed --- /dev/null +++ b/runtime/near-vm/lib/types/src/values.rs @@ -0,0 +1,476 @@ +use crate::extern_ref::ExternRef; +use crate::lib::std::convert::TryFrom; +use crate::lib::std::fmt; +use crate::lib::std::ptr; +use crate::lib::std::string::{String, ToString}; +use crate::types::Type; + +/// Possible runtime values that a WebAssembly module can either consume or +/// produce. +#[derive(Clone, PartialEq)] +pub enum Value { + /// A 32-bit integer. + /// + /// In Wasm integers are sign-agnostic, i.e. this can either be signed or unsigned. + I32(i32), + + /// A 64-bit integer. + /// + /// In Wasm integers are sign-agnostic, i.e. this can either be signed or unsigned. + I64(i64), + + /// A 32-bit float. + F32(f32), + + /// A 64-bit float. + F64(f64), + + /// An `externref` value which can hold opaque data to the wasm instance itself. + /// + /// Note that this is a nullable value as well. + ExternRef(ExternRef), + + /// A first-class reference to a WebAssembly function. + FuncRef(Option), + + /// A 128-bit number + V128(u128), +} + +macro_rules! accessors { + ($bind:ident $(($variant:ident($ty:ty) $get:ident $unwrap:ident $cvt:expr))*) => ($( + /// Attempt to access the underlying value of this `Value`, returning + /// `None` if it is not the correct type. + pub fn $get(&self) -> Option<$ty> { + if let Self::$variant($bind) = self { + Some($cvt) + } else { + None + } + } + + /// Returns the underlying value of this `Value`, panicking if it's the + /// wrong type. + /// + /// # Panics + /// + /// Panics if `self` is not of the right type. + pub fn $unwrap(&self) -> $ty { + self.$get().expect(concat!("expected ", stringify!($ty))) + } + )*) +} + +/// Trait for reading and writing Wasm values into binary for use on the layer +/// between the API and the VM internals, specifically with `wasmer_types::Value`. +pub trait WasmValueType: std::fmt::Debug + 'static { + /// Write the value + unsafe fn write_value_to(&self, p: *mut i128); + + /// read the value + // TODO(reftypes): passing the store as `dyn Any` is a hack to work around the + // structure of our crates. We need to talk about the store in the rest of the + // VM (for example where this method is used) but cannot do so. Fixing this + // may be non-trivial. + unsafe fn read_value_from(store: &dyn std::any::Any, p: *const i128) -> Self; +} + +impl WasmValueType for () { + unsafe fn write_value_to(&self, _p: *mut i128) {} + + unsafe fn read_value_from(_store: &dyn std::any::Any, _p: *const i128) -> Self { + () + } +} + +impl Value +where + T: WasmValueType, +{ + /// Returns a null `externref` value. + pub fn null() -> Self { + Self::ExternRef(ExternRef::null()) + } + + /// Returns the corresponding [`Type`] for this `Value`. + pub fn ty(&self) -> Type { + match self { + Self::I32(_) => Type::I32, + Self::I64(_) => Type::I64, + Self::F32(_) => Type::F32, + Self::F64(_) => Type::F64, + Self::ExternRef(_) => Type::ExternRef, + Self::FuncRef(_) => Type::FuncRef, + Self::V128(_) => Type::V128, + } + } + + /// Writes it's value to a given pointer + /// + /// # Safety + /// `p` must be: + /// - Sufficiently aligned for the Rust equivalent of the type in `self` + /// - Non-null and pointing to valid, mutable memory + pub unsafe fn write_value_to(&self, p: *mut i128) { + match self { + Self::I32(i) => ptr::write(p as *mut i32, *i), + Self::I64(i) => ptr::write(p as *mut i64, *i), + Self::F32(u) => ptr::write(p as *mut f32, *u), + Self::F64(u) => ptr::write(p as *mut f64, *u), + Self::V128(b) => ptr::write(p as *mut u128, *b), + Self::FuncRef(Some(b)) => T::write_value_to(b, p), + Self::FuncRef(None) => ptr::write(p as *mut usize, 0), + // TODO(reftypes): review clone here + Self::ExternRef(extern_ref) => ptr::write(p as *mut ExternRef, extern_ref.clone()), + } + } + + /// Gets a `Value` given a pointer and a `Type` + /// + /// # Safety + /// `p` must be: + /// - Properly aligned to the specified `ty`'s Rust equivalent + /// - Non-null and pointing to valid memory + pub unsafe fn read_value_from(store: &dyn std::any::Any, p: *const i128, ty: Type) -> Self { + match ty { + Type::I32 => Self::I32(ptr::read(p as *const i32)), + Type::I64 => Self::I64(ptr::read(p as *const i64)), + Type::F32 => Self::F32(ptr::read(p as *const f32)), + Type::F64 => Self::F64(ptr::read(p as *const f64)), + Type::V128 => Self::V128(ptr::read(p as *const u128)), + Type::FuncRef => { + // We do the null check ourselves + if (*(p as *const usize)) == 0 { + Self::FuncRef(None) + } else { + Self::FuncRef(Some(T::read_value_from(store, p))) + } + } + Type::ExternRef => { + let extern_ref = (&*(p as *const ExternRef)).clone(); + Self::ExternRef(extern_ref) + } + } + } + + accessors! { + e + (I32(i32) i32 unwrap_i32 *e) + (I64(i64) i64 unwrap_i64 *e) + (F32(f32) f32 unwrap_f32 *e) + (F64(f64) f64 unwrap_f64 *e) + (ExternRef(ExternRef) externref unwrap_externref e.clone()) + (FuncRef(&Option) funcref unwrap_funcref e) + (V128(u128) v128 unwrap_v128 *e) + } +} + +impl fmt::Debug for Value +where + T: WasmValueType, +{ + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + match self { + Self::I32(v) => write!(f, "I32({:?})", v), + Self::I64(v) => write!(f, "I64({:?})", v), + Self::F32(v) => write!(f, "F32({:?})", v), + Self::F64(v) => write!(f, "F64({:?})", v), + Self::ExternRef(v) => write!(f, "ExternRef({:?})", v), + Self::FuncRef(None) => write!(f, "Null FuncRef"), + Self::FuncRef(Some(v)) => write!(f, "FuncRef({:?})", v), + Self::V128(v) => write!(f, "V128({:?})", v), + } + } +} + +impl ToString for Value +where + T: WasmValueType, +{ + fn to_string(&self) -> String { + match self { + Self::I32(v) => v.to_string(), + Self::I64(v) => v.to_string(), + Self::F32(v) => v.to_string(), + Self::F64(v) => v.to_string(), + Self::ExternRef(_) => "externref".to_string(), + Self::FuncRef(_) => "funcref".to_string(), + Self::V128(v) => v.to_string(), + } + } +} + +impl From for Value +where + T: WasmValueType, +{ + fn from(val: i32) -> Self { + Self::I32(val) + } +} + +impl From for Value +where + T: WasmValueType, +{ + fn from(val: u32) -> Self { + // In Wasm integers are sign-agnostic, so i32 is basically a 4 byte storage we can use for signed or unsigned 32-bit integers. + Self::I32(val as i32) + } +} + +impl From for Value +where + T: WasmValueType, +{ + fn from(val: i64) -> Self { + Self::I64(val) + } +} + +impl From for Value +where + T: WasmValueType, +{ + fn from(val: u64) -> Self { + // In Wasm integers are sign-agnostic, so i64 is basically an 8 byte storage we can use for signed or unsigned 64-bit integers. + Self::I64(val as i64) + } +} + +impl From for Value +where + T: WasmValueType, +{ + fn from(val: f32) -> Self { + Self::F32(val) + } +} + +impl From for Value +where + T: WasmValueType, +{ + fn from(val: f64) -> Self { + Self::F64(val) + } +} + +impl From for Value +where + T: WasmValueType, +{ + fn from(val: ExternRef) -> Self { + Self::ExternRef(val) + } +} + +// impl From for Value { +// fn from(val: T) -> Self { +// Self::FuncRef(val) +// } +// } + +const NOT_I32: &str = "Value is not of Wasm type i32"; +const NOT_I64: &str = "Value is not of Wasm type i64"; +const NOT_F32: &str = "Value is not of Wasm type f32"; +const NOT_F64: &str = "Value is not of Wasm type f64"; + +impl TryFrom> for i32 +where + T: WasmValueType, +{ + type Error = &'static str; + + fn try_from(value: Value) -> Result { + value.i32().ok_or(NOT_I32) + } +} + +impl TryFrom> for u32 +where + T: WasmValueType, +{ + type Error = &'static str; + + fn try_from(value: Value) -> Result { + value.i32().ok_or(NOT_I32).map(|int| int as Self) + } +} + +impl TryFrom> for i64 +where + T: WasmValueType, +{ + type Error = &'static str; + + fn try_from(value: Value) -> Result { + value.i64().ok_or(NOT_I64) + } +} + +impl TryFrom> for u64 +where + T: WasmValueType, +{ + type Error = &'static str; + + fn try_from(value: Value) -> Result { + value.i64().ok_or(NOT_I64).map(|int| int as Self) + } +} + +impl TryFrom> for f32 +where + T: WasmValueType, +{ + type Error = &'static str; + + fn try_from(value: Value) -> Result { + value.f32().ok_or(NOT_F32) + } +} + +impl TryFrom> for f64 +where + T: WasmValueType, +{ + type Error = &'static str; + + fn try_from(value: Value) -> Result { + value.f64().ok_or(NOT_F64) + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn test_value_i32_from_u32() { + let bytes = [0x00, 0x00, 0x00, 0x00]; + let v = Value::<()>::from(u32::from_be_bytes(bytes.clone())); + assert_eq!(v, Value::I32(i32::from_be_bytes(bytes.clone()))); + + let bytes = [0x00, 0x00, 0x00, 0x01]; + let v = Value::<()>::from(u32::from_be_bytes(bytes.clone())); + assert_eq!(v, Value::I32(i32::from_be_bytes(bytes.clone()))); + + let bytes = [0xAA, 0xBB, 0xCC, 0xDD]; + let v = Value::<()>::from(u32::from_be_bytes(bytes.clone())); + assert_eq!(v, Value::I32(i32::from_be_bytes(bytes.clone()))); + + let bytes = [0xFF, 0xFF, 0xFF, 0xFF]; + let v = Value::<()>::from(u32::from_be_bytes(bytes.clone())); + assert_eq!(v, Value::I32(i32::from_be_bytes(bytes.clone()))); + } + + #[test] + fn test_value_i64_from_u64() { + let bytes = [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]; + let v = Value::<()>::from(u64::from_be_bytes(bytes.clone())); + assert_eq!(v, Value::I64(i64::from_be_bytes(bytes.clone()))); + + let bytes = [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01]; + let v = Value::<()>::from(u64::from_be_bytes(bytes.clone())); + assert_eq!(v, Value::I64(i64::from_be_bytes(bytes.clone()))); + + let bytes = [0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF, 0x00, 0x11]; + let v = Value::<()>::from(u64::from_be_bytes(bytes.clone())); + assert_eq!(v, Value::I64(i64::from_be_bytes(bytes.clone()))); + + let bytes = [0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF]; + let v = Value::<()>::from(u64::from_be_bytes(bytes.clone())); + assert_eq!(v, Value::I64(i64::from_be_bytes(bytes.clone()))); + } + + #[test] + fn convert_value_to_i32() { + let value = Value::<()>::I32(5678); + let result = i32::try_from(value); + assert_eq!(result.unwrap(), 5678); + + let value = Value::<()>::from(u32::MAX); + let result = i32::try_from(value); + assert_eq!(result.unwrap(), -1); + + let value = Value::<()>::V128(42); + let result = i32::try_from(value); + assert_eq!(result.unwrap_err(), "Value is not of Wasm type i32"); + } + + #[test] + fn convert_value_to_u32() { + let value = Value::<()>::from(u32::MAX); + let result = u32::try_from(value); + assert_eq!(result.unwrap(), u32::MAX); + + let value = Value::<()>::I32(-1); + let result = u32::try_from(value); + assert_eq!(result.unwrap(), u32::MAX); + + let value = Value::<()>::V128(42); + let result = u32::try_from(value); + assert_eq!(result.unwrap_err(), "Value is not of Wasm type i32"); + } + + #[test] + fn convert_value_to_i64() { + let value = Value::<()>::I64(5678); + let result = i64::try_from(value); + assert_eq!(result.unwrap(), 5678); + + let value = Value::<()>::from(u64::MAX); + let result = i64::try_from(value); + assert_eq!(result.unwrap(), -1); + + let value = Value::<()>::V128(42); + let result = i64::try_from(value); + assert_eq!(result.unwrap_err(), "Value is not of Wasm type i64"); + } + + #[test] + fn convert_value_to_u64() { + let value = Value::<()>::from(u64::MAX); + let result = u64::try_from(value); + assert_eq!(result.unwrap(), u64::MAX); + + let value = Value::<()>::I64(-1); + let result = u64::try_from(value); + assert_eq!(result.unwrap(), u64::MAX); + + let value = Value::<()>::V128(42); + let result = u64::try_from(value); + assert_eq!(result.unwrap_err(), "Value is not of Wasm type i64"); + } + + #[test] + fn convert_value_to_f32() { + let value = Value::<()>::F32(1.234); + let result = f32::try_from(value); + assert_eq!(result.unwrap(), 1.234); + + let value = Value::<()>::V128(42); + let result = f32::try_from(value); + assert_eq!(result.unwrap_err(), "Value is not of Wasm type f32"); + + let value = Value::<()>::F64(1.234); + let result = f32::try_from(value); + assert_eq!(result.unwrap_err(), "Value is not of Wasm type f32"); + } + + #[test] + fn convert_value_to_f64() { + let value = Value::<()>::F64(1.234); + let result = f64::try_from(value); + assert_eq!(result.unwrap(), 1.234); + + let value = Value::<()>::V128(42); + let result = f64::try_from(value); + assert_eq!(result.unwrap_err(), "Value is not of Wasm type f64"); + + let value = Value::<()>::F32(1.234); + let result = f64::try_from(value); + assert_eq!(result.unwrap_err(), "Value is not of Wasm type f64"); + } +} diff --git a/runtime/near-vm/lib/types/tests/partial-sum-map/corpus/.gitkeep b/runtime/near-vm/lib/types/tests/partial-sum-map/corpus/.gitkeep new file mode 100644 index 00000000000..e69de29bb2d diff --git a/runtime/near-vm/lib/types/tests/partial-sum-map/crashes/.gitkeep b/runtime/near-vm/lib/types/tests/partial-sum-map/crashes/.gitkeep new file mode 100644 index 00000000000..e69de29bb2d diff --git a/runtime/near-vm/lib/types/tests/partial-sum-map/main.rs b/runtime/near-vm/lib/types/tests/partial-sum-map/main.rs new file mode 100644 index 00000000000..4006946afbf --- /dev/null +++ b/runtime/near-vm/lib/types/tests/partial-sum-map/main.rs @@ -0,0 +1,32 @@ +use wasmer_types::partial_sum_map::{Error, PartialSumMap}; + +fn main() { + bolero::check!() + .with_type::<(Vec<(u32, u32)>, Vec)>() + .for_each(|input| { + let adds = &input.0; + let tests = &input.1; + let mut psm = PartialSumMap::new(); + let mut v = Vec::new(); + let mut size: u32 = 0; + for a in adds { + let push_res = psm.push(a.0, a.1); + match size.checked_add(a.0) { + None => { + assert_eq!(push_res, Err(Error::Overflow)); + continue; + } + Some(new_size) => { + assert_eq!(push_res, Ok(())); + size = new_size; + } + } + v.push(((size - a.0)..size, a.1)); + } + for t in tests { + let psm_answer = psm.find(*t); + let iset_answer = v.iter().find(|(r, _)| r.contains(&t)).map(|(_, v)| v); + assert_eq!(psm_answer, iset_answer); + } + }); +} diff --git a/runtime/near-vm/lib/vm/Cargo.toml b/runtime/near-vm/lib/vm/Cargo.toml new file mode 100644 index 00000000000..a7b652fa4f8 --- /dev/null +++ b/runtime/near-vm/lib/vm/Cargo.toml @@ -0,0 +1,41 @@ +[package] +name = "wasmer-vm-near" +version = "2.4.0" +description = "Runtime library support for Wasmer" +categories = ["wasm"] +keywords = ["wasm", "webassembly"] +authors = ["Wasmer Engineering Team "] +repository = "https://github.com/wasmerio/wasmer" +license = "MIT OR Apache-2.0 WITH LLVM-exception" +readme = "README.md" +edition = "2018" + +[lib] +name = "wasmer_vm" + +[dependencies] +backtrace = "0.3" +cfg-if = "1.0" +finite-wasm = "0.3.0" +indexmap = { version = "1.6" } +libc = { version = "^0.2", default-features = false } +memoffset = "0.6" +more-asserts = "0.2" +region = "3.0" +rkyv = { version = "0.7.20" } +thiserror = "1.0" +tracing = "0.1" +wasmer-types = { path = "../types", package = "wasmer-types-near", version = "=2.4.0" } +wasmparser = "0.99.0" + +[target.'cfg(target_os = "windows")'.dependencies] +winapi = { version = "0.3", features = ["winbase", "memoryapi", "errhandlingapi"] } + +[build-dependencies] +cc = "1.0" + +[badges] +maintenance = { status = "actively-developed" } + +[features] +default = [] diff --git a/runtime/near-vm/lib/vm/README.md b/runtime/near-vm/lib/vm/README.md new file mode 100644 index 00000000000..f534f97cd93 --- /dev/null +++ b/runtime/near-vm/lib/vm/README.md @@ -0,0 +1,26 @@ +# `wasmer-vm` [![Build Status](https://github.com/wasmerio/wasmer/workflows/build/badge.svg?style=flat-square)](https://github.com/wasmerio/wasmer/actions?query=workflow%3Abuild) [![Join Wasmer Slack](https://img.shields.io/static/v1?label=Slack&message=join%20chat&color=brighgreen&style=flat-square)](https://slack.wasmer.io) [![MIT License](https://img.shields.io/github/license/wasmerio/wasmer.svg?style=flat-square)](https://github.com/wasmerio/wasmer/blob/master/LICENSE) + +This crate contains the Wasmer VM runtime library, supporting the Wasm ABI used by any [`wasmer-engine`] implementation. + +The Wasmer runtime is modular by design, and provides several +libraries where each of them provides a specific set of features. This +`wasmer-vm` library contains the low-level foundation for the runtime +itself. + +It provides all the APIs the +[`wasmer-engine`](https://crates.io/crates/wasmer-engine) needs to operate, +from the `instance`, to `memory`, `probestack`, signature registry, `trap`, +`table`, `VMContext`, `libcalls` etc. + +It is very unlikely that a user will need to deal with `wasmer-vm` +directly. The `wasmer` crate provides types that embed types from +`wasmer-vm` with a higher-level API. + + +[`wasmer-engine`]: https://crates.io/crates/wasmer-engine + +### Acknowledgments + +This project borrowed some of the code for the VM structure and trapping from the [wasmtime-runtime](https://crates.io/crates/wasmtime-runtime). + +Please check [Wasmer ATTRIBUTIONS](https://github.com/wasmerio/wasmer/blob/master/ATTRIBUTIONS.md) to further see licenses and other attributions of the project. diff --git a/runtime/near-vm/lib/vm/build.rs b/runtime/near-vm/lib/vm/build.rs new file mode 100644 index 00000000000..278eb570db7 --- /dev/null +++ b/runtime/near-vm/lib/vm/build.rs @@ -0,0 +1,19 @@ +//! Runtime build script compiles C code using setjmp for trap handling. + +use std::env; + +fn main() { + println!("cargo:rerun-if-changed=src/trap/handlers.c"); + + cc::Build::new() + .warnings(true) + .define( + &format!( + "CFG_TARGET_OS_{}", + env::var("CARGO_CFG_TARGET_OS").unwrap().to_uppercase() + ), + None, + ) + .file("src/trap/handlers.c") + .compile("handlers"); +} diff --git a/runtime/near-vm/lib/vm/src/artifact.rs b/runtime/near-vm/lib/vm/src/artifact.rs new file mode 100644 index 00000000000..ed6904b0611 --- /dev/null +++ b/runtime/near-vm/lib/vm/src/artifact.rs @@ -0,0 +1,98 @@ +use crate::{InstanceHandle, Resolver, Tunables, VMLocalFunction, VMSharedSignatureIndex}; +use std::{any::Any, collections::BTreeMap, sync::Arc}; +use wasmer_types::{ + entity::BoxedSlice, ElemIndex, FunctionIndex, GlobalInit, GlobalType, ImportCounts, + InstanceConfig, LocalFunctionIndex, OwnedDataInitializer, OwnedTableInitializer, +}; + +mod private { + pub struct Internal(pub(super) ()); +} + +/// [`Artifact`]s that can be instantiated. +pub trait Instantiatable: Artifact { + /// The errors that can occur when instantiating. + type Error: std::error::Error + Send + Sync; + + /// Crate an `Instance` from this `Artifact`. + /// + /// # Safety + /// + /// See [`InstanceHandle::new`]. + unsafe fn instantiate( + self: Arc, + tunables: &dyn Tunables, + resolver: &dyn Resolver, + host_state: Box, + config: InstanceConfig, + ) -> Result; +} + +/// A predecesor of a full module Instance. +/// +/// This type represents parts of a compiled WASM module ([`Executable`](crate::Executable)) that +/// are pre-allocated in within some Engine's store. +/// +/// Some other operations such as linking, relocating and similar may also be performed during +/// constructon of the Artifact, making this type particularly well suited for caching in-memory. +pub trait Artifact: Send + Sync { + /// Internal: support for downcasting `Executable`s. + #[doc(hidden)] + fn type_id(&self, _: private::Internal) -> std::any::TypeId + where + Self: 'static, + { + std::any::TypeId::of::() + } + + /// The information about offsets into the VM context table. + fn offsets(&self) -> &crate::VMOffsets; + + /// The count of imported entities. + fn import_counts(&self) -> &ImportCounts; + + /// The locally defined functions. + /// + /// These are published and ready to call. + fn functions(&self) -> &BoxedSlice; + + /// Passive table elements. + fn passive_elements(&self) -> &BTreeMap>; + + /// Table initializers. + fn element_segments(&self) -> &[OwnedTableInitializer]; + + /// Memory initializers. + /// TODO: consider making it an iterator of `DataInitializer`s instead? + fn data_segments(&self) -> &[OwnedDataInitializer]; + + /// Passive table elements. + fn globals(&self) -> &[(GlobalType, GlobalInit)]; + + /// The function index to the start function. + fn start_function(&self) -> Option; + + /// Function by export name. + fn export_field(&self, name: &str) -> Option; + + /// Mapping between module SignatureIndex and VMSharedSignatureIndex. + fn signatures(&self) -> &[VMSharedSignatureIndex]; + + /// Obtain the function signature for either the import or local definition. + fn function_signature(&self, index: FunctionIndex) -> Option; +} + +impl dyn Artifact { + /// Downcast a dynamic Executable object to a concrete implementation of the trait. + pub fn downcast_arc(self: Arc) -> Result, Arc> { + if std::any::TypeId::of::() == Artifact::type_id(&*self, private::Internal(())) { + // SAFETY: err, its probably sound, we effectively construct a transmute here. + unsafe { + let ptr = Arc::into_raw(self).cast::(); + Ok(Arc::from_raw(ptr)) + } + } else { + Err(self) + } + } +} diff --git a/runtime/near-vm/lib/vm/src/export.rs b/runtime/near-vm/lib/vm/src/export.rs new file mode 100644 index 00000000000..eebf0b4a7b1 --- /dev/null +++ b/runtime/near-vm/lib/vm/src/export.rs @@ -0,0 +1,235 @@ +// This file contains code from external sources. +// Attributions: https://github.com/wasmerio/wasmer/blob/master/ATTRIBUTIONS.md + +use crate::global::Global; +use crate::instance::WeakOrStrongInstanceRef; +use crate::memory::{Memory, MemoryStyle}; +use crate::table::{Table, TableStyle}; +use crate::vmcontext::{VMFunctionBody, VMFunctionEnvironment, VMFunctionKind, VMTrampoline}; +use crate::VMSharedSignatureIndex; +use std::sync::Arc; +use wasmer_types::{MemoryType, TableType}; + +/// The value of an export passed from one instance to another. +#[derive(Debug)] +pub enum VMExtern { + /// A function export value. + Function(VMFunction), + + /// A table export value. + Table(VMTable), + + /// A memory export value. + Memory(VMMemory), + + /// A global export value. + Global(VMGlobal), +} + +/// A function export value. +#[derive(Clone, Debug, PartialEq)] +pub struct VMFunction { + /// The address of the native-code function. + pub address: *const VMFunctionBody, + + /// Pointer to the containing `VMContext`. + pub vmctx: VMFunctionEnvironment, + + /// The function type, used for compatibility checking. + pub signature: VMSharedSignatureIndex, + + /// The function kind (specifies the calling convention for the + /// function). + pub kind: VMFunctionKind, + + /// Address of the function call trampoline owned by the same + /// VMContext that owns the VMFunctionBody. + /// + /// May be `None` when the function is a host function (`FunctionType` + /// == `Dynamic` or `vmctx` == `nullptr`). + pub call_trampoline: Option, + + /// A “reference” to the instance through the + /// `InstanceRef`. `None` if it is a host function. + pub instance_ref: Option, +} + +impl VMFunction { + /// Converts the stored instance ref into a strong `InstanceRef` if it is weak. + /// Returns None if it cannot be upgraded. + pub fn upgrade_instance_ref(&mut self) -> Option<()> { + if let Some(ref mut ir) = self.instance_ref { + *ir = ir.upgrade()?; + } + Some(()) + } +} + +/// # Safety +/// There is no non-threadsafe logic directly in this type. Calling the function +/// may not be threadsafe. +unsafe impl Send for VMFunction {} +/// # Safety +/// The members of an VMFunction are immutable after construction. +unsafe impl Sync for VMFunction {} + +impl From for VMExtern { + fn from(func: VMFunction) -> Self { + Self::Function(func) + } +} + +/// A table export value. +#[derive(Clone, Debug)] +pub struct VMTable { + /// Pointer to the containing `Table`. + pub from: Arc, + + /// A “reference” to the instance through the + /// `InstanceRef`. `None` if it is a host table. + pub instance_ref: Option, +} + +/// # Safety +/// This is correct because there is no non-threadsafe logic directly in this type; +/// correct use of the raw table from multiple threads via `definition` requires `unsafe` +/// and is the responsibilty of the user of this type. +unsafe impl Send for VMTable {} + +/// # Safety +/// This is correct because the values directly in `definition` should be considered immutable +/// and the type is both `Send` and `Clone` (thus marking it `Sync` adds no new behavior, it +/// only makes this type easier to use) +unsafe impl Sync for VMTable {} + +impl VMTable { + /// Get the table type for this exported table + pub fn ty(&self) -> &TableType { + self.from.ty() + } + + /// Get the style for this exported table + pub fn style(&self) -> &TableStyle { + self.from.style() + } + + /// Returns whether or not the two `VMTable`s refer to the same Memory. + pub fn same(&self, other: &Self) -> bool { + Arc::ptr_eq(&self.from, &other.from) + } + + /// Converts the stored instance ref into a strong `InstanceRef` if it is weak. + /// Returns None if it cannot be upgraded. + pub fn upgrade_instance_ref(&mut self) -> Option<()> { + if let Some(ref mut ir) = self.instance_ref { + *ir = ir.upgrade()?; + } + Some(()) + } +} + +impl From for VMExtern { + fn from(table: VMTable) -> Self { + Self::Table(table) + } +} + +/// A memory export value. +#[derive(Debug, Clone)] +pub struct VMMemory { + /// Pointer to the containing `Memory`. + pub from: Arc, + + /// A “reference” to the instance through the + /// `InstanceRef`. `None` if it is a host memory. + pub instance_ref: Option, +} + +/// # Safety +/// This is correct because there is no non-threadsafe logic directly in this type; +/// correct use of the raw memory from multiple threads via `definition` requires `unsafe` +/// and is the responsibilty of the user of this type. +unsafe impl Send for VMMemory {} + +/// # Safety +/// This is correct because the values directly in `definition` should be considered immutable +/// and the type is both `Send` and `Clone` (thus marking it `Sync` adds no new behavior, it +/// only makes this type easier to use) +unsafe impl Sync for VMMemory {} + +impl VMMemory { + /// Get the type for this exported memory + pub fn ty(&self) -> MemoryType { + self.from.ty() + } + + /// Get the style for this exported memory + pub fn style(&self) -> &MemoryStyle { + self.from.style() + } + + /// Returns whether or not the two `VMMemory`s refer to the same Memory. + pub fn same(&self, other: &Self) -> bool { + Arc::ptr_eq(&self.from, &other.from) + } + + /// Converts the stored instance ref into a strong `InstanceRef` if it is weak. + /// Returns None if it cannot be upgraded. + pub fn upgrade_instance_ref(&mut self) -> Option<()> { + if let Some(ref mut ir) = self.instance_ref { + *ir = ir.upgrade()?; + } + Some(()) + } +} + +impl From for VMExtern { + fn from(memory: VMMemory) -> Self { + Self::Memory(memory) + } +} + +/// A global export value. +#[derive(Debug, Clone)] +pub struct VMGlobal { + /// The global declaration, used for compatibility checking. + pub from: Arc, + + /// A “reference” to the instance through the + /// `InstanceRef`. `None` if it is a host global. + pub instance_ref: Option, +} + +/// # Safety +/// This is correct because there is no non-threadsafe logic directly in this type; +/// correct use of the raw global from multiple threads via `definition` requires `unsafe` +/// and is the responsibilty of the user of this type. +unsafe impl Send for VMGlobal {} + +/// # Safety +/// This is correct because the values directly in `definition` should be considered immutable +/// from the perspective of users of this type and the type is both `Send` and `Clone` (thus +/// marking it `Sync` adds no new behavior, it only makes this type easier to use) +unsafe impl Sync for VMGlobal {} + +impl VMGlobal { + /// Returns whether or not the two `VMGlobal`s refer to the same Global. + pub fn same(&self, other: &Self) -> bool { + Arc::ptr_eq(&self.from, &other.from) + } + + /// Converts the stored instance ref into a strong `InstanceRef` if it is weak. + /// Returns None if it cannot be upgraded. + pub fn upgrade_instance_ref(&mut self) -> Option<()> { + if let Some(ref mut ir) = self.instance_ref { + *ir = ir.upgrade()?; + } + Some(()) + } +} + +impl From for VMExtern { + fn from(global: VMGlobal) -> Self { + Self::Global(global) + } +} diff --git a/runtime/near-vm/lib/vm/src/func_data_registry.rs b/runtime/near-vm/lib/vm/src/func_data_registry.rs new file mode 100644 index 00000000000..3b0059c9e8e --- /dev/null +++ b/runtime/near-vm/lib/vm/src/func_data_registry.rs @@ -0,0 +1,116 @@ +//! A registry for `VMFuncRef`s. This allows us to deduplicate funcrefs so that +//! identical `VMCallerCheckedAnyfunc`s will give us identical funcrefs. +//! +//! This registry also helps ensure that the `VMFuncRef`s can stay valid for as +//! long as we need them to. + +use crate::vmcontext::VMCallerCheckedAnyfunc; +use std::collections::HashMap; +use std::sync::Mutex; + +/// The registry that holds the values that `VMFuncRef`s point to. +#[derive(Debug)] +pub struct FuncDataRegistry { + // This structure is stored in an `Engine` and is intended to be shared + // across many instances. Ideally instances can themselves be sent across + // threads, and ideally we can compile across many threads. As a result we + // use interior mutability here with a lock to avoid having callers to + // externally synchronize calls to compilation. + inner: Mutex, +} + +// We use raw pointers but the data never moves, so it's not a problem +unsafe impl Send for FuncDataRegistry {} +unsafe impl Sync for FuncDataRegistry {} + +/// A function reference. A single word that points to metadata about a function. +#[repr(transparent)] +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] +pub struct VMFuncRef(pub(crate) *const VMCallerCheckedAnyfunc); + +impl wasmer_types::NativeWasmType for VMFuncRef { + const WASM_TYPE: wasmer_types::Type = wasmer_types::Type::FuncRef; + type Abi = Self; + + #[inline] + fn from_abi(abi: Self::Abi) -> Self { + abi + } + + #[inline] + fn into_abi(self) -> Self::Abi { + self + } + + #[inline] + fn to_binary(self) -> i128 { + self.0 as _ + } + + #[inline] + fn from_binary(bits: i128) -> Self { + // TODO: ensure that the safety invariants are actually upheld here + Self(bits as _) + } +} + +impl VMFuncRef { + /// Check if the FuncRef is null + // TODO: make this const when `std::ptr::is_null` is const + pub fn is_null(&self) -> bool { + self.0.is_null() + } + + /// Create a new null FuncRef + pub const fn null() -> Self { + Self(std::ptr::null()) + } +} + +impl std::ops::Deref for VMFuncRef { + type Target = *const VMCallerCheckedAnyfunc; + + fn deref(&self) -> &Self::Target { + &self.0 + } +} + +impl std::ops::DerefMut for VMFuncRef { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.0 + } +} + +// We use raw pointers but the data never moves, so it's not a problem +// TODO: update docs +unsafe impl Send for VMFuncRef {} +unsafe impl Sync for VMFuncRef {} + +#[derive(Debug, Default)] +struct Inner { + func_data: Vec, + anyfunc_to_index: HashMap, +} + +impl FuncDataRegistry { + /// Create a new `FuncDataRegistry`. + pub fn new() -> Self { + Self { + inner: Default::default(), + } + } + + /// Register a signature and return its unique index. + pub fn register(&self, anyfunc: VMCallerCheckedAnyfunc) -> VMFuncRef { + let mut inner = self.inner.lock().unwrap(); + let data = if let Some(&idx) = inner.anyfunc_to_index.get(&anyfunc) { + &inner.func_data[idx] + } else { + let idx = inner.func_data.len(); + inner.func_data.push(anyfunc); + inner.anyfunc_to_index.insert(anyfunc, idx); + &inner.func_data[idx] + }; + VMFuncRef(data) + } +} diff --git a/runtime/near-vm/lib/vm/src/global.rs b/runtime/near-vm/lib/vm/src/global.rs new file mode 100644 index 00000000000..a3d53a096a9 --- /dev/null +++ b/runtime/near-vm/lib/vm/src/global.rs @@ -0,0 +1,139 @@ +use crate::vmcontext::VMGlobalDefinition; +use std::cell::UnsafeCell; +use std::ptr::NonNull; +use std::sync::Mutex; +use thiserror::Error; +use wasmer_types::{GlobalType, Mutability, Type, Value, WasmValueType}; + +#[derive(Debug)] +/// A Global instance +pub struct Global { + ty: GlobalType, + // TODO: this box is unnecessary + vm_global_definition: Box>, + // used to synchronize gets/sets + lock: Mutex<()>, +} + +/// # Safety +/// This is safe to send between threads because there is no-thread specific logic. +/// TODO: look into other reasons that make something not `Send` +unsafe impl Send for Global {} +/// # Safety +/// This is safe to share between threads because it uses a `Mutex` internally. +unsafe impl Sync for Global {} + +/// Error type describing things that can go wrong when operating on Wasm Globals. +#[derive(Error, Debug, Clone, PartialEq, Hash)] +pub enum GlobalError { + /// The error returned when attempting to set an immutable global. + #[error("Attempted to set an immutable global")] + ImmutableGlobalCannotBeSet, + + /// The error returned when attempting to operate on a global as a specific type + /// that differs from the global's own type. + #[error("Attempted to operate on a global of type {expected} as a global of type {found}")] + IncorrectType { + /// The type that the global is. + expected: Type, + /// The type that we were asked to use it as. + found: Type, + }, +} + +impl Global { + /// Create a new, zero bit-pattern initialized global from a [`GlobalType`]. + pub fn new(global_type: GlobalType) -> Self { + Self { + ty: global_type, + vm_global_definition: Box::new(UnsafeCell::new(VMGlobalDefinition::new())), + lock: Mutex::new(()), + } + } + + /// Get the type of the global. + pub fn ty(&self) -> &GlobalType { + &self.ty + } + + /// Get a pointer to the underlying definition used by the generated code. + pub fn vmglobal(&self) -> NonNull { + let ptr = self.vm_global_definition.as_ref() as *const UnsafeCell + as *const VMGlobalDefinition as *mut VMGlobalDefinition; + unsafe { NonNull::new_unchecked(ptr) } + } + + /// Get a value from the global. + // TODO(reftypes): the `&dyn Any` here for `Store` is a work-around for the fact + // that `Store` is defined in `API` when we need it earlier. Ideally this should + // be removed. + pub fn get(&self, store: &dyn std::any::Any) -> Value { + let _global_guard = self.lock.lock().unwrap(); + unsafe { + let definition = &*self.vm_global_definition.get(); + match self.ty().ty { + Type::I32 => Value::I32(definition.to_i32()), + Type::I64 => Value::I64(definition.to_i64()), + Type::F32 => Value::F32(definition.to_f32()), + Type::F64 => Value::F64(definition.to_f64()), + Type::V128 => Value::V128(definition.to_u128()), + Type::ExternRef => Value::ExternRef(definition.to_externref().into()), + Type::FuncRef => { + let p = definition.to_u128() as i128; + if p as usize == 0 { + Value::FuncRef(None) + } else { + let v = T::read_value_from(store, &p); + Value::FuncRef(Some(v)) + } + } + } + } + } + + /// Set a value for the global. + /// + /// # Safety + /// The caller should check that the `val` comes from the same store as this global. + pub unsafe fn set(&self, val: Value) -> Result<(), GlobalError> { + let _global_guard = self.lock.lock().unwrap(); + if self.ty().mutability != Mutability::Var { + return Err(GlobalError::ImmutableGlobalCannotBeSet); + } + if val.ty() != self.ty().ty { + return Err(GlobalError::IncorrectType { + expected: self.ty.ty, + found: val.ty(), + }); + } + self.set_unchecked(val) + } + + /// Set a value from the global (unchecked) + /// + /// # Safety + /// The caller should check that the `val` comes from the same store as this global. + /// The caller should also ensure that this global is synchronized. Otherwise, use + /// `set` instead. + pub unsafe fn set_unchecked(&self, val: Value) -> Result<(), GlobalError> { + // ideally we'd use atomics for the global value rather than needing to lock it + let definition = &mut *self.vm_global_definition.get(); + match val { + Value::I32(i) => *definition.as_i32_mut() = i, + Value::I64(i) => *definition.as_i64_mut() = i, + Value::F32(f) => *definition.as_f32_mut() = f, + Value::F64(f) => *definition.as_f64_mut() = f, + Value::V128(x) => *definition.as_bytes_mut() = x.to_ne_bytes(), + Value::ExternRef(r) => { + let extern_ref = definition.as_externref_mut(); + extern_ref.ref_drop(); + *extern_ref = r.into() + } + Value::FuncRef(None) => *definition.as_u128_mut() = 0, + Value::FuncRef(Some(r)) => { + r.write_value_to(definition.as_u128_mut() as *mut u128 as *mut i128) + } + } + Ok(()) + } +} diff --git a/runtime/near-vm/lib/vm/src/imports.rs b/runtime/near-vm/lib/vm/src/imports.rs new file mode 100644 index 00000000000..f315d33183c --- /dev/null +++ b/runtime/near-vm/lib/vm/src/imports.rs @@ -0,0 +1,108 @@ +// This file contains code from external sources. +// Attributions: https://github.com/wasmerio/wasmer/blob/master/ATTRIBUTIONS.md + +use crate::instance::ImportFunctionEnv; +use crate::vmcontext::{VMFunctionImport, VMGlobalImport, VMMemoryImport, VMTableImport}; +use crate::{VMSharedSignatureIndex, VMTrampoline}; +use wasmer_types::entity::{BoxedSlice, PrimaryMap}; +use wasmer_types::{FunctionIndex, GlobalIndex, MemoryIndex, TableIndex}; + +/// Type of the import. +pub enum VMImportType { + /// A function import. + Function { + /// Signature for the function import. + sig: VMSharedSignatureIndex, + /// Trampoline to use for functions that use [`VMFunctionKind::Static`]. + static_trampoline: VMTrampoline, + }, + /// A global. + Global(wasmer_types::GlobalType), + /// A table. + Table(wasmer_types::TableType), + /// Some memory. + Memory(wasmer_types::MemoryType, crate::MemoryStyle), +} + +/// A module import. +pub struct VMImport { + /// This is passed to the `resolve` method. + /// + /// This index is shared between different import types. + pub import_no: u32, + /// The module name. + pub module: String, + /// The field name. + pub field: String, + /// Type of the import. + pub ty: VMImportType, +} + +/// Resolved import pointers. +#[derive(Clone)] +pub struct Imports { + /// Resolved addresses for imported functions. + pub functions: BoxedSlice, + + /// Initializers for host function environments. This is split out from `functions` + /// because the generated code never needs to touch this and the extra wasted + /// space may affect Wasm runtime performance due to increased cache pressure. + /// + /// We make it optional so that we can free the data after use. + /// + /// We move this data in `get_imported_function_envs` because there's + /// no value to keeping it around; host functions must be initialized + /// exactly once so we save some memory and improve correctness by + /// moving this data. + pub host_function_env_initializers: Option>, + + /// Resolved addresses for imported tables. + pub tables: BoxedSlice, + + /// Resolved addresses for imported memories. + pub memories: BoxedSlice, + + /// Resolved addresses for imported globals. + pub globals: BoxedSlice, +} + +impl Imports { + /// Construct a new `Imports` instance. + pub fn new( + function_imports: PrimaryMap, + host_function_env_initializers: PrimaryMap, + table_imports: PrimaryMap, + memory_imports: PrimaryMap, + global_imports: PrimaryMap, + ) -> Self { + Self { + functions: function_imports.into_boxed_slice(), + host_function_env_initializers: Some(host_function_env_initializers.into_boxed_slice()), + tables: table_imports.into_boxed_slice(), + memories: memory_imports.into_boxed_slice(), + globals: global_imports.into_boxed_slice(), + } + } + + /// Construct a new `Imports` instance with no imports. + pub fn none() -> Self { + Self { + functions: PrimaryMap::new().into_boxed_slice(), + host_function_env_initializers: None, + tables: PrimaryMap::new().into_boxed_slice(), + memories: PrimaryMap::new().into_boxed_slice(), + globals: PrimaryMap::new().into_boxed_slice(), + } + } + + /// Get the `WasmerEnv::init_with_instance` function pointers and the pointers + /// to the envs to call it on. + /// + /// This function can only be called once, it deletes the data it returns after + /// returning it to ensure that it's not called more than once. + pub fn get_imported_function_envs(&mut self) -> BoxedSlice { + self.host_function_env_initializers + .take() + .unwrap_or_else(|| PrimaryMap::new().into_boxed_slice()) + } +} diff --git a/runtime/near-vm/lib/vm/src/instance/allocator.rs b/runtime/near-vm/lib/vm/src/instance/allocator.rs new file mode 100644 index 00000000000..b192e40f560 --- /dev/null +++ b/runtime/near-vm/lib/vm/src/instance/allocator.rs @@ -0,0 +1,208 @@ +use super::{Instance, InstanceRef}; +use crate::vmcontext::{VMMemoryDefinition, VMTableDefinition}; +use crate::VMOffsets; +use std::alloc::{self, Layout}; +use std::convert::TryFrom; +use std::mem; +use std::ptr::{self, NonNull}; +use wasmer_types::entity::EntityRef; +use wasmer_types::{LocalMemoryIndex, LocalTableIndex}; + +/// This is an intermediate type that manages the raw allocation and +/// metadata when creating an [`Instance`]. +/// +/// This type will free the allocated memory if it's dropped before +/// being used. +/// +/// It is important to remind that [`Instance`] is dynamically-sized +/// based on `VMOffsets`: The `Instance.vmctx` field represents a +/// dynamically-sized array that extends beyond the nominal end of the +/// type. So in order to create an instance of it, we must: +/// +/// 1. Define the correct layout for `Instance` (size and alignment), +/// 2. Allocate it properly. +/// +/// The [`InstanceAllocator::instance_layout`] computes the correct +/// layout to represent the wanted [`Instance`]. +/// +/// Then we use this layout to allocate an empty `Instance` properly. +pub struct InstanceAllocator { + /// The buffer that will contain the [`Instance`] and dynamic fields. + instance_ptr: NonNull, + + /// The layout of the `instance_ptr` buffer. + instance_layout: Layout, + + /// Information about the offsets into the `instance_ptr` buffer for + /// the dynamic fields. + offsets: VMOffsets, + + /// Whether or not this type has transferred ownership of the + /// `instance_ptr` buffer. If it has not when being dropped, + /// the buffer should be freed. + consumed: bool, +} + +impl Drop for InstanceAllocator { + fn drop(&mut self) { + if !self.consumed { + // If `consumed` has not been set, then we still have ownership + // over the buffer and must free it. + let instance_ptr = self.instance_ptr.as_ptr(); + + unsafe { + std::alloc::dealloc(instance_ptr as *mut u8, self.instance_layout); + } + } + } +} + +impl InstanceAllocator { + /// Allocates instance data for use with [`InstanceHandle::new`]. + /// + /// Returns a wrapper type around the allocation and 2 vectors of + /// pointers into the allocated buffer. These lists of pointers + /// correspond to the location in memory for the local memories and + /// tables respectively. These pointers should be written to before + /// calling [`InstanceHandle::new`]. + /// + /// [`InstanceHandle::new`]: super::InstanceHandle::new + pub fn new( + offsets: VMOffsets, + ) -> ( + Self, + Vec>, + Vec>, + ) { + let instance_layout = Self::instance_layout(&offsets); + + #[allow(clippy::cast_ptr_alignment)] + let instance_ptr = unsafe { alloc::alloc(instance_layout) as *mut Instance }; + + let instance_ptr = if let Some(ptr) = NonNull::new(instance_ptr) { + ptr + } else { + alloc::handle_alloc_error(instance_layout); + }; + + let allocator = Self { + instance_ptr, + instance_layout, + offsets, + consumed: false, + }; + + // # Safety + // Both of these calls are safe because we allocate the pointer + // above with the same `offsets` that these functions use. + // Thus there will be enough valid memory for both of them. + let memories = unsafe { allocator.memory_definition_locations() }; + let tables = unsafe { allocator.table_definition_locations() }; + + (allocator, memories, tables) + } + + /// Calculate the appropriate layout for the [`Instance`]. + fn instance_layout(offsets: &VMOffsets) -> Layout { + let vmctx_size = usize::try_from(offsets.size_of_vmctx()) + .expect("Failed to convert the size of `vmctx` to a `usize`"); + + let instance_vmctx_layout = + Layout::array::(vmctx_size).expect("Failed to create a layout for `VMContext`"); + + let (instance_layout, _offset) = Layout::new::() + .extend(instance_vmctx_layout) + .expect("Failed to extend to `Instance` layout to include `VMContext`"); + + instance_layout.pad_to_align() + } + + /// Get the locations of where the local [`VMMemoryDefinition`]s should be stored. + /// + /// This function lets us create `Memory` objects on the host with backing + /// memory in the VM. + /// + /// # Safety + /// + /// - `Self.instance_ptr` must point to enough memory that all of + /// the offsets in `Self.offsets` point to valid locations in + /// memory, i.e. `Self.instance_ptr` must have been allocated by + /// `Self::new`. + unsafe fn memory_definition_locations(&self) -> Vec> { + let num_memories = self.offsets.num_local_memories(); + let num_memories = usize::try_from(num_memories).unwrap(); + let mut out = Vec::with_capacity(num_memories); + + // We need to do some pointer arithmetic now. The unit is `u8`. + let ptr = self.instance_ptr.cast::().as_ptr(); + let base_ptr = ptr.add(mem::size_of::()); + + for i in 0..num_memories { + let mem_offset = self + .offsets + .vmctx_vmmemory_definition(LocalMemoryIndex::new(i)); + let mem_offset = usize::try_from(mem_offset).unwrap(); + + let new_ptr = NonNull::new_unchecked(base_ptr.add(mem_offset)); + + out.push(new_ptr.cast()); + } + + out + } + + /// Get the locations of where the [`VMTableDefinition`]s should be stored. + /// + /// This function lets us create [`Table`] objects on the host with backing + /// memory in the VM. + /// + /// # Safety + /// + /// - `Self.instance_ptr` must point to enough memory that all of + /// the offsets in `Self.offsets` point to valid locations in + /// memory, i.e. `Self.instance_ptr` must have been allocated by + /// `Self::new`. + unsafe fn table_definition_locations(&self) -> Vec> { + let num_tables = self.offsets.num_local_tables(); + let num_tables = usize::try_from(num_tables).unwrap(); + let mut out = Vec::with_capacity(num_tables); + + // We need to do some pointer arithmetic now. The unit is `u8`. + let ptr = self.instance_ptr.cast::().as_ptr(); + let base_ptr = ptr.add(std::mem::size_of::()); + + for i in 0..num_tables { + let table_offset = self + .offsets + .vmctx_vmtable_definition(LocalTableIndex::new(i)); + let table_offset = usize::try_from(table_offset).unwrap(); + + let new_ptr = NonNull::new_unchecked(base_ptr.add(table_offset)); + + out.push(new_ptr.cast()); + } + out + } + + /// Finish preparing by writing the [`Instance`] into memory, and + /// consume this `InstanceAllocator`. + pub(crate) fn write_instance(mut self, instance: Instance) -> InstanceRef { + // Prevent the old state's drop logic from being called as we + // transition into the new state. + self.consumed = true; + + unsafe { + // `instance` is moved at `Self.instance_ptr`. This + // pointer has been allocated by `Self::allocate_instance` + // (so by `InstanceRef::allocate_instance`). + ptr::write(self.instance_ptr.as_ptr(), instance); + // Now `instance_ptr` is correctly initialized! + } + let instance = self.instance_ptr; + let instance_layout = self.instance_layout; + + // This is correct because of the invariants of `Self` and + // because we write `Instance` to the pointer in this function. + unsafe { InstanceRef::new(instance, instance_layout) } + } +} diff --git a/runtime/near-vm/lib/vm/src/instance/mod.rs b/runtime/near-vm/lib/vm/src/instance/mod.rs new file mode 100644 index 00000000000..c25809ca280 --- /dev/null +++ b/runtime/near-vm/lib/vm/src/instance/mod.rs @@ -0,0 +1,1368 @@ +// This file contains code from external sources. +// Attributions: https://github.com/wasmerio/wasmer/blob/master/ATTRIBUTIONS.md + +//! An `Instance` contains all the runtime state used by execution of +//! a WebAssembly module (except its callstack and register state). An +//! `InstanceRef` is a wrapper around `Instance` that manages +//! how it is allocated and deallocated. An `InstanceHandle` is a +//! wrapper around an `InstanceRef`. + +mod allocator; +mod r#ref; + +pub use allocator::InstanceAllocator; +pub use r#ref::{InstanceRef, WeakInstanceRef, WeakOrStrongInstanceRef}; + +use crate::func_data_registry::VMFuncRef; +use crate::global::Global; +use crate::imports::Imports; +use crate::memory::{Memory, MemoryError}; +use crate::sig_registry::VMSharedSignatureIndex; +use crate::table::{Table, TableElement}; +use crate::trap::traphandlers::get_trap_handler; +use crate::trap::{catch_traps, Trap, TrapCode}; +use crate::vmcontext::{ + VMBuiltinFunctionsArray, VMCallerCheckedAnyfunc, VMContext, VMFunctionBody, + VMFunctionEnvironment, VMFunctionImport, VMFunctionKind, VMGlobalDefinition, VMGlobalImport, + VMLocalFunction, VMMemoryDefinition, VMMemoryImport, VMTableDefinition, VMTableImport, +}; +use crate::{wasmer_call_trampoline, Artifact, VMOffsets, VMTrampoline}; +use crate::{VMExtern, VMFunction, VMGlobal}; +use memoffset::offset_of; +use more_asserts::assert_lt; +use std::any::Any; +use std::cell::RefCell; +use std::collections::BTreeMap; +use std::convert::TryFrom; +use std::ffi; +use std::fmt; +use std::mem; +use std::ptr::{self, NonNull}; +use std::slice; +use std::sync::Arc; +use wasmer_types::entity::{packed_option::ReservedValue, BoxedSlice, EntityRef, PrimaryMap}; +use wasmer_types::{ + DataIndex, DataInitializer, ElemIndex, ExportIndex, FastGasCounter, FunctionIndex, GlobalIndex, + GlobalInit, InstanceConfig, LocalGlobalIndex, LocalMemoryIndex, LocalTableIndex, MemoryIndex, + OwnedTableInitializer, Pages, TableIndex, +}; + +/// The function pointer to call with data and an [`Instance`] pointer to +/// finish initializing the host env. +pub type ImportInitializerFuncPtr = + fn(*mut ffi::c_void, *const ffi::c_void) -> Result<(), ResultErr>; + +/// A WebAssembly instance. +/// +/// The type is dynamically-sized. Indeed, the `vmctx` field can +/// contain various data. That's why the type has a C representation +/// to ensure that the `vmctx` field is last. See the documentation of +/// the `vmctx` field to learn more. +#[repr(C)] +pub struct Instance { + pub(crate) artifact: Arc, + + /// External configuration for instance. + config: InstanceConfig, + + /// WebAssembly linear memory data. + memories: BoxedSlice>, + + /// Table data... + tables: BoxedSlice>, + + /// WebAssembly global data. + globals: BoxedSlice>, + + /// Passive elements in this instantiation. As `elem.drop`s happen, these + /// entries get removed. + passive_elements: RefCell>>, + + /// Passive data segments from our module. As `data.drop`s happen, entries + /// get removed. A missing entry is considered equivalent to an empty slice. + passive_data: RefCell>>, + + /// Mapping of function indices to their func ref backing data. `VMFuncRef`s + /// will point to elements here for functions defined or imported by this + /// instance. + funcrefs: BoxedSlice, + + /// Hosts can store arbitrary per-instance information here. + host_state: Box, + + /// Functions to operate on host environments in the imports + /// and pointers to the environments. + /// + /// TODO: Be sure to test with serialize/deserialize and imported + /// functions from other Wasm modules. + imported_function_envs: BoxedSlice, + + /// Additional context used by compiled WebAssembly code. This + /// field is last, and represents a dynamically-sized array that + /// extends beyond the nominal end of the struct (similar to a + /// flexible array member). + vmctx: VMContext, +} + +/// A collection of data about host envs used by imported functions. +#[derive(Debug)] +pub enum ImportFunctionEnv { + /// The `vmctx` pointer does not refer to a host env, there is no + /// metadata about it. + NoEnv, + /// We're dealing with a user-defined host env. + /// + /// This host env may be either unwrapped (the user-supplied host env + /// directly) or wrapped. i.e. in the case of Dynamic functions, we + /// store our own extra data along with the user supplied env, + /// thus the `env` pointer here points to the outermost type. + Env { + /// The function environment. This is not always the user-supplied + /// env. + env: *mut ffi::c_void, + + /// A clone function for duplicating the env. + clone: fn(*mut ffi::c_void) -> *mut ffi::c_void, + /// This field is not always present. When it is present, it + /// should be set to `None` after use to prevent double + /// initialization. + initializer: Option, + /// The destructor to clean up the type in `env`. + /// + /// # Safety + /// - This function must be called ina synchronized way. For + /// example, in the `Drop` implementation of this type. + destructor: unsafe fn(*mut ffi::c_void), + }, +} + +impl Clone for ImportFunctionEnv { + fn clone(&self) -> Self { + match &self { + Self::NoEnv => Self::NoEnv, + Self::Env { + env, + clone, + destructor, + initializer, + } => { + let new_env = (*clone)(*env); + Self::Env { + env: new_env, + clone: *clone, + destructor: *destructor, + initializer: *initializer, + } + } + } + } +} + +impl Drop for ImportFunctionEnv { + fn drop(&mut self) { + match self { + Self::Env { + env, destructor, .. + } => { + // # Safety + // - This is correct because we know no other references + // to this data can exist if we're dropping it. + unsafe { + (destructor)(*env); + } + } + Self::NoEnv => (), + } + } +} + +impl fmt::Debug for Instance { + fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { + formatter.debug_struct("Instance").finish() + } +} + +#[allow(clippy::cast_ptr_alignment)] +impl Instance { + /// Helper function to access various locations offset from our `*mut + /// VMContext` object. + unsafe fn vmctx_plus_offset(&self, offset: u32) -> *mut T { + (self.vmctx_ptr() as *mut u8) + .add(usize::try_from(offset).unwrap()) + .cast() + } + + /// Offsets in the `vmctx` region. + fn offsets(&self) -> &VMOffsets { + self.artifact.offsets() + } + + /// Return a pointer to the `VMSharedSignatureIndex`s. + fn signature_ids_ptr(&self) -> *mut VMSharedSignatureIndex { + unsafe { self.vmctx_plus_offset(self.offsets().vmctx_signature_ids_begin()) } + } + + /// Return the indexed `VMFunctionImport`. + fn imported_function(&self, index: FunctionIndex) -> &VMFunctionImport { + let index = usize::try_from(index.as_u32()).unwrap(); + unsafe { &*self.imported_functions_ptr().add(index) } + } + + /// Return a pointer to the `VMFunctionImport`s. + fn imported_functions_ptr(&self) -> *mut VMFunctionImport { + unsafe { self.vmctx_plus_offset(self.offsets().vmctx_imported_functions_begin()) } + } + + /// Return the index `VMTableImport`. + fn imported_table(&self, index: TableIndex) -> &VMTableImport { + let index = usize::try_from(index.as_u32()).unwrap(); + unsafe { &*self.imported_tables_ptr().add(index) } + } + + /// Return a pointer to the `VMTableImports`s. + fn imported_tables_ptr(&self) -> *mut VMTableImport { + unsafe { self.vmctx_plus_offset(self.offsets().vmctx_imported_tables_begin()) } + } + + /// Return the indexed `VMMemoryImport`. + fn imported_memory(&self, index: MemoryIndex) -> &VMMemoryImport { + let index = usize::try_from(index.as_u32()).unwrap(); + unsafe { &*self.imported_memories_ptr().add(index) } + } + + /// Return a pointer to the `VMMemoryImport`s. + fn imported_memories_ptr(&self) -> *mut VMMemoryImport { + unsafe { self.vmctx_plus_offset(self.offsets().vmctx_imported_memories_begin()) } + } + + /// Return the indexed `VMGlobalImport`. + fn imported_global(&self, index: GlobalIndex) -> &VMGlobalImport { + let index = usize::try_from(index.as_u32()).unwrap(); + unsafe { &*self.imported_globals_ptr().add(index) } + } + + /// Return a pointer to the `VMGlobalImport`s. + fn imported_globals_ptr(&self) -> *mut VMGlobalImport { + unsafe { self.vmctx_plus_offset(self.offsets().vmctx_imported_globals_begin()) } + } + + /// Return the indexed `VMTableDefinition`. + #[allow(unused)] + fn table(&self, index: LocalTableIndex) -> VMTableDefinition { + unsafe { *self.table_ptr(index).as_ref() } + } + + /// Updates the value for a defined table to `VMTableDefinition`. + #[allow(unused)] + fn set_table(&self, index: LocalTableIndex, table: &VMTableDefinition) { + unsafe { + *self.table_ptr(index).as_ptr() = *table; + } + } + + /// Return the indexed `VMTableDefinition`. + fn table_ptr(&self, index: LocalTableIndex) -> NonNull { + let index = usize::try_from(index.as_u32()).unwrap(); + NonNull::new(unsafe { self.tables_ptr().add(index) }).unwrap() + } + + /// Return a pointer to the `VMTableDefinition`s. + fn tables_ptr(&self) -> *mut VMTableDefinition { + unsafe { self.vmctx_plus_offset(self.offsets().vmctx_tables_begin()) } + } + + /// Return the indexed `VMMemoryDefinition`. + fn memory_definition(&self, index: MemoryIndex) -> &VMMemoryDefinition { + match self.artifact.import_counts().local_memory_index(index) { + Ok(local) => unsafe { self.memory_ptr(local).as_ref() }, + Err(import) => unsafe { &self.imported_memory(import).from.vmmemory().as_ref() }, + } + } + + #[allow(dead_code)] + /// Set the indexed memory to `VMMemoryDefinition`. + fn set_memory(&self, index: LocalMemoryIndex, mem: &VMMemoryDefinition) { + unsafe { + *self.memory_ptr(index).as_ptr() = *mem; + } + } + + /// Return the indexed `VMMemoryDefinition`. + fn memory_ptr(&self, index: LocalMemoryIndex) -> NonNull { + let index = usize::try_from(index.as_u32()).unwrap(); + NonNull::new(unsafe { self.memories_ptr().add(index) }).unwrap() + } + + /// Return a pointer to the `VMMemoryDefinition`s. + fn memories_ptr(&self) -> *mut VMMemoryDefinition { + unsafe { self.vmctx_plus_offset(self.offsets().vmctx_memories_begin()) } + } + + /// Return the indexed `VMGlobalDefinition`. + fn global(&self, index: GlobalIndex) -> &VMGlobalDefinition { + match self.artifact.import_counts().local_global_index(index) { + Ok(local) => unsafe { self.global_ptr(local).as_ref() }, + Err(import) => unsafe { self.imported_global(import).definition.as_ref() }, + } + } + + /// Set the indexed global to `VMGlobalDefinition`. + #[allow(dead_code)] + fn set_global(&self, index: LocalGlobalIndex, global: &VMGlobalDefinition) { + unsafe { + *self.global_ptr(index).as_ptr() = global.clone(); + } + } + + /// Return the indexed `VMGlobalDefinition`. + fn global_ptr(&self, index: LocalGlobalIndex) -> NonNull { + let index = usize::try_from(index.as_u32()).unwrap(); + // TODO: + NonNull::new(unsafe { *self.globals_ptr().add(index) }).unwrap() + } + + /// Return a pointer to the `VMGlobalDefinition`s. + fn globals_ptr(&self) -> *mut *mut VMGlobalDefinition { + unsafe { self.vmctx_plus_offset(self.offsets().vmctx_globals_begin()) } + } + + /// Return a pointer to the `VMBuiltinFunctionsArray`. + fn builtin_functions_ptr(&self) -> *mut VMBuiltinFunctionsArray { + unsafe { self.vmctx_plus_offset(self.offsets().vmctx_builtin_functions_begin()) } + } + + /// Return a reference to the vmctx used by compiled wasm code. + fn vmctx(&self) -> &VMContext { + &self.vmctx + } + + /// Return a raw pointer to the vmctx used by compiled wasm code. + fn vmctx_ptr(&self) -> *mut VMContext { + self.vmctx() as *const VMContext as *mut VMContext + } + + /// Return a reference to the custom state attached to this instance. + #[inline] + pub fn host_state(&self) -> &dyn Any { + &*self.host_state + } + + /// Return a pointer to the trap catcher. + fn trap_catcher_ptr(&self) -> *mut *const u8 { + unsafe { self.vmctx_plus_offset(self.offsets().vmctx_trap_handler()) } + } + + /// Return a pointer to the gas limiter. + pub fn gas_counter_ptr(&self) -> *mut *const FastGasCounter { + unsafe { self.vmctx_plus_offset(self.offsets().vmctx_gas_limiter_pointer()) } + } + + /// Return a pointer to initial stack limit. + pub fn stack_limit_initial_ptr(&self) -> *mut i32 { + unsafe { self.vmctx_plus_offset(self.offsets().vmctx_stack_limit_initial_begin()) } + } + + /// Return a pointer to current stack limit. + pub fn stack_limit_ptr(&self) -> *mut i32 { + unsafe { self.vmctx_plus_offset(self.offsets().vmctx_stack_limit_begin()) } + } + + /// Invoke the WebAssembly start function of the instance, if one is present. + fn invoke_start_function(&self) -> Result<(), Trap> { + let start_index = match self.artifact.start_function() { + Some(idx) => idx, + None => return Ok(()), + }; + let start_funcref = self.funcrefs[start_index]; + // Make the call. + self.reset_stack_meter(); + let result = unsafe { + catch_traps(|| { + mem::transmute::<*const VMFunctionBody, unsafe extern "C" fn(VMFunctionEnvironment)>( + start_funcref.func_ptr, + )(start_funcref.vmctx) + }) + }; + result + } + + pub fn reset_stack_meter(&self) { + unsafe { + *(self.stack_limit_ptr()) = *(self.stack_limit_initial_ptr()); + } + } + + /// Return the offset from the vmctx pointer to its containing `Instance`. + #[inline] + pub(crate) fn vmctx_offset() -> isize { + offset_of!(Self, vmctx) as isize + } + + /// Return the table index for the given `VMTableDefinition`. + pub(crate) fn table_index(&self, table: &VMTableDefinition) -> LocalTableIndex { + let begin: *const VMTableDefinition = self.tables_ptr() as *const _; + let end: *const VMTableDefinition = table; + // TODO: Use `offset_from` once it stablizes. + let index = LocalTableIndex::new( + (end as usize - begin as usize) / mem::size_of::(), + ); + assert_lt!(index.index(), self.tables.len()); + index + } + + /// Return the memory index for the given `VMMemoryDefinition`. + pub(crate) fn memory_index(&self, memory: &VMMemoryDefinition) -> LocalMemoryIndex { + let begin: *const VMMemoryDefinition = self.memories_ptr() as *const _; + let end: *const VMMemoryDefinition = memory; + // TODO: Use `offset_from` once it stablizes. + let index = LocalMemoryIndex::new( + (end as usize - begin as usize) / mem::size_of::(), + ); + assert_lt!(index.index(), self.memories.len()); + index + } + + /// Grow memory by the specified amount of pages. + /// + /// Returns `None` if memory can't be grown by the specified amount + /// of pages. + pub(crate) fn memory_grow( + &self, + memory_index: LocalMemoryIndex, + delta: IntoPages, + ) -> Result + where + IntoPages: Into, + { + let mem = self + .memories + .get(memory_index) + .unwrap_or_else(|| panic!("no memory for index {}", memory_index.index())); + mem.grow(delta.into()) + } + + /// Grow imported memory by the specified amount of pages. + /// + /// Returns `None` if memory can't be grown by the specified amount + /// of pages. + /// + /// # Safety + /// This and `imported_memory_size` are currently unsafe because they + /// dereference the memory import's pointers. + pub(crate) unsafe fn imported_memory_grow( + &self, + memory_index: MemoryIndex, + delta: IntoPages, + ) -> Result + where + IntoPages: Into, + { + let import = self.imported_memory(memory_index); + import.from.grow(delta.into()) + } + + /// Returns the number of allocated wasm pages. + pub(crate) fn memory_size(&self, memory_index: LocalMemoryIndex) -> Pages { + self.memories + .get(memory_index) + .unwrap_or_else(|| panic!("no memory for index {}", memory_index.index())) + .size() + } + + /// Returns the number of allocated wasm pages in an imported memory. + /// + /// # Safety + /// This and `imported_memory_grow` are currently unsafe because they + /// dereference the memory import's pointers. + pub(crate) unsafe fn imported_memory_size(&self, memory_index: MemoryIndex) -> Pages { + self.imported_memory(memory_index).from.size() + } + + /// Returns the number of elements in a given table. + pub(crate) fn table_size(&self, table_index: LocalTableIndex) -> u32 { + self.tables[table_index].size() + } + + /// Returns the number of elements in a given imported table. + /// + /// # Safety + /// `table_index` must be a valid, imported table index. + pub(crate) unsafe fn imported_table_size(&self, table_index: TableIndex) -> u32 { + self.imported_table(table_index).from.size() + } + + /// Grow table by the specified amount of elements. + /// + /// Returns `None` if table can't be grown by the specified amount + /// of elements. + pub(crate) fn table_grow( + &self, + table_index: LocalTableIndex, + delta: u32, + init_value: TableElement, + ) -> Option { + let result = self + .tables + .get(table_index) + .unwrap_or_else(|| panic!("no table for index {}", table_index.index())) + .grow(delta, init_value); + + result + } + + /// Grow table by the specified amount of elements. + /// + /// # Safety + /// `table_index` must be a valid, imported table index. + pub(crate) unsafe fn imported_table_grow( + &self, + table_index: TableIndex, + delta: u32, + init_value: TableElement, + ) -> Option { + let import = self.imported_table(table_index); + import.from.grow(delta, init_value) + } + + /// Get table element by index. + pub(crate) fn table_get( + &self, + table_index: LocalTableIndex, + index: u32, + ) -> Option { + self.tables + .get(table_index) + .unwrap_or_else(|| panic!("no table for index {}", table_index.index())) + .get(index) + } + + /// Returns the element at the given index. + /// + /// # Safety + /// `table_index` must be a valid, imported table index. + pub(crate) unsafe fn imported_table_get( + &self, + table_index: TableIndex, + index: u32, + ) -> Option { + let import = self.imported_table(table_index); + import.from.get(index) + } + + /// Set table element by index. + pub(crate) fn table_set( + &self, + table_index: LocalTableIndex, + index: u32, + val: TableElement, + ) -> Result<(), Trap> { + self.tables + .get(table_index) + .unwrap_or_else(|| panic!("no table for index {}", table_index.index())) + .set(index, val) + } + + /// Set table element by index for an imported table. + /// + /// # Safety + /// `table_index` must be a valid, imported table index. + pub(crate) unsafe fn imported_table_set( + &self, + table_index: TableIndex, + index: u32, + val: TableElement, + ) -> Result<(), Trap> { + let import = self.imported_table(table_index); + import.from.set(index, val) + } + + pub(crate) fn func_ref(&self, function_index: FunctionIndex) -> Option { + Some(self.get_vm_funcref(function_index)) + } + + /// Get a `VMFuncRef` for the given `FunctionIndex`. + fn get_vm_funcref(&self, index: FunctionIndex) -> VMFuncRef { + if index == FunctionIndex::reserved_value() { + return VMFuncRef::null(); + } + VMFuncRef(&self.funcrefs[index]) + } + + /// The `table.init` operation: initializes a portion of a table with a + /// passive element. + /// + /// # Errors + /// + /// Returns a `Trap` error when the range within the table is out of bounds + /// or the range within the passive element is out of bounds. + pub(crate) fn table_init( + &self, + table_index: TableIndex, + elem_index: ElemIndex, + dst: u32, + src: u32, + len: u32, + ) -> Result<(), Trap> { + // https://webassembly.github.io/bulk-memory-operations/core/exec/instructions.html#exec-table-init + + let table = self.get_table(table_index); + let passive_elements = self.passive_elements.borrow(); + let elem = passive_elements + .get(&elem_index) + .map_or::<&[VMFuncRef], _>(&[], |e| &**e); + + if src + .checked_add(len) + .map_or(true, |n| n as usize > elem.len()) + || dst.checked_add(len).map_or(true, |m| m > table.size()) + { + return Err(Trap::lib(TrapCode::TableAccessOutOfBounds)); + } + + for (dst, src) in (dst..dst + len).zip(src..src + len) { + table + .set(dst, TableElement::FuncRef(elem[src as usize])) + .expect("should never panic because we already did the bounds check above"); + } + + Ok(()) + } + + /// The `table.fill` operation: fills a portion of a table with a given value. + /// + /// # Errors + /// + /// Returns a `Trap` error when the range within the table is out of bounds + pub(crate) fn table_fill( + &self, + table_index: TableIndex, + start_index: u32, + item: TableElement, + len: u32, + ) -> Result<(), Trap> { + // https://webassembly.github.io/bulk-memory-operations/core/exec/instructions.html#exec-table-init + + let table = self.get_table(table_index); + let table_size = table.size() as usize; + + if start_index + .checked_add(len) + .map_or(true, |n| n as usize > table_size) + { + return Err(Trap::lib(TrapCode::TableAccessOutOfBounds)); + } + + for i in start_index..(start_index + len) { + table + .set(i, item.clone()) + .expect("should never panic because we already did the bounds check above"); + } + + Ok(()) + } + + /// Drop an element. + pub(crate) fn elem_drop(&self, elem_index: ElemIndex) { + // https://webassembly.github.io/reference-types/core/exec/instructions.html#exec-elem-drop + + let mut passive_elements = self.passive_elements.borrow_mut(); + passive_elements.remove(&elem_index); + // Note that we don't check that we actually removed an element because + // dropping a non-passive element is a no-op (not a trap). + } + + /// Do a `memory.copy` for a locally defined memory. + /// + /// # Errors + /// + /// Returns a `Trap` error when the source or destination ranges are out of + /// bounds. + pub(crate) fn local_memory_copy( + &self, + memory_index: LocalMemoryIndex, + dst: u32, + src: u32, + len: u32, + ) -> Result<(), Trap> { + // https://webassembly.github.io/reference-types/core/exec/instructions.html#exec-memory-copy + let memory = unsafe { self.memory_ptr(memory_index).as_ref() }; + // The following memory copy is not synchronized and is not atomic: + unsafe { memory.memory_copy(dst, src, len) } + } + + /// Perform a `memory.copy` on an imported memory. + pub(crate) fn imported_memory_copy( + &self, + memory_index: MemoryIndex, + dst: u32, + src: u32, + len: u32, + ) -> Result<(), Trap> { + let import = self.imported_memory(memory_index); + // The following memory copy is not synchronized and is not atomic: + unsafe { import.from.vmmemory().as_ref().memory_copy(dst, src, len) } + } + + /// Perform the `memory.fill` operation on a locally defined memory. + /// + /// # Errors + /// + /// Returns a `Trap` error if the memory range is out of bounds. + pub(crate) fn local_memory_fill( + &self, + memory_index: LocalMemoryIndex, + dst: u32, + val: u32, + len: u32, + ) -> Result<(), Trap> { + let memory = unsafe { self.memory_ptr(memory_index).as_ref() }; + // The following memory fill is not synchronized and is not atomic: + unsafe { memory.memory_fill(dst, val, len) } + } + + /// Perform the `memory.fill` operation on an imported memory. + /// + /// # Errors + /// + /// Returns a `Trap` error if the memory range is out of bounds. + pub(crate) fn imported_memory_fill( + &self, + memory_index: MemoryIndex, + dst: u32, + val: u32, + len: u32, + ) -> Result<(), Trap> { + let import = self.imported_memory(memory_index); + // The following memory fill is not synchronized and is not atomic: + unsafe { import.from.vmmemory().as_ref().memory_fill(dst, val, len) } + } + + /// Performs the `memory.init` operation. + /// + /// # Errors + /// + /// Returns a `Trap` error if the destination range is out of this module's + /// memory's bounds or if the source range is outside the data segment's + /// bounds. + pub(crate) fn memory_init( + &self, + memory_index: MemoryIndex, + data_index: DataIndex, + dst: u32, + src: u32, + len: u32, + ) -> Result<(), Trap> { + // https://webassembly.github.io/bulk-memory-operations/core/exec/instructions.html#exec-memory-init + + let memory = self.memory_definition(memory_index); + let passive_data = self.passive_data.borrow(); + let data = passive_data.get(&data_index).map_or(&[][..], |d| &**d); + + let oob_access = src + .checked_add(len) + .map_or(true, |n| n as usize > data.len()) + || dst.checked_add(len).map_or(true, |m| { + usize::try_from(m).unwrap() > memory.current_length + }); + + if oob_access { + return Err(Trap::lib(TrapCode::HeapAccessOutOfBounds)); + } + let src_slice = &data[src as usize..(src + len) as usize]; + unsafe { + let dst_start = memory.base.add(dst as usize); + let dst_slice = slice::from_raw_parts_mut(dst_start, len as usize); + dst_slice.copy_from_slice(src_slice); + } + Ok(()) + } + + /// Drop the given data segment, truncating its length to zero. + pub(crate) fn data_drop(&self, data_index: DataIndex) { + let mut passive_data = self.passive_data.borrow_mut(); + passive_data.remove(&data_index); + } + + /// Get a table by index regardless of whether it is locally-defined or an + /// imported, foreign table. + pub(crate) fn get_table(&self, table_index: TableIndex) -> &dyn Table { + match self.artifact.import_counts().local_table_index(table_index) { + Ok(local) => self.get_local_table(local), + Err(import) => self.get_foreign_table(import), + } + } + + /// Get a locally-defined table. + pub(crate) fn get_local_table(&self, index: LocalTableIndex) -> &dyn Table { + self.tables[index].as_ref() + } + + /// Get an imported, foreign table. + pub(crate) fn get_foreign_table(&self, index: TableIndex) -> &dyn Table { + let import = self.imported_table(index); + &*import.from + } +} + +/// A handle holding an `InstanceRef`, which holds an `Instance` +/// of a WebAssembly module. +/// +/// This is more or less a public facade of the private `Instance`, +/// providing useful higher-level API. +#[derive(Debug, PartialEq)] +pub struct InstanceHandle { + /// The [`InstanceRef`]. See its documentation to learn more. + instance: InstanceRef, +} + +impl InstanceHandle { + /// Create a new `InstanceHandle` pointing at a new [`InstanceRef`]. + /// + /// # Safety + /// + /// This method is not necessarily inherently unsafe to call, but in general + /// the APIs of an `Instance` are quite unsafe and have not been really + /// audited for safety that much. As a result the unsafety here on this + /// method is a low-overhead way of saying “this is an extremely unsafe type + /// to work with”. + /// + /// Extreme care must be taken when working with `InstanceHandle` and it's + /// recommended to have relatively intimate knowledge of how it works + /// internally if you'd like to do so. If possible it's recommended to use + /// the `wasmer` crate API rather than this type since that is vetted for + /// safety. + /// + /// However the following must be taken care of before calling this function: + /// - The memory at `instance.tables_ptr()` must be initialized with data for + /// all the local tables. + /// - The memory at `instance.memories_ptr()` must be initialized with data for + /// all the local memories. + // FIXME: instances should just store a reference to an Artifact + #[allow(clippy::too_many_arguments)] + pub unsafe fn new( + artifact: Arc, + allocator: InstanceAllocator, + finished_memories: BoxedSlice>, + finished_tables: BoxedSlice>, + finished_globals: BoxedSlice>, + imports: Imports, + passive_data: BTreeMap>, + host_state: Box, + imported_function_envs: BoxedSlice, + instance_config: InstanceConfig, + ) -> Self { + let vmctx_globals = finished_globals + .values() + .map(|m| m.vmglobal()) + .collect::>() + .into_boxed_slice(); + let passive_data = RefCell::new(passive_data); + + let handle = { + // use dummy value to create an instance so we can get the vmctx pointer + let funcrefs = PrimaryMap::new().into_boxed_slice(); + // Create the `Instance`. The unique, the One. + let instance = Instance { + artifact, + config: instance_config.clone(), + memories: finished_memories, + tables: finished_tables, + globals: finished_globals, + passive_elements: Default::default(), + passive_data, + host_state, + funcrefs, + imported_function_envs, + vmctx: VMContext {}, + }; + + let mut instance_ref = allocator.write_instance(instance); + + // Set the funcrefs after we've built the instance + { + let instance = instance_ref.as_mut().unwrap(); + let vmctx_ptr = instance.vmctx_ptr(); + instance.funcrefs = build_funcrefs( + &imports, + instance.artifact.functions().iter().map(|(_, f)| f), + vmctx_ptr, + ); + *(instance.trap_catcher_ptr()) = get_trap_handler(); + *(instance.gas_counter_ptr()) = instance_config.gas_counter; + *(instance.stack_limit_ptr()) = instance_config.stack_limit; + *(instance.stack_limit_initial_ptr()) = instance_config.stack_limit; + } + + Self { + instance: instance_ref, + } + }; + let instance = handle.instance().as_ref(); + + ptr::copy( + instance.artifact.signatures().as_ptr(), + instance.signature_ids_ptr() as *mut VMSharedSignatureIndex, + instance.artifact.signatures().len(), + ); + + ptr::copy( + imports.functions.values().as_slice().as_ptr(), + instance.imported_functions_ptr() as *mut VMFunctionImport, + imports.functions.len(), + ); + ptr::copy( + imports.tables.values().as_slice().as_ptr(), + instance.imported_tables_ptr() as *mut VMTableImport, + imports.tables.len(), + ); + ptr::copy( + imports.memories.values().as_slice().as_ptr(), + instance.imported_memories_ptr() as *mut VMMemoryImport, + imports.memories.len(), + ); + ptr::copy( + imports.globals.values().as_slice().as_ptr(), + instance.imported_globals_ptr() as *mut VMGlobalImport, + imports.globals.len(), + ); + // these should already be set, add asserts here? for: + // - instance.tables_ptr() as *mut VMTableDefinition + // - instance.memories_ptr() as *mut VMMemoryDefinition + ptr::copy( + vmctx_globals.values().as_slice().as_ptr(), + instance.globals_ptr() as *mut NonNull, + vmctx_globals.len(), + ); + ptr::write( + instance.builtin_functions_ptr() as *mut VMBuiltinFunctionsArray, + VMBuiltinFunctionsArray::initialized(), + ); + + // Perform infallible initialization in this constructor, while fallible + // initialization is deferred to the `initialize` method. + initialize_passive_elements(instance); + initialize_globals(instance); + handle + } + + /// Return a reference to the contained `Instance`. + pub fn instance(&self) -> &InstanceRef { + &self.instance + } + + /// Finishes the instantiation process started by `Instance::new`. + /// + /// # Safety + /// + /// Only safe to call immediately after instantiation. + pub unsafe fn finish_instantiation(&self) -> Result<(), Trap> { + let instance = self.instance().as_ref(); + + // Apply the initializers. + initialize_tables(instance)?; + initialize_memories( + instance, + instance.artifact.data_segments().iter().map(Into::into), + )?; + + // The WebAssembly spec specifies that the start function is + // invoked automatically at instantiation time. + instance.invoke_start_function()?; + Ok(()) + } + + /// See [`traphandlers::wasmer_call_trampoline`]. + pub unsafe fn invoke_function( + &self, + vmctx: VMFunctionEnvironment, + trampoline: VMTrampoline, + callee: *const VMFunctionBody, + values_vec: *mut u8, + ) -> Result<(), Trap> { + // `vmctx` is always `*mut VMContext` here, as we call to WASM. + { + let instance = self.instance().as_ref(); + instance.reset_stack_meter(); + } + wasmer_call_trampoline(vmctx, trampoline, callee, values_vec) + } + + /// Return a reference to the vmctx used by compiled wasm code. + pub fn vmctx(&self) -> &VMContext { + self.instance().as_ref().vmctx() + } + + /// Return a raw pointer to the vmctx used by compiled wasm code. + pub fn vmctx_ptr(&self) -> *mut VMContext { + self.instance().as_ref().vmctx_ptr() + } + + /// Return a reference to the `VMOffsets` to get offsets in the + /// `Self::vmctx_ptr` region. Be careful when doing pointer + /// arithmetic! + pub fn vmoffsets(&self) -> &VMOffsets { + self.instance().as_ref().offsets() + } + + /// Lookup an exported function with the specified function index. + pub fn function_by_index(&self, idx: FunctionIndex) -> Option { + let instance = self.instance.as_ref(); + + let (address, signature, vmctx, call_trampoline) = + match instance.artifact.import_counts().local_function_index(idx) { + Ok(local) => { + let func = instance.artifact.functions().get(local)?; + ( + *(func.body), + func.signature, + VMFunctionEnvironment { + vmctx: instance.vmctx_ptr(), + }, + Some(func.trampoline), + ) + } + Err(import) => { + let import = instance.imported_function(import); + ( + *(import.body), + import.signature, + import.environment, + import.trampoline, + ) + } + }; + Some(VMFunction { + // Any function received is already static at this point as: + // 1. All locally defined functions in the Wasm have a static signature. + // 2. All the imported functions are already static (because + // they point to the trampolines rather than the dynamic addresses). + kind: VMFunctionKind::Static, + address, + signature, + vmctx, + call_trampoline, + instance_ref: Some(WeakOrStrongInstanceRef::Strong(self.instance().clone())), + }) + } + + /// Return the indexed `VMMemoryDefinition`. + fn memory_by_index(&self, index: MemoryIndex) -> Option { + let instance = self.instance.as_ref(); + let from = match instance.artifact.import_counts().local_memory_index(index) { + Ok(local) => Arc::clone(&instance.memories[local]), + Err(import) => Arc::clone(&instance.imported_memory(import).from), + }; + Some(crate::VMMemory { + from, + instance_ref: Some(WeakOrStrongInstanceRef::Strong(self.instance().clone())), + }) + } + + /// Return the indexed `VMMemoryDefinition`. + fn table_by_index(&self, index: TableIndex) -> Option { + let instance = self.instance.as_ref(); + let from = match instance.artifact.import_counts().local_table_index(index) { + Ok(local) => Arc::clone(&instance.tables[local]), + Err(import) => Arc::clone(&instance.imported_table(import).from), + }; + Some(crate::VMTable { + from, + instance_ref: Some(WeakOrStrongInstanceRef::Strong(self.instance().clone())), + }) + } + + /// Obtain a reference to a global entity by its index. + pub fn global_by_index(&self, index: GlobalIndex) -> Option { + let instance = self.instance.as_ref(); + let from = match instance.artifact.import_counts().local_global_index(index) { + Ok(local) => Arc::clone(&instance.globals[local]), + Err(import) => Arc::clone(&instance.imported_global(import).from), + }; + Some(crate::VMGlobal { + from, + instance_ref: Some(WeakOrStrongInstanceRef::Strong(self.instance().clone())), + }) + } + + /// Lookup an exported function with the given name. + pub fn lookup(&self, field: &str) -> Option { + let instance = self.instance.as_ref(); + Some(match instance.artifact.export_field(field)? { + ExportIndex::Function(idx) => VMExtern::Function(self.function_by_index(idx)?), + ExportIndex::Table(idx) => VMExtern::Table(self.table_by_index(idx)?), + ExportIndex::Global(idx) => VMExtern::Global(self.global_by_index(idx)?), + ExportIndex::Memory(idx) => VMExtern::Memory(self.memory_by_index(idx)?), + }) + } + + /// Return a reference to the custom state attached to this instance. + pub fn host_state(&self) -> &dyn Any { + self.instance().as_ref().host_state() + } + + /// Return the memory index for the given `VMMemoryDefinition` in this instance. + pub fn memory_index(&self, memory: &VMMemoryDefinition) -> LocalMemoryIndex { + self.instance().as_ref().memory_index(memory) + } + + /// Grow memory in this instance by the specified amount of pages. + /// + /// Returns `None` if memory can't be grown by the specified amount + /// of pages. + pub fn memory_grow( + &self, + memory_index: LocalMemoryIndex, + delta: IntoPages, + ) -> Result + where + IntoPages: Into, + { + self.instance().as_ref().memory_grow(memory_index, delta) + } + + /// Return the table index for the given `VMTableDefinition` in this instance. + pub fn table_index(&self, table: &VMTableDefinition) -> LocalTableIndex { + self.instance().as_ref().table_index(table) + } + + /// Grow table in this instance by the specified amount of pages. + /// + /// Returns `None` if memory can't be grown by the specified amount + /// of pages. + pub fn table_grow( + &self, + table_index: LocalTableIndex, + delta: u32, + init_value: TableElement, + ) -> Option { + self.instance() + .as_ref() + .table_grow(table_index, delta, init_value) + } + + /// Get table element reference. + /// + /// Returns `None` if index is out of bounds. + pub fn table_get(&self, table_index: LocalTableIndex, index: u32) -> Option { + self.instance().as_ref().table_get(table_index, index) + } + + /// Set table element reference. + /// + /// Returns an error if the index is out of bounds + pub fn table_set( + &self, + table_index: LocalTableIndex, + index: u32, + val: TableElement, + ) -> Result<(), Trap> { + self.instance().as_ref().table_set(table_index, index, val) + } + + /// Get a table defined locally within this module. + pub fn get_local_table(&self, index: LocalTableIndex) -> &dyn Table { + self.instance().as_ref().get_local_table(index) + } +} + +/// Initializes the host environments. +/// +/// # Safety +/// - This function must be called with the correct `Err` type parameter: the error type is not +/// visible to code in `wasmer_vm`, so it's the caller's responsibility to ensure these +/// functions are called with the correct type. +/// - `instance_ptr` must point to a valid `wasmer::Instance`. +#[tracing::instrument(skip_all)] +pub unsafe fn initialize_host_envs( + handle: &std::sync::Mutex, + instance_ptr: *const ffi::c_void, +) -> Result<(), Err> { + let initializers = { + let mut instance_lock = handle.lock().unwrap(); + let instance_ref = instance_lock.instance.as_mut_unchecked(); + let mut initializers = vec![]; + for import_function_env in instance_ref.imported_function_envs.values_mut() { + match import_function_env { + ImportFunctionEnv::Env { + env, + ref mut initializer, + .. + } => { + if let Some(init) = initializer.take() { + initializers.push((init, *env)); + } + } + ImportFunctionEnv::NoEnv => (), + } + } + initializers + }; + for (init, env) in initializers { + let f = mem::transmute::<&ImportInitializerFuncPtr, &ImportInitializerFuncPtr>(&init); + f(env, instance_ptr)?; + } + Ok(()) +} + +/// Compute the offset for a memory data initializer. +fn get_memory_init_start(init: &DataInitializer<'_>, instance: &Instance) -> usize { + let mut start = init.location.offset; + if let Some(base) = init.location.base { + let val = instance.global(base).to_u32(); + start += usize::try_from(val).unwrap(); + } + start +} + +#[allow(clippy::mut_from_ref)] +/// Return a byte-slice view of a memory's data. +unsafe fn get_memory_slice<'instance>( + init: &DataInitializer<'_>, + instance: &'instance Instance, +) -> &'instance mut [u8] { + let memory = instance.memory_definition(init.location.memory_index); + slice::from_raw_parts_mut(memory.base, memory.current_length) +} + +/// Compute the offset for a table element initializer. +fn get_table_init_start(init: &OwnedTableInitializer, instance: &Instance) -> usize { + let mut start = init.offset; + if let Some(base) = init.base { + let val = instance.global(base).to_u32(); + start += usize::try_from(val).unwrap(); + } + start +} + +/// Initialize the table memory from the provided initializers. +fn initialize_tables(instance: &Instance) -> Result<(), Trap> { + for init in instance.artifact.element_segments() { + let start = get_table_init_start(init, instance); + let table = instance.get_table(init.table_index); + + if start + .checked_add(init.elements.len()) + .map_or(true, |end| end > table.size() as usize) + { + return Err(Trap::lib(TrapCode::TableAccessOutOfBounds)); + } + + for (i, func_idx) in init.elements.iter().enumerate() { + let anyfunc = instance.get_vm_funcref(*func_idx); + table + .set( + u32::try_from(start + i).unwrap(), + TableElement::FuncRef(anyfunc), + ) + .unwrap(); + } + } + + Ok(()) +} + +/// Initialize the `Instance::passive_elements` map by resolving the +/// `ModuleInfo::passive_elements`'s `FunctionIndex`s into `VMCallerCheckedAnyfunc`s for +/// this instance. +fn initialize_passive_elements(instance: &Instance) { + let mut passive_elements = instance.passive_elements.borrow_mut(); + debug_assert!( + passive_elements.is_empty(), + "should only be called once, at initialization time" + ); + + passive_elements.extend( + instance + .artifact + .passive_elements() + .iter() + .filter(|(_, segments)| !segments.is_empty()) + .map(|(idx, segments)| { + ( + *idx, + segments + .iter() + .map(|s| instance.get_vm_funcref(*s)) + .collect(), + ) + }), + ); +} + +/// Initialize the table memory from the provided initializers. +fn initialize_memories<'a>( + instance: &Instance, + data_initializers: impl Iterator>, +) -> Result<(), Trap> { + for init in data_initializers { + let memory = instance.memory_definition(init.location.memory_index); + + let start = get_memory_init_start(&init, instance); + if start + .checked_add(init.data.len()) + .map_or(true, |end| end > memory.current_length) + { + return Err(Trap::lib(TrapCode::HeapAccessOutOfBounds)); + } + + unsafe { + let mem_slice = get_memory_slice(&init, instance); + let end = start + init.data.len(); + let to_init = &mut mem_slice[start..end]; + to_init.copy_from_slice(init.data); + } + } + + Ok(()) +} + +fn initialize_globals(instance: &Instance) { + for (index, (_, initializer)) in instance.artifact.globals().iter().enumerate() { + unsafe { + let to = instance.global_ptr(LocalGlobalIndex::new(index)).as_ptr(); + match initializer { + GlobalInit::I32Const(x) => *(*to).as_i32_mut() = *x, + GlobalInit::I64Const(x) => *(*to).as_i64_mut() = *x, + GlobalInit::F32Const(x) => *(*to).as_f32_mut() = *x, + GlobalInit::F64Const(x) => *(*to).as_f64_mut() = *x, + GlobalInit::V128Const(x) => *(*to).as_bytes_mut() = *x.bytes(), + GlobalInit::GetGlobal(x) => *to = instance.global(*x).clone(), + GlobalInit::RefNullConst => *(*to).as_funcref_mut() = VMFuncRef::null(), + GlobalInit::RefFunc(func_idx) => { + let funcref = instance.func_ref(*func_idx).unwrap(); + *(*to).as_funcref_mut() = funcref; + } + } + } + } +} + +/// Eagerly builds all the `VMFuncRef`s for imported and local functions so that all +/// future funcref operations are just looking up this data. +pub fn build_funcrefs<'a>( + imports: &Imports, + finished_functions: impl ExactSizeIterator, + // vmshared_signatures: &BoxedSlice, + vmctx_ptr: *mut VMContext, +) -> BoxedSlice { + let mut func_refs = + PrimaryMap::with_capacity(imports.functions.len() + finished_functions.len()); + for (_, import) in imports.functions.iter() { + let anyfunc = VMCallerCheckedAnyfunc { + func_ptr: *(import.body), + type_index: import.signature, + vmctx: import.environment, + }; + func_refs.push(anyfunc); + } + // local functions + for function in finished_functions { + let anyfunc = VMCallerCheckedAnyfunc { + func_ptr: *(function.body), + type_index: function.signature, + vmctx: VMFunctionEnvironment { vmctx: vmctx_ptr }, + }; + func_refs.push(anyfunc); + } + func_refs.into_boxed_slice() +} diff --git a/runtime/near-vm/lib/vm/src/instance/ref.rs b/runtime/near-vm/lib/vm/src/instance/ref.rs new file mode 100644 index 00000000000..f2d0f20712b --- /dev/null +++ b/runtime/near-vm/lib/vm/src/instance/ref.rs @@ -0,0 +1,231 @@ +use super::Instance; +use std::alloc::Layout; +use std::convert::TryFrom; +use std::ptr::{self, NonNull}; +use std::sync::{Arc, Weak}; + +/// Dynamic instance allocation. +/// +/// This structure has a C representation because `Instance` is +/// dynamically-sized, and the `instance` field must be last. +/// +/// This `InstanceRef` must be freed with [`InstanceInner::deallocate_instance`] +/// if and only if it has been set correctly. The `Drop` implementation of +/// [`InstanceInner`] calls its `deallocate_instance` method without +/// checking if this property holds, only when `Self.strong` is equal to 1. +#[derive(Debug)] +#[repr(C)] +struct InstanceInner { + /// The layout of `Instance` (which can vary). + instance_layout: Layout, + + /// The `Instance` itself. It must be the last field of + /// `InstanceRef` since `Instance` is dyamically-sized. + /// + /// `Instance` must not be dropped manually by Rust, because it's + /// allocated manually with `alloc` and a specific layout (Rust + /// would be able to drop `Instance` itself but it will imply a + /// memory leak because of `alloc`). + /// + /// No one in the code has a copy of the `Instance`'s + /// pointer. `Self` is the only one. + instance: NonNull, +} + +impl InstanceInner { + /// Deallocate `Instance`. + /// + /// # Safety + /// + /// `Self.instance` must be correctly set and filled before being + /// dropped and deallocated. + unsafe fn deallocate_instance(&mut self) { + let instance_ptr = self.instance.as_ptr(); + + ptr::drop_in_place(instance_ptr); + std::alloc::dealloc(instance_ptr as *mut u8, self.instance_layout); + } + + /// Get a reference to the `Instance`. + #[inline] + pub(crate) fn as_ref(&self) -> &Instance { + // SAFETY: The pointer is properly aligned, it is + // “dereferencable”, it points to an initialized memory of + // `Instance`, and the reference has the lifetime `'a`. + unsafe { self.instance.as_ref() } + } + + #[inline] + pub(super) fn as_mut(&mut self) -> &mut Instance { + unsafe { self.instance.as_mut() } + } +} + +impl PartialEq for InstanceInner { + /// Two `InstanceInner` are equal if and only if + /// `Self.instance` points to the same location. + fn eq(&self, other: &Self) -> bool { + self.instance == other.instance + } +} + +impl Drop for InstanceInner { + /// Drop the `InstanceInner`. + fn drop(&mut self) { + unsafe { Self::deallocate_instance(self) }; + } +} + +/// TODO: Review this super carefully. +unsafe impl Send for InstanceInner {} +unsafe impl Sync for InstanceInner {} + +/// An `InstanceRef` is responsible to properly deallocate, +/// and to give access to an `Instance`, in such a way that `Instance` +/// is unique, can be shared, safely, across threads, without +/// duplicating the pointer in multiple locations. `InstanceRef` +/// must be the only “owner” of an `Instance`. +/// +/// Consequently, one must not share `Instance` but +/// `InstanceRef`. It acts like an Atomically Reference Counter +/// to `Instance`. In short, `InstanceRef` is roughly a +/// simplified version of `std::sync::Arc`. +/// +/// Note for the curious reader: [`InstanceAllocator::new`] +/// and [`InstanceHandle::new`] will respectively allocate a proper +/// `Instance` and will fill it correctly. +/// +/// A little bit of background: The initial goal was to be able to +/// share an [`Instance`] between an [`InstanceHandle`] and the module +/// exports, so that one can drop a [`InstanceHandle`] but still being +/// able to use the exports properly. +#[derive(Debug, PartialEq, Clone)] +pub struct InstanceRef(Arc); + +impl InstanceRef { + /// Create a new `InstanceRef`. It allocates nothing. It fills + /// nothing. The `Instance` must be already valid and + /// filled. + /// + /// # Safety + /// + /// `instance` must a non-null, non-dangling, properly aligned, + /// and correctly initialized pointer to `Instance`. See + /// [`InstanceAllocator`] for an example of how to correctly use + /// this API. + pub(super) unsafe fn new(instance: NonNull, instance_layout: Layout) -> Self { + Self(Arc::new(InstanceInner { + instance_layout, + instance, + })) + } + + /// Get a reference to the `Instance`. + #[inline] + pub fn as_ref(&self) -> &Instance { + (&*self.0).as_ref() + } + + /// Only succeeds if ref count is 1. + #[inline] + pub(super) fn as_mut(&mut self) -> Option<&mut Instance> { + Some(Arc::get_mut(&mut self.0)?.as_mut()) + } + + /// Like [`InstanceRef::as_mut`] but always succeeds. + /// May cause undefined behavior if used improperly. + /// + /// # Safety + /// It is the caller's responsibility to ensure exclusivity and synchronization of the + /// instance before calling this function. No other pointers to any Instance data + /// should be dereferenced for the lifetime of the returned `&mut Instance`. + #[inline] + pub(super) unsafe fn as_mut_unchecked(&mut self) -> &mut Instance { + let ptr: *mut InstanceInner = Arc::as_ptr(&self.0) as *mut _; + (&mut *ptr).as_mut() + } +} + +/// A weak instance ref. This type does not keep the underlying `Instance` alive +/// but can be converted into a full `InstanceRef` if the underlying `Instance` hasn't +/// been deallocated. +#[derive(Debug, Clone)] +pub struct WeakInstanceRef(Weak); + +impl PartialEq for WeakInstanceRef { + fn eq(&self, other: &Self) -> bool { + self.0.ptr_eq(&other.0) + } +} + +impl WeakInstanceRef { + /// Try to convert into a strong, `InstanceRef`. + pub fn upgrade(&self) -> Option { + let inner = self.0.upgrade()?; + Some(InstanceRef(inner)) + } +} + +/// An `InstanceRef` that may or may not be keeping the `Instance` alive. +/// +/// This type is useful for types that conditionally must keep / not keep the +/// underlying `Instance` alive. For example, to prevent cycles in `WasmerEnv`s. +#[derive(Debug, Clone, PartialEq)] +pub enum WeakOrStrongInstanceRef { + /// A weak instance ref. + Weak(WeakInstanceRef), + /// A strong instance ref. + Strong(InstanceRef), +} + +impl WeakOrStrongInstanceRef { + /// Tries to upgrade weak references to a strong reference, returning None + /// if it can't be done. + pub fn upgrade(&self) -> Option { + match self { + Self::Weak(weak) => weak.upgrade().map(Self::Strong), + Self::Strong(strong) => Some(Self::Strong(strong.clone())), + } + } + + /// Clones self into a weak reference. + pub fn downgrade(&self) -> Self { + match self { + Self::Weak(weak) => Self::Weak(weak.clone()), + Self::Strong(strong) => Self::Weak(WeakInstanceRef(Arc::downgrade(&strong.0))), + } + } +} + +impl TryFrom for InstanceRef { + type Error = &'static str; + fn try_from(value: WeakOrStrongInstanceRef) -> Result { + match value { + WeakOrStrongInstanceRef::Strong(strong) => Ok(strong), + WeakOrStrongInstanceRef::Weak(weak) => { + weak.upgrade().ok_or("Failed to upgrade weak reference") + } + } + } +} + +impl From for WeakInstanceRef { + fn from(value: WeakOrStrongInstanceRef) -> Self { + match value { + WeakOrStrongInstanceRef::Strong(strong) => Self(Arc::downgrade(&strong.0)), + WeakOrStrongInstanceRef::Weak(weak) => weak, + } + } +} + +impl From for WeakOrStrongInstanceRef { + fn from(value: WeakInstanceRef) -> Self { + Self::Weak(value) + } +} + +impl From for WeakOrStrongInstanceRef { + fn from(value: InstanceRef) -> Self { + Self::Strong(value) + } +} diff --git a/runtime/near-vm/lib/vm/src/lib.rs b/runtime/near-vm/lib/vm/src/lib.rs new file mode 100644 index 00000000000..8bd07ce0fdc --- /dev/null +++ b/runtime/near-vm/lib/vm/src/lib.rs @@ -0,0 +1,79 @@ +//! Runtime library support for Wasmer. + +#![deny(missing_docs, trivial_numeric_casts, unused_extern_crates)] +#![deny(trivial_numeric_casts, unused_extern_crates)] +#![warn(unused_import_braces)] +#![cfg_attr( + feature = "cargo-clippy", + allow(clippy::new_without_default, clippy::vtable_address_comparisons) +)] +#![cfg_attr( + feature = "cargo-clippy", + warn( + clippy::float_arithmetic, + clippy::mut_mut, + clippy::nonminimal_bool, + clippy::map_unwrap_or, + clippy::option_map_unwrap_or_else, + clippy::print_stdout, + clippy::unicode_not_nfc, + clippy::use_self + ) +)] + +mod artifact; +mod export; +mod func_data_registry; +mod global; +mod imports; +mod instance; +mod memory; +mod mmap; +mod probestack; +mod resolver; +mod sig_registry; +mod table; +mod trap; +mod tunables; +mod vmcontext; +mod vmoffsets; + +pub mod libcalls; + +pub use crate::artifact::{Artifact, Instantiatable}; +pub use crate::export::*; +pub use crate::func_data_registry::{FuncDataRegistry, VMFuncRef}; +pub use crate::global::*; +pub use crate::imports::{Imports, VMImport, VMImportType}; +pub use crate::instance::{ + initialize_host_envs, ImportFunctionEnv, ImportInitializerFuncPtr, InstanceAllocator, + InstanceHandle, WeakOrStrongInstanceRef, +}; +pub use crate::memory::{LinearMemory, Memory, MemoryError, MemoryStyle}; +pub use crate::mmap::Mmap; +pub use crate::probestack::PROBESTACK; +pub use crate::resolver::{ + ChainableNamedResolver, Export, ExportFunction, ExportFunctionMetadata, NamedResolver, + NamedResolverChain, NullResolver, Resolver, +}; +pub use crate::sig_registry::{SignatureRegistry, VMSharedSignatureIndex}; +pub use crate::table::{LinearTable, Table, TableElement, TableStyle}; +pub use crate::trap::*; +pub use crate::tunables::{TestTunables, Tunables}; +pub use crate::vmcontext::{ + FunctionBodyPtr, FunctionExtent, SectionBodyPtr, VMBuiltinFunctionIndex, + VMCallerCheckedAnyfunc, VMContext, VMDynamicFunctionContext, VMFunctionBody, + VMFunctionEnvironment, VMFunctionImport, VMFunctionKind, VMGlobalDefinition, VMGlobalImport, + VMLocalFunction, VMMemoryDefinition, VMMemoryImport, VMTableDefinition, VMTableImport, + VMTrampoline, +}; +pub use crate::vmoffsets::{TargetSharedSignatureIndex, VMOffsets}; +#[deprecated( + since = "2.1.0", + note = "ModuleInfo, ExportsIterator, ImportsIterator should be imported from wasmer_types." +)] +pub use wasmer_types::ModuleInfo; +pub use wasmer_types::VMExternRef; + +/// Version number of this crate. +pub const VERSION: &str = env!("CARGO_PKG_VERSION"); diff --git a/runtime/near-vm/lib/vm/src/libcalls.rs b/runtime/near-vm/lib/vm/src/libcalls.rs new file mode 100644 index 00000000000..ca1a1d710e3 --- /dev/null +++ b/runtime/near-vm/lib/vm/src/libcalls.rs @@ -0,0 +1,861 @@ +// This file contains code from external sources. +// Attributions: https://github.com/wasmerio/wasmer/blob/master/ATTRIBUTIONS.md + +//! Runtime library calls. +//! +//! Note that Wasm compilers may sometimes perform these inline rather than +//! calling them, particularly when CPUs have special instructions which compute +//! them directly. +//! +//! These functions are called by compiled Wasm code, and therefore must take +//! certain care about some things: +//! +//! * They must always be `pub extern "C"` and should only contain basic, raw +//! i32/i64/f32/f64/pointer parameters that are safe to pass across the system +//! ABI! +//! +//! * If any nested function propagates an `Err(trap)` out to the library +//! function frame, we need to raise it. This involves some nasty and quite +//! unsafe code under the covers! Notable, after raising the trap, drops +//! **will not** be run for local variables! This can lead to things like +//! leaking `InstanceHandle`s which leads to never deallocating JIT code, +//! instances, and modules! Therefore, always use nested blocks to ensure +//! drops run before raising a trap: +//! +//! ```ignore +//! pub extern "C" fn my_lib_function(...) { +//! let result = { +//! // Do everything in here so drops run at the end of the block. +//! ... +//! }; +//! if let Err(trap) = result { +//! // Now we can safely raise the trap without leaking! +//! raise_lib_trap(trap); +//! } +//! } +//! ``` + +#![allow(missing_docs)] // For some reason lint fails saying that `LibCall` is not documented, when it actually is + +use crate::func_data_registry::VMFuncRef; +use crate::probestack::PROBESTACK; +use crate::table::{RawTableElement, TableElement}; +use crate::trap::{raise_lib_trap, Trap, TrapCode}; +use crate::vmcontext::VMContext; +use crate::VMExternRef; +use std::fmt; +use wasmer_types::{ + DataIndex, ElemIndex, FunctionIndex, LocalMemoryIndex, LocalTableIndex, MemoryIndex, + TableIndex, Type, +}; + +/// Implementation of f32.ceil +#[no_mangle] +pub extern "C" fn near_vm_f32_ceil(x: f32) -> f32 { + x.ceil() +} + +/// Implementation of f32.floor +#[no_mangle] +pub extern "C" fn near_vm_f32_floor(x: f32) -> f32 { + x.floor() +} + +/// Implementation of f32.trunc +#[no_mangle] +pub extern "C" fn near_vm_f32_trunc(x: f32) -> f32 { + x.trunc() +} + +/// Implementation of f32.nearest +#[allow(clippy::float_arithmetic, clippy::float_cmp)] +#[no_mangle] +pub extern "C" fn near_vm_f32_nearest(x: f32) -> f32 { + // Rust doesn't have a nearest function, so do it manually. + if x == 0.0 { + // Preserve the sign of zero. + x + } else { + // Nearest is either ceil or floor depending on which is nearest or even. + let u = x.ceil(); + let d = x.floor(); + let um = (x - u).abs(); + let dm = (x - d).abs(); + if um < dm + || (um == dm && { + let h = u / 2.; + h.floor() == h + }) + { + u + } else { + d + } + } +} + +/// Implementation of f64.ceil +#[no_mangle] +pub extern "C" fn near_vm_f64_ceil(x: f64) -> f64 { + x.ceil() +} + +/// Implementation of f64.floor +#[no_mangle] +pub extern "C" fn near_vm_f64_floor(x: f64) -> f64 { + x.floor() +} + +/// Implementation of f64.trunc +#[no_mangle] +pub extern "C" fn near_vm_f64_trunc(x: f64) -> f64 { + x.trunc() +} + +/// Implementation of f64.nearest +#[allow(clippy::float_arithmetic, clippy::float_cmp)] +#[no_mangle] +pub extern "C" fn near_vm_f64_nearest(x: f64) -> f64 { + // Rust doesn't have a nearest function, so do it manually. + if x == 0.0 { + // Preserve the sign of zero. + x + } else { + // Nearest is either ceil or floor depending on which is nearest or even. + let u = x.ceil(); + let d = x.floor(); + let um = (x - u).abs(); + let dm = (x - d).abs(); + if um < dm + || (um == dm && { + let h = u / 2.; + h.floor() == h + }) + { + u + } else { + d + } + } +} + +/// Implementation of memory.grow for locally-defined 32-bit memories. +/// +/// # Safety +/// +/// `vmctx` must be dereferenceable. +#[no_mangle] +pub unsafe extern "C" fn near_vm_memory32_grow( + vmctx: *mut VMContext, + delta: u32, + memory_index: u32, +) -> u32 { + let instance = (&*vmctx).instance(); + let memory_index = LocalMemoryIndex::from_u32(memory_index); + + instance + .memory_grow(memory_index, delta) + .map(|pages| pages.0) + .unwrap_or(u32::max_value()) +} + +/// Implementation of memory.grow for imported 32-bit memories. +/// +/// # Safety +/// +/// `vmctx` must be dereferenceable. +#[no_mangle] +pub unsafe extern "C" fn near_vm_imported_memory32_grow( + vmctx: *mut VMContext, + delta: u32, + memory_index: u32, +) -> u32 { + let instance = (&*vmctx).instance(); + let memory_index = MemoryIndex::from_u32(memory_index); + + instance + .imported_memory_grow(memory_index, delta) + .map(|pages| pages.0) + .unwrap_or(u32::max_value()) +} + +/// Implementation of memory.size for locally-defined 32-bit memories. +/// +/// # Safety +/// +/// `vmctx` must be dereferenceable. +#[no_mangle] +pub unsafe extern "C" fn near_vm_memory32_size(vmctx: *mut VMContext, memory_index: u32) -> u32 { + let instance = (&*vmctx).instance(); + let memory_index = LocalMemoryIndex::from_u32(memory_index); + + instance.memory_size(memory_index).0 +} + +/// Implementation of memory.size for imported 32-bit memories. +/// +/// # Safety +/// +/// `vmctx` must be dereferenceable. +#[no_mangle] +pub unsafe extern "C" fn near_vm_imported_memory32_size( + vmctx: *mut VMContext, + memory_index: u32, +) -> u32 { + let instance = (&*vmctx).instance(); + let memory_index = MemoryIndex::from_u32(memory_index); + + instance.imported_memory_size(memory_index).0 +} + +/// Implementation of `table.copy`. +/// +/// # Safety +/// +/// `vmctx` must be dereferenceable. +#[no_mangle] +pub unsafe extern "C" fn near_vm_table_copy( + vmctx: *mut VMContext, + dst_table_index: u32, + src_table_index: u32, + dst: u32, + src: u32, + len: u32, +) { + let result = { + let dst_table_index = TableIndex::from_u32(dst_table_index); + let src_table_index = TableIndex::from_u32(src_table_index); + let instance = (&*vmctx).instance(); + let dst_table = instance.get_table(dst_table_index); + let src_table = instance.get_table(src_table_index); + dst_table.copy(src_table, dst, src, len) + }; + if let Err(trap) = result { + raise_lib_trap(trap); + } +} + +/// Implementation of `table.init`. +/// +/// # Safety +/// +/// `vmctx` must be dereferenceable. +#[no_mangle] +pub unsafe extern "C" fn near_vm_table_init( + vmctx: *mut VMContext, + table_index: u32, + elem_index: u32, + dst: u32, + src: u32, + len: u32, +) { + let result = { + let table_index = TableIndex::from_u32(table_index); + let elem_index = ElemIndex::from_u32(elem_index); + let instance = (&*vmctx).instance(); + instance.table_init(table_index, elem_index, dst, src, len) + }; + if let Err(trap) = result { + raise_lib_trap(trap); + } +} + +/// Implementation of `table.fill`. +/// +/// # Safety +/// +/// `vmctx` must be dereferenceable. +#[no_mangle] +pub unsafe extern "C" fn near_vm_table_fill( + vmctx: *mut VMContext, + table_index: u32, + start_idx: u32, + item: RawTableElement, + len: u32, +) { + let result = { + let table_index = TableIndex::from_u32(table_index); + let instance = (&*vmctx).instance(); + let elem = match instance.get_table(table_index).ty().ty { + Type::ExternRef => TableElement::ExternRef(item.extern_ref.into()), + Type::FuncRef => TableElement::FuncRef(item.func_ref), + _ => panic!("Unrecognized table type: does not contain references"), + }; + + instance.table_fill(table_index, start_idx, elem, len) + }; + if let Err(trap) = result { + raise_lib_trap(trap); + } +} + +/// Implementation of `table.size`. +/// +/// # Safety +/// +/// `vmctx` must be dereferenceable. +#[no_mangle] +pub unsafe extern "C" fn near_vm_table_size(vmctx: *mut VMContext, table_index: u32) -> u32 { + let instance = (&*vmctx).instance(); + let table_index = LocalTableIndex::from_u32(table_index); + + instance.table_size(table_index) +} + +/// Implementation of `table.size` for imported tables. +/// +/// # Safety +/// +/// `vmctx` must be dereferenceable. +#[no_mangle] +pub unsafe extern "C" fn near_vm_imported_table_size( + vmctx: *mut VMContext, + table_index: u32, +) -> u32 { + let instance = (&*vmctx).instance(); + let table_index = TableIndex::from_u32(table_index); + + instance.imported_table_size(table_index) +} + +/// Implementation of `table.get`. +/// +/// # Safety +/// +/// `vmctx` must be dereferenceable. +#[no_mangle] +pub unsafe extern "C" fn near_vm_table_get( + vmctx: *mut VMContext, + table_index: u32, + elem_index: u32, +) -> RawTableElement { + let instance = (&*vmctx).instance(); + let table_index = LocalTableIndex::from_u32(table_index); + + // TODO: type checking, maybe have specialized accessors + match instance.table_get(table_index, elem_index) { + Some(table_ref) => table_ref.into(), + None => raise_lib_trap(Trap::lib(TrapCode::TableAccessOutOfBounds)), + } +} + +/// Implementation of `table.get` for imported tables. +/// +/// # Safety +/// +/// `vmctx` must be dereferenceable. +#[no_mangle] +pub unsafe extern "C" fn near_vm_imported_table_get( + vmctx: *mut VMContext, + table_index: u32, + elem_index: u32, +) -> RawTableElement { + let instance = (&*vmctx).instance(); + let table_index = TableIndex::from_u32(table_index); + + // TODO: type checking, maybe have specialized accessors + match instance.imported_table_get(table_index, elem_index) { + Some(table_ref) => table_ref.into(), + None => raise_lib_trap(Trap::lib(TrapCode::TableAccessOutOfBounds)), + } +} + +/// Implementation of `table.set`. +/// +/// # Safety +/// +/// `vmctx` must be dereferenceable. +/// +/// It is the caller's responsibility to increment the ref count of any ref counted +/// type before passing it to this function. +#[no_mangle] +pub unsafe extern "C" fn near_vm_table_set( + vmctx: *mut VMContext, + table_index: u32, + elem_index: u32, + value: RawTableElement, +) { + let instance = (&*vmctx).instance(); + let table_index = TableIndex::from_u32(table_index); + if let Ok(local_table) = instance + .artifact + .import_counts() + .local_table_index(table_index) + { + let elem = match instance.get_local_table(local_table).ty().ty { + Type::ExternRef => TableElement::ExternRef(value.extern_ref.into()), + Type::FuncRef => TableElement::FuncRef(value.func_ref), + _ => panic!("Unrecognized table type: does not contain references"), + }; + // TODO: type checking, maybe have specialized accessors + let result = instance.table_set(local_table, elem_index, elem); + if let Err(trap) = result { + raise_lib_trap(trap); + } + } else { + panic!("near_vm_imported_table_set should have been called"); + } +} + +/// Implementation of `table.set` for imported tables. +/// +/// # Safety +/// +/// `vmctx` must be dereferenceable. +#[no_mangle] +pub unsafe extern "C" fn near_vm_imported_table_set( + vmctx: *mut VMContext, + table_index: u32, + elem_index: u32, + value: RawTableElement, +) { + let instance = (&*vmctx).instance(); + let table_index = TableIndex::from_u32(table_index); + let elem = match instance.get_foreign_table(table_index).ty().ty { + Type::ExternRef => TableElement::ExternRef(value.extern_ref.into()), + Type::FuncRef => TableElement::FuncRef(value.func_ref), + _ => panic!("Unrecognized table type: does not contain references"), + }; + let result = instance.imported_table_set(table_index, elem_index, elem); + if let Err(trap) = result { + raise_lib_trap(trap); + } +} + +/// Implementation of `table.grow` for locally-defined tables. +/// +/// # Safety +/// +/// `vmctx` must be dereferenceable. +#[no_mangle] +pub unsafe extern "C" fn near_vm_table_grow( + vmctx: *mut VMContext, + init_value: RawTableElement, + delta: u32, + table_index: u32, +) -> u32 { + let instance = (&*vmctx).instance(); + let table_index = LocalTableIndex::from_u32(table_index); + let init_value = match instance.get_local_table(table_index).ty().ty { + Type::ExternRef => TableElement::ExternRef(init_value.extern_ref.into()), + Type::FuncRef => TableElement::FuncRef(init_value.func_ref), + _ => panic!("Unrecognized table type: does not contain references"), + }; + instance + .table_grow(table_index, delta, init_value) + .unwrap_or(u32::max_value()) +} + +/// Implementation of `table.grow` for imported tables. +/// +/// # Safety +/// +/// `vmctx` must be dereferenceable. +#[no_mangle] +pub unsafe extern "C" fn near_vm_imported_table_grow( + vmctx: *mut VMContext, + init_value: RawTableElement, + delta: u32, + table_index: u32, +) -> u32 { + let instance = (&*vmctx).instance(); + let table_index = TableIndex::from_u32(table_index); + let init_value = match instance.get_table(table_index).ty().ty { + Type::ExternRef => TableElement::ExternRef(init_value.extern_ref.into()), + Type::FuncRef => TableElement::FuncRef(init_value.func_ref), + _ => panic!("Unrecognized table type: does not contain references"), + }; + + instance + .imported_table_grow(table_index, delta, init_value) + .unwrap_or(u32::max_value()) +} + +/// Implementation of `func.ref`. +/// +/// # Safety +/// +/// `vmctx` must be dereferenceable. +#[no_mangle] +pub unsafe extern "C" fn near_vm_func_ref(vmctx: *mut VMContext, function_index: u32) -> VMFuncRef { + let instance = (&*vmctx).instance(); + let function_index = FunctionIndex::from_u32(function_index); + + instance.func_ref(function_index).unwrap() +} + +/// Implementation of externref increment +/// +/// # Safety +/// +/// `vmctx` must be dereferenceable. +/// +/// This function must only be called at precise locations to prevent memory leaks. +#[no_mangle] +pub unsafe extern "C" fn near_vm_externref_inc(externref: VMExternRef) { + externref.ref_clone(); +} + +/// Implementation of externref decrement +/// +/// # Safety +/// +/// `vmctx` must be dereferenceable. +/// +/// This function must only be called at precise locations, otherwise use-after-free +/// and other serious memory bugs may occur. +#[no_mangle] +pub unsafe extern "C" fn near_vm_externref_dec(mut externref: VMExternRef) { + externref.ref_drop() +} + +/// Implementation of `elem.drop`. +/// +/// # Safety +/// +/// `vmctx` must be dereferenceable. +#[no_mangle] +pub unsafe extern "C" fn near_vm_elem_drop(vmctx: *mut VMContext, elem_index: u32) { + let elem_index = ElemIndex::from_u32(elem_index); + let instance = (&*vmctx).instance(); + instance.elem_drop(elem_index); +} + +/// Implementation of `memory.copy` for locally defined memories. +/// +/// # Safety +/// +/// `vmctx` must be dereferenceable. +#[no_mangle] +pub unsafe extern "C" fn near_vm_memory32_copy( + vmctx: *mut VMContext, + memory_index: u32, + dst: u32, + src: u32, + len: u32, +) { + let result = { + let memory_index = LocalMemoryIndex::from_u32(memory_index); + let instance = (&*vmctx).instance(); + instance.local_memory_copy(memory_index, dst, src, len) + }; + if let Err(trap) = result { + raise_lib_trap(trap); + } +} + +/// Implementation of `memory.copy` for imported memories. +/// +/// # Safety +/// +/// `vmctx` must be dereferenceable. +#[no_mangle] +pub unsafe extern "C" fn near_vm_imported_memory32_copy( + vmctx: *mut VMContext, + memory_index: u32, + dst: u32, + src: u32, + len: u32, +) { + let result = { + let memory_index = MemoryIndex::from_u32(memory_index); + let instance = (&*vmctx).instance(); + instance.imported_memory_copy(memory_index, dst, src, len) + }; + if let Err(trap) = result { + raise_lib_trap(trap); + } +} + +/// Implementation of `memory.fill` for locally defined memories. +/// +/// # Safety +/// +/// `vmctx` must be dereferenceable. +#[no_mangle] +pub unsafe extern "C" fn near_vm_memory32_fill( + vmctx: *mut VMContext, + memory_index: u32, + dst: u32, + val: u32, + len: u32, +) { + let result = { + let memory_index = LocalMemoryIndex::from_u32(memory_index); + let instance = (&*vmctx).instance(); + instance.local_memory_fill(memory_index, dst, val, len) + }; + if let Err(trap) = result { + raise_lib_trap(trap); + } +} + +/// Implementation of `memory.fill` for imported memories. +/// +/// # Safety +/// +/// `vmctx` must be dereferenceable. +#[no_mangle] +pub unsafe extern "C" fn near_vm_imported_memory32_fill( + vmctx: *mut VMContext, + memory_index: u32, + dst: u32, + val: u32, + len: u32, +) { + let result = { + let memory_index = MemoryIndex::from_u32(memory_index); + let instance = (&*vmctx).instance(); + instance.imported_memory_fill(memory_index, dst, val, len) + }; + if let Err(trap) = result { + raise_lib_trap(trap); + } +} + +/// Implementation of `memory.init`. +/// +/// # Safety +/// +/// `vmctx` must be dereferenceable. +#[no_mangle] +pub unsafe extern "C" fn near_vm_memory32_init( + vmctx: *mut VMContext, + memory_index: u32, + data_index: u32, + dst: u32, + src: u32, + len: u32, +) { + let result = { + let memory_index = MemoryIndex::from_u32(memory_index); + let data_index = DataIndex::from_u32(data_index); + let instance = (&*vmctx).instance(); + instance.memory_init(memory_index, data_index, dst, src, len) + }; + if let Err(trap) = result { + raise_lib_trap(trap); + } +} + +/// Implementation of `data.drop`. +/// +/// # Safety +/// +/// `vmctx` must be dereferenceable. +#[no_mangle] +pub unsafe extern "C" fn near_vm_data_drop(vmctx: *mut VMContext, data_index: u32) { + let data_index = DataIndex::from_u32(data_index); + let instance = (&*vmctx).instance(); + instance.data_drop(data_index) +} + +/// Implementation for raising a trap +/// +/// # Safety +/// +/// Only safe to call when wasm code is on the stack, aka `wasmer_call` or +/// `wasmer_call_trampoline` must have been previously called. +#[no_mangle] +pub unsafe extern "C" fn near_vm_raise_trap(trap_code: TrapCode) -> ! { + let trap = Trap::lib(trap_code); + raise_lib_trap(trap) +} + +/// Probestack check +/// +/// # Safety +/// +/// This function does not follow the standard function ABI, and is called as +/// part of the function prologue. +#[no_mangle] +pub static near_vm_probestack: unsafe extern "C" fn() = PROBESTACK; + +/// The name of a runtime library routine. +/// +/// This list is likely to grow over time. +#[derive( + rkyv::Serialize, rkyv::Deserialize, rkyv::Archive, Copy, Clone, Debug, PartialEq, Eq, Hash, +)] +pub enum LibCall { + /// ceil.f32 + CeilF32, + + /// ceil.f64 + CeilF64, + + /// floor.f32 + FloorF32, + + /// floor.f64 + FloorF64, + + /// nearest.f32 + NearestF32, + + /// nearest.f64 + NearestF64, + + /// trunc.f32 + TruncF32, + + /// trunc.f64 + TruncF64, + + /// memory.size for local functions + Memory32Size, + + /// memory.size for imported functions + ImportedMemory32Size, + + /// table.copy + TableCopy, + + /// table.init + TableInit, + + /// table.fill + TableFill, + + /// table.size for local tables + TableSize, + + /// table.size for imported tables + ImportedTableSize, + + /// table.get for local tables + TableGet, + + /// table.get for imported tables + ImportedTableGet, + + /// table.set for local tables + TableSet, + + /// table.set for imported tables + ImportedTableSet, + + /// table.grow for local tables + TableGrow, + + /// table.grow for imported tables + ImportedTableGrow, + + /// ref.func + FuncRef, + + /// elem.drop + ElemDrop, + + /// memory.copy for local memories + Memory32Copy, + + /// memory.copy for imported memories + ImportedMemory32Copy, + + /// memory.fill for local memories + Memory32Fill, + + /// memory.fill for imported memories + ImportedMemory32Fill, + + /// memory.init + Memory32Init, + + /// data.drop + DataDrop, + + /// A custom trap + RaiseTrap, + + /// probe for stack overflow. These are emitted for functions which need + /// when the `enable_probestack` setting is true. + Probestack, +} + +impl LibCall { + /// The function pointer to a libcall + pub fn function_pointer(self) -> usize { + match self { + Self::CeilF32 => near_vm_f32_ceil as usize, + Self::CeilF64 => near_vm_f64_ceil as usize, + Self::FloorF32 => near_vm_f32_floor as usize, + Self::FloorF64 => near_vm_f64_floor as usize, + Self::NearestF32 => near_vm_f32_nearest as usize, + Self::NearestF64 => near_vm_f64_nearest as usize, + Self::TruncF32 => near_vm_f32_trunc as usize, + Self::TruncF64 => near_vm_f64_trunc as usize, + Self::Memory32Size => near_vm_memory32_size as usize, + Self::ImportedMemory32Size => near_vm_imported_memory32_size as usize, + Self::TableCopy => near_vm_table_copy as usize, + Self::TableInit => near_vm_table_init as usize, + Self::TableFill => near_vm_table_fill as usize, + Self::TableSize => near_vm_table_size as usize, + Self::ImportedTableSize => near_vm_imported_table_size as usize, + Self::TableGet => near_vm_table_get as usize, + Self::ImportedTableGet => near_vm_imported_table_get as usize, + Self::TableSet => near_vm_table_set as usize, + Self::ImportedTableSet => near_vm_imported_table_set as usize, + Self::TableGrow => near_vm_table_grow as usize, + Self::ImportedTableGrow => near_vm_imported_table_grow as usize, + Self::FuncRef => near_vm_func_ref as usize, + Self::ElemDrop => near_vm_elem_drop as usize, + Self::Memory32Copy => near_vm_memory32_copy as usize, + Self::ImportedMemory32Copy => near_vm_imported_memory32_copy as usize, + Self::Memory32Fill => near_vm_memory32_fill as usize, + Self::ImportedMemory32Fill => near_vm_memory32_fill as usize, + Self::Memory32Init => near_vm_memory32_init as usize, + Self::DataDrop => near_vm_data_drop as usize, + Self::Probestack => near_vm_probestack as usize, + Self::RaiseTrap => near_vm_raise_trap as usize, + } + } + + /// Return the function name associated to the libcall. + pub fn to_function_name(&self) -> &str { + match self { + Self::CeilF32 => "near_vm_f32_ceil", + Self::CeilF64 => "near_vm_f64_ceil", + Self::FloorF32 => "near_vm_f32_floor", + Self::FloorF64 => "near_vm_f64_floor", + Self::NearestF32 => "near_vm_f32_nearest", + Self::NearestF64 => "near_vm_f64_nearest", + Self::TruncF32 => "near_vm_f32_trunc", + Self::TruncF64 => "near_vm_f64_trunc", + Self::Memory32Size => "near_vm_memory32_size", + Self::ImportedMemory32Size => "near_vm_imported_memory32_size", + Self::TableCopy => "near_vm_table_copy", + Self::TableInit => "near_vm_table_init", + Self::TableFill => "near_vm_table_fill", + Self::TableSize => "near_vm_table_size", + Self::ImportedTableSize => "near_vm_imported_table_size", + Self::TableGet => "near_vm_table_get", + Self::ImportedTableGet => "near_vm_imported_table_get", + Self::TableSet => "near_vm_table_set", + Self::ImportedTableSet => "near_vm_imported_table_set", + Self::TableGrow => "near_vm_table_grow", + Self::ImportedTableGrow => "near_vm_imported_table_grow", + Self::FuncRef => "near_vm_func_ref", + Self::ElemDrop => "near_vm_elem_drop", + Self::Memory32Copy => "near_vm_memory32_copy", + Self::ImportedMemory32Copy => "near_vm_imported_memory32_copy", + Self::Memory32Fill => "near_vm_memory32_fill", + Self::ImportedMemory32Fill => "near_vm_imported_memory32_fill", + Self::Memory32Init => "near_vm_memory32_init", + Self::DataDrop => "near_vm_data_drop", + Self::RaiseTrap => "near_vm_raise_trap", + // We have to do this because macOS requires a leading `_` and it's not + // a normal function, it's a static variable, so we have to do it manually. + #[cfg(target_vendor = "apple")] + Self::Probestack => "_near_vm_probestack", + #[cfg(not(target_vendor = "apple"))] + Self::Probestack => "near_vm_probestack", + } + } +} + +impl fmt::Display for LibCall { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + fmt::Debug::fmt(self, f) + } +} diff --git a/runtime/near-vm/lib/vm/src/memory.rs b/runtime/near-vm/lib/vm/src/memory.rs new file mode 100644 index 00000000000..52fd4d9c356 --- /dev/null +++ b/runtime/near-vm/lib/vm/src/memory.rs @@ -0,0 +1,403 @@ +// This file contains code from external sources. +// Attributions: https://github.com/wasmerio/wasmer/blob/master/ATTRIBUTIONS.md + +//! Memory management for linear memories. +//! +//! `LinearMemory` is to WebAssembly linear memories what `Table` is to WebAssembly tables. + +use crate::mmap::Mmap; +use crate::vmcontext::VMMemoryDefinition; +use more_asserts::assert_ge; +use std::borrow::BorrowMut; +use std::cell::UnsafeCell; +use std::convert::TryInto; +use std::fmt; +use std::ptr::NonNull; +use std::sync::Mutex; +use thiserror::Error; +use wasmer_types::{Bytes, MemoryType, Pages}; + +/// Error type describing things that can go wrong when operating on Wasm Memories. +#[derive(Error, Debug, Clone, PartialEq, Hash)] +pub enum MemoryError { + /// Low level error with mmap. + #[error("Error when allocating memory: {0}")] + Region(String), + /// The operation would cause the size of the memory to exceed the maximum or would cause + /// an overflow leading to unindexable memory. + #[error("The memory could not grow: current size {} pages, requested increase: {} pages", current.0, attempted_delta.0)] + CouldNotGrow { + /// The current size in pages. + current: Pages, + /// The attempted amount to grow by in pages. + attempted_delta: Pages, + }, + /// The operation would cause the size of the memory size exceed the maximum. + #[error("The memory is invalid because {}", reason)] + InvalidMemory { + /// The reason why the provided memory is invalid. + reason: String, + }, + /// Caller asked for more minimum memory than we can give them. + #[error("The minimum requested ({} pages) memory is greater than the maximum allowed memory ({} pages)", min_requested.0, max_allowed.0)] + MinimumMemoryTooLarge { + /// The number of pages requested as the minimum amount of memory. + min_requested: Pages, + /// The maximum amount of memory we can allocate. + max_allowed: Pages, + }, + /// Caller asked for a maximum memory greater than we can give them. + #[error("The maximum requested memory ({} pages) is greater than the maximum allowed memory ({} pages)", max_requested.0, max_allowed.0)] + MaximumMemoryTooLarge { + /// The number of pages requested as the maximum amount of memory. + max_requested: Pages, + /// The number of pages requested as the maximum amount of memory. + max_allowed: Pages, + }, + /// A user defined error value, used for error cases not listed above. + #[error("A user-defined error occurred: {0}")] + Generic(String), +} + +/// Implementation styles for WebAssembly linear memory. +#[derive(Debug, Clone, PartialEq, Eq, Hash, rkyv::Serialize, rkyv::Deserialize, rkyv::Archive)] +pub enum MemoryStyle { + /// The actual memory can be resized and moved. + Dynamic { + /// Our chosen offset-guard size. + /// + /// It represents the size in bytes of extra guard pages after the end + /// to optimize loads and stores with constant offsets. + offset_guard_size: u64, + }, + /// Address space is allocated up front. + Static { + /// The number of mapped and unmapped pages. + bound: Pages, + /// Our chosen offset-guard size. + /// + /// It represents the size in bytes of extra guard pages after the end + /// to optimize loads and stores with constant offsets. + offset_guard_size: u64, + }, +} + +impl MemoryStyle { + /// Returns the offset-guard size + pub fn offset_guard_size(&self) -> u64 { + match self { + Self::Dynamic { offset_guard_size } => *offset_guard_size, + Self::Static { + offset_guard_size, .. + } => *offset_guard_size, + } + } +} + +/// Trait for implementing Wasm Memory used by Wasmer. +pub trait Memory: fmt::Debug + Send + Sync { + /// Returns the memory type for this memory. + fn ty(&self) -> MemoryType; + + /// Returns the memory style for this memory. + fn style(&self) -> &MemoryStyle; + + /// Returns the number of allocated wasm pages. + fn size(&self) -> Pages; + + /// Grow memory by the specified amount of wasm pages. + fn grow(&self, delta: Pages) -> Result; + + /// Return a [`VMMemoryDefinition`] for exposing the memory to compiled wasm code. + /// + /// The pointer returned in [`VMMemoryDefinition`] must be valid for the lifetime of this memory. + fn vmmemory(&self) -> NonNull; +} + +/// A linear memory instance. +#[derive(Debug)] +pub struct LinearMemory { + // The underlying allocation. + mmap: Mutex, + + // The optional maximum size in wasm pages of this linear memory. + maximum: Option, + + /// The WebAssembly linear memory description. + memory: MemoryType, + + /// Our chosen implementation style. + style: MemoryStyle, + + // Size in bytes of extra guard pages after the end to optimize loads and stores with + // constant offsets. + offset_guard_size: usize, + + /// The owned memory definition used by the generated code + vm_memory_definition: VMMemoryDefinitionOwnership, +} + +/// A type to help manage who is responsible for the backing memory of them +/// `VMMemoryDefinition`. +#[derive(Debug)] +enum VMMemoryDefinitionOwnership { + /// The `VMMemoryDefinition` is owned by the `Instance` and we should use + /// its memory. This is how a local memory that's exported should be stored. + VMOwned(NonNull), + /// The `VMMemoryDefinition` is owned by the host and we should manage its + /// memory. This is how an imported memory that doesn't come from another + /// Wasm module should be stored. + HostOwned(Box>), +} + +/// We must implement this because of `VMMemoryDefinitionOwnership::VMOwned`. +/// This is correct because synchronization of memory accesses is controlled +/// by the VM. +// REVIEW: I don't believe ^; this probably shouldn't be `Send`... +// mutations from other threads into this data could be a problem, but we probably +// don't want to use atomics for this in the generated code. +// TODO: +unsafe impl Send for LinearMemory {} + +/// This is correct because all internal mutability is protected by a mutex. +unsafe impl Sync for LinearMemory {} + +#[derive(Debug)] +struct WasmMmap { + // Our OS allocation of mmap'd memory. + alloc: Mmap, + // The current logical size in wasm pages of this linear memory. + size: Pages, +} + +impl LinearMemory { + /// Create a new linear memory instance with specified minimum and maximum number of wasm pages. + /// + /// This creates a `LinearMemory` with owned metadata: this can be used to create a memory + /// that will be imported into Wasm modules. + pub fn new(memory: &MemoryType, style: &MemoryStyle) -> Result { + unsafe { Self::new_internal(memory, style, None) } + } + + /// Create a new linear memory instance with specified minimum and maximum number of wasm pages. + /// + /// This creates a `LinearMemory` with metadata owned by a VM, pointed to by + /// `vm_memory_location`: this can be used to create a local memory. + /// + /// # Safety + /// - `vm_memory_location` must point to a valid location in VM memory. + pub unsafe fn from_definition( + memory: &MemoryType, + style: &MemoryStyle, + vm_memory_location: NonNull, + ) -> Result { + Self::new_internal(memory, style, Some(vm_memory_location)) + } + + /// Build a `LinearMemory` with either self-owned or VM owned metadata. + unsafe fn new_internal( + memory: &MemoryType, + style: &MemoryStyle, + vm_memory_location: Option>, + ) -> Result { + if memory.minimum > Pages::max_value() { + return Err(MemoryError::MinimumMemoryTooLarge { + min_requested: memory.minimum, + max_allowed: Pages::max_value(), + }); + } + // `maximum` cannot be set to more than `65536` pages. + if let Some(max) = memory.maximum { + if max > Pages::max_value() { + return Err(MemoryError::MaximumMemoryTooLarge { + max_requested: max, + max_allowed: Pages::max_value(), + }); + } + if max < memory.minimum { + return Err(MemoryError::InvalidMemory { + reason: format!( + "the maximum ({} pages) is less than the minimum ({} pages)", + max.0, memory.minimum.0 + ), + }); + } + } + + let offset_guard_bytes = style.offset_guard_size() as usize; + + let minimum_pages = match style { + MemoryStyle::Dynamic { .. } => memory.minimum, + MemoryStyle::Static { bound, .. } => { + assert_ge!(*bound, memory.minimum); + *bound + } + }; + let minimum_bytes = minimum_pages.bytes().0; + let request_bytes = minimum_bytes.checked_add(offset_guard_bytes).unwrap(); + let mapped_pages = memory.minimum; + let mapped_bytes = mapped_pages.bytes(); + + let mut mmap = WasmMmap { + alloc: Mmap::accessible_reserved(mapped_bytes.0, request_bytes) + .map_err(MemoryError::Region)?, + size: memory.minimum, + }; + + let base_ptr = mmap.alloc.as_mut_ptr(); + let mem_length = memory.minimum.bytes().0; + Ok(Self { + mmap: Mutex::new(mmap), + maximum: memory.maximum, + offset_guard_size: offset_guard_bytes, + vm_memory_definition: if let Some(mem_loc) = vm_memory_location { + { + let mut ptr = mem_loc; + let md = ptr.as_mut(); + md.base = base_ptr; + md.current_length = mem_length; + } + VMMemoryDefinitionOwnership::VMOwned(mem_loc) + } else { + VMMemoryDefinitionOwnership::HostOwned(Box::new(UnsafeCell::new( + VMMemoryDefinition { + base: base_ptr, + current_length: mem_length, + }, + ))) + }, + memory: *memory, + style: style.clone(), + }) + } + + /// Get the `VMMemoryDefinition`. + /// + /// # Safety + /// - You must ensure that you have mutually exclusive access before calling + /// this function. You can get this by locking the `mmap` mutex. + unsafe fn get_vm_memory_definition(&self) -> NonNull { + match &self.vm_memory_definition { + VMMemoryDefinitionOwnership::VMOwned(ptr) => *ptr, + VMMemoryDefinitionOwnership::HostOwned(boxed_ptr) => { + NonNull::new_unchecked(boxed_ptr.get()) + } + } + } +} + +impl Memory for LinearMemory { + /// Returns the type for this memory. + fn ty(&self) -> MemoryType { + let minimum = self.size(); + let mut out = self.memory; + out.minimum = minimum; + + out + } + + /// Returns the memory style for this memory. + fn style(&self) -> &MemoryStyle { + &self.style + } + + /// Returns the number of allocated wasm pages. + fn size(&self) -> Pages { + // TODO: investigate this function for race conditions + unsafe { + let md_ptr = self.get_vm_memory_definition(); + let md = md_ptr.as_ref(); + Bytes::from(md.current_length).try_into().unwrap() + } + } + + /// Grow memory by the specified amount of wasm pages. + /// + /// Returns `None` if memory can't be grown by the specified amount + /// of wasm pages. + fn grow(&self, delta: Pages) -> Result { + let mut mmap_guard = self.mmap.lock().unwrap(); + let mmap = mmap_guard.borrow_mut(); + // Optimization of memory.grow 0 calls. + if delta.0 == 0 { + return Ok(mmap.size); + } + + let new_pages = mmap + .size + .checked_add(delta) + .ok_or(MemoryError::CouldNotGrow { + current: mmap.size, + attempted_delta: delta, + })?; + let prev_pages = mmap.size; + + if let Some(maximum) = self.maximum { + if new_pages > maximum { + return Err(MemoryError::CouldNotGrow { + current: mmap.size, + attempted_delta: delta, + }); + } + } + + // Wasm linear memories are never allowed to grow beyond what is + // indexable. If the memory has no maximum, enforce the greatest + // limit here. + if new_pages >= Pages::max_value() { + // Linear memory size would exceed the index range. + return Err(MemoryError::CouldNotGrow { + current: mmap.size, + attempted_delta: delta, + }); + } + + let delta_bytes = delta.bytes().0; + let prev_bytes = prev_pages.bytes().0; + let new_bytes = new_pages.bytes().0; + + if new_bytes > mmap.alloc.len() - self.offset_guard_size { + // If the new size is within the declared maximum, but needs more memory than we + // have on hand, it's a dynamic heap and it can move. + let guard_bytes = self.offset_guard_size; + let request_bytes = + new_bytes + .checked_add(guard_bytes) + .ok_or_else(|| MemoryError::CouldNotGrow { + current: new_pages, + attempted_delta: Bytes(guard_bytes).try_into().unwrap(), + })?; + + let mut new_mmap = + Mmap::accessible_reserved(new_bytes, request_bytes).map_err(MemoryError::Region)?; + + let copy_len = mmap.alloc.len() - self.offset_guard_size; + new_mmap.as_mut_slice()[..copy_len].copy_from_slice(&mmap.alloc.as_slice()[..copy_len]); + + mmap.alloc = new_mmap; + } else if delta_bytes > 0 { + // Make the newly allocated pages accessible. + mmap.alloc + .make_accessible(prev_bytes, delta_bytes) + .map_err(MemoryError::Region)?; + } + + mmap.size = new_pages; + + // update memory definition + unsafe { + let mut md_ptr = self.get_vm_memory_definition(); + let md = md_ptr.as_mut(); + md.current_length = new_pages.bytes().0; + md.base = mmap.alloc.as_mut_ptr() as _; + } + + Ok(prev_pages) + } + + /// Return a `VMMemoryDefinition` for exposing the memory to compiled wasm code. + fn vmmemory(&self) -> NonNull { + let _mmap_guard = self.mmap.lock().unwrap(); + unsafe { self.get_vm_memory_definition() } + } +} diff --git a/runtime/near-vm/lib/vm/src/mmap.rs b/runtime/near-vm/lib/vm/src/mmap.rs new file mode 100644 index 00000000000..6b3dcdd19cd --- /dev/null +++ b/runtime/near-vm/lib/vm/src/mmap.rs @@ -0,0 +1,298 @@ +// This file contains code from external sources. +// Attributions: https://github.com/wasmerio/wasmer/blob/master/ATTRIBUTIONS.md + +//! Low-level abstraction for allocating and managing zero-filled pages +//! of memory. + +use more_asserts::assert_le; +use more_asserts::assert_lt; +use std::io; +use std::ptr; +use std::slice; + +/// Round `size` up to the nearest multiple of `page_size`. +fn round_up_to_page_size(size: usize, page_size: usize) -> usize { + (size + (page_size - 1)) & !(page_size - 1) +} + +/// A simple struct consisting of a page-aligned pointer to page-aligned +/// and initially-zeroed memory and a length. +#[derive(Debug)] +pub struct Mmap { + // Note that this is stored as a `usize` instead of a `*const` or `*mut` + // pointer to allow this structure to be natively `Send` and `Sync` without + // `unsafe impl`. This type is sendable across threads and shareable since + // the coordination all happens at the OS layer. + ptr: usize, + len: usize, +} + +impl Mmap { + /// Construct a new empty instance of `Mmap`. + pub fn new() -> Self { + // Rust's slices require non-null pointers, even when empty. `Vec` + // contains code to create a non-null dangling pointer value when + // constructed empty, so we reuse that here. + let empty = Vec::::new(); + Self { + ptr: empty.as_ptr() as usize, + len: 0, + } + } + + /// Create a new `Mmap` pointing to at least `size` bytes of page-aligned accessible memory. + pub fn with_at_least(size: usize) -> Result { + let page_size = region::page::size(); + let rounded_size = round_up_to_page_size(size, page_size); + Self::accessible_reserved(rounded_size, rounded_size) + } + + /// Create a new `Mmap` pointing to `accessible_size` bytes of page-aligned accessible memory, + /// within a reserved mapping of `mapping_size` bytes. `accessible_size` and `mapping_size` + /// must be native page-size multiples. + #[cfg(not(target_os = "windows"))] + pub fn accessible_reserved( + accessible_size: usize, + mapping_size: usize, + ) -> Result { + let page_size = region::page::size(); + assert_le!(accessible_size, mapping_size); + assert_eq!(mapping_size & (page_size - 1), 0); + assert_eq!(accessible_size & (page_size - 1), 0); + + // Mmap may return EINVAL if the size is zero, so just + // special-case that. + if mapping_size == 0 { + return Ok(Self::new()); + } + + Ok(if accessible_size == mapping_size { + // Allocate a single read-write region at once. + let ptr = unsafe { + libc::mmap( + ptr::null_mut(), + mapping_size, + libc::PROT_READ | libc::PROT_WRITE, + libc::MAP_PRIVATE | libc::MAP_ANON, + -1, + 0, + ) + }; + if ptr as isize == -1_isize { + return Err(io::Error::last_os_error().to_string()); + } + + Self { + ptr: ptr as usize, + len: mapping_size, + } + } else { + // Reserve the mapping size. + let ptr = unsafe { + libc::mmap( + ptr::null_mut(), + mapping_size, + libc::PROT_NONE, + libc::MAP_PRIVATE | libc::MAP_ANON, + -1, + 0, + ) + }; + if ptr as isize == -1_isize { + return Err(io::Error::last_os_error().to_string()); + } + + let mut result = Self { + ptr: ptr as usize, + len: mapping_size, + }; + + if accessible_size != 0 { + // Commit the accessible size. + result.make_accessible(0, accessible_size)?; + } + + result + }) + } + + /// Create a new `Mmap` pointing to `accessible_size` bytes of page-aligned accessible memory, + /// within a reserved mapping of `mapping_size` bytes. `accessible_size` and `mapping_size` + /// must be native page-size multiples. + #[cfg(target_os = "windows")] + pub fn accessible_reserved( + accessible_size: usize, + mapping_size: usize, + ) -> Result { + use winapi::um::memoryapi::VirtualAlloc; + use winapi::um::winnt::{MEM_COMMIT, MEM_RESERVE, PAGE_NOACCESS, PAGE_READWRITE}; + + let page_size = region::page::size(); + assert_le!(accessible_size, mapping_size); + assert_eq!(mapping_size & (page_size - 1), 0); + assert_eq!(accessible_size & (page_size - 1), 0); + + // VirtualAlloc may return ERROR_INVALID_PARAMETER if the size is zero, + // so just special-case that. + if mapping_size == 0 { + return Ok(Self::new()); + } + + Ok(if accessible_size == mapping_size { + // Allocate a single read-write region at once. + let ptr = unsafe { + VirtualAlloc( + ptr::null_mut(), + mapping_size, + MEM_RESERVE | MEM_COMMIT, + PAGE_READWRITE, + ) + }; + if ptr.is_null() { + return Err(io::Error::last_os_error().to_string()); + } + + Self { + ptr: ptr as usize, + len: mapping_size, + } + } else { + // Reserve the mapping size. + let ptr = + unsafe { VirtualAlloc(ptr::null_mut(), mapping_size, MEM_RESERVE, PAGE_NOACCESS) }; + if ptr.is_null() { + return Err(io::Error::last_os_error().to_string()); + } + + let mut result = Self { + ptr: ptr as usize, + len: mapping_size, + }; + + if accessible_size != 0 { + // Commit the accessible size. + result.make_accessible(0, accessible_size)?; + } + + result + }) + } + + /// Make the memory starting at `start` and extending for `len` bytes accessible. + /// `start` and `len` must be native page-size multiples and describe a range within + /// `self`'s reserved memory. + #[cfg(not(target_os = "windows"))] + pub fn make_accessible(&mut self, start: usize, len: usize) -> Result<(), String> { + let page_size = region::page::size(); + assert_eq!(start & (page_size - 1), 0); + assert_eq!(len & (page_size - 1), 0); + assert_lt!(len, self.len); + assert_lt!(start, self.len - len); + + // Commit the accessible size. + let ptr = self.ptr as *const u8; + unsafe { region::protect(ptr.add(start), len, region::Protection::READ_WRITE) } + .map_err(|e| e.to_string()) + } + + /// Make the memory starting at `start` and extending for `len` bytes accessible. + /// `start` and `len` must be native page-size multiples and describe a range within + /// `self`'s reserved memory. + #[cfg(target_os = "windows")] + pub fn make_accessible(&mut self, start: usize, len: usize) -> Result<(), String> { + use winapi::ctypes::c_void; + use winapi::um::memoryapi::VirtualAlloc; + use winapi::um::winnt::{MEM_COMMIT, PAGE_READWRITE}; + let page_size = region::page::size(); + assert_eq!(start & (page_size - 1), 0); + assert_eq!(len & (page_size - 1), 0); + assert_lt!(len, self.len); + assert_lt!(start, self.len - len); + + // Commit the accessible size. + let ptr = self.ptr as *const u8; + if unsafe { + VirtualAlloc( + ptr.add(start) as *mut c_void, + len, + MEM_COMMIT, + PAGE_READWRITE, + ) + } + .is_null() + { + return Err(io::Error::last_os_error().to_string()); + } + + Ok(()) + } + + /// Return the allocated memory as a slice of u8. + pub fn as_slice(&self) -> &[u8] { + unsafe { slice::from_raw_parts(self.ptr as *const u8, self.len) } + } + + /// Return the allocated memory as a mutable slice of u8. + pub fn as_mut_slice(&mut self) -> &mut [u8] { + unsafe { slice::from_raw_parts_mut(self.ptr as *mut u8, self.len) } + } + + /// Return the allocated memory as a pointer to u8. + pub fn as_ptr(&self) -> *const u8 { + self.ptr as *const u8 + } + + /// Return the allocated memory as a mutable pointer to u8. + pub fn as_mut_ptr(&mut self) -> *mut u8 { + self.ptr as *mut u8 + } + + /// Return the length of the allocated memory. + pub fn len(&self) -> usize { + self.len + } + + /// Return whether any memory has been allocated. + pub fn is_empty(&self) -> bool { + self.len() == 0 + } +} + +impl Drop for Mmap { + #[cfg(not(target_os = "windows"))] + fn drop(&mut self) { + if self.len != 0 { + let r = unsafe { libc::munmap(self.ptr as *mut libc::c_void, self.len) }; + assert_eq!(r, 0, "munmap failed: {}", io::Error::last_os_error()); + } + } + + #[cfg(target_os = "windows")] + fn drop(&mut self) { + if self.len != 0 { + use winapi::ctypes::c_void; + use winapi::um::memoryapi::VirtualFree; + use winapi::um::winnt::MEM_RELEASE; + let r = unsafe { VirtualFree(self.ptr as *mut c_void, 0, MEM_RELEASE) }; + assert_ne!(r, 0); + } + } +} + +fn _assert() { + fn _assert_send_sync() {} + _assert_send_sync::(); +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn test_round_up_to_page_size() { + assert_eq!(round_up_to_page_size(0, 4096), 0); + assert_eq!(round_up_to_page_size(1, 4096), 4096); + assert_eq!(round_up_to_page_size(4096, 4096), 4096); + assert_eq!(round_up_to_page_size(4097, 4096), 8192); + } +} diff --git a/runtime/near-vm/lib/vm/src/probestack.rs b/runtime/near-vm/lib/vm/src/probestack.rs new file mode 100644 index 00000000000..cba4389d322 --- /dev/null +++ b/runtime/near-vm/lib/vm/src/probestack.rs @@ -0,0 +1,64 @@ +// This file contains code from external sources. +// Attributions: https://github.com/wasmerio/wasmer/blob/master/ATTRIBUTIONS.md + +//! This section defines the `PROBESTACK` intrinsic which is used in the +//! implementation of "stack probes" on certain platforms. +//! +//! The purpose of a stack probe is to provide a static guarantee that if a +//! thread has a guard page then a stack overflow is guaranteed to hit that +//! guard page. If a function did not have a stack probe then there's a risk of +//! having a stack frame *larger* than the guard page, so a function call could +//! skip over the guard page entirely and then later hit maybe the heap or +//! another thread, possibly leading to security vulnerabilities such as [The +//! Stack Clash], for example. +//! +//! [The Stack Clash]: https://blog.qualys.com/securitylabs/2017/06/19/the-stack-clash + +// A declaration for the stack probe function in Rust's standard library, for +// catching callstack overflow. +cfg_if::cfg_if! { + if #[cfg(all( + target_os = "windows", + target_env = "msvc", + target_pointer_width = "64" + ))] { + extern "C" { + pub fn __chkstk(); + } + /// The probestack for 64bit Windows when compiled with MSVC (note the double underscore) + pub const PROBESTACK: unsafe extern "C" fn() = __chkstk; + } else if #[cfg(all( + target_os = "windows", + target_env = "msvc", + target_pointer_width = "32" + ))] { + extern "C" { + pub fn _chkstk(); + } + /// The probestack for 32bit Windows when compiled with MSVC (note the singular underscore) + pub const PROBESTACK: unsafe extern "C" fn() = _chkstk; + } else if #[cfg(all(target_os = "windows", target_env = "gnu"))] { + extern "C" { + // ___chkstk (note the triple underscore) is implemented in compiler-builtins/src/x86_64.rs + // by the Rust compiler for the MinGW target + #[cfg(all(target_os = "windows", target_env = "gnu"))] + pub fn ___chkstk(); + } + /// The probestack for Windows when compiled with GNU + pub const PROBESTACK: unsafe extern "C" fn() = ___chkstk; + } else if #[cfg(not(any(target_arch = "x86_64", target_arch = "x86")))] { + // As per + // https://github.com/rust-lang/compiler-builtins/blob/cae3e6ea23739166504f9f9fb50ec070097979d4/src/probestack.rs#L39, + // LLVM only has stack-probe support on x86-64 and x86. Thus, on any other CPU + // architecture, we simply use an empty stack-probe function. + extern "C" fn empty_probestack() {} + /// A default probestack for other architectures + pub const PROBESTACK: unsafe extern "C" fn() = empty_probestack; + } else { + extern "C" { + pub fn __rust_probestack(); + } + /// The probestack based on the Rust probestack + pub static PROBESTACK: unsafe extern "C" fn() = __rust_probestack; + } +} diff --git a/runtime/near-vm/lib/vm/src/resolver.rs b/runtime/near-vm/lib/vm/src/resolver.rs new file mode 100644 index 00000000000..010eaad0ab5 --- /dev/null +++ b/runtime/near-vm/lib/vm/src/resolver.rs @@ -0,0 +1,332 @@ +use std::sync::Arc; + +use crate::{ImportInitializerFuncPtr, VMExtern, VMFunction, VMGlobal, VMMemory, VMTable}; + +/// The value of an export passed from one instance to another. +#[derive(Debug, Clone)] +pub enum Export { + /// A function export value. + Function(ExportFunction), + + /// A table export value. + Table(VMTable), + + /// A memory export value. + Memory(VMMemory), + + /// A global export value. + Global(VMGlobal), +} + +impl From for VMExtern { + fn from(other: Export) -> Self { + match other { + Export::Function(ExportFunction { vm_function, .. }) => Self::Function(vm_function), + Export::Memory(vm_memory) => Self::Memory(vm_memory), + Export::Table(vm_table) => Self::Table(vm_table), + Export::Global(vm_global) => Self::Global(vm_global), + } + } +} + +impl From for Export { + fn from(other: VMExtern) -> Self { + match other { + VMExtern::Function(vm_function) => Self::Function(ExportFunction { + vm_function, + metadata: None, + }), + VMExtern::Memory(vm_memory) => Self::Memory(vm_memory), + VMExtern::Table(vm_table) => Self::Table(vm_table), + VMExtern::Global(vm_global) => Self::Global(vm_global), + } + } +} + +/// Extra metadata about `ExportFunction`s. +/// +/// The metadata acts as a kind of manual virtual dispatch. We store the +/// user-supplied `WasmerEnv` as a void pointer and have methods on it +/// that have been adapted to accept a void pointer. +/// +/// This struct owns the original `host_env`, thus when it gets dropped +/// it calls the `drop` function on it. +#[derive(Debug, PartialEq)] +pub struct ExportFunctionMetadata { + /// This field is stored here to be accessible by `Drop`. + /// + /// At the time it was added, it's not accessed anywhere outside of + /// the `Drop` implementation. This field is the "master copy" of the env, + /// that is, the original env passed in by the user. Every time we create + /// an `Instance` we clone this with the `host_env_clone_fn` field. + /// + /// Thus, we only bother to store the master copy at all here so that + /// we can free it. + /// + /// See `wasmer_vm::export::VMFunction::vmctx` for the version of + /// this pointer that is used by the VM when creating an `Instance`. + pub host_env: *mut std::ffi::c_void, + + /// Function pointer to `WasmerEnv::init_with_instance(&mut self, instance: &Instance)`. + /// + /// This function is called to finish setting up the environment after + /// we create the `api::Instance`. + // This one is optional for now because dynamic host envs need the rest + // of this without the init fn + pub import_init_function_ptr: Option, + + /// A function analogous to `Clone::clone` that returns a leaked `Box`. + pub host_env_clone_fn: fn(*mut std::ffi::c_void) -> *mut std::ffi::c_void, + + /// The destructor to free the host environment. + /// + /// # Safety + /// - This function should only be called in when properly synchronized. + /// For example, in the `Drop` implementation of this type. + pub host_env_drop_fn: unsafe fn(*mut std::ffi::c_void), +} + +/// This can be `Send` because `host_env` comes from `WasmerEnv` which is +/// `Send`. Therefore all operations should work on any thread. +unsafe impl Send for ExportFunctionMetadata {} +/// This data may be shared across threads, `drop` is an unsafe function +/// pointer, so care must be taken when calling it. +unsafe impl Sync for ExportFunctionMetadata {} + +impl ExportFunctionMetadata { + /// Create an `ExportFunctionMetadata` type with information about + /// the exported function. + /// + /// # Safety + /// - the `host_env` must be `Send`. + /// - all function pointers must work on any thread. + pub unsafe fn new( + host_env: *mut std::ffi::c_void, + import_init_function_ptr: Option, + host_env_clone_fn: fn(*mut std::ffi::c_void) -> *mut std::ffi::c_void, + host_env_drop_fn: fn(*mut std::ffi::c_void), + ) -> Self { + Self { + host_env, + import_init_function_ptr, + host_env_clone_fn, + host_env_drop_fn, + } + } +} + +// We have to free `host_env` here because we always clone it before using it +// so all the `host_env`s freed at the `Instance` level won't touch the original. +impl Drop for ExportFunctionMetadata { + fn drop(&mut self) { + if !self.host_env.is_null() { + // # Safety + // - This is correct because we know no other references + // to this data can exist if we're dropping it. + unsafe { + (self.host_env_drop_fn)(self.host_env); + } + } + } +} + +/// A function export value with an extra function pointer to initialize +/// host environments. +#[derive(Debug, Clone, PartialEq)] +pub struct ExportFunction { + /// The VM function, containing most of the data. + pub vm_function: VMFunction, + /// Contains functions necessary to create and initialize host envs + /// with each `Instance` as well as being responsible for the + /// underlying memory of the host env. + pub metadata: Option>, +} + +impl From for Export { + fn from(func: ExportFunction) -> Self { + Self::Function(func) + } +} + +impl From for Export { + fn from(table: VMTable) -> Self { + Self::Table(table) + } +} + +impl From for Export { + fn from(memory: VMMemory) -> Self { + Self::Memory(memory) + } +} + +impl From for Export { + fn from(global: VMGlobal) -> Self { + Self::Global(global) + } +} + +/// +/// Import resolver connects imports with available exported values. +pub trait Resolver { + /// Resolves an import a WebAssembly module to an export it's hooked up to. + /// + /// The `index` provided is the index of the import in the wasm module + /// that's being resolved. For example 1 means that it's the second import + /// listed in the wasm module. + /// + /// The `module` and `field` arguments provided are the module/field names + /// listed on the import itself. + /// + /// # Notes: + /// + /// The index is useful because some WebAssembly modules may rely on that + /// for resolving ambiguity in their imports. Such as: + /// ```ignore + /// (module + /// (import "" "" (func)) + /// (import "" "" (func (param i32) (result i32))) + /// ) + /// ``` + fn resolve(&self, _index: u32, module: &str, field: &str) -> Option; +} + +/// Import resolver connects imports with available exported values. +/// +/// This is a specific subtrait for [`Resolver`] for those users who don't +/// care about the `index`, but only about the `module` and `field` for +/// the resolution. +pub trait NamedResolver { + /// Resolves an import a WebAssembly module to an export it's hooked up to. + /// + /// It receives the `module` and `field` names and return the [`Export`] in + /// case it's found. + fn resolve_by_name(&self, module: &str, field: &str) -> Option; +} + +// All NamedResolvers should extend `Resolver`. +impl Resolver for T { + /// By default this method will be calling [`NamedResolver::resolve_by_name`], + /// dismissing the provided `index`. + fn resolve(&self, _index: u32, module: &str, field: &str) -> Option { + self.resolve_by_name(module, field) + } +} + +impl NamedResolver for &T { + fn resolve_by_name(&self, module: &str, field: &str) -> Option { + (**self).resolve_by_name(module, field) + } +} + +impl NamedResolver for Box { + fn resolve_by_name(&self, module: &str, field: &str) -> Option { + (**self).resolve_by_name(module, field) + } +} + +impl NamedResolver for () { + /// Always returns `None`. + fn resolve_by_name(&self, _module: &str, _field: &str) -> Option { + None + } +} + +/// `Resolver` implementation that always resolves to `None`. Equivalent to `()`. +pub struct NullResolver {} + +impl Resolver for NullResolver { + fn resolve(&self, _idx: u32, _module: &str, _field: &str) -> Option { + None + } +} + +/// A [`Resolver`] that links two resolvers together in a chain. +pub struct NamedResolverChain { + a: A, + b: B, +} + +/// A trait for chaining resolvers together. +/// +/// ``` +/// # use wasmer_vm::{ChainableNamedResolver, NamedResolver}; +/// # fn chainable_test(imports1: A, imports2: B) +/// # where A: NamedResolver + Sized + Send + Sync, +/// # B: NamedResolver + Sized + Send + Sync, +/// # { +/// // override duplicates with imports from `imports2` +/// imports1.chain_front(imports2); +/// # } +/// ``` +pub trait ChainableNamedResolver: NamedResolver + Sized + Send + Sync { + /// Chain a resolver in front of the current resolver. + /// + /// This will cause the second resolver to override the first. + /// + /// ``` + /// # use wasmer_vm::{ChainableNamedResolver, NamedResolver}; + /// # fn chainable_test(imports1: A, imports2: B) + /// # where A: NamedResolver + Sized + Send + Sync, + /// # B: NamedResolver + Sized + Send + Sync, + /// # { + /// // override duplicates with imports from `imports2` + /// imports1.chain_front(imports2); + /// # } + /// ``` + fn chain_front(self, other: U) -> NamedResolverChain + where + U: NamedResolver + Send + Sync, + { + NamedResolverChain { a: other, b: self } + } + + /// Chain a resolver behind the current resolver. + /// + /// This will cause the first resolver to override the second. + /// + /// ``` + /// # use wasmer_vm::{ChainableNamedResolver, NamedResolver}; + /// # fn chainable_test(imports1: A, imports2: B) + /// # where A: NamedResolver + Sized + Send + Sync, + /// # B: NamedResolver + Sized + Send + Sync, + /// # { + /// // override duplicates with imports from `imports1` + /// imports1.chain_back(imports2); + /// # } + /// ``` + fn chain_back(self, other: U) -> NamedResolverChain + where + U: NamedResolver + Send + Sync, + { + NamedResolverChain { a: self, b: other } + } +} + +// We give these chain methods to all types implementing NamedResolver +impl ChainableNamedResolver for T {} + +impl NamedResolver for NamedResolverChain +where + A: NamedResolver + Send + Sync, + B: NamedResolver + Send + Sync, +{ + fn resolve_by_name(&self, module: &str, field: &str) -> Option { + self.a + .resolve_by_name(module, field) + .or_else(|| self.b.resolve_by_name(module, field)) + } +} + +impl Clone for NamedResolverChain +where + A: NamedResolver + Clone + Send + Sync, + B: NamedResolver + Clone + Send + Sync, +{ + fn clone(&self) -> Self { + Self { + a: self.a.clone(), + b: self.b.clone(), + } + } +} diff --git a/runtime/near-vm/lib/vm/src/sig_registry.rs b/runtime/near-vm/lib/vm/src/sig_registry.rs new file mode 100644 index 00000000000..2f8920e3816 --- /dev/null +++ b/runtime/near-vm/lib/vm/src/sig_registry.rs @@ -0,0 +1,75 @@ +// This file contains code from external sources. +// Attributions: https://github.com/wasmerio/wasmer/blob/master/ATTRIBUTIONS.md + +//! Implement a registry of function signatures, for fast indirect call +//! signature checking. + +use std::collections::{hash_map, HashMap}; +use std::convert::TryFrom; +use wasmer_types::FunctionType; + +/// An index into the shared signature registry, usable for checking signatures +/// at indirect calls. +#[repr(C)] +#[derive(Debug, Eq, PartialEq, Clone, Copy, Hash)] +pub struct VMSharedSignatureIndex(u32); + +impl VMSharedSignatureIndex { + /// Create a new `VMSharedSignatureIndex`. + pub fn new(value: u32) -> Self { + Self(value) + } +} + +/// WebAssembly requires that the caller and callee signatures in an indirect +/// call must match. To implement this efficiently, keep a registry of all +/// signatures, shared by all instances, so that call sites can just do an +/// index comparison. +#[derive(Debug)] +pub struct SignatureRegistry { + type_to_index: HashMap, + index_to_data: Vec, +} + +impl SignatureRegistry { + /// Create a new `SignatureRegistry`. + pub fn new() -> Self { + Self { + type_to_index: HashMap::new(), + index_to_data: Vec::new(), + } + } + + /// Register a signature and return its unique index. + pub fn register(&mut self, sig: FunctionType) -> VMSharedSignatureIndex { + let len = self.index_to_data.len(); + // TODO(0-copy): this. should. not. allocate. (and take FunctionTypeRef as a parameter) + // + // This is pretty hard to avoid, however. In order to implement bijective map, we'd want + // a `Rc`, but indexing into a map keyed by `Rc` with + // `FunctionTypeRef` is… not possible given the current API either. + // + // Consider `transmute` or `hashbrown`'s raw_entry. + match self.type_to_index.entry(sig.clone()) { + hash_map::Entry::Occupied(entry) => *entry.get(), + hash_map::Entry::Vacant(entry) => { + debug_assert!( + u32::try_from(len).is_ok(), + "invariant: can't have more than 2³²-1 signatures!" + ); + let sig_id = VMSharedSignatureIndex::new(u32::try_from(len).unwrap()); + entry.insert(sig_id); + self.index_to_data.push(sig); + sig_id + } + } + } + + /// Looks up a shared signature index within this registry. + /// + /// Note that for this operation to be semantically correct the `idx` must + /// have previously come from a call to `register` of this same object. + pub fn lookup(&self, idx: VMSharedSignatureIndex) -> Option<&FunctionType> { + self.index_to_data.get(idx.0 as usize) + } +} diff --git a/runtime/near-vm/lib/vm/src/table.rs b/runtime/near-vm/lib/vm/src/table.rs new file mode 100644 index 00000000000..104d6eb8a55 --- /dev/null +++ b/runtime/near-vm/lib/vm/src/table.rs @@ -0,0 +1,409 @@ +// This file contains code from external sources. +// Attributions: https://github.com/wasmerio/wasmer/blob/master/ATTRIBUTIONS.md + +//! Memory management for tables. +//! +//! `Table` is to WebAssembly tables what `LinearMemory` is to WebAssembly linear memories. + +use crate::func_data_registry::VMFuncRef; +use crate::trap::{Trap, TrapCode}; +use crate::vmcontext::VMTableDefinition; +use crate::VMExternRef; +use std::borrow::{Borrow, BorrowMut}; +use std::cell::UnsafeCell; +use std::convert::TryFrom; +use std::fmt; +use std::ptr::NonNull; +use std::sync::Mutex; +use wasmer_types::{ExternRef, TableType, Type as ValType}; + +/// Implementation styles for WebAssembly tables. +#[derive(Debug, Clone, Hash, PartialEq, Eq, rkyv::Serialize, rkyv::Deserialize, rkyv::Archive)] +pub enum TableStyle { + /// Signatures are stored in the table and checked in the caller. + CallerChecksSignature, +} + +/// Trait for implementing the interface of a Wasm table. +pub trait Table: fmt::Debug + Send + Sync { + /// Returns the style for this Table. + fn style(&self) -> &TableStyle; + + /// Returns the type for this Table. + fn ty(&self) -> &TableType; + + /// Returns the number of allocated elements. + fn size(&self) -> u32; + + /// Grow table by the specified amount of elements. + /// + /// Returns `None` if table can't be grown by the specified amount + /// of elements, otherwise returns the previous size of the table. + fn grow(&self, delta: u32, init_value: TableElement) -> Option; + + /// Get reference to the specified element. + /// + /// Returns `None` if the index is out of bounds. + fn get(&self, index: u32) -> Option; + + /// Set reference to the specified element. + /// + /// # Errors + /// + /// Returns an error if the index is out of bounds. + fn set(&self, index: u32, reference: TableElement) -> Result<(), Trap>; + + /// Return a `VMTableDefinition` for exposing the table to compiled wasm code. + fn vmtable(&self) -> NonNull; + + /// Copy `len` elements from `src_table[src_index..]` into `dst_table[dst_index..]`. + /// + /// # Errors + /// + /// Returns an error if the range is out of bounds of either the source or + /// destination tables. + fn copy( + &self, + src_table: &dyn Table, + dst_index: u32, + src_index: u32, + len: u32, + ) -> Result<(), Trap> { + // https://webassembly.github.io/bulk-memory-operations/core/exec/instructions.html#exec-table-copy + + if src_index + .checked_add(len) + .map_or(true, |n| n > src_table.size()) + { + return Err(Trap::lib(TrapCode::TableAccessOutOfBounds)); + } + + if dst_index.checked_add(len).map_or(true, |m| m > self.size()) { + return Err(Trap::lib(TrapCode::TableAccessOutOfBounds)); + } + + let srcs = src_index..src_index + len; + let dsts = dst_index..dst_index + len; + + // Note on the unwraps: the bounds check above means that these will + // never panic. + // + // TODO: investigate replacing this get/set loop with a `memcpy`. + if dst_index <= src_index { + for (s, d) in (srcs).zip(dsts) { + self.set(d, src_table.get(s).unwrap())?; + } + } else { + for (s, d) in srcs.rev().zip(dsts.rev()) { + self.set(d, src_table.get(s).unwrap())?; + } + } + + Ok(()) + } +} + +/// A reference stored in a table. Can be either an externref or a funcref. +#[derive(Debug, Clone)] +pub enum TableElement { + /// Opaque pointer to arbitrary host data. + // Note: we use `ExternRef` instead of `VMExternRef` here to ensure that we don't + // leak by not dec-refing on failure types. + ExternRef(ExternRef), + /// Pointer to function: contains enough information to call it. + FuncRef(VMFuncRef), +} + +impl From for RawTableElement { + fn from(other: TableElement) -> Self { + match other { + TableElement::ExternRef(extern_ref) => Self { + extern_ref: extern_ref.into(), + }, + TableElement::FuncRef(func_ref) => Self { func_ref }, + } + } +} + +#[repr(C)] +#[derive(Clone, Copy)] +pub union RawTableElement { + pub(crate) extern_ref: VMExternRef, + pub(crate) func_ref: VMFuncRef, +} + +#[cfg(test)] +#[test] +fn table_element_size_test() { + use std::mem::size_of; + assert_eq!(size_of::(), size_of::()); + assert_eq!(size_of::(), size_of::()); +} + +impl fmt::Debug for RawTableElement { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + f.debug_struct("RawTableElement").finish() + } +} + +impl Default for RawTableElement { + fn default() -> Self { + Self { + func_ref: VMFuncRef::null(), + } + } +} + +impl Default for TableElement { + fn default() -> Self { + Self::FuncRef(VMFuncRef::null()) + } +} + +/// A table instance. +#[derive(Debug)] +pub struct LinearTable { + // TODO: we can remove the mutex by using atomic swaps and preallocating the max table size + vec: Mutex>, + maximum: Option, + /// The WebAssembly table description. + table: TableType, + /// Our chosen implementation style. + style: TableStyle, + vm_table_definition: VMTableDefinitionOwnership, +} + +/// A type to help manage who is responsible for the backing table of the +/// `VMTableDefinition`. +#[derive(Debug)] +enum VMTableDefinitionOwnership { + /// The `VMTableDefinition` is owned by the `Instance` and we should use + /// its table. This is how a local table that's exported should be stored. + VMOwned(NonNull), + /// The `VMTableDefinition` is owned by the host and we should manage its + /// table. This is how an imported table that doesn't come from another + /// Wasm module should be stored. + HostOwned(Box>), +} + +/// This is correct because there is no thread-specific data tied to this type. +unsafe impl Send for LinearTable {} +/// This is correct because all internal mutability is protected by a mutex. +unsafe impl Sync for LinearTable {} + +impl LinearTable { + /// Create a new linear table instance with specified minimum and maximum number of elements. + /// + /// This creates a `LinearTable` with metadata owned by a VM, pointed to by + /// `vm_table_location`: this can be used to create a local table. + pub fn new(table: &TableType, style: &TableStyle) -> Result { + unsafe { Self::new_inner(table, style, None) } + } + + /// Create a new linear table instance with specified minimum and maximum number of elements. + /// + /// This creates a `LinearTable` with metadata owned by a VM, pointed to by + /// `vm_table_location`: this can be used to create a local table. + /// + /// # Safety + /// - `vm_table_location` must point to a valid location in VM memory. + pub unsafe fn from_definition( + table: &TableType, + style: &TableStyle, + vm_table_location: NonNull, + ) -> Result { + Self::new_inner(table, style, Some(vm_table_location)) + } + + /// Create a new `LinearTable` with either self-owned or VM owned metadata. + unsafe fn new_inner( + table: &TableType, + style: &TableStyle, + vm_table_location: Option>, + ) -> Result { + match table.ty { + ValType::FuncRef | ValType::ExternRef => (), + ty => { + return Err(format!( + "tables of types other than funcref or externref ({})", + ty + )) + } + }; + if let Some(max) = table.maximum { + if max < table.minimum { + return Err(format!( + "Table minimum ({}) is larger than maximum ({})!", + table.minimum, max + )); + } + } + let table_minimum = usize::try_from(table.minimum) + .map_err(|_| "Table minimum is bigger than usize".to_string())?; + let mut vec = vec![RawTableElement::default(); table_minimum]; + let base = vec.as_mut_ptr(); + match style { + TableStyle::CallerChecksSignature => Ok(Self { + vec: Mutex::new(vec), + maximum: table.maximum, + table: *table, + style: style.clone(), + vm_table_definition: if let Some(table_loc) = vm_table_location { + { + let mut ptr = table_loc; + let td = ptr.as_mut(); + td.base = base as _; + td.current_elements = table_minimum as _; + } + VMTableDefinitionOwnership::VMOwned(table_loc) + } else { + VMTableDefinitionOwnership::HostOwned(Box::new(UnsafeCell::new( + VMTableDefinition { + base: base as _, + current_elements: table_minimum as _, + }, + ))) + }, + }), + } + } + + /// Get the `VMTableDefinition`. + /// + /// # Safety + /// - You must ensure that you have mutually exclusive access before calling + /// this function. You can get this by locking the `vec` mutex. + unsafe fn get_vm_table_definition(&self) -> NonNull { + match &self.vm_table_definition { + VMTableDefinitionOwnership::VMOwned(ptr) => *ptr, + VMTableDefinitionOwnership::HostOwned(boxed_ptr) => { + NonNull::new_unchecked(boxed_ptr.get()) + } + } + } +} + +impl Table for LinearTable { + /// Returns the type for this Table. + fn ty(&self) -> &TableType { + &self.table + } + + /// Returns the style for this Table. + fn style(&self) -> &TableStyle { + &self.style + } + + /// Returns the number of allocated elements. + fn size(&self) -> u32 { + // TODO: investigate this function for race conditions + unsafe { + let td_ptr = self.get_vm_table_definition(); + let td = td_ptr.as_ref(); + td.current_elements + } + } + + /// Grow table by the specified amount of elements. + /// + /// Returns `None` if table can't be grown by the specified amount + /// of elements, otherwise returns the previous size of the table. + fn grow(&self, delta: u32, init_value: TableElement) -> Option { + let mut vec_guard = self.vec.lock().unwrap(); + let vec = vec_guard.borrow_mut(); + let size = self.size(); + let new_len = size.checked_add(delta)?; + if self.maximum.map_or(false, |max| new_len > max) { + return None; + } + if new_len == size { + debug_assert_eq!(delta, 0); + return Some(size); + } + + // Update the ref count + let element = match init_value { + TableElement::ExternRef(extern_ref) => { + let extern_ref: VMExternRef = extern_ref.into(); + // We reduce the amount we increment by because `into` prevents + // dropping `init_value` (which is a caller-inc'd ref). + if let Some(val) = (new_len as usize).checked_sub(size as usize + 1) { + extern_ref.ref_inc_by(val); + } + RawTableElement { extern_ref } + } + TableElement::FuncRef(func_ref) => RawTableElement { func_ref }, + }; + + vec.resize(usize::try_from(new_len).unwrap(), element); + + // update table definition + unsafe { + let mut td_ptr = self.get_vm_table_definition(); + let td = td_ptr.as_mut(); + td.current_elements = new_len; + td.base = vec.as_mut_ptr() as _; + } + Some(size) + } + + /// Get reference to the specified element. + /// + /// Returns `None` if the index is out of bounds. + fn get(&self, index: u32) -> Option { + let vec_guard = self.vec.lock().unwrap(); + let raw_data = vec_guard.borrow().get(index as usize).cloned()?; + Some(match self.table.ty { + ValType::ExternRef => { + TableElement::ExternRef(unsafe { raw_data.extern_ref.ref_clone() }.into()) + } + ValType::FuncRef => TableElement::FuncRef(unsafe { raw_data.func_ref }), + _ => todo!("getting invalid type from table, handle this error"), + }) + } + + /// Set reference to the specified element. + /// + /// # Errors + /// + /// Returns an error if the index is out of bounds. + fn set(&self, index: u32, reference: TableElement) -> Result<(), Trap> { + let mut vec_guard = self.vec.lock().unwrap(); + let vec = vec_guard.borrow_mut(); + match vec.get_mut(index as usize) { + Some(slot) => { + match (self.table.ty, reference) { + (ValType::ExternRef, TableElement::ExternRef(extern_ref)) => { + let extern_ref = extern_ref.into(); + unsafe { + let elem = &mut *slot; + elem.extern_ref.ref_drop(); + elem.extern_ref = extern_ref + } + } + (ValType::FuncRef, r @ TableElement::FuncRef(_)) => { + let element_data = r.into(); + *slot = element_data; + } + // This path should never be hit by the generated code due to Wasm + // validation. + (ty, v) => { + panic!( + "Attempted to set a table of type {} with the value {:?}", + ty, v + ) + } + }; + + Ok(()) + } + None => Err(Trap::lib(TrapCode::TableAccessOutOfBounds)), + } + } + + /// Return a `VMTableDefinition` for exposing the table to compiled wasm code. + fn vmtable(&self) -> NonNull { + let _vec_guard = self.vec.lock().unwrap(); + unsafe { self.get_vm_table_definition() } + } +} diff --git a/runtime/near-vm/lib/vm/src/trap/handlers.c b/runtime/near-vm/lib/vm/src/trap/handlers.c new file mode 100644 index 00000000000..3273353acc2 --- /dev/null +++ b/runtime/near-vm/lib/vm/src/trap/handlers.c @@ -0,0 +1,66 @@ +// This file contains partial code from other sources. +// Attributions: https://github.com/wasmerio/wasmer/blob/master/ATTRIBUTIONS.md + +#include +#include +#if defined(CFG_TARGET_OS_MACOS) +#include +#include +#include +#endif +// Note that `sigsetjmp` and `siglongjmp` are used here where possible to +// explicitly pass a 0 argument to `sigsetjmp` that we don't need to preserve +// the process signal mask. This should make this call a bit faster b/c it +// doesn't need to touch the kernel signal handling routines. +// In case of macOS, stackoverflow +#if defined(CFG_TARGET_OS_WINDOWS) +// On Windows, default setjmp/longjmp sequence will try to unwind the stack +// it's fine most of the time, but not for JIT'd code that may not respect stack ordring +// Using a special setjmp here, with NULL as second parameter to disable that behaviour +// and have a regular simple setjmp/longjmp sequence +#ifdef __MINGW32__ +// MINGW64 doesn't expose the __intrinsic_setjmp function, but a similar _setjump instead +#define platform_setjmp(buf) _setjmp(buf, NULL) +#else +#define platform_setjmp(buf) __intrinsic_setjmp(buf, NULL) +#endif +#define platform_longjmp(buf, arg) longjmp(buf, arg) +#define platform_jmp_buf jmp_buf +#elif defined(CFG_TARGET_OS_MACOS) +// TODO: This is not the most performant, since it adds overhead when calling functions +// https://github.com/wasmerio/wasmer/issues/2562 +#define platform_setjmp(buf) sigsetjmp(buf, 1) +#define platform_longjmp(buf, arg) siglongjmp(buf, arg) +#define platform_jmp_buf sigjmp_buf +#else +#define platform_setjmp(buf) sigsetjmp(buf, 0) +#define platform_longjmp(buf, arg) siglongjmp(buf, arg) +#define platform_jmp_buf sigjmp_buf +#endif + +int wasmer_register_setjmp( + void **buf_storage, + void (*body)(void*), + void *payload) { + #if 0 && defined(CFG_TARGET_OS_MACOS) + // Enable this block to ba able to debug Segfault with lldb + // This will mask the EXC_BAD_ACCESS from lldb... + static int allow_bad_access = 0; + if(!allow_bad_access) { + allow_bad_access = 1; + task_set_exception_ports(mach_task_self(), EXC_MASK_BAD_ACCESS, MACH_PORT_NULL, EXCEPTION_DEFAULT, 0); + } + #endif + platform_jmp_buf buf; + if (platform_setjmp(buf) != 0) { + return 0; + } + *buf_storage = &buf; + body(payload); + return 1; +} + +void wasmer_unwind(void *JmpBuf) { + platform_jmp_buf *buf = (platform_jmp_buf*) JmpBuf; + platform_longjmp(*buf, 1); +} diff --git a/runtime/near-vm/lib/vm/src/trap/mod.rs b/runtime/near-vm/lib/vm/src/trap/mod.rs new file mode 100644 index 00000000000..691a080f170 --- /dev/null +++ b/runtime/near-vm/lib/vm/src/trap/mod.rs @@ -0,0 +1,14 @@ +// This file contains code from external sources. +// Attributions: https://github.com/wasmerio/wasmer/blob/master/ATTRIBUTIONS.md + +//! This is the module that facilitates the usage of Traps +//! in Wasmer Runtime +mod trapcode; +pub mod traphandlers; + +pub use trapcode::TrapCode; +pub use traphandlers::resume_panic; +pub use traphandlers::{ + catch_traps, catch_traps_with_result, raise_lib_trap, raise_user_trap, wasmer_call_trampoline, + TlsRestore, Trap, +}; diff --git a/runtime/near-vm/lib/vm/src/trap/trapcode.rs b/runtime/near-vm/lib/vm/src/trap/trapcode.rs new file mode 100644 index 00000000000..5f929a14f90 --- /dev/null +++ b/runtime/near-vm/lib/vm/src/trap/trapcode.rs @@ -0,0 +1,172 @@ +// This file contains code from external sources. +// Attributions: https://github.com/wasmerio/wasmer/blob/master/ATTRIBUTIONS.md + +//! Trap codes describing the reason for a trap. + +use core::fmt::{self, Display, Formatter}; +use core::str::FromStr; +use thiserror::Error; + +/// A trap code describing the reason for a trap. +/// +/// All trap instructions have an explicit trap code. +#[derive( + Clone, + Copy, + PartialEq, + Eq, + Debug, + Hash, + Error, + rkyv::Serialize, + rkyv::Deserialize, + rkyv::Archive, +)] +#[repr(u32)] +pub enum TrapCode { + /// The current stack space was exhausted. + /// + /// On some platforms, a stack overflow may also be indicated by a segmentation fault from the + /// stack guard page. + StackOverflow = 0, + + /// A `heap_addr` instruction detected an out-of-bounds error. + /// + /// Note that not all out-of-bounds heap accesses are reported this way; + /// some are detected by a segmentation fault on the heap unmapped or + /// offset-guard pages. + HeapAccessOutOfBounds = 1, + + /// A `heap_addr` instruction was misaligned. + HeapMisaligned = 2, + + /// A `table_addr` instruction detected an out-of-bounds error. + TableAccessOutOfBounds = 3, + + /// Other bounds checking error. + OutOfBounds = 4, + + /// Indirect call to a null table entry. + IndirectCallToNull = 5, + + /// Signature mismatch on indirect call. + BadSignature = 6, + + /// An integer arithmetic operation caused an overflow. + IntegerOverflow = 7, + + /// An integer division by zero. + IntegerDivisionByZero = 8, + + /// Failed float-to-int conversion. + BadConversionToInteger = 9, + + /// Code that was supposed to have been unreachable was reached. + UnreachableCodeReached = 10, + + /// An atomic memory access was attempted with an unaligned pointer. + UnalignedAtomic = 11, + + /// Hit the gas limit. + GasExceeded = 12, +} + +impl TrapCode { + /// Gets the message for this trap code + pub fn message(&self) -> &str { + match self { + Self::StackOverflow => "call stack exhausted", + Self::HeapAccessOutOfBounds => "out of bounds memory access", + Self::HeapMisaligned => "misaligned heap", + Self::TableAccessOutOfBounds => "undefined element: out of bounds table access", + Self::OutOfBounds => "out of bounds", + Self::IndirectCallToNull => "uninitialized element", + Self::BadSignature => "indirect call type mismatch", + Self::IntegerOverflow => "integer overflow", + Self::IntegerDivisionByZero => "integer divide by zero", + Self::BadConversionToInteger => "invalid conversion to integer", + Self::UnreachableCodeReached => "unreachable", + Self::UnalignedAtomic => "unaligned atomic access", + Self::GasExceeded => "gas limit exceeded", + } + } +} + +impl Display for TrapCode { + fn fmt(&self, f: &mut Formatter) -> fmt::Result { + let identifier = match *self { + Self::StackOverflow => "stk_ovf", + Self::HeapAccessOutOfBounds => "heap_get_oob", + Self::HeapMisaligned => "heap_misaligned", + Self::TableAccessOutOfBounds => "table_get_oob", + Self::OutOfBounds => "oob", + Self::IndirectCallToNull => "icall_null", + Self::BadSignature => "bad_sig", + Self::IntegerOverflow => "int_ovf", + Self::IntegerDivisionByZero => "int_divz", + Self::BadConversionToInteger => "bad_toint", + Self::UnreachableCodeReached => "unreachable", + Self::UnalignedAtomic => "unalign_atom", + Self::GasExceeded => "out_of_gas", + }; + f.write_str(identifier) + } +} + +impl FromStr for TrapCode { + type Err = (); + + fn from_str(s: &str) -> Result { + match s { + "stk_ovf" => Ok(Self::StackOverflow), + "heap_get_oob" => Ok(Self::HeapAccessOutOfBounds), + "heap_misaligned" => Ok(Self::HeapMisaligned), + "table_get_oob" => Ok(Self::TableAccessOutOfBounds), + "oob" => Ok(Self::OutOfBounds), + "icall_null" => Ok(Self::IndirectCallToNull), + "bad_sig" => Ok(Self::BadSignature), + "int_ovf" => Ok(Self::IntegerOverflow), + "int_divz" => Ok(Self::IntegerDivisionByZero), + "bad_toint" => Ok(Self::BadConversionToInteger), + "unreachable" => Ok(Self::UnreachableCodeReached), + "unalign_atom" => Ok(Self::UnalignedAtomic), + _ => Err(()), + } + } +} + +#[cfg(test)] +mod tests { + use super::*; + + // Everything but user-defined codes. + const CODES: [TrapCode; 12] = [ + TrapCode::StackOverflow, + TrapCode::HeapAccessOutOfBounds, + TrapCode::HeapMisaligned, + TrapCode::TableAccessOutOfBounds, + TrapCode::OutOfBounds, + TrapCode::IndirectCallToNull, + TrapCode::BadSignature, + TrapCode::IntegerOverflow, + TrapCode::IntegerDivisionByZero, + TrapCode::BadConversionToInteger, + TrapCode::UnreachableCodeReached, + TrapCode::UnalignedAtomic, + ]; + + #[test] + fn display() { + for r in &CODES { + let tc = *r; + assert_eq!(tc.to_string().parse(), Ok(tc)); + } + assert_eq!("bogus".parse::(), Err(())); + + // assert_eq!(TrapCode::User(17).to_string(), "user17"); + // assert_eq!("user22".parse(), Ok(TrapCode::User(22))); + assert_eq!("user".parse::(), Err(())); + assert_eq!("user-1".parse::(), Err(())); + assert_eq!("users".parse::(), Err(())); + } +} diff --git a/runtime/near-vm/lib/vm/src/trap/traphandlers.rs b/runtime/near-vm/lib/vm/src/trap/traphandlers.rs new file mode 100644 index 00000000000..c1f453deade --- /dev/null +++ b/runtime/near-vm/lib/vm/src/trap/traphandlers.rs @@ -0,0 +1,428 @@ +// This file contains code from external sources. +// Attributions: https://github.com/wasmerio/wasmer/blob/master/ATTRIBUTIONS.md + +//! WebAssembly trap handling, which is built on top of the lower-level +//! signalhandling mechanisms. + +use super::trapcode::TrapCode; +use crate::vmcontext::{VMFunctionBody, VMFunctionEnvironment, VMTrampoline}; +use backtrace::Backtrace; +use std::any::Any; +use std::cell::{Cell, UnsafeCell}; +use std::error::Error; +use std::mem::{self, MaybeUninit}; +use std::ptr; +pub use tls::TlsRestore; + +extern "C" { + fn wasmer_register_setjmp( + jmp_buf: *mut *const u8, + callback: extern "C" fn(*mut u8), + payload: *mut u8, + ) -> i32; + fn wasmer_unwind(jmp_buf: *const u8) -> !; +} + +/// Raises a user-defined trap immediately. +/// +/// This function performs as-if a wasm trap was just executed, only the trap +/// has a dynamic payload associated with it which is user-provided. This trap +/// payload is then returned from `catch_traps` below. +/// +/// # Safety +/// +/// Only safe to call when wasm code is on the stack, aka `catch_traps` must +/// have been previous called and not yet returned. +/// Additionally no Rust destructors may be on the stack. +/// They will be skipped and not executed. +pub unsafe fn raise_user_trap(data: Box) -> ! { + tls::with(|info| info.unwrap().unwind_with(UnwindReason::UserTrap(data))) +} + +/// Raises a trap from inside library code immediately. +/// +/// This function performs as-if a wasm trap was just executed. This trap +/// payload is then returned from `catch_traps` below. +/// +/// # Safety +/// +/// Only safe to call when wasm code is on the stack, aka `catch_traps` must +/// have been previous called and not yet returned. +/// Additionally no Rust destructors may be on the stack. +/// They will be skipped and not executed. +pub unsafe fn raise_lib_trap(trap: Trap) -> ! { + tls::with(|info| info.unwrap().unwind_with(UnwindReason::LibTrap(trap))) +} + +/// Carries a Rust panic across wasm code and resumes the panic on the other +/// side. +/// +/// # Safety +/// +/// Only safe to call when wasm code is on the stack, aka `catch_traps` must +/// have been previously called and not returned. Additionally no Rust destructors may be on the +/// stack. They will be skipped and not executed. +pub unsafe fn resume_panic(payload: Box) -> ! { + tls::with(|info| info.unwrap().unwind_with(UnwindReason::Panic(payload))) +} + +/// Stores trace message with backtrace. +#[derive(Debug)] +pub enum Trap { + /// A user-raised trap through `raise_user_trap`. + User(Box), + + /// A trap raised from the Wasm generated code + /// + /// Note: this trap is deterministic (assuming a deterministic host implementation) + Wasm { + /// The program counter in generated code where this trap happened. + pc: usize, + /// Native stack backtrace at the time the trap occurred + backtrace: Backtrace, + /// Optional trapcode associated to the signal that caused the trap + signal_trap: Option, + }, + + /// A trap raised from a wasm libcall + /// + /// Note: this trap is deterministic (assuming a deterministic host implementation) + Lib { + /// Code of the trap. + trap_code: TrapCode, + /// Native stack backtrace at the time the trap occurred + backtrace: Backtrace, + }, + + /// A trap indicating that the runtime was unable to allocate sufficient memory. + /// + /// Note: this trap is nondeterministic, since it depends on the host system. + OOM { + /// Native stack backtrace at the time the OOM occurred + backtrace: Backtrace, + }, +} + +impl Trap { + /// Construct a new Wasm trap with the given source location and backtrace. + /// + /// Internally saves a backtrace when constructed. + pub fn wasm(pc: usize, backtrace: Backtrace, signal_trap: Option) -> Self { + Self::Wasm { + pc, + backtrace, + signal_trap, + } + } + + /// Construct a new Wasm trap with the given trap code. + /// + /// Internally saves a backtrace when constructed. + pub fn lib(trap_code: TrapCode) -> Self { + let backtrace = Backtrace::new_unresolved(); + Self::Lib { + trap_code, + backtrace, + } + } + + /// Construct a new OOM trap with the given source location and trap code. + /// + /// Internally saves a backtrace when constructed. + pub fn oom() -> Self { + let backtrace = Backtrace::new_unresolved(); + Self::OOM { backtrace } + } +} + +/// Call the VM function pointed to by `callee`. +/// +/// * `callee_env` - the function environment +/// * `trampoline` - the jit-generated trampoline whose ABI takes 3 values, the +/// callee funcenv, the `callee` argument below, and then the `values_vec` argument. +/// * `callee` - the 2nd argument to the `trampoline` function +/// * `values_vec` - points to a buffer which holds the incoming arguments, and to +/// which the outgoing return values will be written. +/// +/// Prefer invoking this via `Instance::invoke_trampoline`. +/// +/// # Safety +/// +/// Wildly unsafe because it calls raw function pointers and reads/writes raw +/// function pointers. +pub unsafe fn wasmer_call_trampoline( + callee_env: VMFunctionEnvironment, + trampoline: VMTrampoline, + callee: *const VMFunctionBody, + values_vec: *mut u8, +) -> Result<(), Trap> { + catch_traps(|| { + mem::transmute::<_, extern "C" fn(VMFunctionEnvironment, *const VMFunctionBody, *mut u8)>( + trampoline, + )(callee_env, callee, values_vec); + }) +} + +/// Catches any wasm traps that happen within the execution of `closure`, +/// returning them as a `Result`. +/// +/// # Safety +/// +/// Soundness must not depend on `closure` destructors being run. +pub unsafe fn catch_traps(mut closure: F) -> Result<(), Trap> +where + F: FnMut(), +{ + return CallThreadState::new().with(|cx| { + wasmer_register_setjmp( + cx.jmp_buf.as_ptr(), + call_closure::, + &mut closure as *mut F as *mut u8, + ) + }); + + extern "C" fn call_closure(payload: *mut u8) + where + F: FnMut(), + { + unsafe { (*(payload as *mut F))() } + } +} + +/// Catches any wasm traps that happen within the execution of `closure`, +/// returning them as a `Result`, with the closure contents. +/// +/// The main difference from this method and `catch_traps`, is that is able +/// to return the results from the closure. +/// +/// # Safety +/// +/// Check [`catch_traps`]. +pub unsafe fn catch_traps_with_result(mut closure: F) -> Result +where + F: FnMut() -> R, +{ + let mut global_results = MaybeUninit::::uninit(); + catch_traps(|| { + global_results.as_mut_ptr().write(closure()); + })?; + Ok(global_results.assume_init()) +} + +/// Temporary state stored on the stack which is registered in the `tls` module +/// below for calls into wasm. +pub struct CallThreadState { + unwind: UnsafeCell>, + jmp_buf: Cell<*const u8>, + prev: Cell, +} + +enum UnwindReason { + /// A panic caused by the host + Panic(Box), + /// A custom error triggered by the user + UserTrap(Box), + /// A Trap triggered by a wasm libcall + LibTrap(Trap), + /// A trap caused by the Wasm generated code + WasmTrap { + backtrace: Backtrace, + pc: usize, + signal_trap: Option, + }, +} + +impl<'a> CallThreadState { + #[inline] + fn new() -> Self { + Self { + unwind: UnsafeCell::new(MaybeUninit::uninit()), + jmp_buf: Cell::new(ptr::null()), + prev: Cell::new(ptr::null()), + } + } + + fn with(self, closure: impl FnOnce(&Self) -> i32) -> Result<(), Trap> { + let ret = tls::set(&self, || closure(&self))?; + if ret != 0 { + return Ok(()); + } + // We will only reach this path if ret == 0. And that will + // only happen if a trap did happen. As such, it's safe to + // assume that the `unwind` field is already initialized + // at this moment. + match unsafe { (*self.unwind.get()).as_ptr().read() } { + UnwindReason::UserTrap(data) => Err(Trap::User(data)), + UnwindReason::LibTrap(trap) => Err(trap), + UnwindReason::WasmTrap { + backtrace, + pc, + signal_trap, + } => Err(Trap::wasm(pc, backtrace, signal_trap)), + UnwindReason::Panic(panic) => std::panic::resume_unwind(panic), + } + } + + fn unwind_with(&self, reason: UnwindReason) -> ! { + unsafe { + (*self.unwind.get()).as_mut_ptr().write(reason); + wasmer_unwind(self.jmp_buf.get()); + } + } +} + +// A private inner module for managing the TLS state that we require across +// calls in wasm. The WebAssembly code is called from C++ and then a trap may +// happen which requires us to read some contextual state to figure out what to +// do with the trap. This `tls` module is used to persist that information from +// the caller to the trap site. +mod tls { + use super::CallThreadState; + use crate::Trap; + use std::mem; + use std::ptr; + + pub use raw::Ptr; + + // An even *more* inner module for dealing with TLS. This actually has the + // thread local variable and has functions to access the variable. + // + // Note that this is specially done to fully encapsulate that the accessors + // for tls must not be inlined. Wasmer's async support will employ stack + // switching which can resume execution on different OS threads. This means + // that borrows of our TLS pointer must never live across accesses because + // otherwise the access may be split across two threads and cause unsafety. + // + // This also means that extra care is taken by the runtime to save/restore + // these TLS values when the runtime may have crossed threads. + mod raw { + use super::CallThreadState; + use crate::Trap; + use std::cell::Cell; + use std::ptr; + + pub type Ptr = *const CallThreadState; + + // The first entry here is the `Ptr` which is what's used as part of the + // public interface of this module. The second entry is a boolean which + // allows the runtime to perform per-thread initialization if necessary + // for handling traps (e.g. setting up ports on macOS and sigaltstack on + // Unix). + thread_local!(static PTR: Cell = Cell::new(ptr::null())); + + #[inline(never)] // see module docs for why this is here + pub fn replace(val: Ptr) -> Result { + PTR.with(|p| { + // When a new value is configured that means that we may be + // entering WebAssembly so check to see if this thread has + // performed per-thread initialization for traps. + let prev = p.get(); + p.set(val); + Ok(prev) + }) + } + + #[inline(never)] // see module docs for why this is here + pub fn get() -> Ptr { + PTR.with(|p| p.get()) + } + } + + /// Opaque state used to help control TLS state across stack switches for + /// async support. + pub struct TlsRestore(raw::Ptr); + + impl TlsRestore { + /// Takes the TLS state that is currently configured and returns a + /// token that is used to replace it later. + /// + /// # Safety + /// + /// This is not a safe operation since it's intended to only be used + /// with stack switching found with fibers and async wasmer. + pub unsafe fn take() -> Result { + // Our tls pointer must be set at this time, and it must not be + // null. We need to restore the previous pointer since we're + // removing ourselves from the call-stack, and in the process we + // null out our own previous field for safety in case it's + // accidentally used later. + let raw = raw::get(); + assert!(!raw.is_null()); + let prev = (*raw).prev.replace(ptr::null()); + raw::replace(prev)?; + Ok(Self(raw)) + } + + /// Restores a previous tls state back into this thread's TLS. + /// + /// # Safety + /// + /// This is unsafe because it's intended to only be used within the + /// context of stack switching within wasmer. + pub unsafe fn replace(self) -> Result<(), super::Trap> { + // We need to configure our previous TLS pointer to whatever is in + // TLS at this time, and then we set the current state to ourselves. + let prev = raw::get(); + assert!((*self.0).prev.get().is_null()); + (*self.0).prev.set(prev); + raw::replace(self.0)?; + Ok(()) + } + } + + /// Configures thread local state such that for the duration of the + /// execution of `closure` any call to `with` will yield `ptr`, unless this + /// is recursively called again. + pub fn set(state: &CallThreadState, closure: impl FnOnce() -> R) -> Result { + struct Reset<'a>(&'a CallThreadState); + + impl Drop for Reset<'_> { + #[inline] + fn drop(&mut self) { + raw::replace(self.0.prev.replace(ptr::null())) + .expect("tls should be previously initialized"); + } + } + + // Note that this extension of the lifetime to `'static` should be + // safe because we only ever access it below with an anonymous + // lifetime, meaning `'static` never leaks out of this module. + let ptr = unsafe { mem::transmute::<*const CallThreadState, _>(state) }; + let prev = raw::replace(ptr)?; + state.prev.set(prev); + let _reset = Reset(state); + Ok(closure()) + } + + /// Returns the last pointer configured with `set` above. Panics if `set` + /// has not been previously called and not returned. + pub fn with(closure: impl FnOnce(Option<&CallThreadState>) -> R) -> R { + let p = raw::get(); + unsafe { closure(if p.is_null() { None } else { Some(&*p) }) } + } +} + +extern "C" fn signal_less_trap_handler(pc: *const u8, trap: TrapCode) { + let jmp_buf = tls::with(|info| { + let backtrace = Backtrace::new_unresolved(); + let info = info.unwrap(); + unsafe { + (*info.unwind.get()) + .as_mut_ptr() + .write(UnwindReason::WasmTrap { + backtrace, + signal_trap: Some(trap), + pc: pc as usize, + }); + info.jmp_buf.get() + } + }); + unsafe { + wasmer_unwind(jmp_buf); + } +} + +/// Returns pointer to the trap handler used in VMContext. +pub fn get_trap_handler() -> *const u8 { + signal_less_trap_handler as *const u8 +} diff --git a/runtime/near-vm/lib/vm/src/tunables.rs b/runtime/near-vm/lib/vm/src/tunables.rs new file mode 100644 index 00000000000..0c5db975f33 --- /dev/null +++ b/runtime/near-vm/lib/vm/src/tunables.rs @@ -0,0 +1,121 @@ +use crate::MemoryError; +use crate::{Memory, Table}; +use crate::{MemoryStyle, TableStyle}; +use crate::{VMMemoryDefinition, VMTableDefinition}; +use std::ptr::NonNull; +use std::sync::Arc; +use wasmer_types::{MemoryType, TableType}; + +/// An engine delegates the creation of memories, tables, and globals +/// to a foreign implementor of this trait. +pub trait Tunables: Sync { + /// Construct a `MemoryStyle` for the provided `MemoryType` + fn memory_style(&self, memory: &MemoryType) -> MemoryStyle; + + /// Construct a `TableStyle` for the provided `TableType` + fn table_style(&self, table: &TableType) -> TableStyle; + + /// Create a memory owned by the host given a [`MemoryType`] and a [`MemoryStyle`]. + fn create_host_memory( + &self, + ty: &MemoryType, + style: &MemoryStyle, + ) -> Result, MemoryError>; + + /// Create a memory owned by the VM given a [`MemoryType`] and a [`MemoryStyle`]. + /// + /// # Safety + /// - `vm_definition_location` must point to a valid location in VM memory. + unsafe fn create_vm_memory( + &self, + ty: &MemoryType, + style: &MemoryStyle, + vm_definition_location: NonNull, + ) -> Result, MemoryError>; + + /// Create a table owned by the host given a [`TableType`] and a [`TableStyle`]. + fn create_host_table( + &self, + ty: &TableType, + style: &TableStyle, + ) -> Result, String>; + + /// Create a table owned by the VM given a [`TableType`] and a [`TableStyle`]. + /// + /// # Safety + /// - `vm_definition_location` must point to a valid location in VM memory. + unsafe fn create_vm_table( + &self, + ty: &TableType, + style: &TableStyle, + vm_definition_location: NonNull, + ) -> Result, String>; + + /// Instrumentation configuration: stack limiter config + fn stack_limiter_cfg(&self) -> Box; + + /// Instrumentation configuration: gas accounting config + fn gas_cfg(&self) -> Box>; + + /// Cost for initializing a stack frame + fn stack_init_gas_cost(&self, frame_size: u64) -> u64; +} + +#[doc(hidden)] +pub struct TestTunables; + +impl Tunables for TestTunables { + fn memory_style(&self, _memory: &MemoryType) -> MemoryStyle { + unimplemented!() + } + + fn table_style(&self, _table: &TableType) -> TableStyle { + unimplemented!() + } + + fn create_host_memory( + &self, + _ty: &MemoryType, + _style: &MemoryStyle, + ) -> Result, MemoryError> { + unimplemented!() + } + + unsafe fn create_vm_memory( + &self, + _ty: &MemoryType, + _style: &MemoryStyle, + _vm_definition_location: NonNull, + ) -> Result, MemoryError> { + unimplemented!() + } + + fn create_host_table( + &self, + _ty: &TableType, + _style: &TableStyle, + ) -> Result, String> { + unimplemented!() + } + + unsafe fn create_vm_table( + &self, + _ty: &TableType, + _style: &TableStyle, + _vm_definition_location: NonNull, + ) -> Result, String> { + unimplemented!() + } + + fn stack_limiter_cfg(&self) -> Box { + unimplemented!() + } + + fn gas_cfg(&self) -> Box> { + unimplemented!() + } + + fn stack_init_gas_cost(&self, _frame_size: u64) -> u64 { + unimplemented!() + } +} diff --git a/runtime/near-vm/lib/vm/src/vmcontext.rs b/runtime/near-vm/lib/vm/src/vmcontext.rs new file mode 100644 index 00000000000..419dc0e42c3 --- /dev/null +++ b/runtime/near-vm/lib/vm/src/vmcontext.rs @@ -0,0 +1,1143 @@ +// This file contains code from external sources. +// Attributions: https://github.com/wasmerio/wasmer/blob/master/ATTRIBUTIONS.md + +//! This file declares `VMContext` and several related structs which contain +//! fields that compiled wasm code accesses directly. + +use crate::func_data_registry::VMFuncRef; +use crate::global::Global; +use crate::instance::Instance; +use crate::memory::Memory; +use crate::sig_registry::VMSharedSignatureIndex; +use crate::table::Table; +use crate::trap::{Trap, TrapCode}; +use crate::VMExternRef; +use std::any::Any; +use std::convert::TryFrom; +use std::fmt; +use std::ptr::{self, NonNull}; +use std::sync::Arc; +use std::u32; + +/// Union representing the first parameter passed when calling a function. +/// +/// It may either be a pointer to the [`VMContext`] if it's a Wasm function +/// or a pointer to arbitrary data controlled by the host if it's a host function. +#[derive(Copy, Clone, Eq)] +pub union VMFunctionEnvironment { + /// Wasm functions take a pointer to [`VMContext`]. + pub vmctx: *mut VMContext, + /// Host functions can have custom environments. + pub host_env: *mut std::ffi::c_void, +} + +impl VMFunctionEnvironment { + /// Check whether the pointer stored is null or not. + pub fn is_null(&self) -> bool { + unsafe { self.host_env.is_null() } + } +} + +impl std::fmt::Debug for VMFunctionEnvironment { + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + f.debug_struct("VMFunctionEnvironment") + .field("vmctx_or_hostenv", unsafe { &self.host_env }) + .finish() + } +} + +impl std::cmp::PartialEq for VMFunctionEnvironment { + fn eq(&self, rhs: &Self) -> bool { + unsafe { self.host_env as usize == rhs.host_env as usize } + } +} + +impl std::hash::Hash for VMFunctionEnvironment { + fn hash(&self, state: &mut H) { + unsafe { + self.vmctx.hash(state); + } + } +} + +/// Represents a continuous region of executable memory starting with a function +/// entry point. +#[derive(Debug)] +#[repr(C)] +pub struct FunctionExtent { + /// Entry point for normal entry of the function. All addresses in the + /// function lie after this address. + pub address: FunctionBodyPtr, + /// Length in bytes. + pub length: usize, +} + +/// An imported function. +#[derive(Debug, Copy, Clone)] +#[repr(C)] +pub struct VMFunctionImport { + /// A pointer to the imported function body. + pub body: FunctionBodyPtr, + + /// Function signature index within the source module. + pub signature: VMSharedSignatureIndex, + + /// Function call trampoline + pub trampoline: Option, + + /// A pointer to the `VMContext` that owns the function or host env data. + pub environment: VMFunctionEnvironment, +} + +#[cfg(test)] +mod test_vmfunction_import { + use super::VMFunctionImport; + use crate::VMOffsets; + use memoffset::offset_of; + use std::mem::size_of; + use wasmer_types::ModuleInfo; + + #[test] + fn check_vmfunction_import_offsets() { + let module = ModuleInfo::new(); + let offsets = VMOffsets::new(size_of::<*mut u8>() as u8).with_module_info(&module); + assert_eq!( + size_of::(), + usize::from(offsets.size_of_vmfunction_import()) + ); + assert_eq!( + offset_of!(VMFunctionImport, body), + usize::from(offsets.vmfunction_import_body()) + ); + assert_eq!( + offset_of!(VMFunctionImport, environment), + usize::from(offsets.vmfunction_import_vmctx()) + ); + } +} + +/// A locally defined function. +#[derive(Debug, Copy, Clone)] +#[repr(C)] +pub struct VMLocalFunction { + /// A pointer to the imported function body. + pub body: FunctionBodyPtr, + + /// Length of the function code + pub length: u32, + + /// Function signature + pub signature: VMSharedSignatureIndex, + + /// Trampoline for host->VM function calls. + pub trampoline: VMTrampoline, +} + +/// The `VMDynamicFunctionContext` is the context that dynamic +/// functions will receive when called (rather than `vmctx`). +/// A dynamic function is a function for which we don't know the signature +/// until runtime. +/// +/// As such, we need to expose the dynamic function `context` +/// containing the relevant context for running the function indicated +/// in `address`. +#[repr(C)] +pub struct VMDynamicFunctionContext { + /// The address of the inner dynamic function. + /// + /// Note: The function must be on the form of + /// `(*mut T, SignatureIndex, *mut i128)`. + pub address: *const VMFunctionBody, + + /// The context that the inner dynamic function will receive. + pub ctx: T, +} + +// The `ctx` itself must be `Send`, `address` can be passed between +// threads because all usage is `unsafe` and synchronized. +unsafe impl Send for VMDynamicFunctionContext {} +// The `ctx` itself must be `Sync`, `address` can be shared between +// threads because all usage is `unsafe` and synchronized. +unsafe impl Sync for VMDynamicFunctionContext {} + +impl Clone for VMDynamicFunctionContext { + fn clone(&self) -> Self { + Self { + address: self.address, + ctx: self.ctx.clone(), + } + } +} + +#[cfg(test)] +mod test_vmdynamicfunction_import_context { + use super::VMDynamicFunctionContext; + use crate::VMOffsets; + use memoffset::offset_of; + use std::mem::size_of; + use wasmer_types::ModuleInfo; + + #[test] + fn check_vmdynamicfunction_import_context_offsets() { + let module = ModuleInfo::new(); + let offsets = VMOffsets::new(size_of::<*mut u8>() as u8).with_module_info(&module); + assert_eq!( + size_of::>(), + usize::from(offsets.size_of_vmdynamicfunction_import_context()) + ); + assert_eq!( + offset_of!(VMDynamicFunctionContext, address), + usize::from(offsets.vmdynamicfunction_import_context_address()) + ); + assert_eq!( + offset_of!(VMDynamicFunctionContext, ctx), + usize::from(offsets.vmdynamicfunction_import_context_ctx()) + ); + } +} + +/// A placeholder byte-sized type which is just used to provide some amount of type +/// safety when dealing with pointers to JIT-compiled function bodies. Note that it's +/// deliberately not Copy, as we shouldn't be carelessly copying function body bytes +/// around. +#[repr(C)] +pub struct VMFunctionBody(u8); + +#[cfg(test)] +mod test_vmfunction_body { + use super::VMFunctionBody; + use std::mem::size_of; + + #[test] + fn check_vmfunction_body_offsets() { + assert_eq!(size_of::(), 1); + } +} + +/// A pointer to the beginning of the function body. +#[derive(Clone, Copy, Debug)] +#[repr(transparent)] +pub struct FunctionBodyPtr(pub *const VMFunctionBody); + +impl std::ops::Deref for FunctionBodyPtr { + type Target = *const VMFunctionBody; + + fn deref(&self) -> &Self::Target { + &self.0 + } +} + +// SAFETY: The VMFunctionBody that this points to is opaque, so there's no data to read or write +// through this pointer. This is essentially a usize. +unsafe impl Send for FunctionBodyPtr {} + +/// SAFETY: The VMFunctionBody that this points to is opaque, so there's no data to read or write +/// through this pointer. This is essentially a usize. +unsafe impl Sync for FunctionBodyPtr {} + +/// A function kind is a calling convention into and out of wasm code. +#[derive(Debug, Copy, Clone, PartialEq)] +#[repr(C)] +pub enum VMFunctionKind { + /// A static function has the native signature: + /// `extern "C" (vmctx, arg1, arg2...) -> (result1, result2, ...)`. + /// + /// This is the default for functions that are defined: + /// 1. In the Host, natively + /// 2. In the WebAssembly file + Static, + + /// A dynamic function has the native signature: + /// `extern "C" (ctx, &[Value]) -> Vec`. + /// + /// This is the default for functions that are defined: + /// 1. In the Host, dynamically + Dynamic, +} + +/// The fields compiled code needs to access to utilize a WebAssembly table +/// imported from another instance. +#[derive(Debug, Clone)] +#[repr(C)] +pub struct VMTableImport { + /// A pointer to the imported table description. + pub definition: NonNull, + + /// A pointer to the `Table` that owns the table description. + pub from: Arc, +} + +#[cfg(test)] +mod test_vmtable_import { + use super::VMTableImport; + use crate::VMOffsets; + use memoffset::offset_of; + use std::mem::size_of; + use wasmer_types::ModuleInfo; + + #[test] + fn check_vmtable_import_offsets() { + let module = ModuleInfo::new(); + let offsets = VMOffsets::new(size_of::<*mut u8>() as u8).with_module_info(&module); + assert_eq!( + size_of::(), + usize::from(offsets.size_of_vmtable_import()) + ); + assert_eq!( + offset_of!(VMTableImport, definition), + usize::from(offsets.vmtable_import_definition()) + ); + assert_eq!( + offset_of!(VMTableImport, from), + usize::from(offsets.vmtable_import_from()) + ); + } +} + +/// The fields compiled code needs to access to utilize a WebAssembly linear +/// memory imported from another instance. +#[derive(Debug, Clone)] +#[repr(C)] +pub struct VMMemoryImport { + /// A pointer to the imported memory description. + pub definition: NonNull, + + /// A pointer to the `Memory` that owns the memory description. + pub from: Arc, +} + +#[cfg(test)] +mod test_vmmemory_import { + use super::VMMemoryImport; + use crate::VMOffsets; + use memoffset::offset_of; + use std::mem::size_of; + use wasmer_types::ModuleInfo; + + #[test] + fn check_vmmemory_import_offsets() { + let module = ModuleInfo::new(); + let offsets = VMOffsets::new(size_of::<*mut u8>() as u8).with_module_info(&module); + assert_eq!( + size_of::(), + usize::from(offsets.size_of_vmmemory_import()) + ); + assert_eq!( + offset_of!(VMMemoryImport, definition), + usize::from(offsets.vmmemory_import_definition()) + ); + assert_eq!( + offset_of!(VMMemoryImport, from), + usize::from(offsets.vmmemory_import_from()) + ); + } +} + +/// The fields compiled code needs to access to utilize a WebAssembly global +/// variable imported from another instance. +#[derive(Debug, Clone)] +#[repr(C)] +pub struct VMGlobalImport { + /// A pointer to the imported global variable description. + pub definition: NonNull, + + /// A pointer to the `Global` that owns the global description. + pub from: Arc, +} + +/// # Safety +/// This data is safe to share between threads because it's plain data that +/// is the user's responsibility to synchronize. Additionally, all operations +/// on `from` are thread-safe through the use of a mutex in [`Global`]. +unsafe impl Send for VMGlobalImport {} +/// # Safety +/// This data is safe to share between threads because it's plain data that +/// is the user's responsibility to synchronize. And because it's `Clone`, there's +/// really no difference between passing it by reference or by value as far as +/// correctness in a multi-threaded context is concerned. +unsafe impl Sync for VMGlobalImport {} + +#[cfg(test)] +mod test_vmglobal_import { + use super::VMGlobalImport; + use crate::VMOffsets; + use memoffset::offset_of; + use std::mem::size_of; + use wasmer_types::ModuleInfo; + + #[test] + fn check_vmglobal_import_offsets() { + let module = ModuleInfo::new(); + let offsets = VMOffsets::new(size_of::<*mut u8>() as u8).with_module_info(&module); + assert_eq!( + size_of::(), + usize::from(offsets.size_of_vmglobal_import()) + ); + assert_eq!( + offset_of!(VMGlobalImport, definition), + usize::from(offsets.vmglobal_import_definition()) + ); + assert_eq!( + offset_of!(VMGlobalImport, from), + usize::from(offsets.vmglobal_import_from()) + ); + } +} + +/// The fields compiled code needs to access to utilize a WebAssembly linear +/// memory defined within the instance, namely the start address and the +/// size in bytes. +#[derive(Debug, Copy, Clone)] +#[repr(C)] +pub struct VMMemoryDefinition { + /// The start address which is always valid, even if the memory grows. + pub base: *mut u8, + + /// The current logical size of this linear memory in bytes. + pub current_length: usize, +} + +/// # Safety +/// This data is safe to share between threads because it's plain data that +/// is the user's responsibility to synchronize. +unsafe impl Send for VMMemoryDefinition {} +/// # Safety +/// This data is safe to share between threads because it's plain data that +/// is the user's responsibility to synchronize. And it's `Copy` so there's +/// really no difference between passing it by reference or by value as far as +/// correctness in a multi-threaded context is concerned. +unsafe impl Sync for VMMemoryDefinition {} + +impl VMMemoryDefinition { + /// Do an unsynchronized, non-atomic `memory.copy` for the memory. + /// + /// # Errors + /// + /// Returns a `Trap` error when the source or destination ranges are out of + /// bounds. + /// + /// # Safety + /// + /// The memory is not copied atomically and is not synchronized: it's the + /// caller's responsibility to synchronize. + pub(crate) unsafe fn memory_copy(&self, dst: u32, src: u32, len: u32) -> Result<(), Trap> { + // https://webassembly.github.io/reference-types/core/exec/instructions.html#exec-memory-copy + if src + .checked_add(len) + .map_or(true, |n| usize::try_from(n).unwrap() > self.current_length) + || dst + .checked_add(len) + .map_or(true, |m| usize::try_from(m).unwrap() > self.current_length) + { + return Err(Trap::lib(TrapCode::HeapAccessOutOfBounds)); + } + + let dst = usize::try_from(dst).unwrap(); + let src = usize::try_from(src).unwrap(); + + // Bounds and casts are checked above, by this point we know that + // everything is safe. + let dst = self.base.add(dst); + let src = self.base.add(src); + ptr::copy(src, dst, len as usize); + + Ok(()) + } + + /// Perform the `memory.fill` operation for the memory in an unsynchronized, + /// non-atomic way. + /// + /// # Errors + /// + /// Returns a `Trap` error if the memory range is out of bounds. + /// + /// # Safety + /// The memory is not filled atomically and is not synchronized: it's the + /// caller's responsibility to synchronize. + pub(crate) unsafe fn memory_fill(&self, dst: u32, val: u32, len: u32) -> Result<(), Trap> { + if dst + .checked_add(len) + .map_or(true, |m| usize::try_from(m).unwrap() > self.current_length) + { + return Err(Trap::lib(TrapCode::HeapAccessOutOfBounds)); + } + + let dst = isize::try_from(dst).unwrap(); + let val = val as u8; + + // Bounds and casts are checked above, by this point we know that + // everything is safe. + let dst = self.base.offset(dst); + ptr::write_bytes(dst, val, len as usize); + + Ok(()) + } +} + +#[cfg(test)] +mod test_vmmemory_definition { + use super::VMMemoryDefinition; + use crate::VMOffsets; + use memoffset::offset_of; + use std::mem::size_of; + use wasmer_types::ModuleInfo; + + #[test] + fn check_vmmemory_definition_offsets() { + let module = ModuleInfo::new(); + let offsets = VMOffsets::new(size_of::<*mut u8>() as u8).with_module_info(&module); + assert_eq!( + size_of::(), + usize::from(offsets.size_of_vmmemory_definition()) + ); + assert_eq!( + offset_of!(VMMemoryDefinition, base), + usize::from(offsets.vmmemory_definition_base()) + ); + assert_eq!( + offset_of!(VMMemoryDefinition, current_length), + usize::from(offsets.vmmemory_definition_current_length()) + ); + } +} + +/// The fields compiled code needs to access to utilize a WebAssembly table +/// defined within the instance. +#[derive(Debug, Clone, Copy)] +#[repr(C)] +pub struct VMTableDefinition { + /// Pointer to the table data. + pub base: *mut u8, + + /// The current number of elements in the table. + pub current_elements: u32, +} + +#[cfg(test)] +mod test_vmtable_definition { + use super::VMTableDefinition; + use crate::VMOffsets; + use memoffset::offset_of; + use std::mem::size_of; + use wasmer_types::ModuleInfo; + + #[test] + fn check_vmtable_definition_offsets() { + let module = ModuleInfo::new(); + let offsets = VMOffsets::new(size_of::<*mut u8>() as u8).with_module_info(&module); + assert_eq!( + size_of::(), + usize::from(offsets.size_of_vmtable_definition()) + ); + assert_eq!( + offset_of!(VMTableDefinition, base), + usize::from(offsets.vmtable_definition_base()) + ); + assert_eq!( + offset_of!(VMTableDefinition, current_elements), + usize::from(offsets.vmtable_definition_current_elements()) + ); + } +} + +/// A typesafe wrapper around the storage for a global variables. +/// +/// # Safety +/// +/// Accessing the different members of this union is always safe because there +/// are no invalid values for any of the types and the whole object is +/// initialized by VMGlobalDefinition::new(). +#[derive(Clone, Copy)] +#[repr(C, align(16))] +pub union VMGlobalDefinitionStorage { + as_i32: i32, + as_u32: u32, + as_f32: f32, + as_i64: i64, + as_u64: u64, + as_f64: f64, + as_u128: u128, + as_funcref: VMFuncRef, + as_externref: VMExternRef, + bytes: [u8; 16], +} + +impl fmt::Debug for VMGlobalDefinitionStorage { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.debug_struct("VMGlobalDefinitionStorage") + .field("bytes", unsafe { &self.bytes }) + .finish() + } +} + +/// The storage for a WebAssembly global defined within the instance. +/// +/// TODO: Pack the globals more densely, rather than using the same size +/// for every type. +#[derive(Debug, Clone)] +#[repr(C, align(16))] +pub struct VMGlobalDefinition { + storage: VMGlobalDefinitionStorage, + // If more elements are added here, remember to add offset_of tests below! +} + +#[cfg(test)] +mod test_vmglobal_definition { + use super::VMGlobalDefinition; + use crate::{VMFuncRef, VMOffsets}; + use more_asserts::assert_ge; + use std::mem::{align_of, size_of}; + use wasmer_types::ModuleInfo; + + #[test] + fn check_vmglobal_definition_alignment() { + assert_ge!(align_of::(), align_of::()); + assert_ge!(align_of::(), align_of::()); + assert_ge!(align_of::(), align_of::()); + assert_ge!(align_of::(), align_of::()); + assert_ge!(align_of::(), align_of::()); + assert_ge!(align_of::(), align_of::<[u8; 16]>()); + } + + #[test] + fn check_vmglobal_definition_offsets() { + let module = ModuleInfo::new(); + let offsets = VMOffsets::new(size_of::<*mut u8>() as u8).with_module_info(&module); + assert_eq!( + size_of::<*const VMGlobalDefinition>(), + usize::from(offsets.size_of_vmglobal_local()) + ); + } + + #[test] + fn check_vmglobal_begins_aligned() { + let module = ModuleInfo::new(); + let offsets = VMOffsets::new(size_of::<*mut u8>() as u8).with_module_info(&module); + assert_eq!(offsets.vmctx_globals_begin() % 16, 0); + } +} + +impl VMGlobalDefinition { + /// Construct a `VMGlobalDefinition`. + pub fn new() -> Self { + Self { + storage: VMGlobalDefinitionStorage { bytes: [0; 16] }, + } + } + + /// Return the value as an i32. + /// + /// If this is not an I32 typed global it is unspecified what value is returned. + pub fn to_i32(&self) -> i32 { + unsafe { self.storage.as_i32 } + } + + /// Return a mutable reference to the value as an i32. + /// + /// # Safety + /// + /// It is the callers responsibility to make sure the global has I32 type. + /// Until the returned borrow is dropped, reads and writes of this global + /// must be done exclusively through this borrow. That includes reads and + /// writes of globals inside wasm functions. + pub unsafe fn as_i32_mut(&mut self) -> &mut i32 { + &mut self.storage.as_i32 + } + + /// Return a reference to the value as an u32. + /// + /// If this is not an I32 typed global it is unspecified what value is returned. + pub fn to_u32(&self) -> u32 { + unsafe { self.storage.as_u32 } + } + + /// Return a mutable reference to the value as an u32. + /// + /// # Safety + /// + /// It is the callers responsibility to make sure the global has I32 type. + /// Until the returned borrow is dropped, reads and writes of this global + /// must be done exclusively through this borrow. That includes reads and + /// writes of globals inside wasm functions. + pub unsafe fn as_u32_mut(&mut self) -> &mut u32 { + &mut self.storage.as_u32 + } + + /// Return a reference to the value as an i64. + /// + /// If this is not an I64 typed global it is unspecified what value is returned. + pub fn to_i64(&self) -> i64 { + unsafe { self.storage.as_i64 } + } + + /// Return a mutable reference to the value as an i64. + /// + /// # Safety + /// + /// It is the callers responsibility to make sure the global has I32 type. + /// Until the returned borrow is dropped, reads and writes of this global + /// must be done exclusively through this borrow. That includes reads and + /// writes of globals inside wasm functions. + pub unsafe fn as_i64_mut(&mut self) -> &mut i64 { + &mut self.storage.as_i64 + } + + /// Return a reference to the value as an u64. + /// + /// If this is not an I64 typed global it is unspecified what value is returned. + pub fn to_u64(&self) -> u64 { + unsafe { self.storage.as_u64 } + } + + /// Return a mutable reference to the value as an u64. + /// + /// # Safety + /// + /// It is the callers responsibility to make sure the global has I64 type. + /// Until the returned borrow is dropped, reads and writes of this global + /// must be done exclusively through this borrow. That includes reads and + /// writes of globals inside wasm functions. + pub unsafe fn as_u64_mut(&mut self) -> &mut u64 { + &mut self.storage.as_u64 + } + + /// Return a reference to the value as an f32. + /// + /// If this is not an F32 typed global it is unspecified what value is returned. + pub fn to_f32(&self) -> f32 { + unsafe { self.storage.as_f32 } + } + + /// Return a mutable reference to the value as an f32. + /// + /// # Safety + /// + /// It is the callers responsibility to make sure the global has F32 type. + /// Until the returned borrow is dropped, reads and writes of this global + /// must be done exclusively through this borrow. That includes reads and + /// writes of globals inside wasm functions. + pub unsafe fn as_f32_mut(&mut self) -> &mut f32 { + &mut self.storage.as_f32 + } + + /// Return a reference to the value as an f64. + /// + /// If this is not an F64 typed global it is unspecified what value is returned. + pub fn to_f64(&self) -> f64 { + unsafe { self.storage.as_f64 } + } + + /// Return a mutable reference to the value as an f64. + /// + /// # Safety + /// + /// It is the callers responsibility to make sure the global has F64 type. + /// Until the returned borrow is dropped, reads and writes of this global + /// must be done exclusively through this borrow. That includes reads and + /// writes of globals inside wasm functions. + pub unsafe fn as_f64_mut(&mut self) -> &mut f64 { + &mut self.storage.as_f64 + } + + /// Return a reference to the value as a `VMFuncRef`. + /// + /// If this is not a `VMFuncRef` typed global it is unspecified what value is returned. + pub fn to_funcref(&self) -> VMFuncRef { + unsafe { self.storage.as_funcref } + } + + /// Return a mutable reference to the value as a `VMFuncRef`. + /// + /// # Safety + /// + /// It is the callers responsibility to make sure the global has `VMFuncRef` type. + /// Until the returned borrow is dropped, reads and writes of this global + /// must be done exclusively through this borrow. That includes reads and + /// writes of globals inside wasm functions. + pub unsafe fn as_funcref_mut(&mut self) -> &mut VMFuncRef { + &mut self.storage.as_funcref + } + + /// Return a mutable reference to the value as an `VMExternRef`. + /// + /// # Safety + /// + /// It is the callers responsibility to make sure the global has I32 type. + /// Until the returned borrow is dropped, reads and writes of this global + /// must be done exclusively through this borrow. That includes reads and + /// writes of globals inside wasm functions. + pub unsafe fn as_externref_mut(&mut self) -> &mut VMExternRef { + &mut self.storage.as_externref + } + + /// Return a reference to the value as an `VMExternRef`. + /// + /// If this is not an I64 typed global it is unspecified what value is returned. + pub fn to_externref(&self) -> VMExternRef { + unsafe { self.storage.as_externref } + } + + /// Return a reference to the value as an u128. + /// + /// If this is not an V128 typed global it is unspecified what value is returned. + pub fn to_u128(&self) -> u128 { + unsafe { self.storage.as_u128 } + } + + /// Return a mutable reference to the value as an u128. + /// + /// # Safety + /// + /// It is the callers responsibility to make sure the global has V128 type. + /// Until the returned borrow is dropped, reads and writes of this global + /// must be done exclusively through this borrow. That includes reads and + /// writes of globals inside wasm functions. + pub unsafe fn as_u128_mut(&mut self) -> &mut u128 { + &mut self.storage.as_u128 + } + + /// Return a reference to the value as bytes. + pub fn to_bytes(&self) -> [u8; 16] { + unsafe { self.storage.bytes } + } + + /// Return a mutable reference to the value as bytes. + /// + /// # Safety + /// + /// Until the returned borrow is dropped, reads and writes of this global + /// must be done exclusively through this borrow. That includes reads and + /// writes of globals inside wasm functions. + pub unsafe fn as_bytes_mut(&mut self) -> &mut [u8; 16] { + &mut self.storage.bytes + } +} + +#[cfg(test)] +mod test_vmshared_signature_index { + use super::VMSharedSignatureIndex; + use crate::vmoffsets::{TargetSharedSignatureIndex, VMOffsets}; + use std::mem::size_of; + use wasmer_types::ModuleInfo; + + #[test] + fn check_vmshared_signature_index() { + let module = ModuleInfo::new(); + let offsets = VMOffsets::new(size_of::<*mut u8>() as u8).with_module_info(&module); + assert_eq!( + size_of::(), + usize::from(offsets.size_of_vmshared_signature_index()) + ); + } + + #[test] + fn check_target_shared_signature_index() { + assert_eq!( + size_of::(), + size_of::() + ); + } +} + +/// The VM caller-checked "anyfunc" record, for caller-side signature checking. +/// It consists of the actual function pointer and a signature id to be checked +/// by the caller. +#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq)] +#[repr(C)] +pub struct VMCallerCheckedAnyfunc { + /// Function body. + pub func_ptr: *const VMFunctionBody, + /// Function signature id. + pub type_index: VMSharedSignatureIndex, + /// Function `VMContext` or host env. + pub vmctx: VMFunctionEnvironment, + // If more elements are added here, remember to add offset_of tests below! +} + +#[cfg(test)] +mod test_vmcaller_checked_anyfunc { + use super::VMCallerCheckedAnyfunc; + use crate::VMOffsets; + use memoffset::offset_of; + use std::mem::size_of; + use wasmer_types::ModuleInfo; + + #[test] + fn check_vmcaller_checked_anyfunc_offsets() { + let module = ModuleInfo::new(); + let offsets = VMOffsets::new(size_of::<*mut u8>() as u8).with_module_info(&module); + assert_eq!( + size_of::(), + usize::from(offsets.size_of_vmcaller_checked_anyfunc()) + ); + assert_eq!( + offset_of!(VMCallerCheckedAnyfunc, func_ptr), + usize::from(offsets.vmcaller_checked_anyfunc_func_ptr()) + ); + assert_eq!( + offset_of!(VMCallerCheckedAnyfunc, type_index), + usize::from(offsets.vmcaller_checked_anyfunc_type_index()) + ); + assert_eq!( + offset_of!(VMCallerCheckedAnyfunc, vmctx), + usize::from(offsets.vmcaller_checked_anyfunc_vmctx()) + ); + } +} + +/// An index type for builtin functions. +#[derive(Copy, Clone, Debug)] +pub struct VMBuiltinFunctionIndex(u32); + +impl VMBuiltinFunctionIndex { + /// Returns an index for wasm's `memory.grow` builtin function. + pub const fn get_memory32_grow_index() -> Self { + Self(0) + } + /// Returns an index for wasm's imported `memory.grow` builtin function. + pub const fn get_imported_memory32_grow_index() -> Self { + Self(1) + } + /// Returns an index for wasm's `memory.size` builtin function. + pub const fn get_memory32_size_index() -> Self { + Self(2) + } + /// Returns an index for wasm's imported `memory.size` builtin function. + pub const fn get_imported_memory32_size_index() -> Self { + Self(3) + } + /// Returns an index for wasm's `table.copy` when both tables are locally + /// defined. + pub const fn get_table_copy_index() -> Self { + Self(4) + } + /// Returns an index for wasm's `table.init`. + pub const fn get_table_init_index() -> Self { + Self(5) + } + /// Returns an index for wasm's `elem.drop`. + pub const fn get_elem_drop_index() -> Self { + Self(6) + } + /// Returns an index for wasm's `memory.copy` for locally defined memories. + pub const fn get_memory_copy_index() -> Self { + Self(7) + } + /// Returns an index for wasm's `memory.copy` for imported memories. + pub const fn get_imported_memory_copy_index() -> Self { + Self(8) + } + /// Returns an index for wasm's `memory.fill` for locally defined memories. + pub const fn get_memory_fill_index() -> Self { + Self(9) + } + /// Returns an index for wasm's `memory.fill` for imported memories. + pub const fn get_imported_memory_fill_index() -> Self { + Self(10) + } + /// Returns an index for wasm's `memory.init` instruction. + pub const fn get_memory_init_index() -> Self { + Self(11) + } + /// Returns an index for wasm's `data.drop` instruction. + pub const fn get_data_drop_index() -> Self { + Self(12) + } + /// Returns an index for wasm's `raise_trap` instruction. + pub const fn get_raise_trap_index() -> Self { + Self(13) + } + /// Returns an index for wasm's `table.size` instruction for local tables. + pub const fn get_table_size_index() -> Self { + Self(14) + } + /// Returns an index for wasm's `table.size` instruction for imported tables. + pub const fn get_imported_table_size_index() -> Self { + Self(15) + } + /// Returns an index for wasm's `table.grow` instruction for local tables. + pub const fn get_table_grow_index() -> Self { + Self(16) + } + /// Returns an index for wasm's `table.grow` instruction for imported tables. + pub const fn get_imported_table_grow_index() -> Self { + Self(17) + } + /// Returns an index for wasm's `table.get` instruction for local tables. + pub const fn get_table_get_index() -> Self { + Self(18) + } + /// Returns an index for wasm's `table.get` instruction for imported tables. + pub const fn get_imported_table_get_index() -> Self { + Self(19) + } + /// Returns an index for wasm's `table.set` instruction for local tables. + pub const fn get_table_set_index() -> Self { + Self(20) + } + /// Returns an index for wasm's `table.set` instruction for imported tables. + pub const fn get_imported_table_set_index() -> Self { + Self(21) + } + /// Returns an index for wasm's `func.ref` instruction. + pub const fn get_func_ref_index() -> Self { + Self(22) + } + /// Returns an index for wasm's `table.fill` instruction for local tables. + pub const fn get_table_fill_index() -> Self { + Self(23) + } + /// Returns an index for a function to increment the externref count. + pub const fn get_externref_inc_index() -> Self { + Self(24) + } + /// Returns an index for a function to decrement the externref count. + pub const fn get_externref_dec_index() -> Self { + Self(25) + } + /// Returns the total number of builtin functions. + pub const fn builtin_functions_total_number() -> u32 { + 26 + } + + /// Return the index as an u32 number. + pub const fn index(self) -> u32 { + self.0 + } +} + +/// An array that stores addresses of builtin functions. We translate code +/// to use indirect calls. This way, we don't have to patch the code. +#[repr(C)] +pub struct VMBuiltinFunctionsArray { + ptrs: [usize; Self::len()], +} + +impl VMBuiltinFunctionsArray { + pub const fn len() -> usize { + VMBuiltinFunctionIndex::builtin_functions_total_number() as usize + } + + pub fn initialized() -> Self { + use crate::libcalls::*; + + let mut ptrs = [0; Self::len()]; + + ptrs[VMBuiltinFunctionIndex::get_memory32_grow_index().index() as usize] = + near_vm_memory32_grow as usize; + ptrs[VMBuiltinFunctionIndex::get_imported_memory32_grow_index().index() as usize] = + near_vm_imported_memory32_grow as usize; + + ptrs[VMBuiltinFunctionIndex::get_memory32_size_index().index() as usize] = + near_vm_memory32_size as usize; + ptrs[VMBuiltinFunctionIndex::get_imported_memory32_size_index().index() as usize] = + near_vm_imported_memory32_size as usize; + + ptrs[VMBuiltinFunctionIndex::get_table_copy_index().index() as usize] = + near_vm_table_copy as usize; + + ptrs[VMBuiltinFunctionIndex::get_table_init_index().index() as usize] = + near_vm_table_init as usize; + ptrs[VMBuiltinFunctionIndex::get_elem_drop_index().index() as usize] = + near_vm_elem_drop as usize; + + ptrs[VMBuiltinFunctionIndex::get_memory_copy_index().index() as usize] = + near_vm_memory32_copy as usize; + ptrs[VMBuiltinFunctionIndex::get_imported_memory_copy_index().index() as usize] = + near_vm_imported_memory32_copy as usize; + ptrs[VMBuiltinFunctionIndex::get_memory_fill_index().index() as usize] = + near_vm_memory32_fill as usize; + ptrs[VMBuiltinFunctionIndex::get_imported_memory_fill_index().index() as usize] = + near_vm_imported_memory32_fill as usize; + ptrs[VMBuiltinFunctionIndex::get_memory_init_index().index() as usize] = + near_vm_memory32_init as usize; + ptrs[VMBuiltinFunctionIndex::get_data_drop_index().index() as usize] = + near_vm_data_drop as usize; + ptrs[VMBuiltinFunctionIndex::get_raise_trap_index().index() as usize] = + near_vm_raise_trap as usize; + ptrs[VMBuiltinFunctionIndex::get_table_size_index().index() as usize] = + near_vm_table_size as usize; + ptrs[VMBuiltinFunctionIndex::get_imported_table_size_index().index() as usize] = + near_vm_imported_table_size as usize; + ptrs[VMBuiltinFunctionIndex::get_table_grow_index().index() as usize] = + near_vm_table_grow as usize; + ptrs[VMBuiltinFunctionIndex::get_imported_table_grow_index().index() as usize] = + near_vm_imported_table_grow as usize; + ptrs[VMBuiltinFunctionIndex::get_table_get_index().index() as usize] = + near_vm_table_get as usize; + ptrs[VMBuiltinFunctionIndex::get_imported_table_get_index().index() as usize] = + near_vm_imported_table_get as usize; + ptrs[VMBuiltinFunctionIndex::get_table_set_index().index() as usize] = + near_vm_table_set as usize; + ptrs[VMBuiltinFunctionIndex::get_imported_table_set_index().index() as usize] = + near_vm_imported_table_set as usize; + ptrs[VMBuiltinFunctionIndex::get_func_ref_index().index() as usize] = + near_vm_func_ref as usize; + ptrs[VMBuiltinFunctionIndex::get_table_fill_index().index() as usize] = + near_vm_table_fill as usize; + ptrs[VMBuiltinFunctionIndex::get_externref_inc_index().index() as usize] = + near_vm_externref_inc as usize; + ptrs[VMBuiltinFunctionIndex::get_externref_dec_index().index() as usize] = + near_vm_externref_dec as usize; + + debug_assert!(ptrs.iter().cloned().all(|p| p != 0)); + + Self { ptrs } + } +} + +/// The VM "context", which is pointed to by the `vmctx` arg in the compiler. +/// This has information about globals, memories, tables, and other runtime +/// state associated with the current instance. +/// +/// The struct here is empty, as the sizes of these fields are dynamic, and +/// we can't describe them in Rust's type system. Sufficient memory is +/// allocated at runtime. +/// +/// TODO: We could move the globals into the `vmctx` allocation too. +#[derive(Debug)] +#[repr(C, align(16))] // align 16 since globals are aligned to that and contained inside +pub struct VMContext {} + +impl VMContext { + /// Return a mutable reference to the associated `Instance`. + /// + /// # Safety + /// This is unsafe because it doesn't work on just any `VMContext`, it must + /// be a `VMContext` allocated as part of an `Instance`. + #[allow(clippy::cast_ptr_alignment)] + #[inline] + pub unsafe fn instance(&self) -> &Instance { + &*((self as *const Self as *mut u8).offset(-Instance::vmctx_offset()) as *const Instance) + } + + /// Return a reference to the host state associated with this `Instance`. + /// + /// # Safety + /// This is unsafe because it doesn't work on just any `VMContext`, it must + /// be a `VMContext` allocated as part of an `Instance`. + #[inline] + pub unsafe fn host_state(&self) -> &dyn Any { + self.instance().host_state() + } +} + +/// +pub type VMTrampoline = unsafe extern "C" fn( + *mut VMContext, // callee vmctx + *const VMFunctionBody, // function we're actually calling + *mut u128, // space for arguments and return values +); + +/// Pointers to section data. +#[derive(Clone, Copy, Debug)] +#[repr(transparent)] +pub struct SectionBodyPtr(pub *const u8); + +impl std::ops::Deref for SectionBodyPtr { + type Target = *const u8; + + fn deref(&self) -> &Self::Target { + &self.0 + } +} diff --git a/runtime/near-vm/lib/vm/src/vmoffsets.rs b/runtime/near-vm/lib/vm/src/vmoffsets.rs new file mode 100644 index 00000000000..74329b895b2 --- /dev/null +++ b/runtime/near-vm/lib/vm/src/vmoffsets.rs @@ -0,0 +1,768 @@ +// This file contains code from external sources. +// Attributions: https://github.com/wasmerio/wasmer/blob/master/ATTRIBUTIONS.md + +//! Offsets and sizes of various structs in wasmer-vm's vmcontext +//! module. + +#![deny(rustdoc::broken_intra_doc_links)] + +use crate::VMBuiltinFunctionIndex; +use more_asserts::assert_lt; +use std::convert::TryFrom; +use wasmer_types::{ + FunctionIndex, GlobalIndex, LocalGlobalIndex, LocalMemoryIndex, LocalTableIndex, MemoryIndex, + ModuleInfo, SignatureIndex, TableIndex, +}; + +#[cfg(target_pointer_width = "32")] +fn cast_to_u32(sz: usize) -> u32 { + u32::try_from(sz).unwrap() +} +#[cfg(target_pointer_width = "64")] +fn cast_to_u32(sz: usize) -> u32 { + u32::try_from(sz).expect("overflow in cast from usize to u32") +} + +/// Align an offset used in this module to a specific byte-width by rounding up +#[inline] +const fn align(offset: u32, width: u32) -> u32 { + (offset + (width - 1)) / width * width +} + +/// This class computes offsets to fields within [`VMContext`] and other +/// related structs that JIT code accesses directly. +/// +/// [`VMContext`]: crate::vmcontext::VMContext +// Invariant: the addresses always fit into an u32 without overflowing +#[derive(Clone, Debug)] +pub struct VMOffsets { + /// The size in bytes of a pointer on the target. + pointer_size: u8, + /// The number of signature declarations in the module. + num_signature_ids: u32, + /// The number of imported functions in the module. + num_imported_functions: u32, + /// The number of imported tables in the module. + num_imported_tables: u32, + /// The number of imported memories in the module. + num_imported_memories: u32, + /// The number of imported globals in the module. + num_imported_globals: u32, + /// The number of defined tables in the module. + num_local_tables: u32, + /// The number of defined memories in the module. + num_local_memories: u32, + /// The number of defined globals in the module. + num_local_globals: u32, + /// If the module has trap handler. + has_trap_handlers: bool, + + vmctx_signature_ids_begin: u32, + vmctx_imported_functions_begin: u32, + vmctx_imported_tables_begin: u32, + vmctx_imported_memories_begin: u32, + vmctx_imported_globals_begin: u32, + vmctx_tables_begin: u32, + vmctx_memories_begin: u32, + vmctx_globals_begin: u32, + vmctx_builtin_functions_begin: u32, + vmctx_trap_handler_begin: u32, + vmctx_gas_limiter_pointer: u32, + vmctx_stack_limit_begin: u32, + vmctx_stack_limit_initial_begin: u32, + size_of_vmctx: u32, +} + +impl VMOffsets { + /// Return a new `VMOffsets` instance, for a given pointer size. + /// + /// The returned `VMOffsets` has no entities. Add entities with other builder methods for this + /// type. + pub fn new(pointer_size: u8) -> Self { + Self { + pointer_size, + num_signature_ids: 0, + num_imported_functions: 0, + num_imported_tables: 0, + num_imported_memories: 0, + num_imported_globals: 0, + num_local_tables: 0, + num_local_memories: 0, + num_local_globals: 0, + has_trap_handlers: false, + vmctx_signature_ids_begin: 0, + vmctx_imported_functions_begin: 0, + vmctx_imported_tables_begin: 0, + vmctx_imported_memories_begin: 0, + vmctx_imported_globals_begin: 0, + vmctx_tables_begin: 0, + vmctx_memories_begin: 0, + vmctx_globals_begin: 0, + vmctx_builtin_functions_begin: 0, + vmctx_trap_handler_begin: 0, + vmctx_gas_limiter_pointer: 0, + vmctx_stack_limit_begin: 0, + vmctx_stack_limit_initial_begin: 0, + size_of_vmctx: 0, + } + } + + /// Return a new `VMOffsets` instance, for a host's pointer size. + /// + /// The returned `VMOffsets` has no entities. Add entities with other builder methods for this + /// type. + pub fn for_host() -> Self { + Self::new(std::mem::size_of::<*const u8>() as u8) + } + + /// Add imports and locals from the provided ModuleInfo. + #[tracing::instrument(skip_all)] + pub fn with_module_info(mut self, module: &ModuleInfo) -> Self { + self.num_imported_functions = module.import_counts.functions; + self.num_imported_tables = module.import_counts.tables; + self.num_imported_memories = module.import_counts.memories; + self.num_imported_globals = module.import_counts.globals; + self.num_signature_ids = cast_to_u32(module.signatures.len()); + // FIXME = these should most likely be subtracting the corresponding imports!!? + self.num_local_tables = cast_to_u32(module.tables.len()); + self.num_local_memories = cast_to_u32(module.memories.len()); + self.num_local_globals = cast_to_u32(module.globals.len()); + self.has_trap_handlers = true; + self.precompute(); + self + } + + /// Add imports and locals from the provided ModuleInfo. + pub fn with_archived_module_info(mut self, module: &rkyv::Archived) -> Self { + self.num_imported_functions = module.import_counts.functions; + self.num_imported_tables = module.import_counts.tables; + self.num_imported_memories = module.import_counts.memories; + self.num_imported_globals = module.import_counts.globals; + self.num_signature_ids = cast_to_u32(module.signatures.len()); + // FIXME = these should most likely be subtracting the corresponding imports!!? + self.num_local_tables = cast_to_u32(module.tables.len()); + self.num_local_memories = cast_to_u32(module.memories.len()); + self.num_local_globals = cast_to_u32(module.globals.len()); + self.has_trap_handlers = true; + self.precompute(); + self + } + + /// Number of local tables defined in the module + pub fn num_local_tables(&self) -> u32 { + self.num_local_tables + } + + /// Number of local memories defined in the module + pub fn num_local_memories(&self) -> u32 { + self.num_local_memories + } + + fn precompute(&mut self) { + /// Offset base by num_items items of size item_size, panicking on overflow + fn offset_by(base: u32, num_items: u32, item_size: u32) -> u32 { + base.checked_add(num_items.checked_mul(item_size).unwrap()) + .unwrap() + } + + self.vmctx_signature_ids_begin = 0; + self.vmctx_imported_functions_begin = offset_by( + self.vmctx_signature_ids_begin, + self.num_signature_ids, + u32::from(self.size_of_vmshared_signature_index()), + ); + self.vmctx_imported_tables_begin = offset_by( + self.vmctx_imported_functions_begin, + self.num_imported_functions, + u32::from(self.size_of_vmfunction_import()), + ); + self.vmctx_imported_memories_begin = offset_by( + self.vmctx_imported_tables_begin, + self.num_imported_tables, + u32::from(self.size_of_vmtable_import()), + ); + self.vmctx_imported_globals_begin = offset_by( + self.vmctx_imported_memories_begin, + self.num_imported_memories, + u32::from(self.size_of_vmmemory_import()), + ); + self.vmctx_tables_begin = offset_by( + self.vmctx_imported_globals_begin, + self.num_imported_globals, + u32::from(self.size_of_vmglobal_import()), + ); + self.vmctx_memories_begin = offset_by( + self.vmctx_tables_begin, + self.num_local_tables, + u32::from(self.size_of_vmtable_definition()), + ); + self.vmctx_globals_begin = align( + offset_by( + self.vmctx_memories_begin, + self.num_local_memories, + u32::from(self.size_of_vmmemory_definition()), + ), + 16, + ); + self.vmctx_builtin_functions_begin = offset_by( + self.vmctx_globals_begin, + self.num_local_globals, + u32::from(self.size_of_vmglobal_local()), + ); + self.vmctx_trap_handler_begin = offset_by( + self.vmctx_builtin_functions_begin, + VMBuiltinFunctionIndex::builtin_functions_total_number(), + u32::from(self.pointer_size), + ); + self.vmctx_gas_limiter_pointer = offset_by( + self.vmctx_trap_handler_begin, + if self.has_trap_handlers { 1 } else { 0 }, + u32::from(self.pointer_size), + ); + self.vmctx_stack_limit_begin = offset_by( + self.vmctx_gas_limiter_pointer, + 1, + u32::from(self.pointer_size), + ); + self.vmctx_stack_limit_initial_begin = self.vmctx_stack_limit_begin.checked_add(4).unwrap(); + self.size_of_vmctx = self.vmctx_stack_limit_begin.checked_add(4).unwrap(); + } +} + +/// Offsets for [`VMFunctionImport`]. +/// +/// [`VMFunctionImport`]: crate::vmcontext::VMFunctionImport +impl VMOffsets { + /// The offset of the `body` field. + #[allow(clippy::erasing_op)] + pub const fn vmfunction_import_body(&self) -> u8 { + 0 * self.pointer_size + } + + /// The offset of the `vmctx` field. + #[allow(clippy::identity_op)] + pub const fn vmfunction_import_vmctx(&self) -> u8 { + 3 * self.pointer_size + } + + /// Return the size of [`VMFunctionImport`]. + /// + /// [`VMFunctionImport`]: crate::vmcontext::VMFunctionImport + pub const fn size_of_vmfunction_import(&self) -> u8 { + 4 * self.pointer_size + } +} + +/// Offsets for [`VMDynamicFunctionContext`]. +/// +/// [`VMDynamicFunctionContext`]: crate::vmcontext::VMDynamicFunctionContext +impl VMOffsets { + /// The offset of the `address` field. + #[allow(clippy::erasing_op)] + pub const fn vmdynamicfunction_import_context_address(&self) -> u8 { + 0 * self.pointer_size + } + + /// The offset of the `ctx` field. + #[allow(clippy::identity_op)] + pub const fn vmdynamicfunction_import_context_ctx(&self) -> u8 { + 1 * self.pointer_size + } + + /// Return the size of [`VMDynamicFunctionContext`]. + /// + /// [`VMDynamicFunctionContext`]: crate::vmcontext::VMDynamicFunctionContext + pub const fn size_of_vmdynamicfunction_import_context(&self) -> u8 { + 2 * self.pointer_size + } +} + +/// Offsets for `*const VMFunctionBody`. +impl VMOffsets { + /// The size of the `current_elements` field. + #[allow(clippy::identity_op)] + pub const fn size_of_vmfunction_body_ptr(&self) -> u8 { + 1 * self.pointer_size + } +} + +/// Offsets for [`VMTableImport`]. +/// +/// [`VMTableImport`]: crate::vmcontext::VMTableImport +impl VMOffsets { + /// The offset of the `definition` field. + #[allow(clippy::erasing_op)] + pub const fn vmtable_import_definition(&self) -> u8 { + 0 * self.pointer_size + } + + /// The offset of the `from` field. + #[allow(clippy::identity_op)] + pub const fn vmtable_import_from(&self) -> u8 { + 1 * self.pointer_size + } + + /// Return the size of [`VMTableImport`]. + /// + /// [`VMTableImport`]: crate::vmcontext::VMTableImport + pub const fn size_of_vmtable_import(&self) -> u8 { + 3 * self.pointer_size + } +} + +/// Offsets for [`VMTableDefinition`]. +/// +/// [`VMTableDefinition`]: crate::vmcontext::VMTableDefinition +impl VMOffsets { + /// The offset of the `base` field. + #[allow(clippy::erasing_op)] + pub const fn vmtable_definition_base(&self) -> u8 { + 0 * self.pointer_size + } + + /// The offset of the `current_elements` field. + #[allow(clippy::identity_op)] + pub const fn vmtable_definition_current_elements(&self) -> u8 { + 1 * self.pointer_size + } + + /// The size of the `current_elements` field. + pub const fn size_of_vmtable_definition_current_elements(&self) -> u8 { + 4 + } + + /// Return the size of [`VMTableDefinition`]. + /// + /// [`VMTableDefinition`]: crate::vmcontext::VMTableDefinition + pub const fn size_of_vmtable_definition(&self) -> u8 { + 2 * self.pointer_size + } +} + +/// Offsets for [`VMMemoryImport`]. +/// +/// [`VMMemoryImport`]: crate::vmcontext::VMMemoryImport +impl VMOffsets { + /// The offset of the `from` field. + #[allow(clippy::erasing_op)] + pub const fn vmmemory_import_definition(&self) -> u8 { + 0 * self.pointer_size + } + + /// The offset of the `from` field. + #[allow(clippy::identity_op)] + pub const fn vmmemory_import_from(&self) -> u8 { + 1 * self.pointer_size + } + + /// Return the size of [`VMMemoryImport`]. + /// + /// [`VMMemoryImport`]: crate::vmcontext::VMMemoryImport + pub const fn size_of_vmmemory_import(&self) -> u8 { + 3 * self.pointer_size + } +} + +/// Offsets for [`VMMemoryDefinition`]. +/// +/// [`VMMemoryDefinition`]: crate::vmcontext::VMMemoryDefinition +impl VMOffsets { + /// The offset of the `base` field. + #[allow(clippy::erasing_op)] + pub const fn vmmemory_definition_base(&self) -> u8 { + 0 * self.pointer_size + } + + /// The offset of the `current_length` field. + #[allow(clippy::identity_op)] + pub const fn vmmemory_definition_current_length(&self) -> u8 { + 1 * self.pointer_size + } + + /// The size of the `current_length` field. + pub const fn size_of_vmmemory_definition_current_length(&self) -> u8 { + 4 + } + + /// Return the size of [`VMMemoryDefinition`]. + /// + /// [`VMMemoryDefinition`]: crate::vmcontext::VMMemoryDefinition + pub const fn size_of_vmmemory_definition(&self) -> u8 { + 2 * self.pointer_size + } +} + +/// Offsets for [`VMGlobalImport`]. +/// +/// [`VMGlobalImport`]: crate::vmcontext::VMGlobalImport +impl VMOffsets { + /// The offset of the `definition` field. + #[allow(clippy::erasing_op)] + pub const fn vmglobal_import_definition(&self) -> u8 { + 0 * self.pointer_size + } + + /// The offset of the `from` field. + #[allow(clippy::identity_op)] + pub const fn vmglobal_import_from(&self) -> u8 { + 1 * self.pointer_size + } + + /// Return the size of [`VMGlobalImport`]. + /// + /// [`VMGlobalImport`]: crate::vmcontext::VMGlobalImport + #[allow(clippy::identity_op)] + pub const fn size_of_vmglobal_import(&self) -> u8 { + 2 * self.pointer_size + } +} + +/// Offsets for a non-null pointer to a [`VMGlobalDefinition`] used as a local global. +/// +/// [`VMGlobalDefinition`]: crate::vmcontext::VMGlobalDefinition +impl VMOffsets { + /// Return the size of a pointer to a [`VMGlobalDefinition`]; + /// + /// The underlying global itself is the size of the largest value type (i.e. a V128), + /// however the size of this type is just the size of a pointer. + /// + /// [`VMGlobalDefinition`]: crate::vmcontext::VMGlobalDefinition + pub const fn size_of_vmglobal_local(&self) -> u8 { + self.pointer_size + } +} + +/// Offsets for [`VMSharedSignatureIndex`]. +/// +/// [`VMSharedSignatureIndex`]: crate::vmcontext::VMSharedSignatureIndex +impl VMOffsets { + /// Return the size of [`VMSharedSignatureIndex`]. + /// + /// [`VMSharedSignatureIndex`]: crate::vmcontext::VMSharedSignatureIndex + pub const fn size_of_vmshared_signature_index(&self) -> u8 { + 4 + } +} + +/// Offsets for [`VMCallerCheckedAnyfunc`]. +/// +/// [`VMCallerCheckedAnyfunc`]: crate::vmcontext::VMCallerCheckedAnyfunc +impl VMOffsets { + /// The offset of the `func_ptr` field. + #[allow(clippy::erasing_op)] + pub const fn vmcaller_checked_anyfunc_func_ptr(&self) -> u8 { + 0 * self.pointer_size + } + + /// The offset of the `type_index` field. + #[allow(clippy::identity_op)] + pub const fn vmcaller_checked_anyfunc_type_index(&self) -> u8 { + 1 * self.pointer_size + } + + /// The offset of the `vmctx` field. + pub const fn vmcaller_checked_anyfunc_vmctx(&self) -> u8 { + 2 * self.pointer_size + } + + /// Return the size of [`VMCallerCheckedAnyfunc`]. + /// + /// [`VMCallerCheckedAnyfunc`]: crate::vmcontext::VMCallerCheckedAnyfunc + pub const fn size_of_vmcaller_checked_anyfunc(&self) -> u8 { + 3 * self.pointer_size + } +} + +/// Offsets for [`VMFuncRef`]. +/// +/// [`VMFuncRef`]: crate::func_data_registry::VMFuncRef +impl VMOffsets { + /// The offset to the pointer to the anyfunc inside the ref. + #[allow(clippy::erasing_op)] + pub const fn vm_funcref_anyfunc_ptr(&self) -> u8 { + 0 * self.pointer_size + } + + /// Return the size of [`VMFuncRef`]. + /// + /// [`VMFuncRef`]: crate::func_data_registry::VMFuncRef + pub const fn size_of_vm_funcref(&self) -> u8 { + self.pointer_size + } +} + +/// Offsets for [`VMContext`]. +/// +/// [`VMContext`]: crate::vmcontext::VMContext +impl VMOffsets { + /// The offset of the `signature_ids` array. + #[inline] + pub fn vmctx_signature_ids_begin(&self) -> u32 { + self.vmctx_signature_ids_begin + } + + /// The offset of the `tables` array. + pub fn vmctx_imported_functions_begin(&self) -> u32 { + self.vmctx_imported_functions_begin + } + + /// The offset of the `tables` array. + #[allow(clippy::identity_op)] + pub fn vmctx_imported_tables_begin(&self) -> u32 { + self.vmctx_imported_tables_begin + } + + /// The offset of the `memories` array. + pub fn vmctx_imported_memories_begin(&self) -> u32 { + self.vmctx_imported_memories_begin + } + + /// The offset of the `globals` array. + pub fn vmctx_imported_globals_begin(&self) -> u32 { + self.vmctx_imported_globals_begin + } + + /// The offset of the `tables` array. + pub fn vmctx_tables_begin(&self) -> u32 { + self.vmctx_tables_begin + } + + /// The offset of the `memories` array. + pub fn vmctx_memories_begin(&self) -> u32 { + self.vmctx_memories_begin + } + + /// The offset of the `globals` array. + pub fn vmctx_globals_begin(&self) -> u32 { + self.vmctx_globals_begin + } + + /// The offset of the builtin functions array. + pub fn vmctx_builtin_functions_begin(&self) -> u32 { + self.vmctx_builtin_functions_begin + } + + /// The offset of the trap handler. + pub fn vmctx_trap_handler_begin(&self) -> u32 { + self.vmctx_trap_handler_begin + } + + /// The offset of the gas limiter pointer. + pub fn vmctx_gas_limiter_pointer(&self) -> u32 { + self.vmctx_gas_limiter_pointer + } + + /// The offset of the current stack limit. + pub fn vmctx_stack_limit_begin(&self) -> u32 { + self.vmctx_stack_limit_begin + } + + /// The offset of the initial stack limit. + pub fn vmctx_stack_limit_initial_begin(&self) -> u32 { + self.vmctx_stack_limit_initial_begin + } + + /// Return the size of the [`VMContext`] allocation. + /// + /// [`VMContext`]: crate::vmcontext::VMContext + pub fn size_of_vmctx(&self) -> u32 { + self.size_of_vmctx + } + + /// Return the offset to [`VMSharedSignatureIndex`] index `index`. + /// + /// [`VMSharedSignatureIndex`]: crate::vmcontext::VMSharedSignatureIndex + // Remember updating precompute upon changes + pub fn vmctx_vmshared_signature_id(&self, index: SignatureIndex) -> u32 { + assert_lt!(index.as_u32(), self.num_signature_ids); + self.vmctx_signature_ids_begin + + index.as_u32() * u32::from(self.size_of_vmshared_signature_index()) + } + + /// Return the offset to [`VMFunctionImport`] index `index`. + /// + /// [`VMFunctionImport`]: crate::vmcontext::VMFunctionImport + // Remember updating precompute upon changes + pub fn vmctx_vmfunction_import(&self, index: FunctionIndex) -> u32 { + assert_lt!(index.as_u32(), self.num_imported_functions); + self.vmctx_imported_functions_begin + + index.as_u32() * u32::from(self.size_of_vmfunction_import()) + } + + /// Return the offset to [`VMTableImport`] index `index`. + /// + /// [`VMTableImport`]: crate::vmcontext::VMTableImport + // Remember updating precompute upon changes + pub fn vmctx_vmtable_import(&self, index: TableIndex) -> u32 { + assert_lt!(index.as_u32(), self.num_imported_tables); + self.vmctx_imported_tables_begin + index.as_u32() * u32::from(self.size_of_vmtable_import()) + } + + /// Return the offset to [`VMMemoryImport`] index `index`. + /// + /// [`VMMemoryImport`]: crate::vmcontext::VMMemoryImport + // Remember updating precompute upon changes + pub fn vmctx_vmmemory_import(&self, index: MemoryIndex) -> u32 { + assert_lt!(index.as_u32(), self.num_imported_memories); + self.vmctx_imported_memories_begin + + index.as_u32() * u32::from(self.size_of_vmmemory_import()) + } + + /// Return the offset to [`VMGlobalImport`] index `index`. + /// + /// [`VMGlobalImport`]: crate::vmcontext::VMGlobalImport + // Remember updating precompute upon changes + pub fn vmctx_vmglobal_import(&self, index: GlobalIndex) -> u32 { + assert_lt!(index.as_u32(), self.num_imported_globals); + self.vmctx_imported_globals_begin + + index.as_u32() * u32::from(self.size_of_vmglobal_import()) + } + + /// Return the offset to [`VMTableDefinition`] index `index`. + /// + /// [`VMTableDefinition`]: crate::vmcontext::VMTableDefinition + // Remember updating precompute upon changes + pub fn vmctx_vmtable_definition(&self, index: LocalTableIndex) -> u32 { + assert_lt!(index.as_u32(), self.num_local_tables); + self.vmctx_tables_begin + index.as_u32() * u32::from(self.size_of_vmtable_definition()) + } + + /// Return the offset to [`VMMemoryDefinition`] index `index`. + /// + /// [`VMMemoryDefinition`]: crate::vmcontext::VMMemoryDefinition + // Remember updating precompute upon changes + pub fn vmctx_vmmemory_definition(&self, index: LocalMemoryIndex) -> u32 { + assert_lt!(index.as_u32(), self.num_local_memories); + self.vmctx_memories_begin + index.as_u32() * u32::from(self.size_of_vmmemory_definition()) + } + + /// Return the offset to the [`VMGlobalDefinition`] index `index`. + /// + /// [`VMGlobalDefinition`]: crate::vmcontext::VMGlobalDefinition + // Remember updating precompute upon changes + pub fn vmctx_vmglobal_definition(&self, index: LocalGlobalIndex) -> u32 { + assert_lt!(index.as_u32(), self.num_local_globals); + self.vmctx_globals_begin + index.as_u32() * u32::from(self.size_of_vmglobal_local()) + } + + /// Return the offset to the `body` field in `*const VMFunctionBody` index `index`. + // Remember updating precompute upon changes + pub fn vmctx_vmfunction_import_body(&self, index: FunctionIndex) -> u32 { + self.vmctx_vmfunction_import(index) + u32::from(self.vmfunction_import_body()) + } + + /// Return the offset to the `vmctx` field in `*const VMFunctionBody` index `index`. + // Remember updating precompute upon changes + pub fn vmctx_vmfunction_import_vmctx(&self, index: FunctionIndex) -> u32 { + self.vmctx_vmfunction_import(index) + u32::from(self.vmfunction_import_vmctx()) + } + + /// Return the offset to the `definition` field in [`VMTableImport`] index `index`. + /// + /// [`VMTableImport`]: crate::vmcontext::VMTableImport + // Remember updating precompute upon changes + pub fn vmctx_vmtable_import_definition(&self, index: TableIndex) -> u32 { + self.vmctx_vmtable_import(index) + u32::from(self.vmtable_import_definition()) + } + + /// Return the offset to the `base` field in [`VMTableDefinition`] index `index`. + /// + /// [`VMTableDefinition`]: crate::vmcontext::VMTableDefinition + // Remember updating precompute upon changes + pub fn vmctx_vmtable_definition_base(&self, index: LocalTableIndex) -> u32 { + self.vmctx_vmtable_definition(index) + u32::from(self.vmtable_definition_base()) + } + + /// Return the offset to the `current_elements` field in [`VMTableDefinition`] index `index`. + /// + /// [`VMTableDefinition`]: crate::vmcontext::VMTableDefinition + // Remember updating precompute upon changes + pub fn vmctx_vmtable_definition_current_elements(&self, index: LocalTableIndex) -> u32 { + self.vmctx_vmtable_definition(index) + u32::from(self.vmtable_definition_current_elements()) + } + + /// Return the offset to the `from` field in [`VMMemoryImport`] index `index`. + /// + /// [`VMMemoryImport`]: crate::vmcontext::VMMemoryImport + // Remember updating precompute upon changes + pub fn vmctx_vmmemory_import_definition(&self, index: MemoryIndex) -> u32 { + self.vmctx_vmmemory_import(index) + u32::from(self.vmmemory_import_definition()) + } + + /// Return the offset to the `vmctx` field in [`VMMemoryImport`] index `index`. + /// + /// [`VMMemoryImport`]: crate::vmcontext::VMMemoryImport + // Remember updating precompute upon changes + pub fn vmctx_vmmemory_import_from(&self, index: MemoryIndex) -> u32 { + self.vmctx_vmmemory_import(index) + u32::from(self.vmmemory_import_from()) + } + + /// Return the offset to the `base` field in [`VMMemoryDefinition`] index `index`. + /// + /// [`VMMemoryDefinition`]: crate::vmcontext::VMMemoryDefinition + // Remember updating precompute upon changes + pub fn vmctx_vmmemory_definition_base(&self, index: LocalMemoryIndex) -> u32 { + self.vmctx_vmmemory_definition(index) + u32::from(self.vmmemory_definition_base()) + } + + /// Return the offset to the `current_length` field in [`VMMemoryDefinition`] index `index`. + /// + /// [`VMMemoryDefinition`]: crate::vmcontext::VMMemoryDefinition + // Remember updating precompute upon changes + pub fn vmctx_vmmemory_definition_current_length(&self, index: LocalMemoryIndex) -> u32 { + self.vmctx_vmmemory_definition(index) + u32::from(self.vmmemory_definition_current_length()) + } + + /// Return the offset to the `from` field in [`VMGlobalImport`] index `index`. + /// + /// [`VMGlobalImport`]: crate::vmcontext::VMGlobalImport + // Remember updating precompute upon changes + pub fn vmctx_vmglobal_import_definition(&self, index: GlobalIndex) -> u32 { + self.vmctx_vmglobal_import(index) + u32::from(self.vmglobal_import_definition()) + } + + /// Return the offset to builtin function in `VMBuiltinFunctionsArray` index `index`. + // Remember updating precompute upon changes + pub fn vmctx_builtin_function(&self, index: VMBuiltinFunctionIndex) -> u32 { + self.vmctx_builtin_functions_begin + index.index() * u32::from(self.pointer_size) + } + + /// Return the offset to the trap handler. + pub fn vmctx_trap_handler(&self) -> u32 { + // Ensure that we never ask for trap handler offset if it's not enabled. + assert!(self.has_trap_handlers); + self.vmctx_trap_handler_begin + } +} + +/// Target specific type for shared signature index. +#[derive(Debug, Copy, Clone)] +pub struct TargetSharedSignatureIndex(u32); + +impl TargetSharedSignatureIndex { + /// Constructs `TargetSharedSignatureIndex`. + pub const fn new(value: u32) -> Self { + Self(value) + } + + /// Returns index value. + pub const fn index(self) -> u32 { + self.0 + } +} + +#[cfg(test)] +mod tests { + use crate::vmoffsets::align; + + #[test] + fn alignment() { + fn is_aligned(x: u32) -> bool { + x % 16 == 0 + } + assert!(is_aligned(align(0, 16))); + assert!(is_aligned(align(32, 16))); + assert!(is_aligned(align(33, 16))); + assert!(is_aligned(align(31, 16))); + } +} diff --git a/runtime/near-vm/rust-toolchain b/runtime/near-vm/rust-toolchain new file mode 100644 index 00000000000..9cf4011bde7 --- /dev/null +++ b/runtime/near-vm/rust-toolchain @@ -0,0 +1 @@ +1.66 diff --git a/runtime/near-vm/scripts/publish.py b/runtime/near-vm/scripts/publish.py new file mode 100644 index 00000000000..b5e53eaccdc --- /dev/null +++ b/runtime/near-vm/scripts/publish.py @@ -0,0 +1,116 @@ +#! /usr/bin/env python3 + +# This is a script for publishing the wasmer crates to crates.io. +# It should be run in the root of wasmer like `python3 scripts/publish.py --no-dry-run`. +# By default the script executes a test run and does not publish the crates to crates.io. + +# install dependencies: +# pip3 install toposort + +import argparse +import os +import re +import subprocess +import time + +from typing import Optional +try: + from toposort import toposort_flatten +except ImportError: + print("Please install toposort, `pip3 install toposort`") + + +# TODO: find this automatically +target_version = "2.1.0" + +# TODO: generate this by parsing toml files +dep_graph = { + "wasmer-types": set([]), + "wasmer-vm": set(["wasmer-types"]), + "wasmer-compiler": set(["wasmer-vm", "wasmer-types"]), + "wasmer-object": set(["wasmer-types", "wasmer-compiler"]), + "wasmer-engine": set(["wasmer-types", "wasmer-vm", "wasmer-compiler"]), + "wasmer-compiler-singlepass": set(["wasmer-types", "wasmer-vm", "wasmer-compiler"]), + "wasmer-engine-universal": set(["wasmer-types", "wasmer-vm", "wasmer-compiler", "wasmer-engine"]), + "wasmer": set(["wasmer-vm", "wasmer-compiler-singlepass", + "wasmer-compiler", "wasmer-engine", "wasmer-engine-universal", + "wasmer-types"]), +} + +# where each crate is located in the `lib` directory +# TODO: this could also be generated from the toml files +location = { + "wasmer-types": "types", + "wasmer-vm": "vm", + "wasmer-compiler": "compiler", + "wasmer-object": "object", + "wasmer-engine": "engine", + "wasmer-compiler-singlepass": "compiler-singlepass", + "wasmer-engine": "engine", + "wasmer-engine-universal": "engine-universal", + "wasmer": "api", +} + +no_dry_run = False + +def get_latest_version_for_crate(crate_name: str) -> Optional[str]: + output = subprocess.run(["cargo", "search", crate_name], capture_output=True) + rexp_src = '^{} = "([^"]+)"'.format(crate_name) + prog = re.compile(rexp_src) + haystack = output.stdout.decode("utf-8") + for line in haystack.splitlines(): + result = prog.match(line) + if result: + return result.group(1) + +def is_crate_already_published(crate_name: str) -> bool: + found_string = get_latest_version_for_crate(crate_name) + if found_string is None: + return False + + return target_version == found_string + +def publish_crate(crate: str): + starting_dir = os.getcwd() + os.chdir("lib/{}".format(location[crate])) + + global no_dry_run + if no_dry_run: + output = subprocess.run(["cargo", "publish"]) + else: + print("In dry-run: not publishing crate `{}`".format(crate)) + + os.chdir(starting_dir) + +def main(): + os.environ['WASMER_PUBLISH_SCRIPT_IS_RUNNING'] = '1' + parser = argparse.ArgumentParser(description='Publish the Wasmer crates to crates.io') + parser.add_argument('--no-dry-run', default=False, action='store_true', + help='Run the script without actually publishing anything to crates.io') + args = vars(parser.parse_args()) + + global no_dry_run + no_dry_run = args['no_dry_run'] + + # get the order to publish the crates in + order = list(toposort_flatten(dep_graph, sort=True)) + + for crate in order: + print("Publishing `{}`...".format(crate)) + if not is_crate_already_published(crate): + publish_crate(crate) + else: + print("`{}` was already published!".format(crate)) + continue + # sleep for 16 seconds between crates to ensure the crates.io index has time to update + # this can be optimized with knowledge of our dep graph via toposort; we can even publish + # crates in parallel; however this is out of scope for the first version of this script + if no_dry_run: + print("Sleeping for 16 seconds to allow the `crates.io` index to update...") + time.sleep(16) + else: + print("In dry-run: not sleeping for crates.io to update.") + + +if __name__ == "__main__": + main() diff --git a/runtime/near-vm/scripts/update-version.sh b/runtime/near-vm/scripts/update-version.sh new file mode 100755 index 00000000000..24a0cb50f9e --- /dev/null +++ b/runtime/near-vm/scripts/update-version.sh @@ -0,0 +1,24 @@ +#! /bin/sh + +# How to install `fd`: https://github.com/sharkdp/fd#installation +: "${FD:=fd}" + +# A script to update the version of all the crates at the same time +PREVIOUS_VERSION='2.0.0' +NEXT_VERSION='2.1.0' + +# quick hack +${FD} Cargo.toml --exec sed -i '{}' -e "s/version = \"$PREVIOUS_VERSION\"/version = \"$NEXT_VERSION\"/" +echo "manually check changes to Cargo.toml" + +${FD} wasmer.iss --exec sed -i '{}' -e "s/AppVersion=$PREVIOUS_VERSION/AppVersion=$NEXT_VERSION/" +echo "manually check changes to wasmer.iss" + +# Order to upload packages in +## wasmer-types +## win-exception-handler +## compiler +## compiler-singlepass +## emscripten +## wasi +## wasmer (api) diff --git a/runtime/near-vm/scripts/wasmer-binfmt.service.example b/runtime/near-vm/scripts/wasmer-binfmt.service.example new file mode 100644 index 00000000000..414aef70f04 --- /dev/null +++ b/runtime/near-vm/scripts/wasmer-binfmt.service.example @@ -0,0 +1,15 @@ +[Unit] +Description=Set up wasmer to handle execution of wasm binaries +DefaultDependencies=no +Conflicts=shutdown.target +After=proc-sys-fs-binfmt_misc.automount +After=proc-sys-fs-binfmt_misc.mount +Before=sysinit.target shutdown.target +ConditionPathIsReadWrite=/proc/sys/ + +[Service] +Type=oneshot +RemainAfterExit=yes +ExecStart=/usr/bin/wasmer binfmt reregister +ExecStop=/usr/bin/wasmer binfmt unregister +TimeoutSec=10s diff --git a/runtime/near-vm/scripts/windows-installer/media/wizard_logo.ico b/runtime/near-vm/scripts/windows-installer/media/wizard_logo.ico new file mode 100644 index 00000000000..80d69b0558d Binary files /dev/null and b/runtime/near-vm/scripts/windows-installer/media/wizard_logo.ico differ diff --git a/runtime/near-vm/scripts/windows-installer/media/wizard_logo_2.bmp b/runtime/near-vm/scripts/windows-installer/media/wizard_logo_2.bmp new file mode 100644 index 00000000000..91c93bac372 Binary files /dev/null and b/runtime/near-vm/scripts/windows-installer/media/wizard_logo_2.bmp differ diff --git a/runtime/near-vm/scripts/windows-installer/media/wizard_logo_small.bmp b/runtime/near-vm/scripts/windows-installer/media/wizard_logo_small.bmp new file mode 100644 index 00000000000..03d6e4dec76 Binary files /dev/null and b/runtime/near-vm/scripts/windows-installer/media/wizard_logo_small.bmp differ diff --git a/runtime/near-vm/scripts/windows-installer/wasmer.iss b/runtime/near-vm/scripts/windows-installer/wasmer.iss new file mode 100644 index 00000000000..586bc4d7a2c --- /dev/null +++ b/runtime/near-vm/scripts/windows-installer/wasmer.iss @@ -0,0 +1,95 @@ +[Setup] +AppName=Wasmer +AppVersion=2.1.0 +DefaultDirName={pf}\Wasmer +DefaultGroupName=Wasmer +Compression=lzma2 +SolidCompression=yes +OutputDir=.\ +DisableProgramGroupPage=yes +ChangesEnvironment=yes +OutputBaseFilename=WasmerInstaller +WizardImageFile=media\wizard_logo_2.bmp +WizardSmallImageFile=media\wizard_logo_small.bmp +SetupIconFile=media\wizard_logo.ico +DisableWelcomePage=no + +[Registry] +Root: HKCU; Subkey: "Environment"; ValueType:string; ValueName: "WASMER_DIR"; \ + ValueData: "{app}"; Flags: preservestringtype +Root: HKCU; Subkey: "Environment"; ValueType:string; ValueName: "WASMER_CACHE_DIR"; \ + ValueData: "{%USERPROFILE}\.wasmer\cache"; Flags: preservestringtype + +[Files] +Source: "..\..\package\bin\*"; DestDir: "{app}\bin" +Source: "..\..\package\include\*"; DestDir: "{app}\include" +Source: "..\..\package\lib\*"; DestDir: "{app}\lib" +Source: "..\..\package\LICENSE"; DestDir: "{app}" +Source: "..\..\package\ATTRIBUTIONS"; DestDir: "{app}" +Source: "wax.cmd"; DestDir: "{app}\bin" + +[Dirs] +Name: "{%USERPROFILE}\.wasmer" + +[Code] +const EnvironmentKey = 'SYSTEM\CurrentControlSet\Control\Session Manager\Environment'; + +procedure EnvAddPath(Path: string); +var + Paths: string; +begin + { Retrieve current path (use empty string if entry not exists) } + if not RegQueryStringValue(HKEY_LOCAL_MACHINE, EnvironmentKey, 'Path', Paths) + then Paths := ''; + + { Skip if string already found in path } + if Pos(';' + Uppercase(Path) + ';', ';' + Uppercase(Paths) + ';') > 0 then exit; + + { App string to the end of the path variable } + Paths := Paths + ';'+ Path +';' + + { Overwrite (or create if missing) path environment variable } + if RegWriteStringValue(HKEY_LOCAL_MACHINE, EnvironmentKey, 'Path', Paths) + then Log(Format('The [%s] added to PATH: [%s]', [Path, Paths])) + else Log(Format('Error while adding the [%s] to PATH: [%s]', [Path, Paths])); +end; + +procedure EnvRemovePath(Path: string); +var + Paths: string; + P: Integer; +begin + { Skip if registry entry not exists } + if not RegQueryStringValue(HKEY_LOCAL_MACHINE, EnvironmentKey, 'Path', Paths) then + exit; + + { Skip if string not found in path } + P := Pos(';' + Uppercase(Path) + ';', ';' + Uppercase(Paths) + ';'); + if P = 0 then exit; + + { Update path variable } + Delete(Paths, P - 1, Length(Path) + 1); + + { Overwrite path environment variable } + if RegWriteStringValue(HKEY_LOCAL_MACHINE, EnvironmentKey, 'Path', Paths) + then Log(Format('The [%s] removed from PATH: [%s]', [Path, Paths])) + else Log(Format('Error while removing the [%s] from PATH: [%s]', [Path, Paths])); +end; + +procedure CurStepChanged(CurStep: TSetupStep); +begin + if CurStep = ssPostInstall + then begin + EnvAddPath(ExpandConstant('{app}') +'\bin'); + EnvAddPath(ExpandConstant('{app}') +'\globals\wapm_packages\.bin'); + end +end; + +procedure CurUninstallStepChanged(CurUninstallStep: TUninstallStep); +begin + if CurUninstallStep = usPostUninstall + then begin + EnvRemovePath(ExpandConstant('{app}') +'\bin'); + EnvAddPath(ExpandConstant('{app}') +'\globals\wapm_packages\.bin'); + end +end; diff --git a/runtime/near-vm/scripts/windows-installer/wax.cmd b/runtime/near-vm/scripts/windows-installer/wax.cmd new file mode 100644 index 00000000000..efe9eaffb03 --- /dev/null +++ b/runtime/near-vm/scripts/windows-installer/wax.cmd @@ -0,0 +1,2 @@ +@echo off +wapm.exe execute %* diff --git a/runtime/near-vm/tests/compilers/compilation.rs b/runtime/near-vm/tests/compilers/compilation.rs new file mode 100644 index 00000000000..8e3e52e5889 --- /dev/null +++ b/runtime/near-vm/tests/compilers/compilation.rs @@ -0,0 +1,108 @@ +use wasmer::*; +use wasmer_engine::{Engine, Executable}; +use wasmer_engine_universal::Universal; +use wasmer_vm::Artifact; + +fn slow_to_compile_contract(n_fns: usize, n_locals: usize) -> Vec { + let fns = format!("(func (local {}))\n", "i32 ".repeat(n_locals)).repeat(n_fns); + let wat = format!(r#"(module {} (func (export "main")))"#, fns); + wat2wasm(wat.as_bytes()).unwrap().to_vec() +} + +fn compile_uncached<'a>( + store: &'a Store, + engine: &'a dyn Engine, + code: &'a [u8], + time: bool, +) -> Result, CompileError> { + use std::time::Instant; + let now = Instant::now(); + engine.validate(code)?; + let validate = now.elapsed().as_millis(); + let now = Instant::now(); + let res = engine.compile(code, store.tunables()); + let compile = now.elapsed().as_millis(); + if time { + println!("validate {}ms compile {}ms", validate, compile); + } + res +} + +#[test] +#[ignore] +fn compilation_test() { + let compiler = Singlepass::default(); + let engine = Universal::new(compiler).engine(); + let store = Store::new(&engine); + for factor in 1..1000 { + let code = slow_to_compile_contract(3, 25 * factor); + match compile_uncached(&store, &engine, &code, false) { + Ok(art) => { + let serialized = art.serialize().unwrap(); + println!( + "{}: artifact is compiled, size is {}", + factor, + serialized.len() + ); + } + Err(err) => { + println!("err is {:?}", err); + } + } + } +} + +/* +Code to create perf map. + +fn write_perf_profiler_map(functions: &Vec) -> Result<(), Box>{ + let pid = process::id(); + let filename = format!("/tmp/perf-{}.map", pid); + let mut file = File::create(filename).expect("Unable to create file"); + for f in functions { + file.write_fmt(format_args!("{:x} {:x} {}\n", f.address, f.size, f.name))?; + } + Ok(()) +} +*/ + +#[test] +fn profiling() { + let wat = r#" + (import "env" "impf" (func)) + (func $f0) + (func (export "f1")) + (func (export "f2")) + (func (export "f3")) + "#; + let wasm = wat2wasm(wat.as_bytes()).unwrap(); + let compiler = Singlepass::default(); + let engine = Universal::new(compiler).engine(); + let store = Store::new(&engine); + match compile_uncached(&store, &engine, &wasm, false) { + Ok(art) => unsafe { + let serialized = art.serialize().unwrap(); + let executable = + wasmer_engine_universal::UniversalExecutableRef::deserialize(&serialized).unwrap(); + let artifact = engine.load_universal_executable_ref(&executable).unwrap(); + let info = artifact + .functions() + .iter() + .filter_map(|(idx, _)| { + let extent = artifact.function_extent(idx)?; + let idx = artifact.import_counts().function_index(idx); + let name = executable.function_name(idx)?; + Some((name, extent)) + }) + .collect::>(); + assert_eq!(4, info.len()); + assert_eq!("f0", info[0].0); + assert_eq!("f1", info[1].0); + assert_eq!("f2", info[2].0); + assert_eq!("f3", info[3].0); + }, + Err(_) => { + assert!(false) + } + } +} diff --git a/runtime/near-vm/tests/compilers/config.rs b/runtime/near-vm/tests/compilers/config.rs new file mode 100644 index 00000000000..a5e3b5d77c2 --- /dev/null +++ b/runtime/near-vm/tests/compilers/config.rs @@ -0,0 +1,101 @@ +use wasmer::{CompilerConfig, Engine as WasmerEngine, Features, Store}; + +#[derive(Clone, Debug, PartialEq)] +pub enum Compiler { + Singlepass, +} + +#[derive(Clone, Debug, PartialEq)] +pub enum Engine { + Dylib, + Universal, +} + +#[derive(Clone)] +pub struct Config { + pub compiler: Compiler, + pub engine: Engine, + pub features: Option, + pub canonicalize_nans: bool, +} + +impl Config { + pub fn new(engine: Engine, compiler: Compiler) -> Self { + Self { + compiler, + engine, + features: None, + canonicalize_nans: false, + } + } + + pub fn set_features(&mut self, features: Features) { + self.features = Some(features); + } + + pub fn set_nan_canonicalization(&mut self, canonicalize_nans: bool) { + self.canonicalize_nans = canonicalize_nans; + } + + pub fn store(&self) -> Store { + let compiler_config = self.compiler_config(self.canonicalize_nans); + let engine = self.engine(compiler_config); + Store::new(&*engine) + } + + pub fn headless_store(&self) -> Store { + let engine = self.engine_headless(); + Store::new(&*engine) + } + + pub fn engine(&self, compiler_config: Box) -> Box { + #[cfg(not(feature = "engine"))] + compile_error!("Plese enable at least one engine via the features"); + match &self.engine { + #[cfg(feature = "universal")] + Engine::Universal => { + let mut engine = wasmer_engine_universal::Universal::new(compiler_config); + if let Some(ref features) = self.features { + engine = engine.features(features.clone()) + } + Box::new(engine.engine()) + } + #[allow(unreachable_patterns)] + engine => panic!( + "The {:?} Engine is not enabled. Please enable it using the features", + engine + ), + } + } + + pub fn engine_headless(&self) -> Box { + match &self.engine { + #[cfg(feature = "universal")] + Engine::Universal => Box::new(wasmer_engine_universal::Universal::headless().engine()), + #[allow(unreachable_patterns)] + engine => panic!( + "The {:?} Engine is not enabled. Please enable it using the features", + engine + ), + } + } + + pub fn compiler_config(&self, canonicalize_nans: bool) -> Box { + match &self.compiler { + #[cfg(feature = "singlepass")] + Compiler::Singlepass => { + let mut compiler = wasmer_compiler_singlepass::Singlepass::new(); + compiler.canonicalize_nans(canonicalize_nans); + compiler.enable_verifier(); + Box::new(compiler) + } + #[allow(unreachable_patterns)] + compiler => { + panic!( + "The {:?} Compiler is not enabled. Enable it via the features", + compiler + ) + } + } + } +} diff --git a/runtime/near-vm/tests/compilers/deterministic.rs b/runtime/near-vm/tests/compilers/deterministic.rs new file mode 100644 index 00000000000..70adc895217 --- /dev/null +++ b/runtime/near-vm/tests/compilers/deterministic.rs @@ -0,0 +1,48 @@ +use anyhow::Result; +use wasmer::{wat2wasm, BaseTunables, Engine}; +use wasmer_compiler_singlepass::Singlepass; +use wasmer_engine_universal::Universal; + +fn compile_and_compare(wasm: &[u8]) -> Result<()> { + let compiler = Singlepass::default(); + let engine = Universal::new(compiler).engine(); + let tunables = BaseTunables::for_target(engine.target()); + + // compile for first time + let executable = engine.compile(wasm, &tunables).unwrap(); + let serialized1 = executable.serialize().unwrap(); + + // compile for second time + let executable = engine.compile(wasm, &tunables).unwrap(); + let serialized2 = executable.serialize().unwrap(); + + assert_eq!(serialized1, serialized2); + + Ok(()) +} + +#[test] +fn deterministic_empty() -> Result<()> { + let wasm_bytes = wat2wasm( + br#" + (module) + "#, + )?; + + compile_and_compare(&wasm_bytes) +} + +#[test] +fn deterministic_table() -> Result<()> { + let wasm_bytes = wat2wasm( + br#" +(module + (table 2 funcref) + (func $f1) + (func $f2) + (elem (i32.const 0) $f1 $f2)) +"#, + )?; + + compile_and_compare(&wasm_bytes) +} diff --git a/runtime/near-vm/tests/compilers/fast_gas_metering.rs b/runtime/near-vm/tests/compilers/fast_gas_metering.rs new file mode 100644 index 00000000000..76e531bba09 --- /dev/null +++ b/runtime/near-vm/tests/compilers/fast_gas_metering.rs @@ -0,0 +1,308 @@ +use std::ptr; +use std::sync::atomic::AtomicUsize; +use std::sync::atomic::Ordering::SeqCst; +use wasmer::*; +use wasmer_compiler_singlepass::Singlepass; +use wasmer_engine_universal::Universal; +use wasmer_types::{FastGasCounter, InstanceConfig}; + +fn get_module_with_start(store: &Store) -> Module { + let wat = r#" + (import "host" "func" (func)) + (import "host" "gas" (func (param i32))) + (memory $mem 1) + (export "memory" (memory $mem)) + (export "bar" (func $bar)) + (func $foo + call 0 + i32.const 42 + call 1 + call 0 + i32.const 100 + call 1 + call 0 + ) + (func $bar + call 0 + i32.const 100 + call 1 + ) + (start $foo) + "#; + + Module::new(&store, &wat).unwrap() +} + +fn get_module(store: &Store) -> Module { + let wat = r#" + (import "host" "func" (func)) + (import "host" "has" (func (param i32))) + (import "host" "gas" (func (param i32))) + (memory $mem 1) + (export "memory" (memory $mem)) + (func (export "foo") + call 0 + i32.const 442 + call 1 + i32.const 42 + call 2 + call 0 + i32.const 100 + call 2 + call 0 + ) + (func (export "bar") (local i32 i32) + call 0 + i32.const 100 + call 2 + ) + (func (export "zoo") + loop + i32.const 1_000_000_000 + call 2 + br 0 + end + ) + "#; + + Module::new(&store, &wat).unwrap() +} + +fn get_module_tricky_arg(store: &Store) -> Module { + let wat = r#" + (import "host" "func" (func)) + (import "host" "gas" (func (param i32))) + (memory $mem 1) + (export "memory" (memory $mem)) + (func $get_gas (param i32) (result i32) + i32.const 1 + get_local 0 + i32.add) + (func (export "foo") + i32.const 1000000000 + call $get_gas + call 1 + ) + (func (export "zoo") + i32.const -2 + call 1 + ) + "#; + + Module::new(&store, &wat).unwrap() +} + +fn get_store(regular_op_cost: u64) -> Store { + let compiler = Singlepass::default(); + let engine = Universal::new(compiler).engine(); + let mut tunables = BaseTunables::for_target(engine.target()); + tunables.set_regular_op_cost(regular_op_cost); + let store = Store::new_with_tunables(&engine, tunables); + store +} + +#[test] +fn test_gas_intrinsic_in_start() { + let store = get_store(0); + let mut gas_counter = FastGasCounter::new(100); + let module = get_module_with_start(&store); + static HITS: AtomicUsize = AtomicUsize::new(0); + let result = Instance::new_with_config( + &module, + unsafe { InstanceConfig::default().with_counter(ptr::addr_of_mut!(gas_counter)) }, + &imports! { + "host" => { + "func" => Function::new(&store, FunctionType::new(vec![], vec![]), |_values| { + HITS.fetch_add(1, SeqCst); + Ok(vec![]) + }), + "gas" => Function::new(&store, FunctionType::new(vec![ValType::I32], vec![]), |_| { + // It shall be never called, as call is intrinsified. + assert!(false); + Ok(vec![]) + }), + }, + }, + ); + assert!(result.is_err()); + match result { + Err(InstantiationError::Start(runtime_error)) => { + assert_eq!(runtime_error.message(), "gas limit exceeded") + } + _ => assert!(false), + } + // Ensure "func" was called twice. + assert_eq!(HITS.swap(0, SeqCst), 2); + // Ensure gas was partially spent. + assert_eq!(gas_counter.burnt(), 142); + assert_eq!(gas_counter.gas_limit, 100); +} + +fn test_gas_regular(opcode_cost: u64) { + let store = get_store(opcode_cost); + let mut gas_counter = FastGasCounter::new(200 + 11 * opcode_cost); + let module = get_module(&store); + let hits = std::sync::Arc::new(AtomicUsize::new(0)); + let instance = Instance::new_with_config( + &module, + unsafe { InstanceConfig::default().with_counter(ptr::addr_of_mut!(gas_counter)) }, + &imports! { + "host" => { + "func" => Function::new(&store, FunctionType::new(vec![], vec![]), { + let hits = hits.clone(); + move |_values| { + hits.fetch_add(1, SeqCst); + Ok(vec![]) + } + }), + "has" => Function::new(&store, FunctionType::new(vec![ValType::I32], vec![]), { + let hits = hits.clone(); + move |_| { + hits.fetch_add(1, SeqCst); + Ok(vec![]) + } + }), + "gas" => Function::new(&store, FunctionType::new(vec![ValType::I32], vec![]), |_| { + // It shall be never called, as call is intrinsified. + assert!(false); + Ok(vec![]) + }), + }, + }, + ); + assert!(instance.is_ok()); + let instance = instance.unwrap(); + let foo_func = instance + .lookup_function("foo") + .expect("expected function foo"); + let bar_func = instance + .lookup_function("bar") + .expect("expected function bar"); + let zoo_func = instance + .lookup_function("zoo") + .expect("expected function zoo"); + // Ensure "func" was not called. + assert_eq!(hits.load(SeqCst), 0); + let e = bar_func.call(&[]); + assert!(e.is_ok()); + // Ensure "func" was called. + assert_eq!(hits.load(SeqCst), 1); + assert_eq!(gas_counter.burnt(), 100 + 3 * opcode_cost); + let _e = foo_func.call(&[]).err().expect("error calling function"); + // Ensure "func" and "has" was called again. + assert_eq!(hits.load(SeqCst), 4); + assert_eq!(gas_counter.burnt(), 242 + 11 * opcode_cost); + // Finally try to exhaust rather large limit + if opcode_cost == 0 { + gas_counter.gas_limit = 1_000_000_000_000_000; + let _e = zoo_func.call(&[]).err().expect("error calling function"); + assert_eq!(gas_counter.burnt(), 1_000_000_000_000_242); + } +} + +#[test] +fn test_gas_intrinsic_regular() { + test_gas_regular(0); +} + +#[test] +fn test_gas_accounting_regular() { + test_gas_regular(3); +} + +#[test] +fn test_gas_intrinsic_default() { + let store = get_store(0); + let module = get_module(&store); + static HITS: AtomicUsize = AtomicUsize::new(0); + let instance = Instance::new( + &module, + &imports! { + "host" => { + "func" => Function::new(&store, FunctionType::new(vec![], vec![]), |_values| { + HITS.fetch_add(1, SeqCst); + Ok(vec![]) + }), + "has" => Function::new(&store, FunctionType::new(vec![ValType::I32], vec![]), |_| { + HITS.fetch_add(1, SeqCst); + Ok(vec![]) + }), + "gas" => Function::new(&store, FunctionType::new(vec![ValType::I32], vec![]), |_| { + // It shall be never called, as call is intrinsified. + assert!(false); + Ok(vec![]) + }), + }, + }, + ); + assert!(instance.is_ok()); + let instance = instance.unwrap(); + let foo_func = instance + .lookup_function("foo") + .expect("expected function foo"); + let bar_func = instance + .lookup_function("bar") + .expect("expected function bar"); + // Ensure "func" was called. + assert_eq!(HITS.load(SeqCst), 0); + let e = bar_func.call(&[]); + assert!(e.is_ok()); + // Ensure "func" was called. + assert_eq!(HITS.load(SeqCst), 1); + let _e = foo_func.call(&[]); + // Ensure "func" and "has" was called. + assert_eq!(HITS.load(SeqCst), 5); +} + +#[test] +fn test_gas_intrinsic_tricky() { + let store = get_store(0); + let module = get_module_tricky_arg(&store); + static BURNT_GAS: AtomicUsize = AtomicUsize::new(0); + static HITS: AtomicUsize = AtomicUsize::new(0); + let instance = Instance::new( + &module, + &imports! { + "host" => { + "func" => Function::new(&store, FunctionType::new(vec![], vec![]), |_values| { + HITS.fetch_add(1, SeqCst); + Ok(vec![]) + }), + "gas" => Function::new(&store, FunctionType::new(vec![ValType::I32], vec![]), |arg| { + // It shall be called, as tricky call is not intrinsified. + HITS.fetch_add(1, SeqCst); + match arg[0] { + Value::I32(arg) => { + BURNT_GAS.fetch_add(arg as usize, SeqCst); + }, + _ => { + assert!(false) + } + } + Ok(vec![]) + }), + }, + }, + ); + assert!(instance.is_ok()); + let instance = instance.unwrap(); + let foo_func = instance + .lookup_function("foo") + .expect("expected function foo"); + + let _e = foo_func.call(&[]); + + assert_eq!(BURNT_GAS.load(SeqCst), 1000000001); + // Ensure "gas" was called. + assert_eq!(HITS.load(SeqCst), 1); + + let zoo_func = instance + .lookup_function("zoo") + .expect("expected function zoo"); + + let _e = zoo_func.call(&[]); + // We decremented gas by two. + assert_eq!(BURNT_GAS.load(SeqCst), 999999999); + // Ensure "gas" was called. + assert_eq!(HITS.load(SeqCst), 2); +} diff --git a/runtime/near-vm/tests/compilers/imports.rs b/runtime/near-vm/tests/compilers/imports.rs new file mode 100644 index 00000000000..c8561278668 --- /dev/null +++ b/runtime/near-vm/tests/compilers/imports.rs @@ -0,0 +1,483 @@ +//! Testing the imports with different provided functions. +//! This tests checks that the provided functions (both native and +//! dynamic ones) work properly. + +use anyhow::Result; +use std::convert::Infallible; +use std::sync::atomic::AtomicBool; +use std::sync::{ + atomic::{AtomicUsize, Ordering::SeqCst}, + Arc, +}; +use wasmer::*; + +fn get_module(store: &Store) -> Result { + let wat = r#" + (import "host" "0" (func)) + (import "host" "1" (func (param i32) (result i32))) + (import "host" "2" (func (param i32) (param i64))) + (import "host" "3" (func (param i32 i64 i32 f32 f64))) + (memory $mem 1) + (export "memory" (memory $mem)) + + (func $foo + call 0 + i32.const 0 + call 1 + i32.const 1 + i32.add + i64.const 3 + call 2 + + i32.const 100 + i64.const 200 + i32.const 300 + f32.const 400 + f64.const 500 + call 3 + ) + (start $foo) + "#; + + let module = Module::new(&store, &wat)?; + Ok(module) +} + +#[compiler_test(imports)] +#[serial_test::serial(dynamic_function)] +fn dynamic_function(config: crate::Config) -> Result<()> { + let store = config.store(); + let module = get_module(&store)?; + static HITS: AtomicUsize = AtomicUsize::new(0); + Instance::new( + &module, + &imports! { + "host" => { + "0" => Function::new(&store, FunctionType::new(vec![], vec![]), |_values| { + assert_eq!(HITS.fetch_add(1, SeqCst), 0); + Ok(vec![]) + }), + "1" => Function::new(&store, FunctionType::new(vec![ValType::I32], vec![ValType::I32]), |values| { + assert_eq!(values[0], Value::I32(0)); + assert_eq!(HITS.fetch_add(1, SeqCst), 1); + Ok(vec![Value::I32(1)]) + }), + "2" => Function::new(&store, FunctionType::new(vec![ValType::I32, ValType::I64], vec![]), |values| { + assert_eq!(values[0], Value::I32(2)); + assert_eq!(values[1], Value::I64(3)); + assert_eq!(HITS.fetch_add(1, SeqCst), 2); + Ok(vec![]) + }), + "3" => Function::new(&store, FunctionType::new(vec![ValType::I32, ValType::I64, ValType::I32, ValType::F32, ValType::F64], vec![]), |values| { + assert_eq!(values[0], Value::I32(100)); + assert_eq!(values[1], Value::I64(200)); + assert_eq!(values[2], Value::I32(300)); + assert_eq!(values[3], Value::F32(400.0)); + assert_eq!(values[4], Value::F64(500.0)); + assert_eq!(HITS.fetch_add(1, SeqCst), 3); + Ok(vec![]) + }), + }, + }, + )?; + assert_eq!(HITS.swap(0, SeqCst), 4); + Ok(()) +} + +#[compiler_test(imports)] +fn dynamic_function_with_env(config: crate::Config) -> Result<()> { + let store = config.store(); + let module = get_module(&store)?; + + #[derive(Clone)] + struct Env { + counter: Arc, + } + impl WasmerEnv for Env {} + + impl std::ops::Deref for Env { + type Target = Arc; + fn deref(&self) -> &Self::Target { + &self.counter + } + } + + let env: Env = Env { + counter: Arc::new(AtomicUsize::new(0)), + }; + Instance::new( + &module, + &imports! { + "host" => { + "0" => Function::new_with_env(&store, FunctionType::new(vec![], vec![]), env.clone(), |env, _values| { + assert_eq!(env.fetch_add(1, SeqCst), 0); + Ok(vec![]) + }), + "1" => Function::new_with_env(&store, FunctionType::new(vec![ValType::I32], vec![ValType::I32]), env.clone(), |env, values| { + assert_eq!(values[0], Value::I32(0)); + assert_eq!(env.fetch_add(1, SeqCst), 1); + Ok(vec![Value::I32(1)]) + }), + "2" => Function::new_with_env(&store, FunctionType::new(vec![ValType::I32, ValType::I64], vec![]), env.clone(), |env, values| { + assert_eq!(values[0], Value::I32(2)); + assert_eq!(values[1], Value::I64(3)); + assert_eq!(env.fetch_add(1, SeqCst), 2); + Ok(vec![]) + }), + "3" => Function::new_with_env(&store, FunctionType::new(vec![ValType::I32, ValType::I64, ValType::I32, ValType::F32, ValType::F64], vec![]), env.clone(), |env, values| { + assert_eq!(values[0], Value::I32(100)); + assert_eq!(values[1], Value::I64(200)); + assert_eq!(values[2], Value::I32(300)); + assert_eq!(values[3], Value::F32(400.0)); + assert_eq!(values[4], Value::F64(500.0)); + assert_eq!(env.fetch_add(1, SeqCst), 3); + Ok(vec![]) + }), + }, + }, + )?; + assert_eq!(env.load(SeqCst), 4); + Ok(()) +} + +#[compiler_test(imports)] +#[serial_test::serial(static_function)] +fn static_function(config: crate::Config) -> Result<()> { + let store = config.store(); + let module = get_module(&store)?; + + static HITS: AtomicUsize = AtomicUsize::new(0); + Instance::new( + &module, + &imports! { + "host" => { + "0" => Function::new_native(&store, || { + assert_eq!(HITS.fetch_add(1, SeqCst), 0); + }), + "1" => Function::new_native(&store, |x: i32| -> i32 { + assert_eq!(x, 0); + assert_eq!(HITS.fetch_add(1, SeqCst), 1); + 1 + }), + "2" => Function::new_native(&store, |x: i32, y: i64| { + assert_eq!(x, 2); + assert_eq!(y, 3); + assert_eq!(HITS.fetch_add(1, SeqCst), 2); + }), + "3" => Function::new_native(&store, |a: i32, b: i64, c: i32, d: f32, e: f64| { + assert_eq!(a, 100); + assert_eq!(b, 200); + assert_eq!(c, 300); + assert_eq!(d, 400.0); + assert_eq!(e, 500.0); + assert_eq!(HITS.fetch_add(1, SeqCst), 3); + }), + }, + }, + )?; + assert_eq!(HITS.swap(0, SeqCst), 4); + Ok(()) +} + +#[compiler_test(imports)] +#[serial_test::serial(static_function_with_results)] +fn static_function_with_results(config: crate::Config) -> Result<()> { + let store = config.store(); + let module = get_module(&store)?; + + static HITS: AtomicUsize = AtomicUsize::new(0); + Instance::new( + &module, + &imports! { + "host" => { + "0" => Function::new_native(&store, || { + assert_eq!(HITS.fetch_add(1, SeqCst), 0); + }), + "1" => Function::new_native(&store, |x: i32| -> Result { + assert_eq!(x, 0); + assert_eq!(HITS.fetch_add(1, SeqCst), 1); + Ok(1) + }), + "2" => Function::new_native(&store, |x: i32, y: i64| { + assert_eq!(x, 2); + assert_eq!(y, 3); + assert_eq!(HITS.fetch_add(1, SeqCst), 2); + }), + "3" => Function::new_native(&store, |a: i32, b: i64, c: i32, d: f32, e: f64| { + assert_eq!(a, 100); + assert_eq!(b, 200); + assert_eq!(c, 300); + assert_eq!(d, 400.0); + assert_eq!(e, 500.0); + assert_eq!(HITS.fetch_add(1, SeqCst), 3); + }), + }, + }, + )?; + assert_eq!(HITS.swap(0, SeqCst), 4); + Ok(()) +} + +#[compiler_test(imports)] +fn static_function_with_env(config: crate::Config) -> Result<()> { + let store = config.store(); + let module = get_module(&store)?; + + #[derive(Clone)] + struct Env(Arc); + impl WasmerEnv for Env {} + + impl std::ops::Deref for Env { + type Target = Arc; + fn deref(&self) -> &Self::Target { + &self.0 + } + } + + let env: Env = Env(Arc::new(AtomicUsize::new(0))); + Instance::new( + &module, + &imports! { + "host" => { + "0" => Function::new_native_with_env(&store, env.clone(), |env: &Env| { + assert_eq!(env.fetch_add(1, SeqCst), 0); + }), + "1" => Function::new_native_with_env(&store, env.clone(), |env: &Env, x: i32| -> i32 { + assert_eq!(x, 0); + assert_eq!(env.fetch_add(1, SeqCst), 1); + 1 + }), + "2" => Function::new_native_with_env(&store, env.clone(), |env: &Env, x: i32, y: i64| { + assert_eq!(x, 2); + assert_eq!(y, 3); + assert_eq!(env.fetch_add(1, SeqCst), 2); + }), + "3" => Function::new_native_with_env(&store, env.clone(), |env: &Env, a: i32, b: i64, c: i32, d: f32, e: f64| { + assert_eq!(a, 100); + assert_eq!(b, 200); + assert_eq!(c, 300); + assert_eq!(d, 400.0); + assert_eq!(e, 500.0); + assert_eq!(env.fetch_add(1, SeqCst), 3); + }), + }, + }, + )?; + assert_eq!(env.load(SeqCst), 4); + Ok(()) +} + +#[compiler_test(imports)] +fn static_function_that_fails(config: crate::Config) -> Result<()> { + let store = config.store(); + let wat = r#" + (import "host" "0" (func)) + + (func $foo + call 0 + ) + (start $foo) + "#; + + let module = Module::new(&store, &wat)?; + + let result = Instance::new( + &module, + &imports! { + "host" => { + "0" => Function::new_native(&store, || -> Result { + Err(RuntimeError::new("oops")) + }), + }, + }, + ); + + assert!(result.is_err()); + + match result { + Err(InstantiationError::Start(runtime_error)) => { + assert_eq!(runtime_error.message(), "oops") + } + _ => assert!(false), + } + + Ok(()) +} + +fn get_module2(store: &Store) -> Result { + let wat = r#" + (import "host" "fn" (func)) + (memory $mem 1) + (export "memory" (memory $mem)) + (export "main" (func $main)) + (func $main (param) (result) + (call 0)) + "#; + + let module = Module::new(&store, &wat)?; + Ok(module) +} + +#[compiler_test(imports)] +fn dynamic_function_with_env_wasmer_env_init_works(config: crate::Config) -> Result<()> { + let store = config.store(); + let module = get_module2(&store)?; + + #[allow(dead_code)] + #[derive(Clone)] + struct Env { + memory: Memory, + } + impl WasmerEnv for Env {} + + let env: Env = Env { + memory: Memory::new( + &store, + MemoryType { + minimum: 0.into(), + maximum: None, + shared: false, + }, + )?, + }; + let function_fn = Function::new_with_env( + &store, + FunctionType::new(vec![], vec![]), + env.clone(), + |env, _values| Ok(vec![]), + ); + let instance = Instance::new( + &module, + &imports! { + "host" => { + "fn" => function_fn, + }, + }, + )?; + let f: NativeFunc<(), ()> = instance.get_native_function("main")?; + f.call()?; + Ok(()) +} + +static REGRESSION_IMPORT_TRAMPOLINES: &str = r#"(module + (type (;0;) (func)) + (type (;1;) (func (param i32))) + (import "env" "panic" (func (;0;) (type 0))) + (import "env" "gas" (func (;1;) (type 1))) + (export "panic" (func 0)) + (export "gas" (func 1)) +)"#; + +#[compiler_test(imports)] +fn regression_import_trampolines(config: crate::Config) -> Result<()> { + let store = config.store(); + let module = Module::new(&store, ®RESSION_IMPORT_TRAMPOLINES)?; + let panic = Function::new_native(&store, || ()); + static GAS_CALLED: AtomicBool = AtomicBool::new(false); + let gas = Function::new_native(&store, |p: i32| { + GAS_CALLED.store(true, SeqCst); + assert_eq!(p, 42) + }); + let imports = imports! { + "env" => { + "panic" => panic, + "gas" => gas, + } + }; + let instance = Instance::new(&module, &imports)?; + let panic = instance.lookup_function("panic").unwrap(); + panic.call(&[])?; + let gas = instance.lookup_function("gas").unwrap(); + gas.call(&[Value::I32(42)])?; + assert_eq!(GAS_CALLED.load(SeqCst), true); + Ok(()) +} + +// TODO(0-copy): no longer possible to get references to exported entities other than functions +// (we don't need that functionality) +// #[compiler_test(imports)] +// fn multi_use_host_fn_manages_memory_correctly(config: crate::Config) -> Result<()> { +// let store = config.store(); +// let module = get_module2(&store)?; +// +// #[allow(dead_code)] +// #[derive(Clone)] +// struct Env { +// memory: LazyInit, +// } +// +// impl WasmerEnv for Env { +// fn init_with_instance(&mut self, instance: &Instance) -> Result<(), HostEnvInitError> { +// let memory = instance.exports.get_memory("memory")?.clone(); +// self.memory.initialize(memory); +// Ok(()) +// } +// } +// +// let env: Env = Env { +// memory: LazyInit::default(), +// }; +// fn host_fn(env: &Env) { +// assert!(env.memory.get_ref().is_some()); +// println!("Hello, world!"); +// } +// +// let imports = imports! { +// "host" => { +// "fn" => Function::new_native_with_env(&store, env.clone(), host_fn), +// }, +// }; +// let instance1 = Instance::new(&module, &imports)?; +// let instance2 = Instance::new(&module, &imports)?; +// { +// let f1: NativeFunc<(), ()> = instance1.get_native_function("main")?; +// f1.call()?; +// } +// drop(instance1); +// { +// let f2: NativeFunc<(), ()> = instance2.get_native_function("main")?; +// f2.call()?; +// } +// drop(instance2); +// Ok(()) +// } +// +// #[compiler_test(imports)] +// fn instance_local_memory_lifetime(config: crate::Config) -> Result<()> { +// let store = config.store(); +// +// let memory: Memory = { +// let wat = r#"(module +// (memory $mem 1) +// (export "memory" (memory $mem)) +// )"#; +// let module = Module::new(&store, wat)?; +// let instance = Instance::new(&module, &imports! {})?; +// instance.exports.get_memory("memory")?.clone() +// }; +// +// let wat = r#"(module +// (import "env" "memory" (memory $mem 1) ) +// (func $get_at (type $get_at_t) (param $idx i32) (result i32) +// (i32.load (local.get $idx))) +// (type $get_at_t (func (param i32) (result i32))) +// (type $set_at_t (func (param i32) (param i32))) +// (func $set_at (type $set_at_t) (param $idx i32) (param $val i32) +// (i32.store (local.get $idx) (local.get $val))) +// (export "get_at" (func $get_at)) +// (export "set_at" (func $set_at)) +// )"#; +// let module = Module::new(&store, wat)?; +// let imports = imports! { +// "env" => { +// "memory" => memory, +// }, +// }; +// let instance = Instance::new(&module, &imports)?; +// let set_at: NativeFunc<(i32, i32), ()> = instance.get_native_function("set_at")?; +// let get_at: NativeFunc = instance.get_native_function("get_at")?; +// set_at.call(200, 123)?; +// assert_eq!(get_at.call(200)?, 123); +// +// Ok(()) +// } diff --git a/runtime/near-vm/tests/compilers/issues.rs b/runtime/near-vm/tests/compilers/issues.rs new file mode 100644 index 00000000000..dda449faa01 --- /dev/null +++ b/runtime/near-vm/tests/compilers/issues.rs @@ -0,0 +1,112 @@ +//! This file is mainly to assure specific issues are working well +use anyhow::Result; +use wasmer::*; + +#[derive(Clone)] +struct Env { + memory: LazyInit, +} + +impl WasmerEnv for Env {} + +/// Corruption of WasmerEnv when using call indirect. +/// +/// Note: this one is specific to Singlepass, but we want to test in all +/// available compilers. +/// +/// https://github.com/wasmerio/wasmer/issues/2329 +#[compiler_test(issues)] +fn issue_2329(mut config: crate::Config) -> Result<()> { + let store = config.store(); + + fn read_memory(env: &Env, guest_ptr: u32) -> u32 { + dbg!(env.memory.get_ref()); + dbg!(guest_ptr); + 0 + } + + let wat = r#" + (module + (type (;0;) (func (param i32) (result i32))) + (type (;1;) (func)) + (type (;2;) (func (param i32 i32) (result i32))) + (import "env" "__read_memory" (func $__read_memory (type 0))) + (func $read_memory (type 1) + (drop + (call $_ZN5other8dispatch17h053cb34ef5d0d7b0E + (i32.const 1) + (i32.const 2))) + (drop + (call $__read_memory + (i32.const 1)))) + (func $_ZN5other8dispatch17h053cb34ef5d0d7b0E (type 2) (param i32 i32) (result i32) + (call_indirect (type 0) + (local.get 1) + (local.get 0))) + (table (;0;) 2 2 funcref) + (memory (;0;) 16) + (global (;0;) (mut i32) (i32.const 1048576)) + (global (;1;) i32 (i32.const 1048576)) + (global (;2;) i32 (i32.const 1048576)) + (export "memory" (memory 0)) + (export "read_memory" (func $read_memory)) + (export "__data_end" (global 1)) + (export "__heap_base" (global 2)) + (elem (;0;) (i32.const 1) func $__read_memory)) + "#; + let module = Module::new(&store, wat)?; + let env = Env { + memory: LazyInit::new(), + }; + let imports: ImportObject = imports! { + "env" => { + "__read_memory" => Function::new_native_with_env( + &store, + env, + read_memory + ), + } + }; + let instance = Instance::new(&module, &imports)?; + instance.lookup_function("read_memory").unwrap().call(&[])?; + Ok(()) +} + +/// Exhaustion of GPRs when calling a function with many floating point arguments +/// +/// Note: this one is specific to Singlepass, but we want to test in all +/// available compilers. +#[compiler_test(issues)] +fn regression_gpr_exhaustion_for_calls(mut config: crate::Config) -> Result<()> { + let store = config.store(); + let wat = r#" + (module + (type (;0;) (func (param f64) (result i32))) + (type (;1;) (func (param f64 f64 f64 f64 f64 f64))) + (func (;0;) (type 0) (param f64) (result i32) + local.get 0 + local.get 0 + local.get 0 + local.get 0 + f64.const 0 + f64.const 0 + f64.const 0 + f64.const 0 + f64.const 0 + f64.const 0 + f64.const 0 + i32.const 0 + call_indirect (type 0) + call_indirect (type 1) + drop + drop + drop + drop + i32.const 0) + (table (;0;) 1 1 funcref)) + "#; + let module = Module::new(&store, wat)?; + let imports: ImportObject = imports! {}; + let instance = Instance::new(&module, &imports)?; + Ok(()) +} diff --git a/runtime/near-vm/tests/compilers/main.rs b/runtime/near-vm/tests/compilers/main.rs new file mode 100644 index 00000000000..6378ef7bd38 --- /dev/null +++ b/runtime/near-vm/tests/compilers/main.rs @@ -0,0 +1,21 @@ +//! This test suite does all the tests that involve any compiler +//! implementation, such as: singlepass. + +#[macro_use] +extern crate compiler_test_derive; + +mod config; +mod deterministic; +mod fast_gas_metering; +mod imports; +mod issues; +// mod multi_value_imports; +mod compilation; +mod native_functions; +mod serialize; +mod stack_limiter; +mod traps; +mod wast; + +pub use crate::config::{Compiler, Config, Engine}; +pub use crate::wast::run_wast; diff --git a/runtime/near-vm/tests/compilers/multi_value_imports.rs b/runtime/near-vm/tests/compilers/multi_value_imports.rs new file mode 100644 index 00000000000..d260bc0635d --- /dev/null +++ b/runtime/near-vm/tests/compilers/multi_value_imports.rs @@ -0,0 +1,205 @@ +//! Testing the imports with different provided functions. +//! This tests checks that the provided functions (both native and +//! dynamic ones) work properly. + +use wasmer::*; + +macro_rules! mvr_test { + ($test_name:ident, $( $result_type:ty ),* ) => { + mod $test_name { + use wasmer::*; + + fn get_module(store: &Store) -> anyhow::Result { + let wat: String = r#" + (type $type (func (param i32) (result +"#.to_string() + + &stringify!( $( $result_type ),* ).replace(",", "").replace("(", "").replace(")", "") + &r#"))) + (import "host" "callback_fn" (func $callback_fn (type $type))) + (func (export "test_call") (type $type) + get_local 0 + call $callback_fn) + (func (export "test_call_indirect") (type $type) + (i32.const 1) + (call_indirect (type $type) (i32.const 0)) + ) + (table funcref + (elem + $callback_fn + ) + ) +"#.to_string(); + Ok(wasmer::Module::new(&store, &wat)?) + } + + fn callback_fn(n: i32) -> ( $( $result_type ),* ) { + ( $( <$result_type>::expected_value(n) ),* ) + } + + #[compiler_test(multi_value_imports)] + fn native(config: crate::Config) -> anyhow::Result<()> { + let store = config.store(); + let module = get_module(&store)?; + let instance = wasmer::Instance::new( + &module, + &wasmer::imports! { + "host" => { + "callback_fn" => wasmer::Function::new_native(&store, callback_fn) + } + } + )?; + let expected_value = vec![ $( <$result_type>::expected_val(1) ),* ].into_boxed_slice(); + assert_eq!(instance.exports.get_function("test_call")?.call(&[wasmer::Val::I32(1)])?, + expected_value); + assert_eq!(instance.exports.get_function("test_call_indirect")?.call(&[wasmer::Val::I32(1)])?, + expected_value); + Ok(()) + } + + fn dynamic_callback_fn(values: &[wasmer::Value]) -> anyhow::Result, wasmer::RuntimeError> { + assert_eq!(values[0], wasmer::Value::I32(1)); + Ok(vec![ $( <$result_type>::expected_val(1) ),* ]) + } + + #[compiler_test(multi_value_imports)] + fn dynamic(config: crate::Config) -> anyhow::Result<()> { + let store = config.store(); + let module = get_module(&store)?; + let callback_fn = wasmer::Function::new(&store, &wasmer::FunctionType::new(vec![wasmer::ValType::I32], vec![ $( <$result_type>::expected_valtype() ),* ]), dynamic_callback_fn); + let instance = wasmer::Instance::new( + &module, + &wasmer::imports! { + "host" => { + "callback_fn" => callback_fn + } + } + )?; + let expected_value = vec![ $( <$result_type>::expected_val(1) ),* ].into_boxed_slice(); + assert_eq!(instance.exports.get_function("test_call")?.call(&[wasmer::Val::I32(1)])?, + expected_value); + assert_eq!(instance.exports.get_function("test_call_indirect")?.call(&[wasmer::Val::I32(1)])?, + expected_value); + Ok(()) + } + } + } +} + +trait ExpectedExpr { + fn expected_value(n: i32) -> Self; + fn expected_val(n: i32) -> wasmer::Val; + fn expected_valtype() -> wasmer::ValType; +} +impl ExpectedExpr for i32 { + fn expected_value(n: i32) -> i32 { + n + 1 + } + fn expected_val(n: i32) -> wasmer::Val { + wasmer::Val::I32(Self::expected_value(n)) + } + fn expected_valtype() -> wasmer::ValType { + wasmer::ValType::I32 + } +} +impl ExpectedExpr for i64 { + fn expected_value(n: i32) -> i64 { + n as i64 + 2i64 + } + fn expected_val(n: i32) -> wasmer::Val { + wasmer::Val::I64(Self::expected_value(n)) + } + fn expected_valtype() -> wasmer::ValType { + wasmer::ValType::I64 + } +} +impl ExpectedExpr for f32 { + fn expected_value(n: i32) -> f32 { + n as f32 * 0.1 + } + fn expected_val(n: i32) -> wasmer::Val { + wasmer::Val::F32(Self::expected_value(n)) + } + fn expected_valtype() -> wasmer::ValType { + wasmer::ValType::F32 + } +} +impl ExpectedExpr for f64 { + fn expected_value(n: i32) -> f64 { + n as f64 * 0.12 + } + fn expected_val(n: i32) -> wasmer::Val { + wasmer::Val::F64(Self::expected_value(n)) + } + fn expected_valtype() -> wasmer::ValType { + wasmer::ValType::F64 + } +} + +mvr_test!(test_mvr_i32_i32, i32, i32); +mvr_test!(test_mvr_i32_f32, i32, f32); +mvr_test!(test_mvr_f32_i32, f32, i32); +mvr_test!(test_mvr_f32_f32, f32, f32); + +mvr_test!(test_mvr_i64_i32, i64, i32); +mvr_test!(test_mvr_i64_f32, i64, f32); +mvr_test!(test_mvr_f64_i32, f64, i32); +mvr_test!(test_mvr_f64_f32, f64, f32); + +mvr_test!(test_mvr_i32_i64, i32, i64); +mvr_test!(test_mvr_f32_i64, f32, i64); +mvr_test!(test_mvr_i32_f64, i32, f64); +mvr_test!(test_mvr_f32_f64, f32, f64); + +mvr_test!(test_mvr_i32_i32_i32, i32, i32, i32); +mvr_test!(test_mvr_i32_i32_f32, i32, i32, f32); +mvr_test!(test_mvr_i32_f32_i32, i32, f32, i32); +mvr_test!(test_mvr_i32_f32_f32, i32, f32, f32); +mvr_test!(test_mvr_f32_i32_i32, f32, i32, i32); +mvr_test!(test_mvr_f32_i32_f32, f32, i32, f32); +mvr_test!(test_mvr_f32_f32_i32, f32, f32, i32); +mvr_test!(test_mvr_f32_f32_f32, f32, f32, f32); + +mvr_test!(test_mvr_i32_i32_i64, i32, i32, i64); +mvr_test!(test_mvr_i32_f32_i64, i32, f32, i64); +mvr_test!(test_mvr_f32_i32_i64, f32, i32, i64); +mvr_test!(test_mvr_f32_f32_i64, f32, f32, i64); +mvr_test!(test_mvr_i32_i32_f64, i32, i32, f64); +mvr_test!(test_mvr_i32_f32_f64, i32, f32, f64); +mvr_test!(test_mvr_f32_i32_f64, f32, i32, f64); +mvr_test!(test_mvr_f32_f32_f64, f32, f32, f64); + +mvr_test!(test_mvr_i32_i64_i32, i32, i64, i32); +mvr_test!(test_mvr_i32_i64_f32, i32, i64, f32); +mvr_test!(test_mvr_f32_i64_i32, f32, i64, i32); +mvr_test!(test_mvr_f32_i64_f32, f32, i64, f32); +mvr_test!(test_mvr_i32_f64_i32, i32, f64, i32); +mvr_test!(test_mvr_i32_f64_f32, i32, f64, f32); +mvr_test!(test_mvr_f32_f64_i32, f32, f64, i32); +mvr_test!(test_mvr_f32_f64_f32, f32, f64, f32); + +mvr_test!(test_mvr_i64_i32_i32, i64, i32, i32); +mvr_test!(test_mvr_i64_i32_f32, i64, i32, f32); +mvr_test!(test_mvr_i64_f32_i32, i64, f32, i32); +mvr_test!(test_mvr_i64_f32_f32, i64, f32, f32); +mvr_test!(test_mvr_f64_i32_i32, f64, i32, i32); +mvr_test!(test_mvr_f64_i32_f32, f64, i32, f32); +mvr_test!(test_mvr_f64_f32_i32, f64, f32, i32); +mvr_test!(test_mvr_f64_f32_f32, f64, f32, f32); + +mvr_test!(test_mvr_i32_i32_i32_i32, i32, i32, i32, i32); +mvr_test!(test_mvr_i32_i32_i32_f32, i32, i32, i32, f32); +mvr_test!(test_mvr_i32_i32_f32_i32, i32, i32, f32, i32); +mvr_test!(test_mvr_i32_i32_f32_f32, i32, i32, f32, f32); +mvr_test!(test_mvr_i32_f32_i32_i32, i32, f32, i32, i32); +mvr_test!(test_mvr_i32_f32_i32_f32, i32, f32, i32, f32); +mvr_test!(test_mvr_i32_f32_f32_i32, i32, f32, f32, i32); +mvr_test!(test_mvr_i32_f32_f32_f32, i32, f32, f32, f32); +mvr_test!(test_mvr_f32_i32_i32_i32, f32, i32, i32, i32); +mvr_test!(test_mvr_f32_i32_i32_f32, f32, i32, i32, f32); +mvr_test!(test_mvr_f32_i32_f32_i32, f32, i32, f32, i32); +mvr_test!(test_mvr_f32_i32_f32_f32, f32, i32, f32, f32); +mvr_test!(test_mvr_f32_f32_i32_i32, f32, f32, i32, i32); +mvr_test!(test_mvr_f32_f32_i32_f32, f32, f32, i32, f32); +mvr_test!(test_mvr_f32_f32_f32_i32, f32, f32, f32, i32); +mvr_test!(test_mvr_f32_f32_f32_f32, f32, f32, f32, f32); + +mvr_test!(test_mvr_i32_i32_i32_i32_i32, i32, i32, i32, i32, i32); diff --git a/runtime/near-vm/tests/compilers/native_functions.rs b/runtime/near-vm/tests/compilers/native_functions.rs new file mode 100644 index 00000000000..44b05f750ca --- /dev/null +++ b/runtime/near-vm/tests/compilers/native_functions.rs @@ -0,0 +1,444 @@ +use anyhow::Result; +use std::convert::Infallible; +use std::sync::{Arc, Mutex}; + +use wasmer::*; + +fn long_f(a: u32, b: u32, c: u32, d: u32, e: u32, f: u16, g: u64, h: u64, i: u16, j: u32) -> u64 { + j as u64 + + i as u64 * 10 + + h * 100 + + g * 1000 + + f as u64 * 10000 + + e as u64 * 100000 + + d as u64 * 1000000 + + c as u64 * 10000000 + + b as u64 * 100000000 + + a as u64 * 1000000000 +} + +fn long_f_dynamic(values: &[Value]) -> Result, RuntimeError> { + Ok(vec![Value::I64( + values[9].unwrap_i32() as i64 + + values[8].unwrap_i32() as i64 * 10 + + values[7].unwrap_i64() * 100 + + values[6].unwrap_i64() * 1000 + + values[5].unwrap_i32() as i64 * 10000 + + values[4].unwrap_i32() as i64 * 100000 + + values[3].unwrap_i32() as i64 * 1000000 + + values[2].unwrap_i32() as i64 * 10000000 + + values[1].unwrap_i32() as i64 * 100000000 + + values[0].unwrap_i32() as i64 * 1000000000, + )]) +} + +#[compiler_test(native_functions)] +fn native_function_works_for_wasm(config: crate::Config) -> anyhow::Result<()> { + let store = config.store(); + let wat = r#"(module + (func $multiply (import "env" "multiply") (param i32 i32) (result i32)) + (func (export "add") (param i32 i32) (result i32) + (i32.add (local.get 0) + (local.get 1))) + (func (export "double_then_add") (param i32 i32) (result i32) + (i32.add (call $multiply (local.get 0) (i32.const 2)) + (call $multiply (local.get 1) (i32.const 2)))) +)"#; + let module = Module::new(&store, wat).unwrap(); + + let import_object = imports! { + "env" => { + "multiply" => Function::new_native(&store, |a: i32, b: i32| a * b), + }, + }; + + let instance = Instance::new(&module, &import_object)?; + + { + let f: NativeFunc<(i32, i32), i32> = instance.get_native_function("add")?; + let result = f.call(4, 6)?; + assert_eq!(result, 10); + } + + { + let f: Function = instance + .lookup_function("double_then_add") + .expect("lookup function"); + let result = f.call(&[Val::I32(4), Val::I32(6)])?; + assert_eq!(result[0], Val::I32(20)); + } + + { + let dyn_f: Function = instance + .lookup_function("double_then_add") + .expect("lookup function"); + let f: NativeFunc<(i32, i32), i32> = dyn_f.native().unwrap(); + let result = f.call(4, 6)?; + assert_eq!(result, 20); + } + + Ok(()) +} + +#[should_panic( + expected = "Closures (functions with captured environments) are currently unsupported with native functions. See: https://github.com/wasmerio/wasmer/issues/1840" +)] +#[compiler_test(native_functions)] +fn native_host_function_closure_panics(config: crate::Config) { + let store = config.store(); + let state = 3; + Function::new_native(&store, move |_: i32| { + println!("{}", state); + }); +} + +#[should_panic( + expected = "Closures (functions with captured environments) are currently unsupported with native functions. See: https://github.com/wasmerio/wasmer/issues/1840" +)] +#[compiler_test(native_functions)] +fn native_with_env_host_function_closure_panics(config: crate::Config) { + let store = config.store(); + let state = 3; + let env = 4; + Function::new_native_with_env(&store, env, move |_env: &i32, _: i32| { + println!("{}", state); + }); +} + +#[compiler_test(native_functions)] +fn non_native_functions_and_closures_with_no_env_work(config: crate::Config) -> anyhow::Result<()> { + let store = config.store(); + let wat = r#"(module + (func $multiply1 (import "env" "multiply1") (param i32 i32) (result i32)) + (func $multiply2 (import "env" "multiply2") (param i32 i32) (result i32)) + (func $multiply3 (import "env" "multiply3") (param i32 i32) (result i32)) + (func $multiply4 (import "env" "multiply4") (param i32 i32) (result i32)) + + (func (export "test") (param i32 i32 i32 i32 i32) (result i32) + (call $multiply4 + (call $multiply3 + (call $multiply2 + (call $multiply1 + (local.get 0) + (local.get 1)) + (local.get 2)) + (local.get 3)) + (local.get 4))) +)"#; + let module = Module::new(&store, wat).unwrap(); + + let ty = FunctionType::new(vec![Type::I32, Type::I32], vec![Type::I32]); + let env = 10; + let captured_by_closure = 20; + let import_object = imports! { + "env" => { + "multiply1" => Function::new(&store, &ty, move |args| { + if let (Value::I32(v1), Value::I32(v2)) = (&args[0], &args[1]) { + Ok(vec![Value::I32(v1 * v2 * captured_by_closure)]) + } else { + panic!("Invalid arguments"); + } + }), + "multiply2" => Function::new_with_env(&store, &ty, env, move |&env, args| { + if let (Value::I32(v1), Value::I32(v2)) = (&args[0], &args[1]) { + Ok(vec![Value::I32(v1 * v2 * captured_by_closure * env)]) + } else { + panic!("Invalid arguments"); + } + }), + "multiply3" => Function::new_native(&store, |arg1: i32, arg2: i32| -> i32 + {arg1 * arg2 }), + "multiply4" => Function::new_native_with_env(&store, env, |&env: &i32, arg1: i32, arg2: i32| -> i32 + {arg1 * arg2 * env }), + }, + }; + + let instance = Instance::new(&module, &import_object)?; + + let test: NativeFunc<(i32, i32, i32, i32, i32), i32> = instance.get_native_function("test")?; + + let result = test.call(2, 3, 4, 5, 6)?; + let manually_computed_result = 6 * (5 * (4 * (3 * 2 * 20) * 10 * 20)) * 10; + assert_eq!(result, manually_computed_result); + Ok(()) +} + +#[compiler_test(native_functions)] +fn native_function_works_for_wasm_function_manyparams(config: crate::Config) -> anyhow::Result<()> { + let store = config.store(); + let wat = r#"(module + (func $longf (import "env" "longf") (param i32 i32 i32 i32 i32 i32 i64 i64 i32 i32) (result i64)) + (func (export "longf_pure") (param i32 i32 i32 i32 i32 i32 i64 i64 i32 i32) (result i64) + (call $longf (local.get 0) (local.get 1) (local.get 2) (local.get 3) (local.get 4) (local.get 5) (local.get 6) (local.get 7) (local.get 8) (local.get 9))) + (func (export "longf") (result i64) + (call $longf (i32.const 1) (i32.const 2) (i32.const 3) (i32.const 4) (i32.const 5) (i32.const 6) (i64.const 7) (i64.const 8) (i32.const 9) (i32.const 0))) +)"#; + let module = Module::new(&store, wat).unwrap(); + + let import_object = imports! { + "env" => { + "longf" => Function::new_native(&store, long_f), + }, + }; + + let instance = Instance::new(&module, &import_object)?; + + { + let dyn_f: Function = instance.lookup_function("longf").unwrap(); + let f: NativeFunc<(), i64> = dyn_f.native().unwrap(); + let result = f.call()?; + assert_eq!(result, 1234567890); + } + + { + let dyn_f: Function = instance.lookup_function("longf_pure").unwrap(); + let f: NativeFunc<(u32, u32, u32, u32, u32, u16, u64, u64, u16, u32), i64> = + dyn_f.native().unwrap(); + let result = f.call(1, 2, 3, 4, 5, 6, 7, 8, 9, 0)?; + assert_eq!(result, 1234567890); + } + + Ok(()) +} + +#[compiler_test(native_functions)] +fn native_function_works_for_wasm_function_manyparams_dynamic( + config: crate::Config, +) -> anyhow::Result<()> { + let store = config.store(); + let wat = r#"(module + (func $longf (import "env" "longf") (param i32 i32 i32 i32 i32 i32 i64 i64 i32 i32) (result i64)) + (func (export "longf_pure") (param i32 i32 i32 i32 i32 i32 i64 i64 i32 i32) (result i64) + (call $longf (local.get 0) (local.get 1) (local.get 2) (local.get 3) (local.get 4) (local.get 5) (local.get 6) (local.get 7) (local.get 8) (local.get 9))) + (func (export "longf") (result i64) + (call $longf (i32.const 1) (i32.const 2) (i32.const 3) (i32.const 4) (i32.const 5) (i32.const 6) (i64.const 7) (i64.const 8) (i32.const 9) (i32.const 0))) +)"#; + let module = Module::new(&store, wat).unwrap(); + + let import_object = imports! { + "env" => { + "longf" => Function::new(&store, FunctionType::new(vec![ValType::I32, ValType::I32, ValType::I32, ValType::I32, ValType::I32, ValType::I32, ValType::I64 , ValType::I64 ,ValType::I32, ValType::I32], vec![ValType::I64]), long_f_dynamic), + }, + }; + + let instance = Instance::new(&module, &import_object)?; + + { + let dyn_f: Function = instance.lookup_function("longf").unwrap(); + let f: NativeFunc<(), i64> = dyn_f.native().unwrap(); + let result = f.call()?; + assert_eq!(result, 1234567890); + } + + { + let dyn_f: Function = instance.lookup_function("longf_pure").unwrap(); + let f: NativeFunc<(u32, u32, u32, u32, u32, u16, u64, u64, u16, u32), i64> = + dyn_f.native().unwrap(); + let result = f.call(1, 2, 3, 4, 5, 6, 7, 8, 9, 0)?; + assert_eq!(result, 1234567890); + } + + Ok(()) +} + +#[compiler_test(native_functions)] +fn static_host_function_without_env(config: crate::Config) -> anyhow::Result<()> { + let store = config.store(); + + fn f(a: i32, b: i64, c: f32, d: f64) -> (f64, f32, i64, i32) { + (d * 4.0, c * 3.0, b * 2, a * 1) + } + + fn f_ok(a: i32, b: i64, c: f32, d: f64) -> Result<(f64, f32, i64, i32), Infallible> { + Ok((d * 4.0, c * 3.0, b * 2, a * 1)) + } + + fn long_f( + a: u32, + b: u32, + c: u32, + d: u32, + e: u32, + f: u16, + g: u64, + h: u64, + i: u16, + j: u32, + ) -> (u32, u64, u32) { + ( + a + b * 10 + c * 100 + d * 1000 + e * 10000 + f as u32 * 100000, + g + h * 10, + i as u32 + j * 10, + ) + } + + // Native static host function that returns a tuple. + { + let f = Function::new_native(&store, f); + let f_native: NativeFunc<(i32, i64, f32, f64), (f64, f32, i64, i32)> = f.native().unwrap(); + let result = f_native.call(1, 3, 5.0, 7.0)?; + assert_eq!(result, (28.0, 15.0, 6, 1)); + } + + // Native static host function that returns a tuple. + { + let long_f = Function::new_native(&store, long_f); + let long_f_native: NativeFunc< + (u32, u32, u32, u32, u32, u16, u64, u64, u16, u32), + (u32, u64, u32), + > = long_f.native().unwrap(); + let result = long_f_native.call(1, 2, 3, 4, 5, 6, 7, 8, 9, 0)?; + assert_eq!(result, (654321, 87, 09)); + } + + // Native static host function that returns a result of a tuple. + { + let f = Function::new_native(&store, f_ok); + let f_native: NativeFunc<(i32, i64, f32, f64), (f64, f32, i64, i32)> = f.native().unwrap(); + let result = f_native.call(1, 3, 5.0, 7.0)?; + assert_eq!(result, (28.0, 15.0, 6, 1)); + } + + Ok(()) +} + +#[compiler_test(native_functions)] +fn static_host_function_with_env(config: crate::Config) -> anyhow::Result<()> { + let store = config.store(); + + fn f(env: &Env, a: i32, b: i64, c: f32, d: f64) -> (f64, f32, i64, i32) { + let mut guard = env.0.lock().unwrap(); + assert_eq!(*guard, 100); + *guard = 101; + + (d * 4.0, c * 3.0, b * 2, a * 1) + } + + fn f_ok(env: &Env, a: i32, b: i64, c: f32, d: f64) -> Result<(f64, f32, i64, i32), Infallible> { + let mut guard = env.0.lock().unwrap(); + assert_eq!(*guard, 100); + *guard = 101; + + Ok((d * 4.0, c * 3.0, b * 2, a * 1)) + } + + #[derive(Clone)] + struct Env(Arc>); + impl WasmerEnv for Env {} + + impl std::ops::Deref for Env { + type Target = Arc>; + fn deref(&self) -> &Self::Target { + &self.0 + } + } + + // Native static host function that returns a tuple. + { + let env = Env(Arc::new(Mutex::new(100))); + + let f = Function::new_native_with_env(&store, env.clone(), f); + let f_native: NativeFunc<(i32, i64, f32, f64), (f64, f32, i64, i32)> = f.native().unwrap(); + + assert_eq!(*env.0.lock().unwrap(), 100); + + let result = f_native.call(1, 3, 5.0, 7.0)?; + + assert_eq!(result, (28.0, 15.0, 6, 1)); + assert_eq!(*env.0.lock().unwrap(), 101); + } + + // Native static host function that returns a result of a tuple. + { + let env = Env(Arc::new(Mutex::new(100))); + + let f = Function::new_native_with_env(&store, env.clone(), f_ok); + let f_native: NativeFunc<(i32, i64, f32, f64), (f64, f32, i64, i32)> = f.native().unwrap(); + + assert_eq!(*env.0.lock().unwrap(), 100); + + let result = f_native.call(1, 3, 5.0, 7.0)?; + + assert_eq!(result, (28.0, 15.0, 6, 1)); + assert_eq!(*env.0.lock().unwrap(), 101); + } + + Ok(()) +} + +#[compiler_test(native_functions)] +fn dynamic_host_function_without_env(config: crate::Config) -> anyhow::Result<()> { + let store = config.store(); + + let f = Function::new( + &store, + FunctionType::new( + vec![ValType::I32, ValType::I64, ValType::F32, ValType::F64], + vec![ValType::F64, ValType::F32, ValType::I64, ValType::I32], + ), + |values| { + Ok(vec![ + Value::F64(values[3].unwrap_f64() * 4.0), + Value::F32(values[2].unwrap_f32() * 3.0), + Value::I64(values[1].unwrap_i64() * 2), + Value::I32(values[0].unwrap_i32() * 1), + ]) + }, + ); + let f_native: NativeFunc<(i32, i64, f32, f64), (f64, f32, i64, i32)> = f.native().unwrap(); + let result = f_native.call(1, 3, 5.0, 7.0)?; + + assert_eq!(result, (28.0, 15.0, 6, 1)); + + Ok(()) +} + +#[compiler_test(native_functions)] +fn dynamic_host_function_with_env(config: crate::Config) -> anyhow::Result<()> { + let store = config.store(); + + #[derive(Clone)] + struct Env(Arc>); + impl WasmerEnv for Env {} + + impl std::ops::Deref for Env { + type Target = Arc>; + fn deref(&self) -> &Self::Target { + &self.0 + } + } + + let env = Env(Arc::new(Mutex::new(100))); + let f = Function::new_with_env( + &store, + FunctionType::new( + vec![ValType::I32, ValType::I64, ValType::F32, ValType::F64], + vec![ValType::F64, ValType::F32, ValType::I64, ValType::I32], + ), + env.clone(), + |env, values| { + let mut guard = env.0.lock().unwrap(); + assert_eq!(*guard, 100); + + *guard = 101; + + Ok(vec![ + Value::F64(values[3].unwrap_f64() * 4.0), + Value::F32(values[2].unwrap_f32() * 3.0), + Value::I64(values[1].unwrap_i64() * 2), + Value::I32(values[0].unwrap_i32() * 1), + ]) + }, + ); + + let f_native: NativeFunc<(i32, i64, f32, f64), (f64, f32, i64, i32)> = f.native().unwrap(); + + assert_eq!(*env.0.lock().unwrap(), 100); + + let result = f_native.call(1, 3, 5.0, 7.0)?; + + assert_eq!(result, (28.0, 15.0, 6, 1)); + assert_eq!(*env.0.lock().unwrap(), 101); + + Ok(()) +} diff --git a/runtime/near-vm/tests/compilers/serialize.rs b/runtime/near-vm/tests/compilers/serialize.rs new file mode 100644 index 00000000000..ccf7f542aaf --- /dev/null +++ b/runtime/near-vm/tests/compilers/serialize.rs @@ -0,0 +1,87 @@ +use anyhow::Result; +use wasmer::*; + +#[compiler_test(serialize)] +fn test_serialize(config: crate::Config) -> Result<()> { + let store = config.store(); + let wasm = wat2wasm( + r#" + (module + (func $hello (import "" "hello")) + (func (export "run") (call $hello)) + ) + "# + .as_bytes(), + ) + .unwrap(); + let engine = store.engine(); + let tunables = BaseTunables::for_target(engine.target()); + let executable = engine.compile(&wasm, &tunables).unwrap(); + let serialized = executable.serialize().unwrap(); + assert!(!serialized.is_empty()); + Ok(()) +} + +// #[compiler_test(serialize)] +// fn test_deserialize(config: crate::Config) -> Result<()> { +// let store = config.store(); +// let wasm = wat2wasm(r#" +// (module $name +// (import "host" "sum_part" (func (param i32 i64 i32 f32 f64) (result i64))) +// (func (export "test_call") (result i64) +// i32.const 100 +// i64.const 200 +// i32.const 300 +// f32.const 400 +// f64.const 500 +// call 0 +// ) +// ) +// "#.as_bytes()).unwrap(); +// +// let engine = store.engine(); +// let tunables = BaseTunables::for_target(engine.target()); +// let executable = engine.compile(&wasm, &tunables).unwrap(); +// let writer = std::io::Cursor::new(vec![]); +// executable.serialize(&mut writer).unwrap(); +// let serialized_bytes = writer.into_inner(); +// +// let headless_store = config.headless_store(); +// +// +// let deserialized_module = unsafe { Module::deserialize(&headless_store, &serialized_bytes)? }; +// assert_eq!(deserialized_module.name(), Some("name")); +// assert_eq!( +// deserialized_module.artifact().module_ref().exports().collect::>(), +// module.exports().collect::>() +// ); +// assert_eq!( +// deserialized_module.artifact().module_ref().imports().collect::>(), +// module.imports().collect::>() +// ); +// +// let func_type = FunctionType::new( +// vec![Type::I32, Type::I64, Type::I32, Type::F32, Type::F64], +// vec![Type::I64], +// ); +// let instance = Instance::new( +// &module, +// &imports! { +// "host" => { +// "sum_part" => Function::new(&store, &func_type, |params| { +// let param_0: i64 = params[0].unwrap_i32() as i64; +// let param_1: i64 = params[1].unwrap_i64() as i64; +// let param_2: i64 = params[2].unwrap_i32() as i64; +// let param_3: i64 = params[3].unwrap_f32() as i64; +// let param_4: i64 = params[4].unwrap_f64() as i64; +// Ok(vec![Value::I64(param_0 + param_1 + param_2 + param_3 + param_4)]) +// }) +// } +// }, +// )?; +// +// let test_call = instance.exports.get_function("test_call")?; +// let result = test_call.call(&[])?; +// assert_eq!(result.to_vec(), vec![Value::I64(1500)]); +// Ok(()) +// } diff --git a/runtime/near-vm/tests/compilers/stack_limiter.rs b/runtime/near-vm/tests/compilers/stack_limiter.rs new file mode 100644 index 00000000000..ce1678e85ee --- /dev/null +++ b/runtime/near-vm/tests/compilers/stack_limiter.rs @@ -0,0 +1,234 @@ +use wasmer::*; +use wasmer_compiler_singlepass::Singlepass; +use wasmer_engine_universal::Universal; +use wasmer_types::InstanceConfig; +use wasmer_vm::TrapCode; + +fn get_store() -> Store { + let compiler = Singlepass::default(); + let store = Store::new(&Universal::new(compiler).engine()); + store +} + +#[test] +fn stack_limit_hit() { + /* This contracts is + (module + (type (;0;) (func)) + (func (;0;) (type 0) + (local f64 <32750 times>) + local.get 1 + local.get 0 + f64.copysign + call 0 + unreachable) + (memory (;0;) 16 144) + (export "main" (func 0))) + */ + let wasm: [u8; 53] = [ + 0x00, 0x61, 0x73, 0x6d, 0x01, 0x00, 0x00, 0x00, 0x01, 0x04, 0x01, 0x60, 0x00, 0x00, 0x03, + 0x02, 0x01, 0x00, 0x05, 0x05, 0x01, 0x01, 0x10, 0x90, 0x01, 0x07, 0x08, 0x01, 0x04, 0x6d, + 0x61, 0x69, 0x6e, 0x00, 0x00, 0x0a, 0x10, 0x01, 0x0e, 0x01, 0xee, 0xff, 0x01, 0x7c, 0x20, + 0x01, 0x20, 0x00, 0xa6, 0x10, 0x00, 0x00, 0x0b, + ]; + let store = get_store(); + let module = Module::new(&store, &wasm).unwrap(); + let instance = Instance::new_with_config( + &module, + unsafe { InstanceConfig::default().with_stack_limit(100000) }, + &imports! {}, + ); + assert!(instance.is_ok()); + let instance = instance.unwrap(); + let main_func = instance + .lookup_function("main") + .expect("expected function main"); + match main_func.call(&[]) { + Err(err) => { + let trap = err.to_trap().unwrap(); + assert_eq!(trap, TrapCode::StackOverflow); + } + _ => assert!(false), + } +} + +#[test] +fn stack_limit_operand_stack() { + let wat = format!( + r#" + (func $foo (param $depth i32) + block + (br_if 1 (i32.eq (local.get $depth) (i32.const 0))) + local.get $depth + i32.const 1 + i32.sub + local.set $depth + {extra_operand_stack} + local.get $depth + call $foo + {depopulate_operand_stack} + end + ) + (func (export "main") + (call $foo (i32.const 1000)) + ) + "#, + extra_operand_stack = "local.get $depth\n".repeat(10000), + depopulate_operand_stack = "drop\n".repeat(10000) + ); + + let store = get_store(); + let module = Module::new(&store, &wat).unwrap(); + let instance = Instance::new_with_config( + &module, + unsafe { InstanceConfig::default().with_stack_limit(1000) }, + &imports! {}, + ); + assert!(instance.is_ok()); + let instance = instance.unwrap(); + let main_func = instance + .lookup_function("main") + .expect("expected function main"); + match main_func.call(&[]) { + Err(err) => { + let trap = err.to_trap().unwrap(); + assert_eq!(trap, TrapCode::StackOverflow); + } + _ => assert!(false), + } +} + +const OK_WAT: &str = r#" + (memory (;0;) 1000 10000) + (func $foo + (local f64) + i32.const 0 + i32.const 1 + i32.add + drop + ) + (func (export "main") + (local $v0 i32) + i32.const 1000000 + local.set $v0 + loop $L0 + local.get $v0 + i32.const 1 + i32.sub + local.set $v0 + call $foo + local.get $v0 + i32.const 0 + i32.gt_s + br_if $L0 + end + ) +"#; + +#[test] +fn stack_limit_ok() { + let wat = OK_WAT; + let store = get_store(); + let module = Module::new(&store, &wat).unwrap(); + let instance = Instance::new_with_config( + &module, + unsafe { InstanceConfig::default().with_stack_limit(1000) }, + &imports! {}, + ); + assert!(instance.is_ok()); + let instance = instance.unwrap(); + let main_func = instance + .lookup_function("main") + .expect("expected function main"); + let e = main_func.call(&[]); + assert!(e.is_ok(), "got stack limit result: {:?}", e); +} + +#[test] +fn stack_limit_huge_limit() { + let wat = OK_WAT; + let store = get_store(); + let module = Module::new(&store, &wat).unwrap(); + let instance = Instance::new_with_config( + &module, + unsafe { InstanceConfig::default().with_stack_limit(0x7FFF_FFFF) }, + &imports! {}, + ); + assert!(instance.is_ok()); + let instance = instance.unwrap(); + let main_func = instance + .lookup_function("main") + .expect("expected function main"); + main_func.call(&[]).unwrap(); +} + +#[test] +fn stack_limit_no_args() { + let wat = r#" + (func $foo + call $foo + ) + (func (export "main") + call $foo + ) + "#; + + let store = get_store(); + let module = Module::new(&store, &wat).unwrap(); + let instance = Instance::new_with_config( + &module, + unsafe { InstanceConfig::default().with_stack_limit(1000) }, + &imports! {}, + ); + assert!(instance.is_ok()); + let instance = instance.unwrap(); + let main_func = instance + .lookup_function("main") + .expect("expected function main"); + match main_func.call(&[]) { + Err(err) => { + let trap = err.to_trap().unwrap(); + assert_eq!(trap, TrapCode::StackOverflow); + } + _ => assert!(false), + } +} + +#[test] +fn deep_but_sane() { + let wat = r#" + (func $foo (param $p0 i32) (result i32) + local.get $p0 + i32.const 1 + i32.sub + local.set $p0 + block $B0 + local.get $p0 + i32.const 0 + i32.le_s + br_if $B0 + local.get $p0 + call $foo + drop + end + local.get $p0 + ) + (func (export "main") + i32.const 1000 + call $foo + drop + ) + "#; + + let store = get_store(); + let module = Module::new(&store, &wat).unwrap(); + let instance = Instance::new_with_config(&module, InstanceConfig::default(), &imports! {}); + assert!(instance.is_ok()); + let instance = instance.unwrap(); + let main_func = instance + .lookup_function("main") + .expect("expected function main"); + + let e = main_func.call(&[]); + assert!(e.is_ok(), "expected successful result was instead {:?}", e); +} diff --git a/runtime/near-vm/tests/compilers/traps.rs b/runtime/near-vm/tests/compilers/traps.rs new file mode 100644 index 00000000000..4031e292675 --- /dev/null +++ b/runtime/near-vm/tests/compilers/traps.rs @@ -0,0 +1,467 @@ +use anyhow::Result; +use std::panic::{self, AssertUnwindSafe}; +use wasmer::*; + +#[compiler_test(traps)] +fn test_trap_return(config: crate::Config) -> Result<()> { + let store = config.store(); + let wat = r#" + (module + (func $hello (import "" "hello")) + (func (export "run") (call $hello)) + ) + "#; + + let module = Module::new(&store, wat)?; + let hello_type = FunctionType::new(vec![], vec![]); + let hello_func = Function::new(&store, &hello_type, |_| Err(RuntimeError::new("test 123"))); + + let instance = Instance::new( + &module, + &imports! { + "" => { + "hello" => hello_func + } + }, + )?; + let run_func = instance + .lookup_function("run") + .expect("expected function export"); + + let e = run_func.call(&[]).err().expect("error calling function"); + + assert_eq!(e.message(), "test 123"); + + Ok(()) +} + +#[cfg_attr(target_env = "musl", ignore)] +#[compiler_test(traps)] +fn test_trap_trace(config: crate::Config) -> Result<()> { + let store = config.store(); + let wat = r#" + (module $hello_mod + (func (export "run") (call $hello)) + (func $hello (unreachable)) + ) + "#; + + let module = Module::new(&store, wat)?; + let instance = Instance::new(&module, &imports! {})?; + let run_func = instance + .lookup_function("run") + .expect("expected function export"); + + let e = run_func.call(&[]).err().expect("error calling function"); + + let trace = e.trace(); + assert_eq!(trace.len(), 2); + assert_eq!(trace[0].module_name(), "hello_mod"); + assert_eq!(trace[0].func_index(), 1); + assert_eq!(trace[0].function_name(), Some("hello")); + assert_eq!(trace[1].module_name(), "hello_mod"); + assert_eq!(trace[1].func_index(), 0); + assert_eq!(trace[1].function_name(), None); + assert!( + e.message().contains("unreachable"), + "wrong message: {}", + e.message() + ); + + Ok(()) +} + +#[compiler_test(traps)] +fn test_trap_trace_cb(config: crate::Config) -> Result<()> { + let store = config.store(); + let wat = r#" + (module $hello_mod + (import "" "throw" (func $throw)) + (func (export "run") (call $hello)) + (func $hello (call $throw)) + ) + "#; + + let fn_type = FunctionType::new(vec![], vec![]); + let fn_func = Function::new(&store, &fn_type, |_| Err(RuntimeError::new("cb throw"))); + + let module = Module::new(&store, wat)?; + let instance = Instance::new( + &module, + &imports! { + "" => { + "throw" => fn_func + } + }, + )?; + let run_func = instance + .lookup_function("run") + .expect("expected function export"); + + let e = run_func.call(&[]).err().expect("error calling function"); + + let trace = e.trace(); + println!("Trace {:?}", trace); + // TODO: Reenable this (disabled as it was not working with llvm/singlepass) + // assert_eq!(trace.len(), 2); + // assert_eq!(trace[0].module_name(), "hello_mod"); + // assert_eq!(trace[0].func_index(), 2); + // assert_eq!(trace[1].module_name(), "hello_mod"); + // assert_eq!(trace[1].func_index(), 1); + assert_eq!(e.message(), "cb throw"); + + Ok(()) +} + +#[cfg_attr(target_env = "musl", ignore)] +#[compiler_test(traps)] +fn test_trap_stack_overflow(config: crate::Config) -> Result<()> { + let store = config.store(); + let wat = r#" + (module $rec_mod + (func $run (export "run") (call $run)) + ) + "#; + + let module = Module::new(&store, wat)?; + let instance = Instance::new(&module, &imports! {})?; + let run_func = instance + .lookup_function("run") + .expect("expected function export"); + + let e = run_func.call(&[]).err().expect("error calling function"); + + let trace = e.trace(); + assert!(trace.len() >= 32); + for i in 0..trace.len() { + assert_eq!(trace[i].module_name(), "rec_mod"); + assert_eq!(trace[i].func_index(), 0); + assert_eq!(trace[i].function_name(), Some("run")); + } + assert!(e.message().contains("call stack exhausted")); + + Ok(()) +} + +#[cfg_attr(target_env = "musl", ignore)] +#[compiler_test(traps)] +fn trap_display_pretty(config: crate::Config) -> Result<()> { + let store = config.store(); + let wat = r#" + (module $m + (func $die unreachable) + (func call $die) + (func $foo call 1) + (func (export "bar") call $foo) + ) + "#; + + let module = Module::new(&store, wat)?; + let instance = Instance::new(&module, &imports! {})?; + let run_func = instance + .lookup_function("bar") + .expect("expected function export"); + + let e = run_func.call(&[]).err().expect("error calling function"); + assert_eq!( + e.to_string(), + "\ +RuntimeError: unreachable + at die (m[0]:0x23) + at (m[1]:0x27) + at foo (m[2]:0x2c) + at (m[3]:0x31)" + ); + Ok(()) +} + +#[cfg_attr(target_env = "musl", ignore)] +#[compiler_test(traps)] +fn trap_display_multi_module(config: crate::Config) -> Result<()> { + let store = config.store(); + let wat = r#" + (module $a + (func $die unreachable) + (func call $die) + (func $foo call 1) + (func (export "bar") call $foo) + ) + "#; + + let module = Module::new(&store, wat)?; + let instance = Instance::new(&module, &imports! {})?; + let bar = instance.lookup_function("bar").unwrap(); + + let wat = r#" + (module $b + (import "" "" (func $bar)) + (func $middle call $bar) + (func (export "bar2") call $middle) + ) + "#; + let module = Module::new(&store, wat)?; + let instance = Instance::new( + &module, + &imports! { + "" => { + "" => bar + } + }, + )?; + let bar2 = instance + .lookup_function("bar2") + .expect("expected function export"); + + let e = bar2.call(&[]).err().expect("error calling function"); + assert_eq!( + e.to_string(), + "\ +RuntimeError: unreachable + at die (a[0]:0x23) + at (a[1]:0x27) + at foo (a[2]:0x2c) + at (a[3]:0x31) + at middle (b[1]:0x29) + at (b[2]:0x2e)" + ); + Ok(()) +} + +#[compiler_test(traps)] +fn trap_start_function_import(config: crate::Config) -> Result<()> { + let store = config.store(); + let binary = r#" + (module $a + (import "" "" (func $foo)) + (start $foo) + ) + "#; + + let module = Module::new(&store, &binary)?; + let sig = FunctionType::new(vec![], vec![]); + let func = Function::new(&store, &sig, |_| Err(RuntimeError::new("user trap"))); + let err = Instance::new( + &module, + &imports! { + "" => { + "" => func + } + }, + ) + .err() + .unwrap(); + match err { + InstantiationError::Start(err) => { + assert_eq!(err.message(), "user trap"); + } + _ => { + panic!("It should be a start error") + } + } + + Ok(()) +} + +#[compiler_test(traps)] +fn rust_panic_import(config: crate::Config) -> Result<()> { + let store = config.store(); + let binary = r#" + (module $a + (import "" "foo" (func $foo)) + (import "" "bar" (func $bar)) + (func (export "foo") call $foo) + (func (export "bar") call $bar) + ) + "#; + + let module = Module::new(&store, &binary)?; + let sig = FunctionType::new(vec![], vec![]); + let func = Function::new(&store, &sig, |_| panic!("this is a panic")); + let instance = Instance::new( + &module, + &imports! { + "" => { + "foo" => func, + "bar" => Function::new_native(&store, || panic!("this is another panic")) + } + }, + )?; + let func = instance.lookup_function("foo").unwrap(); + let err = panic::catch_unwind(AssertUnwindSafe(|| { + drop(func.call(&[])); + })) + .unwrap_err(); + assert_eq!(err.downcast_ref::<&'static str>(), Some(&"this is a panic")); + + // TODO: Reenable this (disabled as it was not working with llvm/singlepass) + // It doesn't work either with cranelift and `--test-threads=1`. + // let func = instance.lookup_function("bar")?.clone(); + // let err = panic::catch_unwind(AssertUnwindSafe(|| { + // drop(func.call(&[])); + // })) + // .unwrap_err(); + // assert_eq!( + // err.downcast_ref::<&'static str>(), + // Some(&"this is another panic") + // ); + Ok(()) +} + +#[compiler_test(traps)] +fn rust_panic_start_function(config: crate::Config) -> Result<()> { + let store = config.store(); + let binary = r#" + (module $a + (import "" "" (func $foo)) + (start $foo) + ) + "#; + + let module = Module::new(&store, &binary)?; + let sig = FunctionType::new(vec![], vec![]); + let func = Function::new(&store, &sig, |_| panic!("this is a panic")); + let err = panic::catch_unwind(AssertUnwindSafe(|| { + drop(Instance::new( + &module, + &imports! { + "" => { + "" => func + } + }, + )); + })) + .unwrap_err(); + assert_eq!(err.downcast_ref::<&'static str>(), Some(&"this is a panic")); + + let func = Function::new_native(&store, || panic!("this is another panic")); + let err = panic::catch_unwind(AssertUnwindSafe(|| { + drop(Instance::new( + &module, + &imports! { + "" => { + "" => func + } + }, + )); + })) + .unwrap_err(); + assert_eq!( + err.downcast_ref::<&'static str>(), + Some(&"this is another panic") + ); + Ok(()) +} + +#[compiler_test(traps)] +fn mismatched_arguments(config: crate::Config) -> Result<()> { + let store = config.store(); + let binary = r#" + (module $a + (func (export "foo") (param i32)) + ) + "#; + + let module = Module::new(&store, &binary)?; + let instance = Instance::new(&module, &imports! {})?; + let func: Function = instance.lookup_function("foo").unwrap(); + assert_eq!( + func.call(&[]).unwrap_err().message(), + "Parameters of type [] did not match signature [I32] -> []" + ); + assert_eq!( + func.call(&[Val::F32(0.0)]).unwrap_err().message(), + "Parameters of type [F32] did not match signature [I32] -> []", + ); + assert_eq!( + func.call(&[Val::I32(0), Val::I32(1)]) + .unwrap_err() + .message(), + "Parameters of type [I32, I32] did not match signature [I32] -> []" + ); + Ok(()) +} + +#[cfg_attr(target_env = "musl", ignore)] +#[compiler_test(traps)] +fn call_signature_mismatch(config: crate::Config) -> Result<()> { + let store = config.store(); + let binary = r#" + (module $a + (func $foo + i32.const 0 + call_indirect) + (func $bar (param i32)) + (start $foo) + + (table 1 anyfunc) + (elem (i32.const 0) 1) + ) + "#; + + let module = Module::new(&store, &binary)?; + let err = Instance::new(&module, &imports! {}) + .err() + .expect("expected error"); + assert_eq!( + format!("{}", err), + "\ +RuntimeError: indirect call type mismatch + at foo (a[0]:0x30)\ +" + ); + Ok(()) +} + +#[compiler_test(traps)] +#[cfg_attr(target_env = "musl", ignore)] +fn start_trap_pretty(config: crate::Config) -> Result<()> { + let store = config.store(); + let wat = r#" + (module $m + (func $die unreachable) + (func call $die) + (func $foo call 1) + (func $start call $foo) + (start $start) + ) + "#; + + let module = Module::new(&store, wat)?; + let err = Instance::new(&module, &imports! {}) + .err() + .expect("expected error"); + + assert_eq!( + format!("{}", err), + "\ +RuntimeError: unreachable + at die (m[0]:0x1d) + at (m[1]:0x21) + at foo (m[2]:0x26) + at start (m[3]:0x2b)\ +" + ); + Ok(()) +} + +#[compiler_test(traps)] +fn present_after_module_drop(config: crate::Config) -> Result<()> { + let store = config.store(); + let module = Module::new(&store, r#"(func (export "foo") unreachable)"#)?; + let instance = Instance::new(&module, &imports! {})?; + let func: Function = instance.lookup_function("foo").unwrap(); + + println!("asserting before we drop modules"); + assert_trap(func.call(&[]).unwrap_err()); + drop((instance, module)); + + println!("asserting after drop"); + assert_trap(func.call(&[]).unwrap_err()); + return Ok(()); + + fn assert_trap(t: RuntimeError) { + println!("{}", t); + // assert_eq!(t.trace().len(), 1); + // assert_eq!(t.trace()[0].func_index(), 0); + } +} diff --git a/runtime/near-vm/tests/compilers/wast.rs b/runtime/near-vm/tests/compilers/wast.rs new file mode 100644 index 00000000000..e8ed631be93 --- /dev/null +++ b/runtime/near-vm/tests/compilers/wast.rs @@ -0,0 +1,66 @@ +use ::wasmer::Features; +use std::path::Path; +use wasmer_wast::Wast; + +// The generated tests (from build.rs) look like: +// #[cfg(test)] +// mod [compiler] { +// mod [spec] { +// mod [vfs] { +// #[test] +// fn [test_name]() -> anyhow::Result<()> { +// crate::run_wasi("tests/spectests/[test_name].wast", "[compiler]", WasiFileSystemKind::[vfs]) +// } +// } +// } +// } +include!(concat!(env!("OUT_DIR"), "/generated_spectests.rs")); + +pub fn run_wast(mut config: crate::Config, wast_path: &str) -> anyhow::Result<()> { + println!("Running wast `{}`", wast_path); + let try_nan_canonicalization = wast_path.contains("nan-canonicalization"); + let mut features = Features::default(); + let is_bulkmemory = wast_path.contains("bulk-memory"); + let is_simd = wast_path.contains("simd"); + if is_bulkmemory { + features.bulk_memory(true); + } + if is_simd { + features.simd(true); + } + if config.compiler == crate::Compiler::Singlepass { + features.multi_value(false); + } + config.set_features(features); + config.set_nan_canonicalization(try_nan_canonicalization); + + let store = config.store(); + let mut wast = Wast::new_with_spectest(store); + // `bulk-memory-operations/bulk.wast` checks for a message that + // specifies which element is uninitialized, but our traps don't + // shepherd that information out. + wast.allow_trap_message("uninitialized element 2", "uninitialized element"); + // `liking.wast` has different wording but the same meaning + wast.allow_trap_message("out of bounds memory access", "memory out of bounds"); + if cfg!(feature = "coverage") { + wast.disable_assert_and_exhaustion(); + } + if is_simd { + // We allow this, so tests can be run properly for `simd_const` test. + wast.allow_instantiation_failures(&[ + "Validation error: multiple tables", + "Validation error: unknown memory 0", + "Validation error: Invalid var_u32", + ]); + } + if config.compiler == crate::Compiler::Singlepass { + // We don't support multivalue yet in singlepass + wast.allow_instantiation_failures(&[ + "Validation error: func type returns multiple values but the multi-value feature is not enabled", + "Validation error: blocks, loops, and ifs may only produce a resulttype when multi-value is not enabled", + ]); + } + wast.fail_fast = false; + let path = Path::new(wast_path); + wast.run_file(path) +} diff --git a/runtime/near-vm/tests/deprecated.rs b/runtime/near-vm/tests/deprecated.rs new file mode 100644 index 00000000000..8b137891791 --- /dev/null +++ b/runtime/near-vm/tests/deprecated.rs @@ -0,0 +1 @@ + diff --git a/runtime/near-vm/tests/deprecated/README.md b/runtime/near-vm/tests/deprecated/README.md new file mode 100644 index 00000000000..8ee7575c595 --- /dev/null +++ b/runtime/near-vm/tests/deprecated/README.md @@ -0,0 +1,11 @@ +# Tests: Deprecated + +In this folder we will test deprecated APIs to verify that they +still work the way it should, so users of Wasmer are happy while +transitioning to newer APIs. + +As time passes and adoption of new APIs rises, tests on this folder +should start tending towards 0. + +Therefore, deprecated tests are intended to be deleted on the long +term. diff --git a/runtime/near-vm/tests/examples/add.wat b/runtime/near-vm/tests/examples/add.wat new file mode 100644 index 00000000000..a544516fac1 --- /dev/null +++ b/runtime/near-vm/tests/examples/add.wat @@ -0,0 +1,3 @@ +(module + (func (export "add") (param $x i64) (param $y i64) (result i64) (i64.add (local.get $x) (local.get $y))) +) \ No newline at end of file diff --git a/runtime/near-vm/tests/examples/call_indirect.wat b/runtime/near-vm/tests/examples/call_indirect.wat new file mode 100644 index 00000000000..613b5bfb4fe --- /dev/null +++ b/runtime/near-vm/tests/examples/call_indirect.wat @@ -0,0 +1,30 @@ +(module + (type $multiply_signature (func (param i32 i32) (result i32))) + (table 1 1 anyfunc) + (elem (i32.const 0) $multiply) + (memory $0 1) + (export "memory" (memory $0)) + (export "dispatch" (func $dispatch)) + (export "multiply" (func $multiply)) + (export "main" (func $main)) + (func $dispatch (; 0 ;) (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (call_indirect (type $multiply_signature) + (get_local $1) + (get_local $2) + (get_local $0) + ) + ) + (func $multiply (; 1 ;) (type $multiply_signature) (param $0 i32) (param $1 i32) (result i32) + (i32.mul + (get_local $1) + (get_local $0) + ) + ) + (func $main (; 2 ;) (result i32) + (call $dispatch + (i32.const 0) + (i32.const 20) + (i32.const 30) + ) + ) +) diff --git a/runtime/near-vm/tests/examples/fac.wat b/runtime/near-vm/tests/examples/fac.wat new file mode 100644 index 00000000000..4de9c0fb76a --- /dev/null +++ b/runtime/near-vm/tests/examples/fac.wat @@ -0,0 +1,82 @@ +(module + ;; Recursive factorial + (func (export "fac-rec") (param i64) (result i64) + (if (result i64) (i64.eq (local.get 0) (i64.const 0)) + (then (i64.const 1)) + (else + (i64.mul (local.get 0) (call 0 (i64.sub (local.get 0) (i64.const 1)))) + ) + ) + ) + + ;; Recursive factorial named + (func $fac-rec-named (export "fac-rec-named") (param $n i64) (result i64) + (if (result i64) (i64.eq (local.get $n) (i64.const 0)) + (then (i64.const 1)) + (else + (i64.mul + (local.get $n) + (call $fac-rec-named (i64.sub (local.get $n) (i64.const 1))) + ) + ) + ) + ) + + ;; Iterative factorial + (func (export "fac-iter") (param i64) (result i64) + (local i64 i64) + (local.set 1 (local.get 0)) + (local.set 2 (i64.const 1)) + (block + (loop + (if + (i64.eq (local.get 1) (i64.const 0)) + (then (br 2)) + (else + (local.set 2 (i64.mul (local.get 1) (local.get 2))) + (local.set 1 (i64.sub (local.get 1) (i64.const 1))) + ) + ) + (br 0) + ) + ) + (local.get 2) + ) + + ;; Iterative factorial named + (func (export "fac-iter-named") (param $n i64) (result i64) + (local $i i64) + (local $res i64) + (local.set $i (local.get $n)) + (local.set $res (i64.const 1)) + (block $done + (loop $loop + (if + (i64.eq (local.get $i) (i64.const 0)) + (then (br $done)) + (else + (local.set $res (i64.mul (local.get $i) (local.get $res))) + (local.set $i (i64.sub (local.get $i) (i64.const 1))) + ) + ) + (br $loop) + ) + ) + (local.get $res) + ) + + ;; Optimized factorial. + (func (export "fac-opt") (param i64) (result i64) + (local i64) + (local.set 1 (i64.const 1)) + (block + (br_if 0 (i64.lt_s (local.get 0) (i64.const 2))) + (loop + (local.set 1 (i64.mul (local.get 1) (local.get 0))) + (local.set 0 (i64.add (local.get 0) (i64.const -1))) + (br_if 0 (i64.gt_s (local.get 0) (i64.const 1))) + ) + ) + (local.get 1) + ) +) diff --git a/runtime/near-vm/tests/examples/fib.wat b/runtime/near-vm/tests/examples/fib.wat new file mode 100644 index 00000000000..c23fbb66bbe --- /dev/null +++ b/runtime/near-vm/tests/examples/fib.wat @@ -0,0 +1,20 @@ +(module + (func $main (result i32) + (call $fib (i32.const 40)) + ) + + (func $fib (param $n i32) (result i32) + (if (i32.eq (get_local $n) (i32.const 0)) + (then (return (i32.const 1))) + ) + (if (i32.eq (get_local $n) (i32.const 1)) + (then (return (i32.const 1))) + ) + (i32.add + (call $fib (i32.sub (get_local $n) (i32.const 1))) + (call $fib (i32.sub (get_local $n) (i32.const 2))) + ) + ) + + (export "_start" (func $main)) +) diff --git a/runtime/near-vm/tests/examples/global.wat b/runtime/near-vm/tests/examples/global.wat new file mode 100644 index 00000000000..9260ed7923c --- /dev/null +++ b/runtime/near-vm/tests/examples/global.wat @@ -0,0 +1,8 @@ +(module + (global $xxx (mut i32) (i32.const 42)) + (func $main (result i32) + (global.set $xxx (i32.const 0)) + (i32.const 1) + ) + (export "_start" (func $main)) +) diff --git a/runtime/near-vm/tests/examples/invalid.wat b/runtime/near-vm/tests/examples/invalid.wat new file mode 100644 index 00000000000..866bbe152d8 --- /dev/null +++ b/runtime/near-vm/tests/examples/invalid.wat @@ -0,0 +1,5 @@ +(module + (func (export "sqrt") (param f32) (result f32) + f32.sqrt + ) +) diff --git a/runtime/near-vm/tests/examples/memory.wat b/runtime/near-vm/tests/examples/memory.wat new file mode 100755 index 00000000000..09c3685e22b --- /dev/null +++ b/runtime/near-vm/tests/examples/memory.wat @@ -0,0 +1,42 @@ +(module + (memory 1) + (table 20 anyfunc) + (elem (i32.const 9) $f) + (func $f (param i32) (result i32) + (get_local 0) + ) + (func $main (export "main") (result i32) + (local i32) + (set_local 0 (i32.const 100)) + (i32.store (get_local 0) (i32.const 1602)) + (i32.load (get_local 0)) + + (drop) + (memory.grow (i32.const 0)) + + (drop) + (memory.grow (i32.const 2)) + + (drop) + (memory.grow (i32.const 65536)) + + (drop) + (memory.grow (i32.const 12)) + ) + + + (func (export "no_dce.i32.load") (param $i i32) (drop (i32.load (local.get $i)))) + (func (export "no_dce.i32.load16_s") (param $i i32) (drop (i32.load16_s (local.get $i)))) + (func (export "no_dce.i32.load16_u") (param $i i32) (drop (i32.load16_u (local.get $i)))) + (func (export "no_dce.i32.load8_s") (param $i i32) (drop (i32.load8_s (local.get $i)))) + (func (export "no_dce.i32.load8_u") (param $i i32) (drop (i32.load8_u (local.get $i)))) + (func (export "no_dce.i64.load") (param $i i32) (drop (i64.load (local.get $i)))) + (func (export "no_dce.i64.load32_s") (param $i i32) (drop (i64.load32_s (local.get $i)))) + (func (export "no_dce.i64.load32_u") (param $i i32) (drop (i64.load32_u (local.get $i)))) + (func (export "no_dce.i64.load16_s") (param $i i32) (drop (i64.load16_s (local.get $i)))) + (func (export "no_dce.i64.load16_u") (param $i i32) (drop (i64.load16_u (local.get $i)))) + (func (export "no_dce.i64.load8_s") (param $i i32) (drop (i64.load8_s (local.get $i)))) + (func (export "no_dce.i64.load8_u") (param $i i32) (drop (i64.load8_u (local.get $i)))) + (func (export "no_dce.f32.load") (param $i i32) (drop (f32.load (local.get $i)))) + (func (export "no_dce.f64.load") (param $i i32) (drop (f64.load (local.get $i)))) +) diff --git a/runtime/near-vm/tests/examples/no_start.wat b/runtime/near-vm/tests/examples/no_start.wat new file mode 100644 index 00000000000..b6e7ee108c2 --- /dev/null +++ b/runtime/near-vm/tests/examples/no_start.wat @@ -0,0 +1,5 @@ +(module + (type (;0;) (func (param f64) (result i32))) + (func (;0;) (type 0) (param f64) (result i32) + unreachable)) + diff --git a/runtime/near-vm/tests/examples/trap.wat b/runtime/near-vm/tests/examples/trap.wat new file mode 100644 index 00000000000..9210cfa1177 --- /dev/null +++ b/runtime/near-vm/tests/examples/trap.wat @@ -0,0 +1,5 @@ +(module + (func $main (export "_start") (result i32) + (i32.div_s (i32.const 0) (i32.const 0)) + ) +) diff --git a/runtime/near-vm/tests/ignores.txt b/runtime/near-vm/tests/ignores.txt new file mode 100644 index 00000000000..6caee36512b --- /dev/null +++ b/runtime/near-vm/tests/ignores.txt @@ -0,0 +1,93 @@ +# Compilers +singlepass spec::multi_value # Singlepass has not implemented multivalue (functions that returns "structs"/"tuples") +singlepass spec::simd # Singlepass doesn't support yet SIMD (no one asked for this feature) + +# Traps +## Traps. Tracing doesn't work properly in Singlepass +## Unwinding is not properly implemented in Singlepass +# Needs investigation +singlepass traps::test_trap_trace +aarch64 traps::test_trap_trace +singlepass traps::test_trap_stack_overflow # Need to investigate +aarch64 traps::test_trap_stack_overflow # Need to investigate +singlepass traps::trap_display_pretty +aarch64 traps::trap_display_pretty +singlepass traps::trap_display_multi_module +aarch64 traps::trap_display_multi_module +singlepass traps::call_signature_mismatch +macos+aarch64 traps::call_signature_mismatch +singlepass traps::start_trap_pretty +aarch64 traps::start_trap_pretty + +singlepass multi_value_imports::dylib # Singlepass doesn't support multivalue +singlepass multi_value_imports::dynamic # Singlepass doesn't support multivalue + +# TODO: We need to fix this in ARM. The issue is caused by libunwind overflowing +# the stack while creating the stacktrace. +# https://github.com/rust-lang/backtrace-rs/issues/356 +singlepass+windows spec::skip_stack_guard_page # Needs investigation. + +# Windows doesn't overcommit and fails to allocate 4GB of memory +windows wasmer::max_size_of_memory + +# Frontends + +## WASI + +### These tests don't pass due to race conditions in the new way we run tests. +### It's not built to be run in parallel with itself, so we disable it for now. + +wasitests::snapshot1::host_fs::writing +wasitests::unstable::host_fs::writing +wasitests::snapshot1::mem_fs::writing +wasitests::unstable::mem_fs::writing + +### due to hard-coded direct calls into WASI for wasi unstable + +wasitests::snapshot1::host_fs::fd_read +wasitests::snapshot1::host_fs::poll_oneoff +wasitests::snapshot1::host_fs::fd_pread +wasitests::snapshot1::host_fs::fd_close +wasitests::snapshot1::host_fs::fd_allocate +wasitests::snapshot1::host_fs::close_preopen_fd +wasitests::snapshot1::host_fs::envvar +wasitests::snapshot1::mem_fs::fd_read +wasitests::snapshot1::mem_fs::poll_oneoff +wasitests::snapshot1::mem_fs::fd_pread +wasitests::snapshot1::mem_fs::fd_close +wasitests::snapshot1::mem_fs::fd_allocate +wasitests::snapshot1::mem_fs::close_preopen_fd +wasitests::snapshot1::mem_fs::envvar + +### TODO: resolve the disabled tests below. These are newly disabled tests from the migration: + +### due to git clone not preserving symlinks: +wasitests::snapshot1::host_fs::readlink +wasitests::unstable::host_fs::readlink +wasitests::snapshot1::mem_fs::readlink +wasitests::unstable::mem_fs::readlink + +### failing due to `remove_dir_all`. this test is also bad for parallelism +wasitests::snapshot1::host_fs::create_dir +wasitests::unstable::host_fs::create_dir +wasitests::snapshot1::mem_fs::create_dir +wasitests::unstable::mem_fs::create_dir + +### failing because it closes `stdout` which breaks our testing system +wasitests::unstable::host_fs::fd_close +wasitests::unstable::mem_fs::fd_close + +### failing because we're operating on stdout which is now overridden. +### TODO: check WasiFile implementation +### Alterative: split test into 2 parts, one printing to stderr, the other printing to stdout to test the real versions +wasitests::unstable::host_fs::poll_oneoff +wasitests::unstable::mem_fs::poll_oneoff + +### randomly failed, mainly on windows but also on macos, due to a race condition when concurently testing multiple compiler / engines +wasitests::snapshot1::host_fs::fd_rename_path + +# This tests are disabled for now +wasitests::unstable::host_fs::unix_open_special_files +wasitests::snapshot1::host_fs::unix_open_special_files +wasitests::unstable::mem_fs::unix_open_special_files +wasitests::snapshot1::mem_fs::unix_open_special_files diff --git a/runtime/near-vm/tests/lib/README.md b/runtime/near-vm/tests/lib/README.md new file mode 100644 index 00000000000..354f6c85e01 --- /dev/null +++ b/runtime/near-vm/tests/lib/README.md @@ -0,0 +1,3 @@ +# Wasmer Test libraries + +Here is the place where the test libraries will live. diff --git a/runtime/near-vm/tests/lib/compiler-test-derive/Cargo.toml b/runtime/near-vm/tests/lib/compiler-test-derive/Cargo.toml new file mode 100644 index 00000000000..e4036c5d1ab --- /dev/null +++ b/runtime/near-vm/tests/lib/compiler-test-derive/Cargo.toml @@ -0,0 +1,24 @@ +[lib] +proc-macro = true + +[package] +name = "compiler-test-derive" +version = "0.0.1" +authors = ["Wasmer Engineering "] +edition = "2018" +license = "MIT" + +description = "A macro to generate easily tests across compilers and engines" +keywords = ["unsafe", "body", "fn", "safety", "hygiene"] +categories = ["rust-patterns", ] + +[dependencies] +proc-macro2 = "1.*" +quote = "1.*" +syn = { version = "1.*", features = ["full"] } + +[features] + +[dev-dependencies] +pretty_assertions = "1.0" +trybuild = "1.0.11" diff --git a/runtime/near-vm/tests/lib/compiler-test-derive/build.rs b/runtime/near-vm/tests/lib/compiler-test-derive/build.rs new file mode 100644 index 00000000000..d65caeba6ac --- /dev/null +++ b/runtime/near-vm/tests/lib/compiler-test-derive/build.rs @@ -0,0 +1,12 @@ +fn main() { + println!("cargo:rerun-if-changed=../../ignores.txt"); + if let Ok(os) = std::env::var("CARGO_CFG_TARGET_OS") { + println!("cargo:rustc-env=CFG_TARGET_OS={}", os); + } + if let Ok(os) = std::env::var("CARGO_CFG_TARGET_ARCH") { + println!("cargo:rustc-env=CFG_TARGET_ARCH={}", os); + } + if let Ok(os) = std::env::var("CARGO_CFG_TARGET_ENV") { + println!("cargo:rustc-env=CFG_TARGET_ENV={}", os); + } +} diff --git a/runtime/near-vm/tests/lib/compiler-test-derive/src/ignores.rs b/runtime/near-vm/tests/lib/compiler-test-derive/src/ignores.rs new file mode 100644 index 00000000000..e710b59dc1d --- /dev/null +++ b/runtime/near-vm/tests/lib/compiler-test-derive/src/ignores.rs @@ -0,0 +1,229 @@ +use std::fs::File; +use std::path::PathBuf; + +use std::io::{BufRead, BufReader}; + +pub const CFG_TARGET_OS: &'static str = env!("CFG_TARGET_OS"); +pub const CFG_TARGET_ARCH: &'static str = env!("CFG_TARGET_ARCH"); +pub const CFG_TARGET_ENV: &'static str = env!("CFG_TARGET_ENV"); + +#[derive(Debug, Clone)] +struct IgnorePattern { + os: Option, + arch: Option, + target_env: Option, + engine: Option, + compiler: Option, + pattern_to_ignore: String, +} + +impl IgnorePattern { + fn should_ignore( + &self, + os: &str, + arch: &str, + target_env: &str, + engine: &str, + compiler: &str, + canonical_path: &str, + ) -> bool { + self.os.as_ref().map_or(true, |val| val == os) + && self.arch.as_ref().map_or(true, |val| val == arch) + && self + .target_env + .as_ref() + .map_or(true, |val| val == target_env) + && self.engine.as_ref().map_or(true, |val| val == engine) + && self.compiler.as_ref().map_or(true, |val| val == compiler) + && (self.pattern_to_ignore == "*" || canonical_path.contains(&*self.pattern_to_ignore)) + } +} + +#[derive(Debug, Clone)] +pub struct Ignores { + /// The canonical path, and the set of features + patterns: Vec, +} + +impl Ignores { + /// If the path matches any of the paths on the list + pub fn should_ignore( + &self, + os: &str, + arch: &str, + target_env: &str, + engine: &str, + compiler: &str, + canonical_path: &str, + ) -> bool { + self.patterns.iter().any(|p| { + // println!(" -> {:?}", p); + p.should_ignore(os, arch, target_env, engine, compiler, canonical_path) + }) + } + + pub fn should_ignore_host(&self, engine: &str, compiler: &str, canonical_path: &str) -> bool { + self.should_ignore( + CFG_TARGET_OS, + CFG_TARGET_ARCH, + CFG_TARGET_ENV, + engine, + compiler, + canonical_path, + ) + } + + /// Build a Ignore structure from a file path + pub fn build_from_path(path: PathBuf) -> Ignores { + let file = File::open(path).unwrap(); + let reader = BufReader::new(file); + let mut patterns = Vec::new(); + + for (i, line) in reader.lines().enumerate() { + let line = line.unwrap(); + // If the line has a `#` we discard all the content that comes after + let line = if line.contains('#') { + let l: Vec<&str> = line.splitn(2, '#').collect(); + l[0].to_string() + } else { + line + }; + + let line = line.trim().to_string(); + + // If the lines contains ` ` it means the test should be ignored + // on the features exposed + if line.contains(" ") { + let l: Vec<&str> = line.splitn(2, " ").collect(); + let mut os: Option = None; + let mut arch: Option = None; + let mut target_env: Option = None; + let mut engine: Option = None; + let mut compiler: Option = None; + for alias in l[0].trim().split("+") { + match alias { + // Operating Systems + "windows" | "macos" | "linux" => { + os = Some(alias.to_string()); + } + // Environments + "musl" => { + target_env = Some(alias.to_string()); + } + // Chipset architectures + "aarch64" | "x86" | "x64" => { + arch = Some(alias.to_string()); + } + // Engines + "universal" | "dylib" => { + engine = Some(alias.to_string()); + } + // Compilers + "singlepass" => { + compiler = Some(alias.to_string()); + } + other => { + panic!("Alias {:?} not currently supported (defined in ignores.txt in line {})", other, i+1); + } + } + } + let pattern_to_ignore = l[1].trim().to_string(); + patterns.push(IgnorePattern { + os, + arch, + target_env, + engine, + compiler, + pattern_to_ignore, + }); + } else { + if line.is_empty() { + continue; + } + patterns.push(IgnorePattern { + os: None, + arch: None, + target_env: None, + engine: None, + compiler: None, + pattern_to_ignore: line, + }); + }; + } + Ignores { patterns } + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn features_match() -> Result<(), ()> { + assert!(IgnorePattern { + os: None, + arch: None, + target_env: None, + engine: None, + compiler: None, + pattern_to_ignore: "*".to_string() + } + .should_ignore( + "unknown", + "unknown", + "", + "engine", + "compiler", + "some::random::text" + )); + assert!(IgnorePattern { + os: None, + arch: None, + target_env: None, + engine: None, + compiler: None, + pattern_to_ignore: "some::random".to_string() + } + .should_ignore( + "unknown", + "unknown", + "", + "engine", + "compiler", + "some::random::text" + )); + assert!(!IgnorePattern { + os: Some("macos".to_string()), + arch: None, + target_env: None, + engine: None, + compiler: None, + pattern_to_ignore: "other".to_string() + } + .should_ignore( + "unknown", + "unknown", + "", + "engine", + "compiler", + "some::random::text" + )); + assert!(!IgnorePattern { + os: Some("macos".to_string()), + arch: None, + target_env: None, + engine: Some("universal".to_string()), + compiler: None, + pattern_to_ignore: "other".to_string() + } + .should_ignore( + "macos", + "unknown", + "", + "universal", + "compiler", + "some::random::text" + )); + Ok(()) + } +} diff --git a/runtime/near-vm/tests/lib/compiler-test-derive/src/lib.rs b/runtime/near-vm/tests/lib/compiler-test-derive/src/lib.rs new file mode 100644 index 00000000000..4447e9ff593 --- /dev/null +++ b/runtime/near-vm/tests/lib/compiler-test-derive/src/lib.rs @@ -0,0 +1,149 @@ +#[cfg(not(test))] +extern crate proc_macro; +#[cfg(not(test))] +use proc_macro::TokenStream; +#[cfg(test)] +use proc_macro2::TokenStream; +use quote::quote; +use std::path::PathBuf; +#[cfg(not(test))] +use syn::parse; +#[cfg(test)] +use syn::parse2 as parse; +use syn::*; + +mod ignores; + +// Reimplement parse_macro_input to use the imported `parse` +// function. This way parse_macro_input will parse a TokenStream2 when +// unit-testing. +macro_rules! parse_macro_input { + ( + $token_stream:ident as $T:ty + ) => { + match parse::<$T>($token_stream) { + Ok(data) => data, + Err(err) => { + return TokenStream::from(err.to_compile_error()); + } + } + }; + + ( + $token_stream:ident + ) => { + parse_macro_input!($token_stream as _) + }; +} + +#[proc_macro_attribute] +pub fn compiler_test(attrs: TokenStream, input: TokenStream) -> TokenStream { + let path: Option = parse::(attrs).ok(); + let mut my_fn: ItemFn = parse_macro_input!(input as ItemFn); + let fn_name = my_fn.sig.ident.clone(); + + // Let's build the ignores to append an `#[ignore]` macro to the + // autogenerated tests in case the test appears in the `ignores.txt` path; + + let mut ignores_txt_path = PathBuf::new(); + ignores_txt_path.push(env!("CARGO_MANIFEST_DIR")); + ignores_txt_path.push("../../ignores.txt"); + + let ignores = crate::ignores::Ignores::build_from_path(ignores_txt_path); + + let should_ignore = |test_name: &str, compiler_name: &str, engine_name: &str| { + let compiler_name = compiler_name.to_lowercase(); + let engine_name = engine_name.to_lowercase(); + // We construct the path manually because we can't get the + // source_file location from the `Span` (it's only available in nightly) + let full_path = format!( + "{}::{}::{}::{}", + quote! { #path }, + test_name, + compiler_name, + engine_name + ) + .replace(" ", ""); + let should_ignore = ignores.should_ignore_host(&engine_name, &compiler_name, &full_path); + // println!("{} -> Should ignore: {}", full_path, should_ignore); + return should_ignore; + }; + let construct_engine_test = |func: &::syn::ItemFn, + compiler_name: &str, + engine_name: &str, + engine_feature_name: &str| + -> ::proc_macro2::TokenStream { + let config_compiler = ::quote::format_ident!("{}", compiler_name); + let config_engine = ::quote::format_ident!("{}", engine_name); + let test_name = ::quote::format_ident!("{}", engine_name.to_lowercase()); + let mut new_sig = func.sig.clone(); + let attrs = func + .attrs + .clone() + .iter() + .fold(quote! {}, |acc, new| quote! {#acc #new}); + new_sig.ident = test_name; + new_sig.inputs = ::syn::punctuated::Punctuated::new(); + let f = quote! { + #[test_log::test] + #attrs + #[cfg(feature = #engine_feature_name)] + #new_sig { + #fn_name(crate::Config::new(crate::Engine::#config_engine, crate::Compiler::#config_compiler)) + } + }; + if should_ignore( + &func.sig.ident.to_string().replace("r#", ""), + compiler_name, + engine_name, + ) && !cfg!(test) + { + quote! { + #[ignore] + #f + } + } else { + f + } + }; + + let construct_compiler_test = + |func: &::syn::ItemFn, compiler_name: &str| -> ::proc_macro2::TokenStream { + let mod_name = ::quote::format_ident!("{}", compiler_name.to_lowercase()); + let universal_engine_test = + construct_engine_test(func, compiler_name, "Universal", "universal"); + let dylib_engine_test = construct_engine_test(func, compiler_name, "Dylib", "dylib"); + let compiler_name_lowercase = compiler_name.to_lowercase(); + + quote! { + #[cfg(feature = #compiler_name_lowercase)] + mod #mod_name { + use super::*; + + #universal_engine_test + #dylib_engine_test + } + } + }; + + let singlepass_compiler_test = construct_compiler_test(&my_fn, "Singlepass"); + + // We remove the method decorators + my_fn.attrs = vec![]; + + let x = quote! { + #[cfg(test)] + mod #fn_name { + use super::*; + + #[allow(unused)] + #my_fn + + #singlepass_compiler_test + } + }; + x.into() +} + +#[cfg(test)] +mod tests; diff --git a/runtime/near-vm/tests/lib/compiler-test-derive/src/tests.rs b/runtime/near-vm/tests/lib/compiler-test-derive/src/tests.rs new file mode 100644 index 00000000000..89acdc6b06b --- /dev/null +++ b/runtime/near-vm/tests/lib/compiler-test-derive/src/tests.rs @@ -0,0 +1,78 @@ +use super::*; +use pretty_assertions::assert_eq; + +macro_rules! gen_tests {( + $( + $test_name:ident: + stringify! { + #[$function:ident $(($($attrs:tt)*))?] + $($input:tt)* + } == $output:expr; + )* +) => ( + $( + #[test] + fn $test_name() + { + let input: TokenStream = + stringify!($($input)*) + .parse() + .expect("Syntax error in test"); + let output: TokenStream = + $output + .parse() + .expect("Syntax error in test"); + let attrs: TokenStream = + stringify!($($($attrs)*)?) + .parse() + .expect("Syntax error in test"); + let ret = $function(attrs, input).to_string(); + eprintln!("{}", ret); + assert_eq!(ret, output.to_string()); + } + )* +)} + +gen_tests! { + identity_for_no_unsafe: + stringify! { + #[compiler_test(derive_test)] + #[cold] + fn foo(config: crate::Config) { + // Do tests + } + } == stringify! { + #[cfg(test)] + mod foo { + use super::*; + + #[allow(unused)] + fn foo(config: crate::Config) { + // Do tests + } + + #[cfg(feature = "singlepass")] + mod singlepass { + use super::*; + #[test_log::test] + #[cold] + #[cfg(feature = "universal")] + fn universal() { + foo(crate::Config::new( + crate::Engine::Universal, + crate::Compiler::Singlepass + )) + } + #[test_log::test] + #[cold] + #[cfg(feature = "dylib")] + fn dylib() { + foo(crate::Config::new( + crate::Engine::Dylib, + crate::Compiler::Singlepass + )) + } + } + } + }; +} diff --git a/runtime/near-vm/tests/lib/test-generator/Cargo.toml b/runtime/near-vm/tests/lib/test-generator/Cargo.toml new file mode 100644 index 00000000000..4b4886bb75b --- /dev/null +++ b/runtime/near-vm/tests/lib/test-generator/Cargo.toml @@ -0,0 +1,14 @@ +[package] +name = "test-generator" +version = "0.1.0" +edition = "2018" +publish = false +license = "Apache-2.0 WITH LLVM-exception" + +[dependencies] +anyhow = "1.0" +target-lexicon = "0.12" + +[features] +test-dylib = [] +test-universal = [] diff --git a/runtime/near-vm/tests/lib/test-generator/src/lib.rs b/runtime/near-vm/tests/lib/test-generator/src/lib.rs new file mode 100644 index 00000000000..2c4f30f7501 --- /dev/null +++ b/runtime/near-vm/tests/lib/test-generator/src/lib.rs @@ -0,0 +1,107 @@ +//! Build library to generate a program which runs all the testsuites. +//! +//! By generating a separate `#[test]` test for each file, we allow cargo test +//! to automatically run the files in parallel. +//! +//! > This program is inspired/forked from: +//! > https://github.com/bytecodealliance/wasmtime/blob/master/build.rs +mod processors; + +pub use crate::processors::{emscripten_processor, wasi_processor, wast_processor}; +use anyhow::Context; +use std::fmt::Write; +use std::path::{Path, PathBuf}; + +pub struct Testsuite { + pub buffer: String, + pub path: Vec, +} + +#[derive(PartialEq, Eq, PartialOrd, Ord)] +pub struct Test { + pub name: String, + pub body: String, +} + +pub fn test_directory_module( + out: &mut Testsuite, + path: impl AsRef, + processor: impl Fn(&mut Testsuite, PathBuf) -> Option, +) -> anyhow::Result { + let path = path.as_ref(); + let testsuite = &extract_name(path); + with_test_module(out, testsuite, |out| test_directory(out, path, processor)) +} + +fn write_test(out: &mut Testsuite, testname: &str, body: &str) -> anyhow::Result<()> { + writeln!( + out.buffer, + "#[compiler_test({})]", + out.path[..out.path.len() - 1].join("::") + )?; + writeln!( + out.buffer, + "fn r#{}(config: crate::Config) -> anyhow::Result<()> {{", + &testname + )?; + writeln!(out.buffer, "{}", body)?; + writeln!(out.buffer, "}}")?; + writeln!(out.buffer)?; + Ok(()) +} + +pub fn test_directory( + out: &mut Testsuite, + path: impl AsRef, + processor: impl Fn(&mut Testsuite, PathBuf) -> Option, +) -> anyhow::Result { + let path = path.as_ref(); + let mut dir_entries: Vec<_> = path + .read_dir() + .context(format!("failed to read {:?}", path))? + .map(|r| r.expect("reading testsuite directory entry")) + .filter_map(|dir_entry| processor(out, dir_entry.path())) + .collect(); + + dir_entries.sort(); + + for Test { + name: testname, + body, + } in dir_entries.iter() + { + out.path.push(testname.to_string()); + write_test(out, &testname, &body).unwrap(); + out.path.pop().unwrap(); + } + + Ok(dir_entries.len()) +} + +/// Extract a valid Rust identifier from the stem of a path. +pub fn extract_name(path: impl AsRef) -> String { + path.as_ref() + .file_stem() + .expect("filename should have a stem") + .to_str() + .expect("filename should be representable as a string") + .replace("-", "_") + .replace("/", "_") +} + +pub fn with_test_module( + out: &mut Testsuite, + testsuite: &str, + f: impl FnOnce(&mut Testsuite) -> anyhow::Result, +) -> anyhow::Result { + out.path.push(testsuite.to_string()); + out.buffer.push_str("mod "); + out.buffer.push_str(testsuite); + out.buffer.push_str(" {\n"); + + let result = f(out)?; + + out.buffer.push_str("}\n"); + out.path.pop().unwrap(); + Ok(result) +} diff --git a/runtime/near-vm/tests/lib/test-generator/src/processors.rs b/runtime/near-vm/tests/lib/test-generator/src/processors.rs new file mode 100644 index 00000000000..ce7ca22cc3a --- /dev/null +++ b/runtime/near-vm/tests/lib/test-generator/src/processors.rs @@ -0,0 +1,95 @@ +//! Here we define the processors usable for each test genrator +use crate::{extract_name, Test, Testsuite}; +use std::path::PathBuf; + +/// Given a Testsuite and a path, process the path in case is a wast +/// file. +pub fn wast_processor(_out: &mut Testsuite, p: PathBuf) -> Option { + let ext = p.extension()?; + // Only look at wast files. + if ext != "wast" { + return None; + } + + // Ignore files starting with `.`, which could be editor temporary files + if p.file_stem()?.to_str()?.starts_with('.') { + return None; + } + + let testname = extract_name(&p); + + // The implementation of `run_wast` lives in /tests/spectest.rs + let body = format!("crate::run_wast(config, r#\"{}\"#)", p.display()); + + Some(Test { + name: testname, + body, + }) +} + +/// Given a Testsuite and a path, process the path in case is a Emscripten +/// wasm file. +pub fn emscripten_processor(_out: &mut Testsuite, p: PathBuf) -> Option { + let ext = p.extension()?; + // Only look at wast files. + if ext != "wasm" { + return None; + } + + let outfile = { + let mut out_ext = p.clone(); + out_ext.set_extension("out"); + if out_ext.exists() { + out_ext + } else { + return None; + } + }; + + let testname = extract_name(&p); + + // The implementation of `run_emscripten` lives in /tests/emtest.rs + let body = format!( + "crate::emscripten::run_emscripten(config, r#\"{}\"#, r#\"{}\"#)", + p.display(), + outfile.display() + ); + + Some(Test { + name: testname, + body, + }) +} + +/// Given a Testsuite and a path, process the path in case is a WASI +/// wasm file. +pub fn wasi_processor( + _out: &mut Testsuite, + p: PathBuf, + wasi_filesystem_kind: &str, +) -> Option { + let ext = p.extension()?; + // Only look at wast files. + if ext != "wast" { + return None; + } + + let wasm_dir = { + let mut inner = p.clone(); + inner.pop(); + inner + }; + let testname = extract_name(&p); + + let body = format!( + "crate::run_wasi(config, r#\"{}\"#, \"{}\", crate::{})", + p.display(), + wasm_dir.display(), + wasi_filesystem_kind, + ); + + Some(Test { + name: testname, + body, + }) +} diff --git a/runtime/near-vm/tests/lib/wast/Cargo.toml b/runtime/near-vm/tests/lib/wast/Cargo.toml new file mode 100644 index 00000000000..125af267fcf --- /dev/null +++ b/runtime/near-vm/tests/lib/wast/Cargo.toml @@ -0,0 +1,25 @@ +[package] +name = "wasmer-wast" +version = "2.1.0" +authors = ["Wasmer Engineering Team "] +description = "wast testing support for wasmer" +license = "MIT OR Apache-2.0 WITH LLVM-exception" +categories = ["wasm"] +keywords = ["wasm", "webassembly"] +repository = "https://github.com/wasmerio/wasmer" +readme = "README.md" +edition = "2018" + +[dependencies] +anyhow = "1.0" +wasmer = { path = "../../../lib/api", version = "=2.4.0", package = "wasmer-near", default-features = false } +wast = "38.0" +tempfile = "3" +thiserror = "1.0" + +[features] +default = ["wat"] +wat = ["wasmer/wat"] + +[badges] +maintenance = { status = "actively-developed" } diff --git a/runtime/near-vm/tests/lib/wast/README.md b/runtime/near-vm/tests/lib/wast/README.md new file mode 100644 index 00000000000..a4f673fee30 --- /dev/null +++ b/runtime/near-vm/tests/lib/wast/README.md @@ -0,0 +1,7 @@ +This is the `wasmer-wast` crate, which contains an implementation of WebAssembly's +"wast" test scripting language, which is used in the +[WebAssembly spec testsuite], using wasmer for execution. + +[WebAssembly spec testsuite]: https://github.com/WebAssembly/testsuite + +> Note: this project started as a fork of [this crate](https://crates.io/crates/wasmtime-wast). diff --git a/runtime/near-vm/tests/lib/wast/src/error.rs b/runtime/near-vm/tests/lib/wast/src/error.rs new file mode 100644 index 00000000000..53f0ab6d3c5 --- /dev/null +++ b/runtime/near-vm/tests/lib/wast/src/error.rs @@ -0,0 +1,37 @@ +use std::fmt; +use thiserror::Error; + +/// A Directive Error +#[derive(Debug)] +pub struct DirectiveError { + /// The line where the directive is defined + pub line: usize, + /// The column where the directive is defined + pub col: usize, + /// The failing message received when running the directive + pub message: String, +} + +/// A structure holding the list of all executed directives +#[derive(Error, Debug)] +pub struct DirectiveErrors { + /// The filename where the error occured + pub filename: String, + /// The list of errors + pub errors: Vec, +} + +impl fmt::Display for DirectiveErrors { + // This trait requires `fmt` with this exact signature. + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + // Write strictly the first element into the supplied output + // stream: `f`. Returns `fmt::Result` which indicates whether the + // operation succeeded or failed. Note that `write!` uses syntax which + // is very similar to `println!`. + writeln!(f, "Failed directives on {}:", self.filename)?; + for error in self.errors.iter() { + writeln!(f, " • {} ({}:{})", error.message, error.line, error.col)?; + } + Ok(()) + } +} diff --git a/runtime/near-vm/tests/lib/wast/src/lib.rs b/runtime/near-vm/tests/lib/wast/src/lib.rs new file mode 100644 index 00000000000..099430e5f93 --- /dev/null +++ b/runtime/near-vm/tests/lib/wast/src/lib.rs @@ -0,0 +1,30 @@ +//! Implementation of the WAST text format for wasmer. + +#![deny(missing_docs, trivial_numeric_casts, unused_extern_crates)] +#![warn(unused_import_braces)] +#![deny(unstable_features)] +#![cfg_attr(feature = "cargo-clippy", allow(clippy::new_without_default))] +#![cfg_attr( + feature = "cargo-clippy", + warn( + clippy::float_arithmetic, + clippy::mut_mut, + clippy::nonminimal_bool, + clippy::map_unwrap_or, + clippy::map_unwrap_or_else, + clippy::print_stdout, + clippy::unicode_not_nfc, + clippy::use_self + ) +)] + +mod error; +mod spectest; +mod wast; + +pub use crate::error::{DirectiveError, DirectiveErrors}; +pub use crate::spectest::spectest_importobject; +pub use crate::wast::Wast; + +/// Version number of this crate. +pub const VERSION: &str = env!("CARGO_PKG_VERSION"); diff --git a/runtime/near-vm/tests/lib/wast/src/spectest.rs b/runtime/near-vm/tests/lib/wast/src/spectest.rs new file mode 100644 index 00000000000..28d13995d18 --- /dev/null +++ b/runtime/near-vm/tests/lib/wast/src/spectest.rs @@ -0,0 +1,48 @@ +use wasmer::*; + +/// Return an instance implementing the "spectest" interface used in the +/// spec testsuite. +pub fn spectest_importobject(store: &Store) -> ImportObject { + let print = Function::new_native(store, || {}); + let print_i32 = Function::new_native(store, |val: i32| println!("{}: i32", val)); + let print_i64 = Function::new_native(store, |val: i64| println!("{}: i64", val)); + let print_f32 = Function::new_native(store, |val: f32| println!("{}: f32", val)); + let print_f64 = Function::new_native(store, |val: f64| println!("{}: f64", val)); + let print_i32_f32 = Function::new_native(store, |i: i32, f: f32| { + println!("{}: i32", i); + println!("{}: f32", f); + }); + let print_f64_f64 = Function::new_native(store, |f1: f64, f2: f64| { + println!("{}: f64", f1); + println!("{}: f64", f2); + }); + + let global_i32 = Global::new(store, Val::I32(666)); + let global_i64 = Global::new(store, Val::I64(666)); + let global_f32 = Global::new(store, Val::F32(f32::from_bits(0x4426_8000))); + let global_f64 = Global::new(store, Val::F64(f64::from_bits(0x4084_d000_0000_0000))); + + let ty = TableType::new(ValType::FuncRef, 10, Some(20)); + let table = Table::new(store, ty, Val::FuncRef(None)).unwrap(); + + let ty = MemoryType::new(1, Some(2), false); + let memory = Memory::new(store, ty).unwrap(); + + imports! { + "spectest" => { + "print" => print, + "print_i32" => print_i32, + "print_i64" => print_i64, + "print_f32" => print_f32, + "print_f64" => print_f64, + "print_i32_f32" => print_i32_f32, + "print_f64_f64" => print_f64_f64, + "global_i32" => global_i32, + "global_i64" => global_i64, + "global_f32" => global_f32, + "global_f64" => global_f64, + "table" => table, + "memory" => memory, + }, + } +} diff --git a/runtime/near-vm/tests/lib/wast/src/wast.rs b/runtime/near-vm/tests/lib/wast/src/wast.rs new file mode 100644 index 00000000000..b71817dff08 --- /dev/null +++ b/runtime/near-vm/tests/lib/wast/src/wast.rs @@ -0,0 +1,676 @@ +use crate::error::{DirectiveError, DirectiveErrors}; +use crate::spectest::spectest_importobject; +use anyhow::{anyhow, bail, Result}; +use std::collections::{BTreeMap, HashMap, HashSet}; +use std::path::Path; +use std::str; +use wasmer::*; + +/// The wast test script language allows modules to be defined and actions +/// to be performed on them. +pub struct Wast { + /// Wast files have a concept of a "current" module, which is the most + /// recently defined. + current: Option, + /// The Import Object that all wast tests will have + import_object: ImportObject, + /// The instances in the test + instances: HashMap, + /// Allowed failures (ideally this should be empty) + allowed_instantiation_failures: HashSet, + /// If the (expected from .wast, actual) message pair is in this list, + /// treat the strings as matching. + match_trap_messages: HashMap, + /// If the current module was an allowed failure, we allow test to fail + current_is_allowed_failure: bool, + /// Extern-ref manager: used for testing extern refs: they're referred to by + /// number in WAST, so we map here. + extern_refs: BTreeMap, + /// The wasm Store + store: Store, + /// A flag indicating if Wast tests should stop as soon as one test fails. + pub fail_fast: bool, + /// A flag indicating that assert_trap and assert_exhaustion should be skipped. + /// See https://github.com/wasmerio/wasmer/issues/1550 for more info + disable_assert_trap_exhaustion: bool, +} + +impl Wast { + /// Construct a new instance of `Wast` with a given imports. + pub fn new(store: Store, import_object: ImportObject) -> Self { + Self { + current: None, + store, + import_object, + allowed_instantiation_failures: HashSet::new(), + match_trap_messages: HashMap::new(), + current_is_allowed_failure: false, + instances: HashMap::new(), + extern_refs: BTreeMap::new(), + fail_fast: true, + disable_assert_trap_exhaustion: false, + } + } + + /// A list of instantiation failures to allow. + pub fn allow_instantiation_failures(&mut self, failures: &[&str]) { + for &failure_str in failures.iter() { + self.allowed_instantiation_failures + .insert(failure_str.to_string()); + } + } + + /// A list of alternative messages to permit for a trap failure. + pub fn allow_trap_message(&mut self, expected: &str, allowed: &str) { + self.match_trap_messages + .insert(expected.into(), allowed.into()); + } + + /// Do not run any code in assert_trap or assert_exhaustion. + pub fn disable_assert_and_exhaustion(&mut self) { + self.disable_assert_trap_exhaustion = true; + } + + /// Construct a new instance of `Wast` with the spectests imports. + pub fn new_with_spectest(store: Store) -> Self { + let import_object = spectest_importobject(&store); + Self::new(store, import_object) + } + + fn get_instance(&self, instance_name: Option<&str>) -> Result { + match instance_name { + Some(name) => self + .instances + .get(name) + .cloned() + .ok_or_else(|| anyhow!("failed to find instance named `{}`", name)), + None => self + .current + .clone() + .ok_or_else(|| anyhow!("no previous instance found")), + } + } + + /// Perform the action portion of a command. + fn perform_execute(&mut self, exec: wast::WastExecute<'_>) -> Result> { + match exec { + wast::WastExecute::Invoke(invoke) => self.perform_invoke(invoke), + wast::WastExecute::Module(mut module) => { + let binary = module.encode()?; + let result = self.instantiate(&binary); + result.map(|_| Vec::new()) + } + wast::WastExecute::Get { module, global } => { + let instance_name = module.map(|i| i.name()); + let instance = self.get_instance(instance_name.as_deref())?; + let global = if let Some(Export::Global(global)) = instance.lookup(global) { + global + } else { + bail!("could not find the global: {}", global) + }; + Ok(vec![global.from.get(&self.store)]) + } + } + } + + fn perform_invoke(&mut self, exec: wast::WastInvoke<'_>) -> Result> { + let values = exec + .args + .iter() + .map(|a| self.runtime_value(a)) + .collect::>>()?; + self.invoke(exec.module.map(|i| i.name()), exec.name, &values) + } + + fn assert_return( + &self, + result: Result>, + results: &[wast::AssertExpression], + ) -> Result<()> { + let values = result?; + for (v, e) in values.iter().zip(results) { + if self.val_matches(v, e)? { + continue; + } + if let Val::V128(bits) = v { + if let wast::AssertExpression::V128(pattern) = e { + bail!( + "expected {:?}, got {:?} (v128 bits: {})", + e, + v128_format(*bits, pattern), + bits + ); + } + } + bail!("expected {:?}, got {:?}", e, v) + } + Ok(()) + } + + fn assert_trap(&self, result: Result>, expected: &str) -> Result<()> { + let actual = match result { + Ok(values) => bail!("expected trap, got {:?}", values), + Err(t) => format!("{}", t), + }; + if self.matches_message_assert_trap(expected, &actual) { + return Ok(()); + } + bail!("expected '{}', got '{}'", expected, actual) + } + + fn run_directive(&mut self, test: &Path, directive: wast::WastDirective) -> Result<()> { + use wast::WastDirective::*; + + match directive { + Module(mut module) => { + let binary = module.encode()?; + self.module(module.id.map(|s| s.name()), &binary)?; + } + Register { + span: _, + name, + module, + } => { + self.register(module.map(|s| s.name()), name)?; + } + Invoke(i) => { + self.perform_invoke(i)?; + } + AssertReturn { + span: _, + exec, + results, + } => { + let result = self.perform_execute(exec); + self.assert_return(result, &results)?; + } + AssertTrap { + span: _, + exec, + message, + } => { + if !self.disable_assert_trap_exhaustion { + let result = self.perform_execute(exec); + self.assert_trap(result, message)?; + } + } + AssertExhaustion { + span: _, + call, + message, + } => { + if !self.disable_assert_trap_exhaustion { + let result = self.perform_invoke(call); + self.assert_trap(result, message)?; + } + } + AssertInvalid { + span: _, + module, + message, + } => { + let wasm = match module { + wast::QuoteModule::Module(mut m) => m.encode()?, + wast::QuoteModule::Quote(list) => self.parse_quote_module(test, &list)?, + }; + let err = match self.module(None, &wasm) { + Ok(()) => bail!("expected module to fail to build"), + Err(e) => e, + }; + let error_message = format!("{:?}", err); + if !Self::matches_message_assert_invalid(message, &error_message) { + bail!( + "assert_invalid: expected \"{}\", got \"{}\"", + message, + error_message + ) + } + } + QuoteModule { .. } => { + // Do nothing + } + AssertException { .. } => { + // Do nothing for now + } + AssertMalformed { + module, + span: _, + message: _, + } => { + let mut module = match module { + wast::QuoteModule::Module(m) => m, + // This is a `*.wat` parser test which we're not + // interested in. + wast::QuoteModule::Quote(_) => return Ok(()), + }; + let bytes = module.encode()?; + if self.module(None, &bytes).is_ok() { + bail!("expected malformed module to fail to instantiate"); + } + } + AssertUnlinkable { + span: _, + mut module, + message, + } => { + let bytes = module.encode()?; + let err = match self.module(None, &bytes) { + Ok(()) => bail!("expected module to fail to link"), + Err(e) => e, + }; + let error_message = format!("{:?}", err); + if !Self::matches_message_assert_unlinkable(message, &error_message) { + bail!( + "assert_unlinkable: expected {}, got {}", + message, + error_message + ) + } + } + } + + Ok(()) + } + + /// Run a wast script from a byte buffer. + pub fn run_buffer(&mut self, test: &Path, wast: &[u8]) -> Result<()> { + let wast = str::from_utf8(wast)?; + let filename = test.to_str().unwrap(); + let adjust_wast = |mut err: wast::Error| { + err.set_path(filename.as_ref()); + err.set_text(wast); + err + }; + + let buf = wast::parser::ParseBuffer::new(wast).map_err(adjust_wast)?; + let ast = wast::parser::parse::(&buf).map_err(adjust_wast)?; + let mut errors = Vec::with_capacity(ast.directives.len()); + for directive in ast.directives { + let sp = directive.span(); + if let Err(e) = self.run_directive(test, directive) { + let message = format!("{}", e); + // If depends on an instance that doesn't exist + if message.contains("no previous instance found") { + continue; + } + // We don't compute it, comes from instantiating an instance + // that we expected to fail. + if self.current.is_none() && self.current_is_allowed_failure { + continue; + } + let (line, col) = sp.linecol_in(wast); + errors.push(DirectiveError { + line: line + 1, + col, + message, + }); + if self.fail_fast { + break; + } + } + } + if !errors.is_empty() { + return Err(DirectiveErrors { + filename: filename.to_string(), + errors, + } + .into()); + } + Ok(()) + } + + fn parse_quote_module(&self, test: &Path, source: &[&[u8]]) -> Result> { + let mut ret = String::new(); + for src in source { + match str::from_utf8(src) { + Ok(s) => ret.push_str(s), + Err(_) => bail!("malformed UTF-8 encoding"), + } + ret.push(' '); + } + let buf = wast::parser::ParseBuffer::new(&ret)?; + let mut wat = wast::parser::parse::(&buf)?; + + // TODO: when memory64 merges into the proper spec then this should be + // removed since it will presumably no longer be a text-format error but + // rather a validation error. Currently all non-memory64 proposals + // assert that this offset is a text-parser error, whereas with memory64 + // support that error is deferred until later. + if ret.contains("offset=4294967296") && !test.iter().any(|t| t == "memory64") { + bail!("i32 constant out of bounds"); + } + Ok(wat.module.encode()?) + } + + /// Run a wast script from a file. + pub fn run_file(&mut self, path: &Path) -> Result<()> { + let bytes = std::fs::read(path)?; + self.run_buffer(path, &bytes) + } +} + +// This is the implementation specific to the Runtime +impl Wast { + /// Define a module and register it. + fn module(&mut self, instance_name: Option<&str>, module: &[u8]) -> Result<()> { + let instance = match self.instantiate(module) { + Ok(i) => i, + Err(e) => { + // We set the current to None to allow running other + // spectests when `fail_fast` is `false`. + self.current = None; + let error_message = format!("{}", e); + self.current_is_allowed_failure = false; + for allowed_failure in self.allowed_instantiation_failures.iter() { + if error_message.contains(allowed_failure) { + self.current_is_allowed_failure = true; + break; + } + } + bail!("instantiation failed with: {}", e) + } + }; + if let Some(name) = instance_name { + self.instances.insert(name.to_string(), instance.clone()); + } + self.current = Some(instance); + self.current_is_allowed_failure = false; + Ok(()) + } + + fn instantiate(&self, module: &[u8]) -> Result { + let module = Module::new(&self.store, module)?; + let instance = Instance::new(&module, &self)?; + Ok(instance) + } + + /// Register an instance to make it available for performing actions. + fn register(&mut self, name: Option<&str>, as_name: &str) -> Result<()> { + let instance = self.get_instance(name)?; + self.instances.insert(as_name.to_string(), instance); + Ok(()) + } + + /// Invoke an exported function from an instance. + fn invoke( + &mut self, + instance_name: Option<&str>, + field: &str, + args: &[Val], + ) -> Result> { + let instance = self.get_instance(instance_name.as_deref())?; + instance.handle().instance().as_ref().reset_stack_meter(); + let func: Function = instance + .lookup_function(field) + .expect("should find the function"); + match func.call(args) { + Ok(result) => Ok(result.into()), + Err(e) => Err(e.into()), + } + } + + /// Translate from a `script::Value` to a `Val`. + fn runtime_value(&mut self, v: &wast::Expression<'_>) -> Result { + use wast::Instruction::*; + + if v.instrs.len() != 1 { + bail!("too many instructions in {:?}", v); + } + Ok(match &v.instrs[0] { + I32Const(x) => Val::I32(*x), + I64Const(x) => Val::I64(*x), + F32Const(x) => Val::F32(f32::from_bits(x.bits)), + F64Const(x) => Val::F64(f64::from_bits(x.bits)), + V128Const(x) => Val::V128(u128::from_le_bytes(x.to_le_bytes())), + RefNull(wast::HeapType::Func) => Val::FuncRef(None), + RefNull(wast::HeapType::Extern) => Val::null(), + RefExtern(number) => { + let extern_ref = self + .extern_refs + .entry(*number) + .or_insert_with(|| ExternRef::new(*number)); + Val::ExternRef(extern_ref.clone()) + } + other => bail!("couldn't convert {:?} to a runtime value", other), + }) + } + + // Checks if the `assert_unlinkable` message matches the expected one + fn matches_message_assert_unlinkable(expected: &str, actual: &str) -> bool { + actual.contains(&expected) + } + + // Checks if the `assert_invalid` message matches the expected one + fn matches_message_assert_invalid(expected: &str, actual: &str) -> bool { + actual.contains(expected) + // Waiting on https://github.com/WebAssembly/bulk-memory-operations/pull/137 + // to propagate to WebAssembly/testsuite. + || (expected.contains("unknown table") && actual.contains("unknown elem")) + // wasmparser return the wrong message + || (expected.contains("unknown memory") && actual.contains("no linear memories are present")) + // `elem.wast` and `proposals/bulk-memory-operations/elem.wast` disagree + // on the expected error message for the same error. + || (expected.contains("out of bounds") && actual.contains("does not fit")) + // handle `unknown global $NUM` error messages that wasmparser doesn't return yet + || (expected.contains("unknown global") && actual.contains("unknown global")) + // handle `unknown memory $NUM` error messages that wasmparser doesn't return yet + || (expected.contains("unknown memory") && actual.contains("unknown memory")) + || (expected.contains("unknown memory") && actual.contains("Data segment extends past end of the data section")) + } + + // Checks if the `assert_trap` message matches the expected one + fn matches_message_assert_trap(&self, expected: &str, actual: &str) -> bool { + actual.contains(expected) + || self + .match_trap_messages + .get(expected) + .map_or(false, |alternative| actual.contains(alternative)) + } + + fn val_matches(&self, actual: &Val, expected: &wast::AssertExpression) -> Result { + Ok(match (actual, expected) { + (Val::I32(a), wast::AssertExpression::I32(b)) => a == b, + (Val::I64(a), wast::AssertExpression::I64(b)) => a == b, + // Note that these float comparisons are comparing bits, not float + // values, so we're testing for bit-for-bit equivalence + (Val::F32(a), wast::AssertExpression::F32(b)) => f32_matches(*a, b), + (Val::F64(a), wast::AssertExpression::F64(b)) => f64_matches(*a, b), + (Val::V128(a), wast::AssertExpression::V128(b)) => v128_matches(*a, b), + (Val::FuncRef(None), wast::AssertExpression::RefNull(Some(wast::HeapType::Func))) => { + true + } + (Val::FuncRef(Some(_)), wast::AssertExpression::RefNull(_)) => false, + (Val::FuncRef(None), wast::AssertExpression::RefFunc(None)) => true, + (Val::FuncRef(None), wast::AssertExpression::RefFunc(Some(_))) => false, + ( + Val::ExternRef(extern_ref), + wast::AssertExpression::RefNull(Some(wast::HeapType::Extern)), + ) if extern_ref.is_null() => true, + (Val::ExternRef(extern_ref), wast::AssertExpression::RefExtern(_)) + if extern_ref.is_null() => + { + false + } + + (Val::ExternRef(_), wast::AssertExpression::RefNull(_)) => false, + (Val::ExternRef(extern_ref), wast::AssertExpression::RefExtern(num)) => { + if let Some(stored_extern_ref) = self.extern_refs.get(num) { + extern_ref == stored_extern_ref + } else { + false + } + } + _ => bail!( + "don't know how to compare {:?} and {:?} yet", + actual, + expected + ), + }) + } +} + +impl NamedResolver for Wast { + fn resolve_by_name(&self, module: &str, field: &str) -> Option { + let imports = self.import_object.clone(); + + if imports.contains_namespace(module) { + imports.resolve_by_name(module, field) + } else { + let instance = self.instances.get(module)?; + instance.lookup(field) + } + } +} + +fn extract_lane_as_i8(bytes: u128, lane: usize) -> i8 { + (bytes >> (lane * 8)) as i8 +} + +fn extract_lane_as_i16(bytes: u128, lane: usize) -> i16 { + (bytes >> (lane * 16)) as i16 +} + +fn extract_lane_as_i32(bytes: u128, lane: usize) -> i32 { + (bytes >> (lane * 32)) as i32 +} + +fn extract_lane_as_i64(bytes: u128, lane: usize) -> i64 { + (bytes >> (lane * 64)) as i64 +} + +fn f32_matches(actual: f32, expected: &wast::NanPattern) -> bool { + match expected { + wast::NanPattern::CanonicalNan => actual.is_canonical_nan(), + wast::NanPattern::ArithmeticNan => actual.is_arithmetic_nan(), + wast::NanPattern::Value(expected_value) => actual.to_bits() == expected_value.bits, + } +} + +fn f64_matches(actual: f64, expected: &wast::NanPattern) -> bool { + match expected { + wast::NanPattern::CanonicalNan => actual.is_canonical_nan(), + wast::NanPattern::ArithmeticNan => actual.is_arithmetic_nan(), + wast::NanPattern::Value(expected_value) => actual.to_bits() == expected_value.bits, + } +} + +fn v128_matches(actual: u128, expected: &wast::V128Pattern) -> bool { + match expected { + wast::V128Pattern::I8x16(b) => b + .iter() + .enumerate() + .all(|(i, b)| *b == extract_lane_as_i8(actual, i)), + wast::V128Pattern::I16x8(b) => b + .iter() + .enumerate() + .all(|(i, b)| *b == extract_lane_as_i16(actual, i)), + wast::V128Pattern::I32x4(b) => b + .iter() + .enumerate() + .all(|(i, b)| *b == extract_lane_as_i32(actual, i)), + wast::V128Pattern::I64x2(b) => b + .iter() + .enumerate() + .all(|(i, b)| *b == extract_lane_as_i64(actual, i)), + wast::V128Pattern::F32x4(b) => b.iter().enumerate().all(|(i, b)| { + let a = extract_lane_as_i32(actual, i) as u32; + f32_matches(f32::from_bits(a), b) + }), + wast::V128Pattern::F64x2(b) => b.iter().enumerate().all(|(i, b)| { + let a = extract_lane_as_i64(actual, i) as u64; + f64_matches(f64::from_bits(a), b) + }), + } +} + +fn v128_format(actual: u128, expected: &wast::V128Pattern) -> wast::V128Pattern { + match expected { + wast::V128Pattern::I8x16(_) => wast::V128Pattern::I8x16([ + extract_lane_as_i8(actual, 0), + extract_lane_as_i8(actual, 1), + extract_lane_as_i8(actual, 2), + extract_lane_as_i8(actual, 3), + extract_lane_as_i8(actual, 4), + extract_lane_as_i8(actual, 5), + extract_lane_as_i8(actual, 6), + extract_lane_as_i8(actual, 7), + extract_lane_as_i8(actual, 8), + extract_lane_as_i8(actual, 9), + extract_lane_as_i8(actual, 10), + extract_lane_as_i8(actual, 11), + extract_lane_as_i8(actual, 12), + extract_lane_as_i8(actual, 13), + extract_lane_as_i8(actual, 14), + extract_lane_as_i8(actual, 15), + ]), + wast::V128Pattern::I16x8(_) => wast::V128Pattern::I16x8([ + extract_lane_as_i16(actual, 0), + extract_lane_as_i16(actual, 1), + extract_lane_as_i16(actual, 2), + extract_lane_as_i16(actual, 3), + extract_lane_as_i16(actual, 4), + extract_lane_as_i16(actual, 5), + extract_lane_as_i16(actual, 6), + extract_lane_as_i16(actual, 7), + ]), + wast::V128Pattern::I32x4(_) => wast::V128Pattern::I32x4([ + extract_lane_as_i32(actual, 0), + extract_lane_as_i32(actual, 1), + extract_lane_as_i32(actual, 2), + extract_lane_as_i32(actual, 3), + ]), + wast::V128Pattern::I64x2(_) => wast::V128Pattern::I64x2([ + extract_lane_as_i64(actual, 0), + extract_lane_as_i64(actual, 1), + ]), + wast::V128Pattern::F32x4(_) => wast::V128Pattern::F32x4([ + wast::NanPattern::Value(wast::Float32 { + bits: extract_lane_as_i32(actual, 0) as _, + }), + wast::NanPattern::Value(wast::Float32 { + bits: extract_lane_as_i32(actual, 1) as _, + }), + wast::NanPattern::Value(wast::Float32 { + bits: extract_lane_as_i32(actual, 2) as _, + }), + wast::NanPattern::Value(wast::Float32 { + bits: extract_lane_as_i32(actual, 3) as _, + }), + ]), + wast::V128Pattern::F64x2(_) => wast::V128Pattern::F64x2([ + wast::NanPattern::Value(wast::Float64 { + bits: extract_lane_as_i64(actual, 0) as _, + }), + wast::NanPattern::Value(wast::Float64 { + bits: extract_lane_as_i64(actual, 1) as _, + }), + ]), + } +} + +pub trait NaNCheck { + fn is_arithmetic_nan(&self) -> bool; + fn is_canonical_nan(&self) -> bool; +} + +impl NaNCheck for f32 { + fn is_arithmetic_nan(&self) -> bool { + const AF32_NAN: u32 = 0x0040_0000; + (self.to_bits() & AF32_NAN) == AF32_NAN + } + + fn is_canonical_nan(&self) -> bool { + (self.to_bits() & 0x7fff_ffff) == 0x7fc0_0000 + } +} + +impl NaNCheck for f64 { + fn is_arithmetic_nan(&self) -> bool { + const AF64_NAN: u64 = 0x0008_0000_0000_0000; + (self.to_bits() & AF64_NAN) == AF64_NAN + } + + fn is_canonical_nan(&self) -> bool { + (self.to_bits() & 0x7fff_ffff_ffff_ffff) == 0x7ff8_0000_0000_0000 + } +} diff --git a/runtime/near-vm/tests/wast/README.md b/runtime/near-vm/tests/wast/README.md new file mode 100644 index 00000000000..4c4636eb636 --- /dev/null +++ b/runtime/near-vm/tests/wast/README.md @@ -0,0 +1,3 @@ +# WebAssembly testsuite + +Here is where all the `.wast` tests live. diff --git a/runtime/near-vm/tests/wast/spec/.gitignore b/runtime/near-vm/tests/wast/spec/.gitignore new file mode 100644 index 00000000000..34e4053fdbf --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/.gitignore @@ -0,0 +1,2 @@ +/commit_message +/repos/ diff --git a/runtime/near-vm/tests/wast/spec/Contributing.md b/runtime/near-vm/tests/wast/spec/Contributing.md new file mode 100644 index 00000000000..1cc607fa471 --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/Contributing.md @@ -0,0 +1,8 @@ +# Contributing to WebAssembly + +Interested in participating? Please follow +[the same contributing guidelines as the design repository][]. + + [the same contributing guidelines as the design repository]: https://github.com/WebAssembly/design/blob/master/Contributing.md + +Also, please be sure to read [the README.md](README.md) for this repository. diff --git a/runtime/near-vm/tests/wast/spec/LICENSE b/runtime/near-vm/tests/wast/spec/LICENSE new file mode 100644 index 00000000000..8f71f43fee3 --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/LICENSE @@ -0,0 +1,202 @@ + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "{}" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright {yyyy} {name of copyright owner} + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + diff --git a/runtime/near-vm/tests/wast/spec/README.md b/runtime/near-vm/tests/wast/spec/README.md new file mode 100644 index 00000000000..50a25417368 --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/README.md @@ -0,0 +1,18 @@ +Amalgamated WebAssembly Test Suite +================================== + +This repository holds a mirror of the WebAssembly core testsuite which is +maintained [here](https://github.com/WebAssembly/spec/tree/master/test/core), +as well as the tests from the various [proposals +repositories](https://github.com/WebAssembly/proposals/blob/master/README.md). + +In addition it also contains tests from various proposals which are currently +forks of the primary spec repo. + +To add new tests or report problems in existing tests, please file issues and +PRs within the spec or individual proposal repositories rather than within this +mirror repository. + +To update the tests in this repo from their upstream sources: + +1. Run `update-tests.sh` diff --git a/runtime/near-vm/tests/wast/spec/address.wast b/runtime/near-vm/tests/wast/spec/address.wast new file mode 100644 index 00000000000..320ea36bc0a --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/address.wast @@ -0,0 +1,610 @@ +;; Load i32 data with different offset/align arguments + +(module + (memory 1) + (data (i32.const 0) "abcdefghijklmnopqrstuvwxyz") + + (func (export "8u_good1") (param $i i32) (result i32) + (i32.load8_u offset=0 (local.get $i)) ;; 97 'a' + ) + (func (export "8u_good2") (param $i i32) (result i32) + (i32.load8_u align=1 (local.get $i)) ;; 97 'a' + ) + (func (export "8u_good3") (param $i i32) (result i32) + (i32.load8_u offset=1 align=1 (local.get $i)) ;; 98 'b' + ) + (func (export "8u_good4") (param $i i32) (result i32) + (i32.load8_u offset=2 align=1 (local.get $i)) ;; 99 'c' + ) + (func (export "8u_good5") (param $i i32) (result i32) + (i32.load8_u offset=25 align=1 (local.get $i)) ;; 122 'z' + ) + + (func (export "8s_good1") (param $i i32) (result i32) + (i32.load8_s offset=0 (local.get $i)) ;; 97 'a' + ) + (func (export "8s_good2") (param $i i32) (result i32) + (i32.load8_s align=1 (local.get $i)) ;; 97 'a' + ) + (func (export "8s_good3") (param $i i32) (result i32) + (i32.load8_s offset=1 align=1 (local.get $i)) ;; 98 'b' + ) + (func (export "8s_good4") (param $i i32) (result i32) + (i32.load8_s offset=2 align=1 (local.get $i)) ;; 99 'c' + ) + (func (export "8s_good5") (param $i i32) (result i32) + (i32.load8_s offset=25 align=1 (local.get $i)) ;; 122 'z' + ) + + (func (export "16u_good1") (param $i i32) (result i32) + (i32.load16_u offset=0 (local.get $i)) ;; 25185 'ab' + ) + (func (export "16u_good2") (param $i i32) (result i32) + (i32.load16_u align=1 (local.get $i)) ;; 25185 'ab' + ) + (func (export "16u_good3") (param $i i32) (result i32) + (i32.load16_u offset=1 align=1 (local.get $i)) ;; 25442 'bc' + ) + (func (export "16u_good4") (param $i i32) (result i32) + (i32.load16_u offset=2 align=2 (local.get $i)) ;; 25699 'cd' + ) + (func (export "16u_good5") (param $i i32) (result i32) + (i32.load16_u offset=25 align=2 (local.get $i)) ;; 122 'z\0' + ) + + (func (export "16s_good1") (param $i i32) (result i32) + (i32.load16_s offset=0 (local.get $i)) ;; 25185 'ab' + ) + (func (export "16s_good2") (param $i i32) (result i32) + (i32.load16_s align=1 (local.get $i)) ;; 25185 'ab' + ) + (func (export "16s_good3") (param $i i32) (result i32) + (i32.load16_s offset=1 align=1 (local.get $i)) ;; 25442 'bc' + ) + (func (export "16s_good4") (param $i i32) (result i32) + (i32.load16_s offset=2 align=2 (local.get $i)) ;; 25699 'cd' + ) + (func (export "16s_good5") (param $i i32) (result i32) + (i32.load16_s offset=25 align=2 (local.get $i)) ;; 122 'z\0' + ) + + (func (export "32_good1") (param $i i32) (result i32) + (i32.load offset=0 (local.get $i)) ;; 1684234849 'abcd' + ) + (func (export "32_good2") (param $i i32) (result i32) + (i32.load align=1 (local.get $i)) ;; 1684234849 'abcd' + ) + (func (export "32_good3") (param $i i32) (result i32) + (i32.load offset=1 align=1 (local.get $i)) ;; 1701077858 'bcde' + ) + (func (export "32_good4") (param $i i32) (result i32) + (i32.load offset=2 align=2 (local.get $i)) ;; 1717920867 'cdef' + ) + (func (export "32_good5") (param $i i32) (result i32) + (i32.load offset=25 align=4 (local.get $i)) ;; 122 'z\0\0\0' + ) + + (func (export "8u_bad") (param $i i32) + (drop (i32.load8_u offset=4294967295 (local.get $i))) + ) + (func (export "8s_bad") (param $i i32) + (drop (i32.load8_s offset=4294967295 (local.get $i))) + ) + (func (export "16u_bad") (param $i i32) + (drop (i32.load16_u offset=4294967295 (local.get $i))) + ) + (func (export "16s_bad") (param $i i32) + (drop (i32.load16_s offset=4294967295 (local.get $i))) + ) + (func (export "32_bad") (param $i i32) + (drop (i32.load offset=4294967295 (local.get $i))) + ) +) + +(assert_return (invoke "8u_good1" (i32.const 0)) (i32.const 97)) +(assert_return (invoke "8u_good2" (i32.const 0)) (i32.const 97)) +(assert_return (invoke "8u_good3" (i32.const 0)) (i32.const 98)) +(assert_return (invoke "8u_good4" (i32.const 0)) (i32.const 99)) +(assert_return (invoke "8u_good5" (i32.const 0)) (i32.const 122)) + +(assert_return (invoke "8s_good1" (i32.const 0)) (i32.const 97)) +(assert_return (invoke "8s_good2" (i32.const 0)) (i32.const 97)) +(assert_return (invoke "8s_good3" (i32.const 0)) (i32.const 98)) +(assert_return (invoke "8s_good4" (i32.const 0)) (i32.const 99)) +(assert_return (invoke "8s_good5" (i32.const 0)) (i32.const 122)) + +(assert_return (invoke "16u_good1" (i32.const 0)) (i32.const 25185)) +(assert_return (invoke "16u_good2" (i32.const 0)) (i32.const 25185)) +(assert_return (invoke "16u_good3" (i32.const 0)) (i32.const 25442)) +(assert_return (invoke "16u_good4" (i32.const 0)) (i32.const 25699)) +(assert_return (invoke "16u_good5" (i32.const 0)) (i32.const 122)) + +(assert_return (invoke "16s_good1" (i32.const 0)) (i32.const 25185)) +(assert_return (invoke "16s_good2" (i32.const 0)) (i32.const 25185)) +(assert_return (invoke "16s_good3" (i32.const 0)) (i32.const 25442)) +(assert_return (invoke "16s_good4" (i32.const 0)) (i32.const 25699)) +(assert_return (invoke "16s_good5" (i32.const 0)) (i32.const 122)) + +(assert_return (invoke "32_good1" (i32.const 0)) (i32.const 1684234849)) +(assert_return (invoke "32_good2" (i32.const 0)) (i32.const 1684234849)) +(assert_return (invoke "32_good3" (i32.const 0)) (i32.const 1701077858)) +(assert_return (invoke "32_good4" (i32.const 0)) (i32.const 1717920867)) +(assert_return (invoke "32_good5" (i32.const 0)) (i32.const 122)) + +(assert_return (invoke "8u_good1" (i32.const 65507)) (i32.const 0)) +(assert_return (invoke "8u_good2" (i32.const 65507)) (i32.const 0)) +(assert_return (invoke "8u_good3" (i32.const 65507)) (i32.const 0)) +(assert_return (invoke "8u_good4" (i32.const 65507)) (i32.const 0)) +(assert_return (invoke "8u_good5" (i32.const 65507)) (i32.const 0)) + +(assert_return (invoke "8s_good1" (i32.const 65507)) (i32.const 0)) +(assert_return (invoke "8s_good2" (i32.const 65507)) (i32.const 0)) +(assert_return (invoke "8s_good3" (i32.const 65507)) (i32.const 0)) +(assert_return (invoke "8s_good4" (i32.const 65507)) (i32.const 0)) +(assert_return (invoke "8s_good5" (i32.const 65507)) (i32.const 0)) + +(assert_return (invoke "16u_good1" (i32.const 65507)) (i32.const 0)) +(assert_return (invoke "16u_good2" (i32.const 65507)) (i32.const 0)) +(assert_return (invoke "16u_good3" (i32.const 65507)) (i32.const 0)) +(assert_return (invoke "16u_good4" (i32.const 65507)) (i32.const 0)) +(assert_return (invoke "16u_good5" (i32.const 65507)) (i32.const 0)) + +(assert_return (invoke "16s_good1" (i32.const 65507)) (i32.const 0)) +(assert_return (invoke "16s_good2" (i32.const 65507)) (i32.const 0)) +(assert_return (invoke "16s_good3" (i32.const 65507)) (i32.const 0)) +(assert_return (invoke "16s_good4" (i32.const 65507)) (i32.const 0)) +(assert_return (invoke "16s_good5" (i32.const 65507)) (i32.const 0)) + +(assert_return (invoke "32_good1" (i32.const 65507)) (i32.const 0)) +(assert_return (invoke "32_good2" (i32.const 65507)) (i32.const 0)) +(assert_return (invoke "32_good3" (i32.const 65507)) (i32.const 0)) +(assert_return (invoke "32_good4" (i32.const 65507)) (i32.const 0)) +(assert_return (invoke "32_good5" (i32.const 65507)) (i32.const 0)) + +(assert_return (invoke "8u_good1" (i32.const 65508)) (i32.const 0)) +(assert_return (invoke "8u_good2" (i32.const 65508)) (i32.const 0)) +(assert_return (invoke "8u_good3" (i32.const 65508)) (i32.const 0)) +(assert_return (invoke "8u_good4" (i32.const 65508)) (i32.const 0)) +(assert_return (invoke "8u_good5" (i32.const 65508)) (i32.const 0)) + +(assert_return (invoke "8s_good1" (i32.const 65508)) (i32.const 0)) +(assert_return (invoke "8s_good2" (i32.const 65508)) (i32.const 0)) +(assert_return (invoke "8s_good3" (i32.const 65508)) (i32.const 0)) +(assert_return (invoke "8s_good4" (i32.const 65508)) (i32.const 0)) +(assert_return (invoke "8s_good5" (i32.const 65508)) (i32.const 0)) + +(assert_return (invoke "16u_good1" (i32.const 65508)) (i32.const 0)) +(assert_return (invoke "16u_good2" (i32.const 65508)) (i32.const 0)) +(assert_return (invoke "16u_good3" (i32.const 65508)) (i32.const 0)) +(assert_return (invoke "16u_good4" (i32.const 65508)) (i32.const 0)) +(assert_return (invoke "16u_good5" (i32.const 65508)) (i32.const 0)) + +(assert_return (invoke "16s_good1" (i32.const 65508)) (i32.const 0)) +(assert_return (invoke "16s_good2" (i32.const 65508)) (i32.const 0)) +(assert_return (invoke "16s_good3" (i32.const 65508)) (i32.const 0)) +(assert_return (invoke "16s_good4" (i32.const 65508)) (i32.const 0)) +(assert_return (invoke "16s_good5" (i32.const 65508)) (i32.const 0)) + +(assert_return (invoke "32_good1" (i32.const 65508)) (i32.const 0)) +(assert_return (invoke "32_good2" (i32.const 65508)) (i32.const 0)) +(assert_return (invoke "32_good3" (i32.const 65508)) (i32.const 0)) +(assert_return (invoke "32_good4" (i32.const 65508)) (i32.const 0)) +(assert_trap (invoke "32_good5" (i32.const 65508)) "out of bounds memory access") + +(assert_trap (invoke "8u_good3" (i32.const -1)) "out of bounds memory access") +(assert_trap (invoke "8s_good3" (i32.const -1)) "out of bounds memory access") +(assert_trap (invoke "16u_good3" (i32.const -1)) "out of bounds memory access") +(assert_trap (invoke "16s_good3" (i32.const -1)) "out of bounds memory access") +(assert_trap (invoke "32_good3" (i32.const -1)) "out of bounds memory access") +(assert_trap (invoke "32_good3" (i32.const -1)) "out of bounds memory access") + +(assert_trap (invoke "8u_bad" (i32.const 0)) "out of bounds memory access") +(assert_trap (invoke "8s_bad" (i32.const 0)) "out of bounds memory access") +(assert_trap (invoke "16u_bad" (i32.const 0)) "out of bounds memory access") +(assert_trap (invoke "16s_bad" (i32.const 0)) "out of bounds memory access") +(assert_trap (invoke "32_bad" (i32.const 0)) "out of bounds memory access") + +(assert_trap (invoke "8u_bad" (i32.const 1)) "out of bounds memory access") +(assert_trap (invoke "8s_bad" (i32.const 1)) "out of bounds memory access") +(assert_trap (invoke "16u_bad" (i32.const 1)) "out of bounds memory access") +(assert_trap (invoke "16s_bad" (i32.const 1)) "out of bounds memory access") +(assert_trap (invoke "32_bad" (i32.const 1)) "out of bounds memory access") + +(assert_malformed + (module quote + "(memory 1)" + "(func (drop (i32.load offset=4294967296 (i32.const 0))))" + ) + "i32 constant" +) + +;; Load i64 data with different offset/align arguments + +(module + (memory 1) + (data (i32.const 0) "abcdefghijklmnopqrstuvwxyz") + + (func (export "8u_good1") (param $i i32) (result i64) + (i64.load8_u offset=0 (local.get $i)) ;; 97 'a' + ) + (func (export "8u_good2") (param $i i32) (result i64) + (i64.load8_u align=1 (local.get $i)) ;; 97 'a' + ) + (func (export "8u_good3") (param $i i32) (result i64) + (i64.load8_u offset=1 align=1 (local.get $i)) ;; 98 'b' + ) + (func (export "8u_good4") (param $i i32) (result i64) + (i64.load8_u offset=2 align=1 (local.get $i)) ;; 99 'c' + ) + (func (export "8u_good5") (param $i i32) (result i64) + (i64.load8_u offset=25 align=1 (local.get $i)) ;; 122 'z' + ) + + (func (export "8s_good1") (param $i i32) (result i64) + (i64.load8_s offset=0 (local.get $i)) ;; 97 'a' + ) + (func (export "8s_good2") (param $i i32) (result i64) + (i64.load8_s align=1 (local.get $i)) ;; 97 'a' + ) + (func (export "8s_good3") (param $i i32) (result i64) + (i64.load8_s offset=1 align=1 (local.get $i)) ;; 98 'b' + ) + (func (export "8s_good4") (param $i i32) (result i64) + (i64.load8_s offset=2 align=1 (local.get $i)) ;; 99 'c' + ) + (func (export "8s_good5") (param $i i32) (result i64) + (i64.load8_s offset=25 align=1 (local.get $i)) ;; 122 'z' + ) + + (func (export "16u_good1") (param $i i32) (result i64) + (i64.load16_u offset=0 (local.get $i)) ;; 25185 'ab' + ) + (func (export "16u_good2") (param $i i32) (result i64) + (i64.load16_u align=1 (local.get $i)) ;; 25185 'ab' + ) + (func (export "16u_good3") (param $i i32) (result i64) + (i64.load16_u offset=1 align=1 (local.get $i)) ;; 25442 'bc' + ) + (func (export "16u_good4") (param $i i32) (result i64) + (i64.load16_u offset=2 align=2 (local.get $i)) ;; 25699 'cd' + ) + (func (export "16u_good5") (param $i i32) (result i64) + (i64.load16_u offset=25 align=2 (local.get $i)) ;; 122 'z\0' + ) + + (func (export "16s_good1") (param $i i32) (result i64) + (i64.load16_s offset=0 (local.get $i)) ;; 25185 'ab' + ) + (func (export "16s_good2") (param $i i32) (result i64) + (i64.load16_s align=1 (local.get $i)) ;; 25185 'ab' + ) + (func (export "16s_good3") (param $i i32) (result i64) + (i64.load16_s offset=1 align=1 (local.get $i)) ;; 25442 'bc' + ) + (func (export "16s_good4") (param $i i32) (result i64) + (i64.load16_s offset=2 align=2 (local.get $i)) ;; 25699 'cd' + ) + (func (export "16s_good5") (param $i i32) (result i64) + (i64.load16_s offset=25 align=2 (local.get $i)) ;; 122 'z\0' + ) + + (func (export "32u_good1") (param $i i32) (result i64) + (i64.load32_u offset=0 (local.get $i)) ;; 1684234849 'abcd' + ) + (func (export "32u_good2") (param $i i32) (result i64) + (i64.load32_u align=1 (local.get $i)) ;; 1684234849 'abcd' + ) + (func (export "32u_good3") (param $i i32) (result i64) + (i64.load32_u offset=1 align=1 (local.get $i)) ;; 1701077858 'bcde' + ) + (func (export "32u_good4") (param $i i32) (result i64) + (i64.load32_u offset=2 align=2 (local.get $i)) ;; 1717920867 'cdef' + ) + (func (export "32u_good5") (param $i i32) (result i64) + (i64.load32_u offset=25 align=4 (local.get $i)) ;; 122 'z\0\0\0' + ) + + (func (export "32s_good1") (param $i i32) (result i64) + (i64.load32_s offset=0 (local.get $i)) ;; 1684234849 'abcd' + ) + (func (export "32s_good2") (param $i i32) (result i64) + (i64.load32_s align=1 (local.get $i)) ;; 1684234849 'abcd' + ) + (func (export "32s_good3") (param $i i32) (result i64) + (i64.load32_s offset=1 align=1 (local.get $i)) ;; 1701077858 'bcde' + ) + (func (export "32s_good4") (param $i i32) (result i64) + (i64.load32_s offset=2 align=2 (local.get $i)) ;; 1717920867 'cdef' + ) + (func (export "32s_good5") (param $i i32) (result i64) + (i64.load32_s offset=25 align=4 (local.get $i)) ;; 122 'z\0\0\0' + ) + + (func (export "64_good1") (param $i i32) (result i64) + (i64.load offset=0 (local.get $i)) ;; 0x6867666564636261 'abcdefgh' + ) + (func (export "64_good2") (param $i i32) (result i64) + (i64.load align=1 (local.get $i)) ;; 0x6867666564636261 'abcdefgh' + ) + (func (export "64_good3") (param $i i32) (result i64) + (i64.load offset=1 align=1 (local.get $i)) ;; 0x6968676665646362 'bcdefghi' + ) + (func (export "64_good4") (param $i i32) (result i64) + (i64.load offset=2 align=2 (local.get $i)) ;; 0x6a69686766656463 'cdefghij' + ) + (func (export "64_good5") (param $i i32) (result i64) + (i64.load offset=25 align=8 (local.get $i)) ;; 122 'z\0\0\0\0\0\0\0' + ) + + (func (export "8u_bad") (param $i i32) + (drop (i64.load8_u offset=4294967295 (local.get $i))) + ) + (func (export "8s_bad") (param $i i32) + (drop (i64.load8_s offset=4294967295 (local.get $i))) + ) + (func (export "16u_bad") (param $i i32) + (drop (i64.load16_u offset=4294967295 (local.get $i))) + ) + (func (export "16s_bad") (param $i i32) + (drop (i64.load16_s offset=4294967295 (local.get $i))) + ) + (func (export "32u_bad") (param $i i32) + (drop (i64.load32_u offset=4294967295 (local.get $i))) + ) + (func (export "32s_bad") (param $i i32) + (drop (i64.load32_s offset=4294967295 (local.get $i))) + ) + (func (export "64_bad") (param $i i32) + (drop (i64.load offset=4294967295 (local.get $i))) + ) +) + +(assert_return (invoke "8u_good1" (i32.const 0)) (i64.const 97)) +(assert_return (invoke "8u_good2" (i32.const 0)) (i64.const 97)) +(assert_return (invoke "8u_good3" (i32.const 0)) (i64.const 98)) +(assert_return (invoke "8u_good4" (i32.const 0)) (i64.const 99)) +(assert_return (invoke "8u_good5" (i32.const 0)) (i64.const 122)) + +(assert_return (invoke "8s_good1" (i32.const 0)) (i64.const 97)) +(assert_return (invoke "8s_good2" (i32.const 0)) (i64.const 97)) +(assert_return (invoke "8s_good3" (i32.const 0)) (i64.const 98)) +(assert_return (invoke "8s_good4" (i32.const 0)) (i64.const 99)) +(assert_return (invoke "8s_good5" (i32.const 0)) (i64.const 122)) + +(assert_return (invoke "16u_good1" (i32.const 0)) (i64.const 25185)) +(assert_return (invoke "16u_good2" (i32.const 0)) (i64.const 25185)) +(assert_return (invoke "16u_good3" (i32.const 0)) (i64.const 25442)) +(assert_return (invoke "16u_good4" (i32.const 0)) (i64.const 25699)) +(assert_return (invoke "16u_good5" (i32.const 0)) (i64.const 122)) + +(assert_return (invoke "16s_good1" (i32.const 0)) (i64.const 25185)) +(assert_return (invoke "16s_good2" (i32.const 0)) (i64.const 25185)) +(assert_return (invoke "16s_good3" (i32.const 0)) (i64.const 25442)) +(assert_return (invoke "16s_good4" (i32.const 0)) (i64.const 25699)) +(assert_return (invoke "16s_good5" (i32.const 0)) (i64.const 122)) + +(assert_return (invoke "32u_good1" (i32.const 0)) (i64.const 1684234849)) +(assert_return (invoke "32u_good2" (i32.const 0)) (i64.const 1684234849)) +(assert_return (invoke "32u_good3" (i32.const 0)) (i64.const 1701077858)) +(assert_return (invoke "32u_good4" (i32.const 0)) (i64.const 1717920867)) +(assert_return (invoke "32u_good5" (i32.const 0)) (i64.const 122)) + +(assert_return (invoke "32s_good1" (i32.const 0)) (i64.const 1684234849)) +(assert_return (invoke "32s_good2" (i32.const 0)) (i64.const 1684234849)) +(assert_return (invoke "32s_good3" (i32.const 0)) (i64.const 1701077858)) +(assert_return (invoke "32s_good4" (i32.const 0)) (i64.const 1717920867)) +(assert_return (invoke "32s_good5" (i32.const 0)) (i64.const 122)) + +(assert_return (invoke "64_good1" (i32.const 0)) (i64.const 0x6867666564636261)) +(assert_return (invoke "64_good2" (i32.const 0)) (i64.const 0x6867666564636261)) +(assert_return (invoke "64_good3" (i32.const 0)) (i64.const 0x6968676665646362)) +(assert_return (invoke "64_good4" (i32.const 0)) (i64.const 0x6a69686766656463)) +(assert_return (invoke "64_good5" (i32.const 0)) (i64.const 122)) + +(assert_return (invoke "8u_good1" (i32.const 65503)) (i64.const 0)) +(assert_return (invoke "8u_good2" (i32.const 65503)) (i64.const 0)) +(assert_return (invoke "8u_good3" (i32.const 65503)) (i64.const 0)) +(assert_return (invoke "8u_good4" (i32.const 65503)) (i64.const 0)) +(assert_return (invoke "8u_good5" (i32.const 65503)) (i64.const 0)) + +(assert_return (invoke "8s_good1" (i32.const 65503)) (i64.const 0)) +(assert_return (invoke "8s_good2" (i32.const 65503)) (i64.const 0)) +(assert_return (invoke "8s_good3" (i32.const 65503)) (i64.const 0)) +(assert_return (invoke "8s_good4" (i32.const 65503)) (i64.const 0)) +(assert_return (invoke "8s_good5" (i32.const 65503)) (i64.const 0)) + +(assert_return (invoke "16u_good1" (i32.const 65503)) (i64.const 0)) +(assert_return (invoke "16u_good2" (i32.const 65503)) (i64.const 0)) +(assert_return (invoke "16u_good3" (i32.const 65503)) (i64.const 0)) +(assert_return (invoke "16u_good4" (i32.const 65503)) (i64.const 0)) +(assert_return (invoke "16u_good5" (i32.const 65503)) (i64.const 0)) + +(assert_return (invoke "16s_good1" (i32.const 65503)) (i64.const 0)) +(assert_return (invoke "16s_good2" (i32.const 65503)) (i64.const 0)) +(assert_return (invoke "16s_good3" (i32.const 65503)) (i64.const 0)) +(assert_return (invoke "16s_good4" (i32.const 65503)) (i64.const 0)) +(assert_return (invoke "16s_good5" (i32.const 65503)) (i64.const 0)) + +(assert_return (invoke "32u_good1" (i32.const 65503)) (i64.const 0)) +(assert_return (invoke "32u_good2" (i32.const 65503)) (i64.const 0)) +(assert_return (invoke "32u_good3" (i32.const 65503)) (i64.const 0)) +(assert_return (invoke "32u_good4" (i32.const 65503)) (i64.const 0)) +(assert_return (invoke "32u_good5" (i32.const 65503)) (i64.const 0)) + +(assert_return (invoke "32s_good1" (i32.const 65503)) (i64.const 0)) +(assert_return (invoke "32s_good2" (i32.const 65503)) (i64.const 0)) +(assert_return (invoke "32s_good3" (i32.const 65503)) (i64.const 0)) +(assert_return (invoke "32s_good4" (i32.const 65503)) (i64.const 0)) +(assert_return (invoke "32s_good5" (i32.const 65503)) (i64.const 0)) + +(assert_return (invoke "64_good1" (i32.const 65503)) (i64.const 0)) +(assert_return (invoke "64_good2" (i32.const 65503)) (i64.const 0)) +(assert_return (invoke "64_good3" (i32.const 65503)) (i64.const 0)) +(assert_return (invoke "64_good4" (i32.const 65503)) (i64.const 0)) +(assert_return (invoke "64_good5" (i32.const 65503)) (i64.const 0)) + +(assert_return (invoke "8u_good1" (i32.const 65504)) (i64.const 0)) +(assert_return (invoke "8u_good2" (i32.const 65504)) (i64.const 0)) +(assert_return (invoke "8u_good3" (i32.const 65504)) (i64.const 0)) +(assert_return (invoke "8u_good4" (i32.const 65504)) (i64.const 0)) +(assert_return (invoke "8u_good5" (i32.const 65504)) (i64.const 0)) + +(assert_return (invoke "8s_good1" (i32.const 65504)) (i64.const 0)) +(assert_return (invoke "8s_good2" (i32.const 65504)) (i64.const 0)) +(assert_return (invoke "8s_good3" (i32.const 65504)) (i64.const 0)) +(assert_return (invoke "8s_good4" (i32.const 65504)) (i64.const 0)) +(assert_return (invoke "8s_good5" (i32.const 65504)) (i64.const 0)) + +(assert_return (invoke "16u_good1" (i32.const 65504)) (i64.const 0)) +(assert_return (invoke "16u_good2" (i32.const 65504)) (i64.const 0)) +(assert_return (invoke "16u_good3" (i32.const 65504)) (i64.const 0)) +(assert_return (invoke "16u_good4" (i32.const 65504)) (i64.const 0)) +(assert_return (invoke "16u_good5" (i32.const 65504)) (i64.const 0)) + +(assert_return (invoke "16s_good1" (i32.const 65504)) (i64.const 0)) +(assert_return (invoke "16s_good2" (i32.const 65504)) (i64.const 0)) +(assert_return (invoke "16s_good3" (i32.const 65504)) (i64.const 0)) +(assert_return (invoke "16s_good4" (i32.const 65504)) (i64.const 0)) +(assert_return (invoke "16s_good5" (i32.const 65504)) (i64.const 0)) + +(assert_return (invoke "32u_good1" (i32.const 65504)) (i64.const 0)) +(assert_return (invoke "32u_good2" (i32.const 65504)) (i64.const 0)) +(assert_return (invoke "32u_good3" (i32.const 65504)) (i64.const 0)) +(assert_return (invoke "32u_good4" (i32.const 65504)) (i64.const 0)) +(assert_return (invoke "32u_good5" (i32.const 65504)) (i64.const 0)) + +(assert_return (invoke "32s_good1" (i32.const 65504)) (i64.const 0)) +(assert_return (invoke "32s_good2" (i32.const 65504)) (i64.const 0)) +(assert_return (invoke "32s_good3" (i32.const 65504)) (i64.const 0)) +(assert_return (invoke "32s_good4" (i32.const 65504)) (i64.const 0)) +(assert_return (invoke "32s_good5" (i32.const 65504)) (i64.const 0)) + +(assert_return (invoke "64_good1" (i32.const 65504)) (i64.const 0)) +(assert_return (invoke "64_good2" (i32.const 65504)) (i64.const 0)) +(assert_return (invoke "64_good3" (i32.const 65504)) (i64.const 0)) +(assert_return (invoke "64_good4" (i32.const 65504)) (i64.const 0)) +(assert_trap (invoke "64_good5" (i32.const 65504)) "out of bounds memory access") + +(assert_trap (invoke "8u_good3" (i32.const -1)) "out of bounds memory access") +(assert_trap (invoke "8s_good3" (i32.const -1)) "out of bounds memory access") +(assert_trap (invoke "16u_good3" (i32.const -1)) "out of bounds memory access") +(assert_trap (invoke "16s_good3" (i32.const -1)) "out of bounds memory access") +(assert_trap (invoke "32u_good3" (i32.const -1)) "out of bounds memory access") +(assert_trap (invoke "32s_good3" (i32.const -1)) "out of bounds memory access") +(assert_trap (invoke "64_good3" (i32.const -1)) "out of bounds memory access") + +(assert_trap (invoke "8u_bad" (i32.const 0)) "out of bounds memory access") +(assert_trap (invoke "8s_bad" (i32.const 0)) "out of bounds memory access") +(assert_trap (invoke "16u_bad" (i32.const 0)) "out of bounds memory access") +(assert_trap (invoke "16s_bad" (i32.const 0)) "out of bounds memory access") +(assert_trap (invoke "32u_bad" (i32.const 0)) "out of bounds memory access") +(assert_trap (invoke "32s_bad" (i32.const 0)) "out of bounds memory access") +(assert_trap (invoke "64_bad" (i32.const 0)) "out of bounds memory access") + +(assert_trap (invoke "8u_bad" (i32.const 1)) "out of bounds memory access") +(assert_trap (invoke "8s_bad" (i32.const 1)) "out of bounds memory access") +(assert_trap (invoke "16u_bad" (i32.const 1)) "out of bounds memory access") +(assert_trap (invoke "16s_bad" (i32.const 1)) "out of bounds memory access") +(assert_trap (invoke "32u_bad" (i32.const 0)) "out of bounds memory access") +(assert_trap (invoke "32s_bad" (i32.const 0)) "out of bounds memory access") +(assert_trap (invoke "64_bad" (i32.const 1)) "out of bounds memory access") + +;; Load f32 data with different offset/align arguments + +(module + (memory 1) + (data (i32.const 0) "\00\00\00\00\00\00\a0\7f\01\00\d0\7f") + + (func (export "32_good1") (param $i i32) (result f32) + (f32.load offset=0 (local.get $i)) ;; 0.0 '\00\00\00\00' + ) + (func (export "32_good2") (param $i i32) (result f32) + (f32.load align=1 (local.get $i)) ;; 0.0 '\00\00\00\00' + ) + (func (export "32_good3") (param $i i32) (result f32) + (f32.load offset=1 align=1 (local.get $i)) ;; 0.0 '\00\00\00\00' + ) + (func (export "32_good4") (param $i i32) (result f32) + (f32.load offset=2 align=2 (local.get $i)) ;; 0.0 '\00\00\00\00' + ) + (func (export "32_good5") (param $i i32) (result f32) + (f32.load offset=8 align=4 (local.get $i)) ;; nan:0x500001 '\01\00\d0\7f' + ) + (func (export "32_bad") (param $i i32) + (drop (f32.load offset=4294967295 (local.get $i))) + ) +) + +(assert_return (invoke "32_good1" (i32.const 0)) (f32.const 0.0)) +(assert_return (invoke "32_good2" (i32.const 0)) (f32.const 0.0)) +(assert_return (invoke "32_good3" (i32.const 0)) (f32.const 0.0)) +(assert_return (invoke "32_good4" (i32.const 0)) (f32.const 0.0)) +(assert_return (invoke "32_good5" (i32.const 0)) (f32.const nan:0x500001)) + +(assert_return (invoke "32_good1" (i32.const 65524)) (f32.const 0.0)) +(assert_return (invoke "32_good2" (i32.const 65524)) (f32.const 0.0)) +(assert_return (invoke "32_good3" (i32.const 65524)) (f32.const 0.0)) +(assert_return (invoke "32_good4" (i32.const 65524)) (f32.const 0.0)) +(assert_return (invoke "32_good5" (i32.const 65524)) (f32.const 0.0)) + +(assert_return (invoke "32_good1" (i32.const 65525)) (f32.const 0.0)) +(assert_return (invoke "32_good2" (i32.const 65525)) (f32.const 0.0)) +(assert_return (invoke "32_good3" (i32.const 65525)) (f32.const 0.0)) +(assert_return (invoke "32_good4" (i32.const 65525)) (f32.const 0.0)) +(assert_trap (invoke "32_good5" (i32.const 65525)) "out of bounds memory access") + +(assert_trap (invoke "32_good3" (i32.const -1)) "out of bounds memory access") +(assert_trap (invoke "32_good3" (i32.const -1)) "out of bounds memory access") + +(assert_trap (invoke "32_bad" (i32.const 0)) "out of bounds memory access") +(assert_trap (invoke "32_bad" (i32.const 1)) "out of bounds memory access") + +;; Load f64 data with different offset/align arguments + +(module + (memory 1) + (data (i32.const 0) "\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\f4\7f\01\00\00\00\00\00\fc\7f") + + (func (export "64_good1") (param $i i32) (result f64) + (f64.load offset=0 (local.get $i)) ;; 0.0 '\00\00\00\00\00\00\00\00' + ) + (func (export "64_good2") (param $i i32) (result f64) + (f64.load align=1 (local.get $i)) ;; 0.0 '\00\00\00\00\00\00\00\00' + ) + (func (export "64_good3") (param $i i32) (result f64) + (f64.load offset=1 align=1 (local.get $i)) ;; 0.0 '\00\00\00\00\00\00\00\00' + ) + (func (export "64_good4") (param $i i32) (result f64) + (f64.load offset=2 align=2 (local.get $i)) ;; 0.0 '\00\00\00\00\00\00\00\00' + ) + (func (export "64_good5") (param $i i32) (result f64) + (f64.load offset=18 align=8 (local.get $i)) ;; nan:0xc000000000001 '\01\00\00\00\00\00\fc\7f' + ) + (func (export "64_bad") (param $i i32) + (drop (f64.load offset=4294967295 (local.get $i))) + ) +) + +(assert_return (invoke "64_good1" (i32.const 0)) (f64.const 0.0)) +(assert_return (invoke "64_good2" (i32.const 0)) (f64.const 0.0)) +(assert_return (invoke "64_good3" (i32.const 0)) (f64.const 0.0)) +(assert_return (invoke "64_good4" (i32.const 0)) (f64.const 0.0)) +(assert_return (invoke "64_good5" (i32.const 0)) (f64.const nan:0xc000000000001)) + +(assert_return (invoke "64_good1" (i32.const 65510)) (f64.const 0.0)) +(assert_return (invoke "64_good2" (i32.const 65510)) (f64.const 0.0)) +(assert_return (invoke "64_good3" (i32.const 65510)) (f64.const 0.0)) +(assert_return (invoke "64_good4" (i32.const 65510)) (f64.const 0.0)) +(assert_return (invoke "64_good5" (i32.const 65510)) (f64.const 0.0)) + +(assert_return (invoke "64_good1" (i32.const 65511)) (f64.const 0.0)) +(assert_return (invoke "64_good2" (i32.const 65511)) (f64.const 0.0)) +(assert_return (invoke "64_good3" (i32.const 65511)) (f64.const 0.0)) +(assert_return (invoke "64_good4" (i32.const 65511)) (f64.const 0.0)) +(assert_trap (invoke "64_good5" (i32.const 65511)) "out of bounds memory access") + +(assert_trap (invoke "64_good3" (i32.const -1)) "out of bounds memory access") +(assert_trap (invoke "64_good3" (i32.const -1)) "out of bounds memory access") + +(assert_trap (invoke "64_bad" (i32.const 0)) "out of bounds memory access") +(assert_trap (invoke "64_bad" (i32.const 1)) "out of bounds memory access") diff --git a/runtime/near-vm/tests/wast/spec/align.wast b/runtime/near-vm/tests/wast/spec/align.wast new file mode 100644 index 00000000000..93064649d38 --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/align.wast @@ -0,0 +1,866 @@ +;; Test alignment annotation rules + +(module (memory 0) (func (drop (i32.load8_s align=1 (i32.const 0))))) +(module (memory 0) (func (drop (i32.load8_u align=1 (i32.const 0))))) +(module (memory 0) (func (drop (i32.load16_s align=2 (i32.const 0))))) +(module (memory 0) (func (drop (i32.load16_u align=2 (i32.const 0))))) +(module (memory 0) (func (drop (i32.load align=4 (i32.const 0))))) +(module (memory 0) (func (drop (i64.load8_s align=1 (i32.const 0))))) +(module (memory 0) (func (drop (i64.load8_u align=1 (i32.const 0))))) +(module (memory 0) (func (drop (i64.load16_s align=2 (i32.const 0))))) +(module (memory 0) (func (drop (i64.load16_u align=2 (i32.const 0))))) +(module (memory 0) (func (drop (i64.load32_s align=4 (i32.const 0))))) +(module (memory 0) (func (drop (i64.load32_u align=4 (i32.const 0))))) +(module (memory 0) (func (drop (i64.load align=8 (i32.const 0))))) +(module (memory 0) (func (drop (f32.load align=4 (i32.const 0))))) +(module (memory 0) (func (drop (f64.load align=8 (i32.const 0))))) +(module (memory 0) (func (i32.store8 align=1 (i32.const 0) (i32.const 1)))) +(module (memory 0) (func (i32.store16 align=2 (i32.const 0) (i32.const 1)))) +(module (memory 0) (func (i32.store align=4 (i32.const 0) (i32.const 1)))) +(module (memory 0) (func (i64.store8 align=1 (i32.const 0) (i64.const 1)))) +(module (memory 0) (func (i64.store16 align=2 (i32.const 0) (i64.const 1)))) +(module (memory 0) (func (i64.store32 align=4 (i32.const 0) (i64.const 1)))) +(module (memory 0) (func (i64.store align=8 (i32.const 0) (i64.const 1)))) +(module (memory 0) (func (f32.store align=4 (i32.const 0) (f32.const 1.0)))) +(module (memory 0) (func (f64.store align=8 (i32.const 0) (f64.const 1.0)))) + +(assert_malformed + (module quote + "(module (memory 0) (func (drop (i32.load8_s align=0 (i32.const 0)))))" + ) + "alignment" +) +(assert_malformed + (module quote + "(module (memory 0) (func (drop (i32.load8_s align=7 (i32.const 0)))))" + ) + "alignment" +) +(assert_malformed + (module quote + "(module (memory 0) (func (drop (i32.load8_u align=0 (i32.const 0)))))" + ) + "alignment" +) +(assert_malformed + (module quote + "(module (memory 0) (func (drop (i32.load8_u align=7 (i32.const 0)))))" + ) + "alignment" +) +(assert_malformed + (module quote + "(module (memory 0) (func (drop (i32.load16_s align=0 (i32.const 0)))))" + ) + "alignment" +) +(assert_malformed + (module quote + "(module (memory 0) (func (drop (i32.load16_s align=7 (i32.const 0)))))" + ) + "alignment" +) +(assert_malformed + (module quote + "(module (memory 0) (func (drop (i32.load16_u align=0 (i32.const 0)))))" + ) + "alignment" +) +(assert_malformed + (module quote + "(module (memory 0) (func (drop (i32.load16_u align=7 (i32.const 0)))))" + ) + "alignment" +) +(assert_malformed + (module quote + "(module (memory 0) (func (drop (i32.load align=0 (i32.const 0)))))" + ) + "alignment" +) +(assert_malformed + (module quote + "(module (memory 0) (func (drop (i32.load align=7 (i32.const 0)))))" + ) + "alignment" +) +(assert_malformed + (module quote + "(module (memory 0) (func (drop (i64.load8_s align=0 (i32.const 0)))))" + ) + "alignment" +) +(assert_malformed + (module quote + "(module (memory 0) (func (drop (i64.load8_s align=7 (i32.const 0)))))" + ) + "alignment" +) +(assert_malformed + (module quote + "(module (memory 0) (func (drop (i64.load8_u align=0 (i32.const 0)))))" + ) + "alignment" +) +(assert_malformed + (module quote + "(module (memory 0) (func (drop (i64.load8_u align=7 (i32.const 0)))))" + ) + "alignment" +) +(assert_malformed + (module quote + "(module (memory 0) (func (drop (i64.load16_s align=0 (i32.const 0)))))" + ) + "alignment" +) +(assert_malformed + (module quote + "(module (memory 0) (func (drop (i64.load16_s align=7 (i32.const 0)))))" + ) + "alignment" +) +(assert_malformed + (module quote + "(module (memory 0) (func (drop (i64.load16_u align=0 (i32.const 0)))))" + ) + "alignment" +) +(assert_malformed + (module quote + "(module (memory 0) (func (drop (i64.load16_u align=7 (i32.const 0)))))" + ) + "alignment" +) +(assert_malformed + (module quote + "(module (memory 0) (func (drop (i64.load32_s align=0 (i32.const 0)))))" + ) + "alignment" +) +(assert_malformed + (module quote + "(module (memory 0) (func (drop (i64.load32_s align=7 (i32.const 0)))))" + ) + "alignment" +) +(assert_malformed + (module quote + "(module (memory 0) (func (drop (i64.load32_u align=0 (i32.const 0)))))" + ) + "alignment" +) +(assert_malformed + (module quote + "(module (memory 0) (func (drop (i64.load32_u align=7 (i32.const 0)))))" + ) + "alignment" +) +(assert_malformed + (module quote + "(module (memory 0) (func (drop (i64.load align=0 (i32.const 0)))))" + ) + "alignment" +) +(assert_malformed + (module quote + "(module (memory 0) (func (drop (i64.load align=7 (i32.const 0)))))" + ) + "alignment" +) +(assert_malformed + (module quote + "(module (memory 0) (func (drop (f32.load align=0 (i32.const 0)))))" + ) + "alignment" +) +(assert_malformed + (module quote + "(module (memory 0) (func (drop (f32.load align=7 (i32.const 0)))))" + ) + "alignment" +) +(assert_malformed + (module quote + "(module (memory 0) (func (drop (f64.load align=0 (i32.const 0)))))" + ) + "alignment" +) +(assert_malformed + (module quote + "(module (memory 0) (func (drop (f64.load align=7 (i32.const 0)))))" + ) + "alignment" +) + +(assert_malformed + (module quote + "(module (memory 0) (func (i32.store8 align=0 (i32.const 0) (i32.const 0))))" + ) + "alignment" +) +(assert_malformed + (module quote + "(module (memory 0) (func (i32.store8 align=7 (i32.const 0) (i32.const 0))))" + ) + "alignment" +) +(assert_malformed + (module quote + "(module (memory 0) (func (i32.store16 align=0 (i32.const 0) (i32.const 0))))" + ) + "alignment" +) +(assert_malformed + (module quote + "(module (memory 0) (func (i32.store16 align=7 (i32.const 0) (i32.const 0))))" + ) + "alignment" +) +(assert_malformed + (module quote + "(module (memory 0) (func (i32.store align=0 (i32.const 0) (i32.const 0))))" + ) + "alignment" +) +(assert_malformed + (module quote + "(module (memory 0) (func (i32.store align=7 (i32.const 0) (i32.const 0))))" + ) + "alignment" +) +(assert_malformed + (module quote + "(module (memory 0) (func (i64.store8 align=0 (i32.const 0) (i64.const 0))))" + ) + "alignment" +) +(assert_malformed + (module quote + "(module (memory 0) (func (i64.store8 align=7 (i32.const 0) (i64.const 0))))" + ) + "alignment" +) +(assert_malformed + (module quote + "(module (memory 0) (func (i64.store16 align=0 (i32.const 0) (i64.const 0))))" + ) + "alignment" +) +(assert_malformed + (module quote + "(module (memory 0) (func (i64.store16 align=7 (i32.const 0) (i64.const 0))))" + ) + "alignment" +) +(assert_malformed + (module quote + "(module (memory 0) (func (i64.store32 align=0 (i32.const 0) (i64.const 0))))" + ) + "alignment" +) +(assert_malformed + (module quote + "(module (memory 0) (func (i64.store32 align=7 (i32.const 0) (i64.const 0))))" + ) + "alignment" +) +(assert_malformed + (module quote + "(module (memory 0) (func (i64.store align=0 (i32.const 0) (i64.const 0))))" + ) + "alignment" +) +(assert_malformed + (module quote + "(module (memory 0) (func (i64.store align=7 (i32.const 0) (i64.const 0))))" + ) + "alignment" +) +(assert_malformed + (module quote + "(module (memory 0) (func (f32.store align=0 (i32.const 0) (f32.const 0))))" + ) + "alignment" +) +(assert_malformed + (module quote + "(module (memory 0) (func (f32.store align=7 (i32.const 0) (f32.const 0))))" + ) + "alignment" +) +(assert_malformed + (module quote + "(module (memory 0) (func (f64.store align=0 (i32.const 0) (f32.const 0))))" + ) + "alignment" +) +(assert_malformed + (module quote + "(module (memory 0) (func (f64.store align=7 (i32.const 0) (f32.const 0))))" + ) + "alignment" +) + +(assert_invalid + (module (memory 0) (func (drop (i32.load8_s align=2 (i32.const 0))))) + "alignment must not be larger than natural" +) +(assert_invalid + (module (memory 0) (func (drop (i32.load8_u align=2 (i32.const 0))))) + "alignment must not be larger than natural" +) +(assert_invalid + (module (memory 0) (func (drop (i32.load16_s align=4 (i32.const 0))))) + "alignment must not be larger than natural" +) +(assert_invalid + (module (memory 0) (func (drop (i32.load16_u align=4 (i32.const 0))))) + "alignment must not be larger than natural" +) +(assert_invalid + (module (memory 0) (func (drop (i32.load align=8 (i32.const 0))))) + "alignment must not be larger than natural" +) +(assert_invalid + (module (memory 0) (func (drop (i64.load8_s align=2 (i32.const 0))))) + "alignment must not be larger than natural" +) +(assert_invalid + (module (memory 0) (func (drop (i64.load8_u align=2 (i32.const 0))))) + "alignment must not be larger than natural" +) +(assert_invalid + (module (memory 0) (func (drop (i64.load16_s align=4 (i32.const 0))))) + "alignment must not be larger than natural" +) +(assert_invalid + (module (memory 0) (func (drop (i64.load16_u align=4 (i32.const 0))))) + "alignment must not be larger than natural" +) +(assert_invalid + (module (memory 0) (func (drop (i64.load32_s align=8 (i32.const 0))))) + "alignment must not be larger than natural" +) +(assert_invalid + (module (memory 0) (func (drop (i64.load32_u align=8 (i32.const 0))))) + "alignment must not be larger than natural" +) +(assert_invalid + (module (memory 0) (func (drop (i64.load align=16 (i32.const 0))))) + "alignment must not be larger than natural" +) +(assert_invalid + (module (memory 0) (func (drop (f32.load align=8 (i32.const 0))))) + "alignment must not be larger than natural" +) +(assert_invalid + (module (memory 0) (func (drop (f64.load align=16 (i32.const 0))))) + "alignment must not be larger than natural" +) + +(assert_invalid + (module (memory 0) (func (drop (i32.load8_s align=2 (i32.const 0))))) + "alignment must not be larger than natural" +) +(assert_invalid + (module (memory 0) (func (drop (i32.load8_u align=2 (i32.const 0))))) + "alignment must not be larger than natural" +) +(assert_invalid + (module (memory 0) (func (drop (i32.load16_s align=4 (i32.const 0))))) + "alignment must not be larger than natural" +) +(assert_invalid + (module (memory 0) (func (drop (i32.load16_u align=4 (i32.const 0))))) + "alignment must not be larger than natural" +) +(assert_invalid + (module (memory 0) (func (drop (i32.load align=8 (i32.const 0))))) + "alignment must not be larger than natural" +) +(assert_invalid + (module (memory 0) (func (drop (i64.load8_s align=2 (i32.const 0))))) + "alignment must not be larger than natural" +) +(assert_invalid + (module (memory 0) (func (drop (i64.load8_u align=2 (i32.const 0))))) + "alignment must not be larger than natural" +) +(assert_invalid + (module (memory 0) (func (drop (i64.load16_s align=4 (i32.const 0))))) + "alignment must not be larger than natural" +) +(assert_invalid + (module (memory 0) (func (drop (i64.load16_u align=4 (i32.const 0))))) + "alignment must not be larger than natural" +) +(assert_invalid + (module (memory 0) (func (drop (i64.load32_s align=8 (i32.const 0))))) + "alignment must not be larger than natural" +) +(assert_invalid + (module (memory 0) (func (drop (i64.load32_u align=8 (i32.const 0))))) + "alignment must not be larger than natural" +) +(assert_invalid + (module (memory 0) (func (drop (i64.load align=16 (i32.const 0))))) + "alignment must not be larger than natural" +) +(assert_invalid + (module (memory 0) (func (drop (f32.load align=8 (i32.const 0))))) + "alignment must not be larger than natural" +) +(assert_invalid + (module (memory 0) (func (drop (f64.load align=16 (i32.const 0))))) + "alignment must not be larger than natural" +) + +(assert_invalid + (module (memory 0) (func (i32.store8 align=2 (i32.const 0) (i32.const 0)))) + "alignment must not be larger than natural" +) +(assert_invalid + (module (memory 0) (func (i32.store16 align=4 (i32.const 0) (i32.const 0)))) + "alignment must not be larger than natural" +) +(assert_invalid + (module (memory 0) (func (i32.store align=8 (i32.const 0) (i32.const 0)))) + "alignment must not be larger than natural" +) +(assert_invalid + (module (memory 0) (func (i64.store8 align=2 (i32.const 0) (i64.const 0)))) + "alignment must not be larger than natural" +) +(assert_invalid + (module (memory 0) (func (i64.store16 align=4 (i32.const 0) (i64.const 0)))) + "alignment must not be larger than natural" +) +(assert_invalid + (module (memory 0) (func (i64.store32 align=8 (i32.const 0) (i64.const 0)))) + "alignment must not be larger than natural" +) +(assert_invalid + (module (memory 0) (func (i64.store align=16 (i32.const 0) (i64.const 0)))) + "alignment must not be larger than natural" +) +(assert_invalid + (module (memory 0) (func (f32.store align=8 (i32.const 0) (f32.const 0)))) + "alignment must not be larger than natural" +) +(assert_invalid + (module (memory 0) (func (f64.store align=16 (i32.const 0) (f64.const 0)))) + "alignment must not be larger than natural" +) + +;; Test aligned and unaligned read/write + +(module + (memory 1) + + ;; $default: natural alignment, $1: align=1, $2: align=2, $4: align=4, $8: align=8 + + (func (export "f32_align_switch") (param i32) (result f32) + (local f32 f32) + (local.set 1 (f32.const 10.0)) + (block $4 + (block $2 + (block $1 + (block $default + (block $0 + (br_table $0 $default $1 $2 $4 (local.get 0)) + ) ;; 0 + (f32.store (i32.const 0) (local.get 1)) + (local.set 2 (f32.load (i32.const 0))) + (br $4) + ) ;; default + (f32.store align=1 (i32.const 0) (local.get 1)) + (local.set 2 (f32.load align=1 (i32.const 0))) + (br $4) + ) ;; 1 + (f32.store align=2 (i32.const 0) (local.get 1)) + (local.set 2 (f32.load align=2 (i32.const 0))) + (br $4) + ) ;; 2 + (f32.store align=4 (i32.const 0) (local.get 1)) + (local.set 2 (f32.load align=4 (i32.const 0))) + ) ;; 4 + (local.get 2) + ) + + (func (export "f64_align_switch") (param i32) (result f64) + (local f64 f64) + (local.set 1 (f64.const 10.0)) + (block $8 + (block $4 + (block $2 + (block $1 + (block $default + (block $0 + (br_table $0 $default $1 $2 $4 $8 (local.get 0)) + ) ;; 0 + (f64.store (i32.const 0) (local.get 1)) + (local.set 2 (f64.load (i32.const 0))) + (br $8) + ) ;; default + (f64.store align=1 (i32.const 0) (local.get 1)) + (local.set 2 (f64.load align=1 (i32.const 0))) + (br $8) + ) ;; 1 + (f64.store align=2 (i32.const 0) (local.get 1)) + (local.set 2 (f64.load align=2 (i32.const 0))) + (br $8) + ) ;; 2 + (f64.store align=4 (i32.const 0) (local.get 1)) + (local.set 2 (f64.load align=4 (i32.const 0))) + (br $8) + ) ;; 4 + (f64.store align=8 (i32.const 0) (local.get 1)) + (local.set 2 (f64.load align=8 (i32.const 0))) + ) ;; 8 + (local.get 2) + ) + + ;; $8s: i32/i64.load8_s, $8u: i32/i64.load8_u, $16s: i32/i64.load16_s, $16u: i32/i64.load16_u, $32: i32.load + ;; $32s: i64.load32_s, $32u: i64.load32_u, $64: i64.load + + (func (export "i32_align_switch") (param i32 i32) (result i32) + (local i32 i32) + (local.set 2 (i32.const 10)) + (block $32 + (block $16u + (block $16s + (block $8u + (block $8s + (block $0 + (br_table $0 $8s $8u $16s $16u $32 (local.get 0)) + ) ;; 0 + (if (i32.eq (local.get 1) (i32.const 0)) + (then + (i32.store8 (i32.const 0) (local.get 2)) + (local.set 3 (i32.load8_s (i32.const 0))) + ) + ) + (if (i32.eq (local.get 1) (i32.const 1)) + (then + (i32.store8 align=1 (i32.const 0) (local.get 2)) + (local.set 3 (i32.load8_s align=1 (i32.const 0))) + ) + ) + (br $32) + ) ;; 8s + (if (i32.eq (local.get 1) (i32.const 0)) + (then + (i32.store8 (i32.const 0) (local.get 2)) + (local.set 3 (i32.load8_u (i32.const 0))) + ) + ) + (if (i32.eq (local.get 1) (i32.const 1)) + (then + (i32.store8 align=1 (i32.const 0) (local.get 2)) + (local.set 3 (i32.load8_u align=1 (i32.const 0))) + ) + ) + (br $32) + ) ;; 8u + (if (i32.eq (local.get 1) (i32.const 0)) + (then + (i32.store16 (i32.const 0) (local.get 2)) + (local.set 3 (i32.load16_s (i32.const 0))) + ) + ) + (if (i32.eq (local.get 1) (i32.const 1)) + (then + (i32.store16 align=1 (i32.const 0) (local.get 2)) + (local.set 3 (i32.load16_s align=1 (i32.const 0))) + ) + ) + (if (i32.eq (local.get 1) (i32.const 2)) + (then + (i32.store16 align=2 (i32.const 0) (local.get 2)) + (local.set 3 (i32.load16_s align=2 (i32.const 0))) + ) + ) + (br $32) + ) ;; 16s + (if (i32.eq (local.get 1) (i32.const 0)) + (then + (i32.store16 (i32.const 0) (local.get 2)) + (local.set 3 (i32.load16_u (i32.const 0))) + ) + ) + (if (i32.eq (local.get 1) (i32.const 1)) + (then + (i32.store16 align=1 (i32.const 0) (local.get 2)) + (local.set 3 (i32.load16_u align=1 (i32.const 0))) + ) + ) + (if (i32.eq (local.get 1) (i32.const 2)) + (then + (i32.store16 align=2 (i32.const 0) (local.get 2)) + (local.set 3 (i32.load16_u align=2 (i32.const 0))) + ) + ) + (br $32) + ) ;; 16u + (if (i32.eq (local.get 1) (i32.const 0)) + (then + (i32.store (i32.const 0) (local.get 2)) + (local.set 3 (i32.load (i32.const 0))) + ) + ) + (if (i32.eq (local.get 1) (i32.const 1)) + (then + (i32.store align=1 (i32.const 0) (local.get 2)) + (local.set 3 (i32.load align=1 (i32.const 0))) + ) + ) + (if (i32.eq (local.get 1) (i32.const 2)) + (then + (i32.store align=2 (i32.const 0) (local.get 2)) + (local.set 3 (i32.load align=2 (i32.const 0))) + ) + ) + (if (i32.eq (local.get 1) (i32.const 4)) + (then + (i32.store align=4 (i32.const 0) (local.get 2)) + (local.set 3 (i32.load align=4 (i32.const 0))) + ) + ) + ) ;; 32 + (local.get 3) + ) + + (func (export "i64_align_switch") (param i32 i32) (result i64) + (local i64 i64) + (local.set 2 (i64.const 10)) + (block $64 + (block $32u + (block $32s + (block $16u + (block $16s + (block $8u + (block $8s + (block $0 + (br_table $0 $8s $8u $16s $16u $32s $32u $64 (local.get 0)) + ) ;; 0 + (if (i32.eq (local.get 1) (i32.const 0)) + (then + (i64.store8 (i32.const 0) (local.get 2)) + (local.set 3 (i64.load8_s (i32.const 0))) + ) + ) + (if (i32.eq (local.get 1) (i32.const 1)) + (then + (i64.store8 align=1 (i32.const 0) (local.get 2)) + (local.set 3 (i64.load8_s align=1 (i32.const 0))) + ) + ) + (br $64) + ) ;; 8s + (if (i32.eq (local.get 1) (i32.const 0)) + (then + (i64.store8 (i32.const 0) (local.get 2)) + (local.set 3 (i64.load8_u (i32.const 0))) + ) + ) + (if (i32.eq (local.get 1) (i32.const 1)) + (then + (i64.store8 align=1 (i32.const 0) (local.get 2)) + (local.set 3 (i64.load8_u align=1 (i32.const 0))) + ) + ) + (br $64) + ) ;; 8u + (if (i32.eq (local.get 1) (i32.const 0)) + (then + (i64.store16 (i32.const 0) (local.get 2)) + (local.set 3 (i64.load16_s (i32.const 0))) + ) + ) + (if (i32.eq (local.get 1) (i32.const 1)) + (then + (i64.store16 align=1 (i32.const 0) (local.get 2)) + (local.set 3 (i64.load16_s align=1 (i32.const 0))) + ) + ) + (if (i32.eq (local.get 1) (i32.const 2)) + (then + (i64.store16 align=2 (i32.const 0) (local.get 2)) + (local.set 3 (i64.load16_s align=2 (i32.const 0))) + ) + ) + (br $64) + ) ;; 16s + (if (i32.eq (local.get 1) (i32.const 0)) + (then + (i64.store16 (i32.const 0) (local.get 2)) + (local.set 3 (i64.load16_u (i32.const 0))) + ) + ) + (if (i32.eq (local.get 1) (i32.const 1)) + (then + (i64.store16 align=1 (i32.const 0) (local.get 2)) + (local.set 3 (i64.load16_u align=1 (i32.const 0))) + ) + ) + (if (i32.eq (local.get 1) (i32.const 2)) + (then + (i64.store16 align=2 (i32.const 0) (local.get 2)) + (local.set 3 (i64.load16_u align=2 (i32.const 0))) + ) + ) + (br $64) + ) ;; 16u + (if (i32.eq (local.get 1) (i32.const 0)) + (then + (i64.store32 (i32.const 0) (local.get 2)) + (local.set 3 (i64.load32_s (i32.const 0))) + ) + ) + (if (i32.eq (local.get 1) (i32.const 1)) + (then + (i64.store32 align=1 (i32.const 0) (local.get 2)) + (local.set 3 (i64.load32_s align=1 (i32.const 0))) + ) + ) + (if (i32.eq (local.get 1) (i32.const 2)) + (then + (i64.store32 align=2 (i32.const 0) (local.get 2)) + (local.set 3 (i64.load32_s align=2 (i32.const 0))) + ) + ) + (if (i32.eq (local.get 1) (i32.const 4)) + (then + (i64.store32 align=4 (i32.const 0) (local.get 2)) + (local.set 3 (i64.load32_s align=4 (i32.const 0))) + ) + ) + (br $64) + ) ;; 32s + (if (i32.eq (local.get 1) (i32.const 0)) + (then + (i64.store32 (i32.const 0) (local.get 2)) + (local.set 3 (i64.load32_u (i32.const 0))) + ) + ) + (if (i32.eq (local.get 1) (i32.const 1)) + (then + (i64.store32 align=1 (i32.const 0) (local.get 2)) + (local.set 3 (i64.load32_u align=1 (i32.const 0))) + ) + ) + (if (i32.eq (local.get 1) (i32.const 2)) + (then + (i64.store32 align=2 (i32.const 0) (local.get 2)) + (local.set 3 (i64.load32_u align=2 (i32.const 0))) + ) + ) + (if (i32.eq (local.get 1) (i32.const 4)) + (then + (i64.store32 align=4 (i32.const 0) (local.get 2)) + (local.set 3 (i64.load32_u align=4 (i32.const 0))) + ) + ) + (br $64) + ) ;; 32u + (if (i32.eq (local.get 1) (i32.const 0)) + (then + (i64.store (i32.const 0) (local.get 2)) + (local.set 3 (i64.load (i32.const 0))) + ) + ) + (if (i32.eq (local.get 1) (i32.const 1)) + (then + (i64.store align=1 (i32.const 0) (local.get 2)) + (local.set 3 (i64.load align=1 (i32.const 0))) + ) + ) + (if (i32.eq (local.get 1) (i32.const 2)) + (then + (i64.store align=2 (i32.const 0) (local.get 2)) + (local.set 3 (i64.load align=2 (i32.const 0))) + ) + ) + (if (i32.eq (local.get 1) (i32.const 4)) + (then + (i64.store align=4 (i32.const 0) (local.get 2)) + (local.set 3 (i64.load align=4 (i32.const 0))) + ) + ) + (if (i32.eq (local.get 1) (i32.const 8)) + (then + (i64.store align=8 (i32.const 0) (local.get 2)) + (local.set 3 (i64.load align=8 (i32.const 0))) + ) + ) + ) ;; 64 + (local.get 3) + ) +) + +(assert_return (invoke "f32_align_switch" (i32.const 0)) (f32.const 10.0)) +(assert_return (invoke "f32_align_switch" (i32.const 1)) (f32.const 10.0)) +(assert_return (invoke "f32_align_switch" (i32.const 2)) (f32.const 10.0)) +(assert_return (invoke "f32_align_switch" (i32.const 3)) (f32.const 10.0)) + +(assert_return (invoke "f64_align_switch" (i32.const 0)) (f64.const 10.0)) +(assert_return (invoke "f64_align_switch" (i32.const 1)) (f64.const 10.0)) +(assert_return (invoke "f64_align_switch" (i32.const 2)) (f64.const 10.0)) +(assert_return (invoke "f64_align_switch" (i32.const 3)) (f64.const 10.0)) +(assert_return (invoke "f64_align_switch" (i32.const 4)) (f64.const 10.0)) + +(assert_return (invoke "i32_align_switch" (i32.const 0) (i32.const 0)) (i32.const 10)) +(assert_return (invoke "i32_align_switch" (i32.const 0) (i32.const 1)) (i32.const 10)) +(assert_return (invoke "i32_align_switch" (i32.const 1) (i32.const 0)) (i32.const 10)) +(assert_return (invoke "i32_align_switch" (i32.const 1) (i32.const 1)) (i32.const 10)) +(assert_return (invoke "i32_align_switch" (i32.const 2) (i32.const 0)) (i32.const 10)) +(assert_return (invoke "i32_align_switch" (i32.const 2) (i32.const 1)) (i32.const 10)) +(assert_return (invoke "i32_align_switch" (i32.const 2) (i32.const 2)) (i32.const 10)) +(assert_return (invoke "i32_align_switch" (i32.const 3) (i32.const 0)) (i32.const 10)) +(assert_return (invoke "i32_align_switch" (i32.const 3) (i32.const 1)) (i32.const 10)) +(assert_return (invoke "i32_align_switch" (i32.const 3) (i32.const 2)) (i32.const 10)) +(assert_return (invoke "i32_align_switch" (i32.const 4) (i32.const 0)) (i32.const 10)) +(assert_return (invoke "i32_align_switch" (i32.const 4) (i32.const 1)) (i32.const 10)) +(assert_return (invoke "i32_align_switch" (i32.const 4) (i32.const 2)) (i32.const 10)) +(assert_return (invoke "i32_align_switch" (i32.const 4) (i32.const 4)) (i32.const 10)) + +(assert_return (invoke "i64_align_switch" (i32.const 0) (i32.const 0)) (i64.const 10)) +(assert_return (invoke "i64_align_switch" (i32.const 0) (i32.const 1)) (i64.const 10)) +(assert_return (invoke "i64_align_switch" (i32.const 1) (i32.const 0)) (i64.const 10)) +(assert_return (invoke "i64_align_switch" (i32.const 1) (i32.const 1)) (i64.const 10)) +(assert_return (invoke "i64_align_switch" (i32.const 2) (i32.const 0)) (i64.const 10)) +(assert_return (invoke "i64_align_switch" (i32.const 2) (i32.const 1)) (i64.const 10)) +(assert_return (invoke "i64_align_switch" (i32.const 2) (i32.const 2)) (i64.const 10)) +(assert_return (invoke "i64_align_switch" (i32.const 3) (i32.const 0)) (i64.const 10)) +(assert_return (invoke "i64_align_switch" (i32.const 3) (i32.const 1)) (i64.const 10)) +(assert_return (invoke "i64_align_switch" (i32.const 3) (i32.const 2)) (i64.const 10)) +(assert_return (invoke "i64_align_switch" (i32.const 4) (i32.const 0)) (i64.const 10)) +(assert_return (invoke "i64_align_switch" (i32.const 4) (i32.const 1)) (i64.const 10)) +(assert_return (invoke "i64_align_switch" (i32.const 4) (i32.const 2)) (i64.const 10)) +(assert_return (invoke "i64_align_switch" (i32.const 4) (i32.const 4)) (i64.const 10)) +(assert_return (invoke "i64_align_switch" (i32.const 5) (i32.const 0)) (i64.const 10)) +(assert_return (invoke "i64_align_switch" (i32.const 5) (i32.const 1)) (i64.const 10)) +(assert_return (invoke "i64_align_switch" (i32.const 5) (i32.const 2)) (i64.const 10)) +(assert_return (invoke "i64_align_switch" (i32.const 5) (i32.const 4)) (i64.const 10)) +(assert_return (invoke "i64_align_switch" (i32.const 6) (i32.const 0)) (i64.const 10)) +(assert_return (invoke "i64_align_switch" (i32.const 6) (i32.const 1)) (i64.const 10)) +(assert_return (invoke "i64_align_switch" (i32.const 6) (i32.const 2)) (i64.const 10)) +(assert_return (invoke "i64_align_switch" (i32.const 6) (i32.const 4)) (i64.const 10)) +(assert_return (invoke "i64_align_switch" (i32.const 6) (i32.const 8)) (i64.const 10)) + +;; Test that an i64 store with 4-byte alignment that's 4 bytes out of bounds traps without storing anything + +(module + (memory 1) + (func (export "store") (param i32 i64) + (i64.store align=4 (local.get 0) (local.get 1)) + ) + (func (export "load") (param i32) (result i32) + (i32.load (local.get 0)) + ) +) + +(assert_trap (invoke "store" (i32.const 65532) (i64.const -1)) "out of bounds memory access") +;; No memory was changed +(assert_return (invoke "load" (i32.const 65532)) (i32.const 0)) diff --git a/runtime/near-vm/tests/wast/spec/binary-leb128.wast b/runtime/near-vm/tests/wast/spec/binary-leb128.wast new file mode 100644 index 00000000000..1d672195835 --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/binary-leb128.wast @@ -0,0 +1,1002 @@ +;; Unsigned LEB128 can have non-minimal length +(module binary + "\00asm" "\01\00\00\00" + "\05\04\01" ;; Memory section with 1 entry + "\00\82\00" ;; no max, minimum 2 +) +(module binary + "\00asm" "\01\00\00\00" + "\05\07\01" ;; Memory section with 1 entry + "\00\82\80\80\80\00" ;; no max, minimum 2 +) +(module binary + "\00asm" "\01\00\00\00" + "\05\06\01" ;; Memory section with 1 entry + "\01\82\00" ;; minimum 2 + "\82\00" ;; max 2 +) +(module binary + "\00asm" "\01\00\00\00" + "\05\09\01" ;; Memory section with 1 entry + "\01\82\00" ;; minimum 2 + "\82\80\80\80\00" ;; max 2 +) +(module binary + "\00asm" "\01\00\00\00" + "\05\03\01" ;; Memory section with 1 entry + "\00\00" ;; no max, minimum 0 + "\0b\07\01" ;; Data section with 1 entry + "\80\00" ;; Memory index 0, encoded with 2 bytes + "\41\00\0b\00" ;; (i32.const 0) with contents "" +) +(module binary + "\00asm" "\01\00\00\00" + "\04\04\01" ;; Table section with 1 entry + "\70\00\00" ;; no max, minimum 0, funcref + "\09\09\01" ;; Element section with 1 entry + "\02" ;; Element with explicit table index + "\80\00" ;; Table index 0, encoded with 2 bytes + "\41\00\0b\00\00" ;; (i32.const 0) with no elements +) +(module binary + "\00asm" "\01\00\00\00" + "\00" ;; custom section + "\8a\00" ;; section size 10, encoded with 2 bytes + "\01" ;; name byte count + "1" ;; name + "23456789" ;; sequence of bytes +) +(module binary + "\00asm" "\01\00\00\00" + "\00" ;; custom section + "\0b" ;; section size + "\88\00" ;; name byte count 8, encoded with 2 bytes + "12345678" ;; name + "9" ;; sequence of bytes +) +(module binary + "\00asm" "\01\00\00\00" + "\01\08\01" ;; type section + "\60" ;; func type + "\82\00" ;; num params 2, encoded with 2 bytes + "\7f\7e" ;; param type + "\01" ;; num results + "\7f" ;; result type +) +(module binary + "\00asm" "\01\00\00\00" + "\01\08\01" ;; type section + "\60" ;; func type + "\02" ;; num params + "\7f\7e" ;; param type + "\81\00" ;; num results 1, encoded with 2 bytes + "\7f" ;; result type +) +(module binary + "\00asm" "\01\00\00\00" + "\01\05\01" ;; type section + "\60\01\7f\00" ;; function type + "\02\17\01" ;; import section + "\88\00" ;; module name length 8, encoded with 2 bytes + "\73\70\65\63\74\65\73\74" ;; module name + "\09" ;; entity name length + "\70\72\69\6e\74\5f\69\33\32" ;; entity name + "\00" ;; import kind + "\00" ;; import signature index +) +(module binary + "\00asm" "\01\00\00\00" + "\01\05\01" ;; type section + "\60\01\7f\00" ;; function type + "\02\17\01" ;; import section + "\08" ;; module name length + "\73\70\65\63\74\65\73\74" ;; module name + "\89\00" ;; entity name length 9, encoded with 2 bytes + "\70\72\69\6e\74\5f\69\33\32" ;; entity name + "\00" ;; import kind + "\00" ;; import signature index +) +(module binary + "\00asm" "\01\00\00\00" + "\01\05\01" ;; type section + "\60\01\7f\00" ;; function type + "\02\17\01" ;; import section + "\08" ;; module name length + "\73\70\65\63\74\65\73\74" ;; module name + "\09" ;; entity name length 9 + "\70\72\69\6e\74\5f\69\33\32" ;; entity name + "\00" ;; import kind + "\80\00" ;; import signature index, encoded with 2 bytes +) +(module binary + "\00asm" "\01\00\00\00" + "\01\04\01" ;; type section + "\60\00\00" ;; function type + "\03\03\01" ;; function section + "\80\00" ;; function 0 signature index, encoded with 2 bytes + "\0a\04\01" ;; code section + "\02\00\0b" ;; function body +) +(module binary + "\00asm" "\01\00\00\00" + "\01\04\01" ;; type section + "\60\00\00" ;; fun type + "\03\02\01\00" ;; function section + "\07\07\01" ;; export section + "\82\00" ;; string length 2, encoded with 2 bytes + "\66\31" ;; export name f1 + "\00" ;; export kind + "\00" ;; export func index + "\0a\04\01" ;; code section + "\02\00\0b" ;; function body +) +(module binary + "\00asm" "\01\00\00\00" + "\01\04\01" ;; type section + "\60\00\00" ;; fun type + "\03\02\01\00" ;; function section + "\07\07\01" ;; export section + "\02" ;; string length 2 + "\66\31" ;; export name f1 + "\00" ;; export kind + "\80\00" ;; export func index, encoded with 2 bytes + "\0a\04\01" ;; code section + "\02\00\0b" ;; function body +) +(module binary + "\00asm" "\01\00\00\00" + "\01\04\01" ;; type section + "\60\00\00" ;; fun type + "\03\02\01\00" ;; function section + "\0a" ;; code section + "\05" ;; section size + "\81\00" ;; num functions, encoded with 2 bytes + "\02\00\0b" ;; function body +) + +;; Signed LEB128 can have non-minimal length +(module binary + "\00asm" "\01\00\00\00" + "\06\07\01" ;; Global section with 1 entry + "\7f\00" ;; i32, immutable + "\41\80\00" ;; i32.const 0 + "\0b" ;; end +) +(module binary + "\00asm" "\01\00\00\00" + "\06\07\01" ;; Global section with 1 entry + "\7f\00" ;; i32, immutable + "\41\ff\7f" ;; i32.const -1 + "\0b" ;; end +) +(module binary + "\00asm" "\01\00\00\00" + "\06\0a\01" ;; Global section with 1 entry + "\7f\00" ;; i32, immutable + "\41\80\80\80\80\00" ;; i32.const 0 + "\0b" ;; end +) +(module binary + "\00asm" "\01\00\00\00" + "\06\0a\01" ;; Global section with 1 entry + "\7f\00" ;; i32, immutable + "\41\ff\ff\ff\ff\7f" ;; i32.const -1 + "\0b" ;; end +) + +(module binary + "\00asm" "\01\00\00\00" + "\06\07\01" ;; Global section with 1 entry + "\7e\00" ;; i64, immutable + "\42\80\00" ;; i64.const 0 with unused bits set + "\0b" ;; end +) +(module binary + "\00asm" "\01\00\00\00" + "\06\07\01" ;; Global section with 1 entry + "\7e\00" ;; i64, immutable + "\42\ff\7f" ;; i64.const -1 with unused bits unset + "\0b" ;; end +) +(module binary + "\00asm" "\01\00\00\00" + "\06\0f\01" ;; Global section with 1 entry + "\7e\00" ;; i64, immutable + "\42\80\80\80\80\80\80\80\80\80\00" ;; i64.const 0 with unused bits set + "\0b" ;; end +) +(module binary + "\00asm" "\01\00\00\00" + "\06\0f\01" ;; Global section with 1 entry + "\7e\00" ;; i64, immutable + "\42\ff\ff\ff\ff\ff\ff\ff\ff\ff\7f" ;; i64.const -1 with unused bits unset + "\0b" ;; end +) + +;; Unsigned LEB128 must not be overlong +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\05\08\01" ;; Memory section with 1 entry + "\00\82\80\80\80\80\00" ;; no max, minimum 2 with one byte too many + ) + "integer representation too long" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\05\0a\01" ;; Memory section with 1 entry + "\01\82\00" ;; minimum 2 + "\82\80\80\80\80\00" ;; max 2 with one byte too many + ) + "integer representation too long" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\05\03\01" ;; Memory section with 1 entry + "\00\00" ;; no max, minimum 0 + "\0b\0b\01" ;; Data section with 1 entry + "\80\80\80\80\80\00" ;; Memory index 0 with one byte too many + "\41\00\0b\00" ;; (i32.const 0) with contents "" + ) + "integer representation too long" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\04\04\01" ;; Table section with 1 entry + "\70\00\00" ;; no max, minimum 0, funcref + "\09\0b\01" ;; Element section with 1 entry + "\80\80\80\80\80\00" ;; Table index 0 with one byte too many + "\41\00\0b\00" ;; (i32.const 0) with no elements + ) + "integer representation too long" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00" ;; custom section + "\83\80\80\80\80\00" ;; section size 3 with one byte too many + "\01" ;; name byte count + "1" ;; name + "2" ;; sequence of bytes + ) + "integer representation too long" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00" ;; custom section + "\0A" ;; section size + "\83\80\80\80\80\00" ;; name byte count 3 with one byte too many + "123" ;; name + "4" ;; sequence of bytes + ) + "integer representation too long" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\0c\01" ;; type section + "\60" ;; func type + "\82\80\80\80\80\00" ;; num params 2 with one byte too many + "\7f\7e" ;; param type + "\01" ;; num result + "\7f" ;; result type + ) + "integer representation too long" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\08\01" ;; type section + "\60" ;; func type + "\02" ;; num params + "\7f\7e" ;; param type + "\81\80\80\80\80\00" ;; num result 1 with one byte too many + "\7f" ;; result type + ) + "integer representation too long" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\05\01" ;; type section + "\60\01\7f\00" ;; function type + "\02\1b\01" ;; import section + "\88\80\80\80\80\00" ;; module name length 8 with one byte too many + "\73\70\65\63\74\65\73\74" ;; module name + "\09" ;; entity name length + "\70\72\69\6e\74\5f\69\33\32" ;; entity name + "\00" ;; import kind + "\00" ;; import signature index + ) + "integer representation too long" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\05\01" ;; type section + "\60\01\7f\00" ;; function type + "\02\1b\01" ;; import section + "\08" ;; module name length + "\73\70\65\63\74\65\73\74" ;; module name + "\89\80\80\80\80\00" ;; entity name length 9 with one byte too many + "\70\72\69\6e\74\5f\69\33\32" ;; entity name + "\00" ;; import kind + "\00" ;; import signature index + ) + "integer representation too long" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\05\01" ;; type section + "\60\01\7f\00" ;; function type + "\02\1b\01" ;; import section + "\08" ;; module name length + "\73\70\65\63\74\65\73\74" ;; module name + "\09" ;; entity name length 9 + "\70\72\69\6e\74\5f\69\33\32" ;; entity name + "\00" ;; import kind + "\80\80\80\80\80\00" ;; import signature index 0 with one byte too many + ) + "integer representation too long" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01" ;; type section + "\60\00\00" ;; function type + "\03\03\01" ;; function section + "\80\80\80\80\80\00" ;; function 0 signature index with one byte too many + "\0a\04\01" ;; code section + "\02\00\0b" ;; function body + ) + "integer representation too long" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01" ;; type section + "\60\00\00" ;; fun type + "\03\02\01\00" ;; function section + "\07\0b\01" ;; export section + "\82\80\80\80\80\00" ;; string length 2 with one byte too many + "\66\31" ;; export name f1 + "\00" ;; export kind + "\00" ;; export func index + "\0a\04\01" ;; code section + "\02\00\0b" ;; function body + ) + "integer representation too long" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01" ;; type section + "\60\00\00" ;; fun type + "\03\02\01\00" ;; function section + "\07\0b\01" ;; export section + "\02" ;; string length 2 + "\66\31" ;; export name f1 + "\00" ;; export kind + "\80\80\80\80\80\00" ;; export func index 0 with one byte too many + "\0a\04\01" ;; code section + "\02\00\0b" ;; function body + ) + "integer representation too long" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01" ;; type section + "\60\00\00" ;; fun type + "\03\02\01\00" ;; function section + "\0a" ;; code section + "\05" ;; section size + "\81\80\80\80\80\00" ;; num functions 1 with one byte too many + "\02\00\0b" ;; function body + ) + "integer representation too long" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01\60\00\00" ;; Type section + "\03\02\01\00" ;; Function section + "\05\03\01\00\01" ;; Memory section + "\0a\11\01" ;; Code section + ;; function 0 + "\0f\01\01" ;; local type count + "\7f" ;; i32 + "\41\00" ;; i32.const 0 + "\28" ;; i32.load + "\02" ;; alignment 2 + "\82\80\80\80\80\00" ;; offset 2 with one byte too many + "\1a" ;; drop + "\0b" ;; end + ) + "integer representation too long" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01\60\00\00" ;; Type section + "\03\02\01\00" ;; Function section + "\05\03\01\00\01" ;; Memory section + "\0a\11\01" ;; Code section + ;; function 0 + "\0f\01\01" ;; local type count + "\7f" ;; i32 + "\41\00" ;; i32.const 0 + "\28" ;; i32.load + "\82\80\80\80\80\00" ;; alignment 2 with one byte too many + "\00" ;; offset 0 + "\1a" ;; drop + "\0b" ;; end + ) + "integer representation too long" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01\60\00\00" ;; Type section + "\03\02\01\00" ;; Function section + "\05\03\01\00\01" ;; Memory section + "\0a\12\01" ;; Code section + ;; function 0 + "\10\01\01" ;; local type count + "\7f" ;; i32 + "\41\00" ;; i32.const 0 + "\41\03" ;; i32.const 3 + "\36" ;; i32.store + "\82\80\80\80\80\00" ;; alignment 2 with one byte too many + "\03" ;; offset 3 + "\0b" ;; end + ) + "integer representation too long" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01\60\00\00" ;; Type section + "\03\02\01\00" ;; Function section + "\05\03\01\00\01" ;; Memory section + "\0a\12\01" ;; Code section + ;; function 0 + "\10\01\01" ;; local type count + "\7f" ;; i32 + "\41\00" ;; i32.const 0 + "\41\03" ;; i32.const 3 + "\36" ;; i32.store + "\02" ;; alignment 2 + "\82\80\80\80\80\00" ;; offset 2 with one byte too many + "\0b" ;; end + ) + "integer representation too long" +) + +;; Signed LEB128 must not be overlong +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\06\0b\01" ;; Global section with 1 entry + "\7f\00" ;; i32, immutable + "\41\80\80\80\80\80\00" ;; i32.const 0 with one byte too many + "\0b" ;; end + ) + "integer representation too long" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\06\0b\01" ;; Global section with 1 entry + "\7f\00" ;; i32, immutable + "\41\ff\ff\ff\ff\ff\7f" ;; i32.const -1 with one byte too many + "\0b" ;; end + ) + "integer representation too long" +) + +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\06\10\01" ;; Global section with 1 entry + "\7e\00" ;; i64, immutable + "\42\80\80\80\80\80\80\80\80\80\80\00" ;; i64.const 0 with one byte too many + "\0b" ;; end + ) + "integer representation too long" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\06\10\01" ;; Global section with 1 entry + "\7e\00" ;; i64, immutable + "\42\ff\ff\ff\ff\ff\ff\ff\ff\ff\ff\7f" ;; i64.const -1 with one byte too many + "\0b" ;; end + ) + "integer representation too long" +) + +;; Unsigned LEB128s zero-extend +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\05\07\01" ;; Memory section with 1 entry + "\00\82\80\80\80\70" ;; no max, minimum 2 with unused bits set + ) + "integer too large" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\05\07\01" ;; Memory section with 1 entry + "\00\82\80\80\80\40" ;; no max, minimum 2 with some unused bits set + ) + "integer too large" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\05\09\01" ;; Memory section with 1 entry + "\01\82\00" ;; minimum 2 + "\82\80\80\80\10" ;; max 2 with unused bits set + ) + "integer too large" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\05\09\01" ;; Memory section with 1 entry + "\01\82\00" ;; minimum 2 + "\82\80\80\80\40" ;; max 2 with some unused bits set + ) + "integer too large" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\05\03\01" ;; Memory section with 1 entry + "\00\00" ;; no max, minimum 0 + "\0b\0a\01" ;; Data section with 1 entry + "\80\80\80\80\10" ;; Memory index 0 with unused bits set + "\41\00\0b\00" ;; (i32.const 0) with contents "" + ) + "integer too large" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\04\04\01" ;; Table section with 1 entry + "\70\00\00" ;; no max, minimum 0, funcref + "\09\0a\01" ;; Element section with 1 entry + "\80\80\80\80\10" ;; Table index 0 with unused bits set + "\41\00\0b\00" ;; (i32.const 0) with no elements + ) + "integer too large" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00" ;; custom section + "\83\80\80\80\10" ;; section size 3 with unused bits set + "\01" ;; name byte count + "1" ;; name + "2" ;; sequence of bytes + ) + "integer too large" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00" ;; custom section + "\09" ;; section size + "\83\80\80\80\40" ;; name byte count 3 with unused bits set + "123" ;; name + "4" ;; sequence of bytes + ) + "integer too large" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\0b\01" ;; type section + "\60" ;; func type + "\82\80\80\80\10" ;; num params 2 with unused bits set + "\7f\7e" ;; param type + "\01" ;; num result + "\7f" ;; result type + ) + "integer too large" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\0b\01" ;; type section + "\60" ;; func type + "\02" ;; num params + "\7f\7e" ;; param type + "\81\80\80\80\40" ;; num result 1 with unused bits set + "\7f" ;; result type + ) + "integer too large" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\05\01" ;; type section + "\60\01\7f\00" ;; function type + "\02\1a\01" ;; import section + "\88\80\80\80\10" ;; module name length 8 with unused bits set + "\73\70\65\63\74\65\73\74" ;; module name + "\09" ;; entity name length + "\70\72\69\6e\74\5f\69\33\32" ;; entity name + "\00" ;; import kind + "\00" ;; import signature index + ) + "integer too large" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\05\01" ;; type section + "\60\01\7f\00" ;; function type + "\02\1a\01" ;; import section + "\08" ;; module name length + "\73\70\65\63\74\65\73\74" ;; module name + "\89\80\80\80\40" ;; entity name length 9 with unused bits set + "\70\72\69\6e\74\5f\69\33\32" ;; entity name + "\00" ;; import kind + "\00" ;; import signature index + ) + "integer too large" +) +(assert_malformed +(module binary + "\00asm" "\01\00\00\00" + "\01\05\01" ;; type section + "\60\01\7f\00" ;; function type + "\02\1a\01" ;; import section + "\08" ;; module name length + "\73\70\65\63\74\65\73\74" ;; module name + "\09" ;; entity name length 9 + "\70\72\69\6e\74\5f\69\33\32" ;; entity name + "\00" ;; import kind + "\80\80\80\80\10" ;; import signature index 0 with unused bits set +) + "integer too large" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01" ;; type section + "\60\00\00" ;; function type + "\03\06\01" ;; function section + "\80\80\80\80\10" ;; function 0 signature index with unused bits set + "\0a\04\01" ;; code section + "\02\00\0b" ;; function body + ) + "integer too large" +) + +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01" ;; type section + "\60\00\00" ;; fun type + "\03\02\01\00" ;; function section + "\07\0a\01" ;; export section + "\82\80\80\80\10" ;; string length 2 with unused bits set + "\66\31" ;; export name f1 + "\00" ;; export kind + "\00" ;; export func index + "\0a\04\01" ;; code section + "\02\00\0b" ;; function body + ) + "integer too large" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01" ;; type section + "\60\00\00" ;; fun type + "\03\02\01\00" ;; function section + "\07\0a\01" ;; export section + "\02" ;; string length 2 + "\66\31" ;; export name f1 + "\00" ;; export kind + "\80\80\80\80\10" ;; export func index with unused bits set + "\0a\04\01" ;; code section + "\02\00\0b" ;; function body + ) + "integer too large" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01" ;; type section + "\60\00\00" ;; fun type + "\03\02\01\00" ;; function section + "\0a" ;; code section + "\08" ;; section size + "\81\80\80\80\10" ;; num functions 1 with unused bits set + "\02\00\0b" ;; function body + ) + "integer too large" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01\60\00\00" ;; Type section + "\03\02\01\00" ;; Function section + "\05\03\01\00\01" ;; Memory section + "\0a\10\01" ;; Code section + ;; function 0 + "\0e\01\01" ;; local type count + "\7f" ;; i32 + "\41\00" ;; i32.const 0 + "\28" ;; i32.load + "\02" ;; alignment 2 + "\82\80\80\80\10" ;; offset 2 with unused bits set + "\1a" ;; drop + "\0b" ;; end + ) + "integer too large" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01\60\00\00" ;; Type section + "\03\02\01\00" ;; Function section + "\05\03\01\00\01" ;; Memory section + "\0a\10\01" ;; Code section + ;; function 0 + "\0e\01\01" ;; local type count + "\7f" ;; i32 + "\41\00" ;; i32.const 0 + "\28" ;; i32.load + "\02" ;; alignment 2 + "\82\80\80\80\40" ;; offset 2 with some unused bits set + "\1a" ;; drop + "\0b" ;; end + ) + "integer too large" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01\60\00\00" ;; Type section + "\03\02\01\00" ;; Function section + "\05\03\01\00\01" ;; Memory section + "\0a\10\01" ;; Code section + "\0e\01\01" ;; local type count + "\7f" ;; i32 + "\41\00" ;; i32.const 0 + "\28" ;; i32.load + "\82\80\80\80\10" ;; alignment 2 with unused bits set + "\00" ;; offset 0 + "\1a" ;; drop + "\0b" ;; end + ) + "integer too large" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01\60\00\00" ;; Type section + "\03\02\01\00" ;; Function section + "\05\03\01\00\01" ;; Memory section + "\0a\10\01" ;; Code section + ;; function 0 + "\0e\01\01" ;; local type count + "\7f" ;; i32 + "\41\00" ;; i32.const 0 + "\28" ;; i32.load + "\82\80\80\80\40" ;; alignment 2 with some unused bits set + "\00" ;; offset 0 + "\1a" ;; drop + "\0b" ;; end + ) + "integer too large" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01\60\00\00" ;; Type section + "\03\02\01\00" ;; Function section + "\05\03\01\00\01" ;; Memory section + "\0a\11\01" ;; Code section + ;; function 0 + "\0f\01\01" ;; local type count + "\7f" ;; i32 + "\41\00" ;; i32.const 0 + "\41\03" ;; i32.const 3 + "\36" ;; i32.store + "\82\80\80\80\10" ;; alignment 2 with unused bits set + "\03" ;; offset 3 + "\0b" ;; end + ) + "integer too large" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01\60\00\00" ;; Type section + "\03\02\01\00" ;; Function section + "\05\03\01\00\01" ;; Memory section + "\0a\11\01" ;; Code section + ;; function 0 + "\0f\01\01" ;; local type count + "\7f" ;; i32 + "\41\00" ;; i32.const 0 + "\41\03" ;; i32.const 3 + "\36" ;; i32.store + "\82\80\80\80\40" ;; alignment 2 with some unused bits set + "\03" ;; offset 3 + "\0b" ;; end + ) + "integer too large" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01\60\00\00" ;; Type section + "\03\02\01\00" ;; Function section + "\05\03\01\00\01" ;; Memory section + "\0a\11\01" ;; Code section + ;; function 0 + "\0f\01\01" ;; local type count + "\7f" ;; i32 + "\41\00" ;; i32.const 0 + "\41\03" ;; i32.const 3 + "\36" ;; i32.store + "\02" ;; alignment 2 + "\82\80\80\80\10" ;; offset 2 with unused bits set + "\0b" ;; end + ) + "integer too large" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01\60\00\00" ;; Type section + "\03\02\01\00" ;; Function section + "\05\03\01\00\01" ;; Memory section + "\0a\11\01" ;; Code section + + ;; function 0 + "\0f\01\01" ;; local type count + "\7f" ;; i32 + "\41\00" ;; i32.const 0 + "\41\03" ;; i32.const 3 + "\36" ;; i32.store + "\02" ;; alignment 2 + "\82\80\80\80\40" ;; offset 2 with some unused bits set + "\0b" ;; end + ) + "integer too large" +) + +;; Signed LEB128s sign-extend +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\06\0a\01" ;; Global section with 1 entry + "\7f\00" ;; i32, immutable + "\41\80\80\80\80\70" ;; i32.const 0 with unused bits set + "\0b" ;; end + ) + "integer too large" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\06\0a\01" ;; Global section with 1 entry + "\7f\00" ;; i32, immutable + "\41\ff\ff\ff\ff\0f" ;; i32.const -1 with unused bits unset + "\0b" ;; end + ) + "integer too large" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\06\0a\01" ;; Global section with 1 entry + "\7f\00" ;; i32, immutable + "\41\80\80\80\80\1f" ;; i32.const 0 with some unused bits set + "\0b" ;; end + ) + "integer too large" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\06\0a\01" ;; Global section with 1 entry + "\7f\00" ;; i32, immutable + "\41\ff\ff\ff\ff\4f" ;; i32.const -1 with some unused bits unset + "\0b" ;; end + ) + "integer too large" +) + +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\06\0f\01" ;; Global section with 1 entry + "\7e\00" ;; i64, immutable + "\42\80\80\80\80\80\80\80\80\80\7e" ;; i64.const 0 with unused bits set + "\0b" ;; end + ) + "integer too large" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\06\0f\01" ;; Global section with 1 entry + "\7e\00" ;; i64, immutable + "\42\ff\ff\ff\ff\ff\ff\ff\ff\ff\01" ;; i64.const -1 with unused bits unset + "\0b" ;; end + ) + "integer too large" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\06\0f\01" ;; Global section with 1 entry + "\7e\00" ;; i64, immutable + "\42\80\80\80\80\80\80\80\80\80\02" ;; i64.const 0 with some unused bits set + "\0b" ;; end + ) + "integer too large" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\06\0f\01" ;; Global section with 1 entry + "\7e\00" ;; i64, immutable + "\42\ff\ff\ff\ff\ff\ff\ff\ff\ff\41" ;; i64.const -1 with some unused bits unset + "\0b" ;; end + ) + "integer too large" +) + + +(module binary + "\00asm" "\01\00\00\00" + "\01\04\01" ;; type section + "\60\00\00" ;; empty function type + "\03\02\01" ;; function section + "\00" ;; function 0, type 0 + "\0a\1b\01\19" ;; code section + "\00" ;; no locals + "\00" ;; unreachable + "\fc\80\00" ;; i32_trunc_sat_f32_s with 2 bytes + "\00" ;; unreachable + "\fc\81\80\00" ;; i32_trunc_sat_f32_u with 3 bytes + "\00" ;; unreachable + "\fc\86\80\80\00" ;; i64_trunc_sat_f64_s with 4 bytes + "\00" ;; unreachable + "\fc\87\80\80\80\00" ;; i64_trunc_sat_f64_u with 5 bytes + "\00" ;; unreachable + "\0b" ;; end +) + +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01" ;; type section + "\60\00\00" ;; empty function type + "\03\02\01" ;; function section + "\00" ;; function 0, type 0 + "\0a\0d\01\0b" ;; code section + "\00" ;; no locals + "\00" ;; unreachable + "\fc\87\80\80\80\80\00" ;; i64_trunc_sat_f64_u with 6 bytes + "\00" ;; unreachable + "\0b" ;; end + ) + "integer representation too long" +) diff --git a/runtime/near-vm/tests/wast/spec/binary.wast b/runtime/near-vm/tests/wast/spec/binary.wast new file mode 100644 index 00000000000..c6f975570b4 --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/binary.wast @@ -0,0 +1,1764 @@ +(module binary "\00asm\01\00\00\00") +(module binary "\00asm" "\01\00\00\00") +(module $M1 binary "\00asm\01\00\00\00") +(module $M2 binary "\00asm" "\01\00\00\00") + +(assert_malformed (module binary "") "unexpected end") +(assert_malformed (module binary "\01") "unexpected end") +(assert_malformed (module binary "\00as") "unexpected end") +(assert_malformed (module binary "asm\00") "magic header not detected") +(assert_malformed (module binary "msa\00") "magic header not detected") +(assert_malformed (module binary "msa\00\01\00\00\00") "magic header not detected") +(assert_malformed (module binary "msa\00\00\00\00\01") "magic header not detected") +(assert_malformed (module binary "asm\01\00\00\00\00") "magic header not detected") +(assert_malformed (module binary "wasm\01\00\00\00") "magic header not detected") +(assert_malformed (module binary "\7fasm\01\00\00\00") "magic header not detected") +(assert_malformed (module binary "\80asm\01\00\00\00") "magic header not detected") +(assert_malformed (module binary "\82asm\01\00\00\00") "magic header not detected") +(assert_malformed (module binary "\ffasm\01\00\00\00") "magic header not detected") + +;; 8-byte endian-reversed. +(assert_malformed (module binary "\00\00\00\01msa\00") "magic header not detected") + +;; Middle-endian byte orderings. +(assert_malformed (module binary "a\00ms\00\01\00\00") "magic header not detected") +(assert_malformed (module binary "sm\00a\00\00\01\00") "magic header not detected") + +;; Upper-cased. +(assert_malformed (module binary "\00ASM\01\00\00\00") "magic header not detected") + +;; EBCDIC-encoded magic. +(assert_malformed (module binary "\00\81\a2\94\01\00\00\00") "magic header not detected") + +;; Leading UTF-8 BOM. +(assert_malformed (module binary "\ef\bb\bf\00asm\01\00\00\00") "magic header not detected") + +;; Malformed binary version. +(assert_malformed (module binary "\00asm") "unexpected end") +(assert_malformed (module binary "\00asm\01") "unexpected end") +(assert_malformed (module binary "\00asm\01\00\00") "unexpected end") +(assert_malformed (module binary "\00asm\00\00\00\00") "unknown binary version") +(assert_malformed (module binary "\00asm\0d\00\00\00") "unknown binary version") +(assert_malformed (module binary "\00asm\0e\00\00\00") "unknown binary version") +(assert_malformed (module binary "\00asm\00\01\00\00") "unknown binary version") +(assert_malformed (module binary "\00asm\00\00\01\00") "unknown binary version") +(assert_malformed (module binary "\00asm\00\00\00\01") "unknown binary version") + +;; Invalid section id. +(assert_malformed (module binary "\00asm" "\01\00\00\00" "\0d\00") "malformed section id") +(assert_malformed (module binary "\00asm" "\01\00\00\00" "\7f\00") "malformed section id") +(assert_malformed (module binary "\00asm" "\01\00\00\00" "\80\00\01\00") "malformed section id") +(assert_malformed (module binary "\00asm" "\01\00\00\00" "\81\00\01\00") "malformed section id") +(assert_malformed (module binary "\00asm" "\01\00\00\00" "\ff\00\01\00") "malformed section id") + +;; Unsigned LEB128 can have non-minimal length +(module binary + "\00asm" "\01\00\00\00" + "\05\04\01" ;; Memory section with 1 entry + "\00\82\00" ;; no max, minimum 2 +) +(module binary + "\00asm" "\01\00\00\00" + "\05\07\01" ;; Memory section with 1 entry + "\00\82\80\80\80\00" ;; no max, minimum 2 +) + +;; Signed LEB128 can have non-minimal length +(module binary + "\00asm" "\01\00\00\00" + "\06\07\01" ;; Global section with 1 entry + "\7f\00" ;; i32, immutable + "\41\80\00" ;; i32.const 0 + "\0b" ;; end +) +(module binary + "\00asm" "\01\00\00\00" + "\06\07\01" ;; Global section with 1 entry + "\7f\00" ;; i32, immutable + "\41\ff\7f" ;; i32.const -1 + "\0b" ;; end +) +(module binary + "\00asm" "\01\00\00\00" + "\06\0a\01" ;; Global section with 1 entry + "\7f\00" ;; i32, immutable + "\41\80\80\80\80\00" ;; i32.const 0 + "\0b" ;; end +) +(module binary + "\00asm" "\01\00\00\00" + "\06\0a\01" ;; Global section with 1 entry + "\7f\00" ;; i32, immutable + "\41\ff\ff\ff\ff\7f" ;; i32.const -1 + "\0b" ;; end +) + +(module binary + "\00asm" "\01\00\00\00" + "\06\07\01" ;; Global section with 1 entry + "\7e\00" ;; i64, immutable + "\42\80\00" ;; i64.const 0 with unused bits set + "\0b" ;; end +) +(module binary + "\00asm" "\01\00\00\00" + "\06\07\01" ;; Global section with 1 entry + "\7e\00" ;; i64, immutable + "\42\ff\7f" ;; i64.const -1 with unused bits unset + "\0b" ;; end +) +(module binary + "\00asm" "\01\00\00\00" + "\06\0f\01" ;; Global section with 1 entry + "\7e\00" ;; i64, immutable + "\42\80\80\80\80\80\80\80\80\80\00" ;; i64.const 0 with unused bits set + "\0b" ;; end +) +(module binary + "\00asm" "\01\00\00\00" + "\06\0f\01" ;; Global section with 1 entry + "\7e\00" ;; i64, immutable + "\42\ff\ff\ff\ff\ff\ff\ff\ff\ff\7f" ;; i64.const -1 with unused bits unset + "\0b" ;; end +) + +(module binary + "\00asm" "\01\00\00\00" + "\05\03\01" ;; Memory section with 1 entry + "\00\00" ;; no max, minimum 0 + "\0b\06\01" ;; Data section with 1 entry + "\00" ;; Memory index 0 + "\41\00\0b\00" ;; (i32.const 0) with contents "" +) + +(module binary + "\00asm" "\01\00\00\00" + "\04\04\01" ;; Table section with 1 entry + "\70\00\00" ;; no max, minimum 0, funcref + "\09\06\01" ;; Element section with 1 entry + "\00" ;; Table index 0 + "\41\00\0b\00" ;; (i32.const 0) with no elements +) + +;; Data segment memory index can have non-minimal length +(module binary + "\00asm" "\01\00\00\00" + "\05\03\01" ;; Memory section with 1 entry + "\00\00" ;; no max, minimum 0 + "\0b\07\01" ;; Data section with 1 entry + "\80\00" ;; Memory index 0, encoded with 2 bytes + "\41\00\0b\00" ;; (i32.const 0) with contents "" +) + +;; Element segment table index can have non-minimal length +(module binary + "\00asm" "\01\00\00\00" + "\04\04\01" ;; Table section with 1 entry + "\70\00\00" ;; no max, minimum 0, funcref + "\09\09\01" ;; Element section with 1 entry + "\02\80\00" ;; Table index 0, encoded with 2 bytes + "\41\00\0b\00\00" ;; (i32.const 0) with no elements +) + +;; Type section with signed LEB128 encoded type +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01" ;; Type section id + "\05" ;; Type section length + "\01" ;; Types vector length + "\e0\7f" ;; Malformed functype, -0x20 in signed LEB128 encoding + "\00\00" + ) + "integer representation too long" +) + +;; Unsigned LEB128 must not be overlong +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\05\08\01" ;; Memory section with 1 entry + "\00\82\80\80\80\80\00" ;; no max, minimum 2 with one byte too many + ) + "integer representation too long" +) + +;; Signed LEB128 must not be overlong +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\06\0b\01" ;; Global section with 1 entry + "\7f\00" ;; i32, immutable + "\41\80\80\80\80\80\00" ;; i32.const 0 with one byte too many + "\0b" ;; end + ) + "integer representation too long" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\06\0b\01" ;; Global section with 1 entry + "\7f\00" ;; i32, immutable + "\41\ff\ff\ff\ff\ff\7f" ;; i32.const -1 with one byte too many + "\0b" ;; end + ) + "integer representation too long" +) + +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\06\10\01" ;; Global section with 1 entry + "\7e\00" ;; i64, immutable + "\42\80\80\80\80\80\80\80\80\80\80\00" ;; i64.const 0 with one byte too many + "\0b" ;; end + ) + "integer representation too long" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\06\10\01" ;; Global section with 1 entry + "\7e\00" ;; i64, immutable + "\42\ff\ff\ff\ff\ff\ff\ff\ff\ff\ff\7f" ;; i64.const -1 with one byte too many + "\0b" ;; end + ) + "integer representation too long" +) + +;; Unsigned LEB128s zero-extend +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\05\07\01" ;; Memory section with 1 entry + "\00\82\80\80\80\70" ;; no max, minimum 2 with unused bits set + ) + "integer too large" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\05\07\01" ;; Memory section with 1 entry + "\00\82\80\80\80\40" ;; no max, minimum 2 with some unused bits set + ) + "integer too large" +) + +;; Signed LEB128s sign-extend +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\06\0a\01" ;; Global section with 1 entry + "\7f\00" ;; i32, immutable + "\41\80\80\80\80\70" ;; i32.const 0 with unused bits set + "\0b" ;; end + ) + "integer too large" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\06\0a\01" ;; Global section with 1 entry + "\7f\00" ;; i32, immutable + "\41\ff\ff\ff\ff\0f" ;; i32.const -1 with unused bits unset + "\0b" ;; end + ) + "integer too large" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\06\0a\01" ;; Global section with 1 entry + "\7f\00" ;; i32, immutable + "\41\80\80\80\80\1f" ;; i32.const 0 with some unused bits set + "\0b" ;; end + ) + "integer too large" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\06\0a\01" ;; Global section with 1 entry + "\7f\00" ;; i32, immutable + "\41\ff\ff\ff\ff\4f" ;; i32.const -1 with some unused bits unset + "\0b" ;; end + ) + "integer too large" +) + +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\06\0f\01" ;; Global section with 1 entry + "\7e\00" ;; i64, immutable + "\42\80\80\80\80\80\80\80\80\80\7e" ;; i64.const 0 with unused bits set + "\0b" ;; end + ) + "integer too large" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\06\0f\01" ;; Global section with 1 entry + "\7e\00" ;; i64, immutable + "\42\ff\ff\ff\ff\ff\ff\ff\ff\ff\01" ;; i64.const -1 with unused bits unset + "\0b" ;; end + ) + "integer too large" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\06\0f\01" ;; Global section with 1 entry + "\7e\00" ;; i64, immutable + "\42\80\80\80\80\80\80\80\80\80\02" ;; i64.const 0 with some unused bits set + "\0b" ;; end + ) + "integer too large" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\06\0f\01" ;; Global section with 1 entry + "\7e\00" ;; i64, immutable + "\42\ff\ff\ff\ff\ff\ff\ff\ff\ff\41" ;; i64.const -1 with some unused bits unset + "\0b" ;; end + ) + "integer too large" +) + +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\06\0f\01" ;; Global section with 1 entry + "\7e\00" ;; i64, immutable + "\42\80\80\80\80\80\80\80\80\80\7e" ;; i64.const 0 with unused bits set + "\0b" ;; end + ) + "integer too large" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\06\0f\01" ;; Global section with 1 entry + "\7e\00" ;; i64, immutable + "\42\ff\ff\ff\ff\ff\ff\ff\ff\ff\01" ;; i64.const -1 with unused bits unset + "\0b" ;; end + ) + "integer too large" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\06\0f\01" ;; Global section with 1 entry + "\7e\00" ;; i64, immutable + "\42\80\80\80\80\80\80\80\80\80\02" ;; i64.const 0 with some unused bits set + "\0b" ;; end + ) + "integer too large" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\06\0f\01" ;; Global section with 1 entry + "\7e\00" ;; i64, immutable + "\42\ff\ff\ff\ff\ff\ff\ff\ff\ff\41" ;; i64.const -1 with some unused bits unset + "\0b" ;; end + ) + "integer too large" +) + + +;; Unsigned LEB128 must not be overlong +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\05\08\01" ;; Memory section with 1 entry + "\00\82\80\80\80\80\00" ;; no max, minimum 2 with one byte too many + ) + "integer representation too long" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01\60\00\00" ;; Type section + "\03\02\01\00" ;; Function section + "\05\03\01\00\01" ;; Memory section + "\0a\11\01" ;; Code section + ;; function 0 + "\0f\01\01" ;; local type count + "\7f" ;; i32 + "\41\00" ;; i32.const 0 + "\28" ;; i32.load + "\02" ;; alignment 2 + "\82\80\80\80\80\00" ;; offset 2 with one byte too many + "\1a" ;; drop + "\0b" ;; end + ) + "integer representation too long" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01\60\00\00" ;; Type section + "\03\02\01\00" ;; Function section + "\05\03\01\00\01" ;; Memory section + "\0a\11\01" ;; Code section + ;; function 0 + "\0f\01\01" ;; local type count + "\7f" ;; i32 + "\41\00" ;; i32.const 0 + "\28" ;; i32.load + "\82\80\80\80\80\00" ;; alignment 2 with one byte too many + "\00" ;; offset 0 + "\1a" ;; drop + "\0b" ;; end + ) + "integer representation too long" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01\60\00\00" ;; Type section + "\03\02\01\00" ;; Function section + "\05\03\01\00\01" ;; Memory section + "\0a\12\01" ;; Code section + ;; function 0 + "\10\01\01" ;; local type count + "\7f" ;; i32 + "\41\00" ;; i32.const 0 + "\41\03" ;; i32.const 3 + "\36" ;; i32.store + "\82\80\80\80\80\00" ;; alignment 2 with one byte too many + "\03" ;; offset 3 + "\0b" ;; end + ) + "integer representation too long" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01\60\00\00" ;; Type section + "\03\02\01\00" ;; Function section + "\05\03\01\00\01" ;; Memory section + "\0a\12\01" ;; Code section + ;; function 0 + "\10\01\01" ;; local type count + "\7f" ;; i32 + "\41\00" ;; i32.const 0 + "\41\03" ;; i32.const 3 + "\36" ;; i32.store + "\02" ;; alignment 2 + "\82\80\80\80\80\00" ;; offset 2 with one byte too many + "\0b" ;; end + ) + "integer representation too long" +) + +;; Signed LEB128 must not be overlong +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\06\0b\01" ;; Global section with 1 entry + "\7f\00" ;; i32, immutable + "\41\80\80\80\80\80\00" ;; i32.const 0 with one byte too many + "\0b" ;; end + ) + "integer representation too long" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\06\0b\01" ;; Global section with 1 entry + "\7f\00" ;; i32, immutable + "\41\ff\ff\ff\ff\ff\7f" ;; i32.const -1 with one byte too many + "\0b" ;; end + ) + "integer representation too long" +) + +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\06\10\01" ;; Global section with 1 entry + "\7e\00" ;; i64, immutable + "\42\80\80\80\80\80\80\80\80\80\80\00" ;; i64.const 0 with one byte too many + "\0b" ;; end + ) + "integer representation too long" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\06\10\01" ;; Global section with 1 entry + "\7e\00" ;; i64, immutable + "\42\ff\ff\ff\ff\ff\ff\ff\ff\ff\ff\7f" ;; i64.const -1 with one byte too many + "\0b" ;; end + ) + "integer representation too long" +) + +;; Unsigned LEB128s zero-extend +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\05\07\01" ;; Memory section with 1 entry + "\00\82\80\80\80\70" ;; no max, minimum 2 with unused bits set + ) + "integer too large" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\05\07\01" ;; Memory section with 1 entry + "\00\82\80\80\80\40" ;; no max, minimum 2 with some unused bits set + ) + "integer too large" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01\60\00\00" ;; Type section + "\03\02\01\00" ;; Function section + "\05\03\01\00\01" ;; Memory section + "\0a\10\01" ;; Code section + ;; function 0 + "\0e\01\01" ;; local type count + "\7f" ;; i32 + "\41\00" ;; i32.const 0 + "\28" ;; i32.load + "\02" ;; alignment 2 + "\82\80\80\80\10" ;; offset 2 with unused bits set + "\1a" ;; drop + "\0b" ;; end + ) + "integer too large" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01\60\00\00" ;; Type section + "\03\02\01\00" ;; Function section + "\05\03\01\00\01" ;; Memory section + "\0a\10\01" ;; Code section + ;; function 0 + "\0e\01\01" ;; local type count + "\7f" ;; i32 + "\41\00" ;; i32.const 0 + "\28" ;; i32.load + "\02" ;; alignment 2 + "\82\80\80\80\40" ;; offset 2 with some unused bits set + "\1a" ;; drop + "\0b" ;; end + ) + "integer too large" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01\60\00\00" ;; Type section + "\03\02\01\00" ;; Function section + "\05\03\01\00\01" ;; Memory section + "\0a\10\01" ;; Code section + "\0e\01\01" ;; local type count + "\7f" ;; i32 + "\41\00" ;; i32.const 0 + "\28" ;; i32.load + "\82\80\80\80\10" ;; alignment 2 with unused bits set + "\00" ;; offset 0 + "\1a" ;; drop + "\0b" ;; end + ) + "integer too large" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01\60\00\00" ;; Type section + "\03\02\01\00" ;; Function section + "\05\03\01\00\01" ;; Memory section + "\0a\10\01" ;; Code section + ;; function 0 + "\0e\01\01" ;; local type count + "\7f" ;; i32 + "\41\00" ;; i32.const 0 + "\28" ;; i32.load + "\82\80\80\80\40" ;; alignment 2 with some unused bits set + "\00" ;; offset 0 + "\1a" ;; drop + "\0b" ;; end + ) + "integer too large" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01\60\00\00" ;; Type section + "\03\02\01\00" ;; Function section + "\05\03\01\00\01" ;; Memory section + "\0a\11\01" ;; Code section + ;; function 0 + "\0f\01\01" ;; local type count + "\7f" ;; i32 + "\41\00" ;; i32.const 0 + "\41\03" ;; i32.const 3 + "\36" ;; i32.store + "\82\80\80\80\10" ;; alignment 2 with unused bits set + "\03" ;; offset 3 + "\0b" ;; end + ) + "integer too large" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01\60\00\00" ;; Type section + "\03\02\01\00" ;; Function section + "\05\03\01\00\01" ;; Memory section + "\0a\11\01" ;; Code section + ;; function 0 + "\0f\01\01" ;; local type count + "\7f" ;; i32 + "\41\00" ;; i32.const 0 + "\41\03" ;; i32.const 3 + "\36" ;; i32.store + "\82\80\80\80\40" ;; alignment 2 with some unused bits set + "\03" ;; offset 3 + "\0b" ;; end + ) + "integer too large" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01\60\00\00" ;; Type section + "\03\02\01\00" ;; Function section + "\05\03\01\00\01" ;; Memory section + "\0a\11\01" ;; Code section + ;; function 0 + "\0f\01\01" ;; local type count + "\7f" ;; i32 + "\41\00" ;; i32.const 0 + "\41\03" ;; i32.const 3 + "\36" ;; i32.store + "\02" ;; alignment 2 + "\82\80\80\80\10" ;; offset 2 with unused bits set + "\0b" ;; end + ) + "integer too large" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01\60\00\00" ;; Type section + "\03\02\01\00" ;; Function section + "\05\03\01\00\01" ;; Memory section + "\0a\11\01" ;; Code section + + ;; function 0 + "\0f\01\01" ;; local type count + "\7f" ;; i32 + "\41\00" ;; i32.const 0 + "\41\03" ;; i32.const 3 + "\36" ;; i32.store + "\02" ;; alignment 2 + "\82\80\80\80\40" ;; offset 2 with some unused bits set + "\0b" ;; end + ) + "integer too large" +) + +;; Signed LEB128s sign-extend +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\06\0a\01" ;; Global section with 1 entry + "\7f\00" ;; i32, immutable + "\41\80\80\80\80\70" ;; i32.const 0 with unused bits set + "\0b" ;; end + ) + "integer too large" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\06\0a\01" ;; Global section with 1 entry + "\7f\00" ;; i32, immutable + "\41\ff\ff\ff\ff\0f" ;; i32.const -1 with unused bits unset + "\0b" ;; end + ) + "integer too large" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\06\0a\01" ;; Global section with 1 entry + "\7f\00" ;; i32, immutable + "\41\80\80\80\80\1f" ;; i32.const 0 with some unused bits set + "\0b" ;; end + ) + "integer too large" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\06\0a\01" ;; Global section with 1 entry + "\7f\00" ;; i32, immutable + "\41\ff\ff\ff\ff\4f" ;; i32.const -1 with some unused bits unset + "\0b" ;; end + ) + "integer too large" +) + +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\06\0f\01" ;; Global section with 1 entry + "\7e\00" ;; i64, immutable + "\42\80\80\80\80\80\80\80\80\80\7e" ;; i64.const 0 with unused bits set + "\0b" ;; end + ) + "integer too large" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\06\0f\01" ;; Global section with 1 entry + "\7e\00" ;; i64, immutable + "\42\ff\ff\ff\ff\ff\ff\ff\ff\ff\01" ;; i64.const -1 with unused bits unset + "\0b" ;; end + ) + "integer too large" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\06\0f\01" ;; Global section with 1 entry + "\7e\00" ;; i64, immutable + "\42\80\80\80\80\80\80\80\80\80\02" ;; i64.const 0 with some unused bits set + "\0b" ;; end + ) + "integer too large" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\06\0f\01" ;; Global section with 1 entry + "\7e\00" ;; i64, immutable + "\42\ff\ff\ff\ff\ff\ff\ff\ff\ff\41" ;; i64.const -1 with some unused bits unset + "\0b" ;; end + ) + "integer too large" +) + +;; memory.grow reserved byte equal to zero. +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01\60\00\00" ;; Type section + "\03\02\01\00" ;; Function section + "\05\03\01\00\00" ;; Memory section + "\0a\09\01" ;; Code section + + ;; function 0 + "\07\00" + "\41\00" ;; i32.const 0 + "\40" ;; memory.grow + "\01" ;; memory.grow reserved byte is not equal to zero! + "\1a" ;; drop + "\0b" ;; end + ) + "zero byte expected" +) + +;; memory.grow reserved byte should not be a "long" LEB128 zero. +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01\60\00\00" ;; Type section + "\03\02\01\00" ;; Function section + "\05\03\01\00\00" ;; Memory section + "\0a\0a\01" ;; Code section + + ;; function 0 + "\08\00" + "\41\00" ;; i32.const 0 + "\40" ;; memory.grow + "\80\00" ;; memory.grow reserved byte + "\1a" ;; drop + "\0b" ;; end + ) + "zero byte expected" +) + +;; Same as above for 3, 4, and 5-byte zero encodings. +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01\60\00\00" ;; Type section + "\03\02\01\00" ;; Function section + "\05\03\01\00\00" ;; Memory section + "\0a\0b\01" ;; Code section + + ;; function 0 + "\09\00" + "\41\00" ;; i32.const 0 + "\40" ;; memory.grow + "\80\80\00" ;; memory.grow reserved byte + "\1a" ;; drop + "\0b" ;; end + ) + "zero byte expected" +) + +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01\60\00\00" ;; Type section + "\03\02\01\00" ;; Function section + "\05\03\01\00\00" ;; Memory section + "\0a\0c\01" ;; Code section + + ;; function 0 + "\0a\00" + "\41\00" ;; i32.const 0 + "\40" ;; memory.grow + "\80\80\80\00" ;; memory.grow reserved byte + "\1a" ;; drop + "\0b" ;; end + ) + "zero byte expected" +) + +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01\60\00\00" ;; Type section + "\03\02\01\00" ;; Function section + "\05\03\01\00\00" ;; Memory section + "\0a\0d\01" ;; Code section + + ;; function 0 + "\0b\00" + "\41\00" ;; i32.const 0 + "\40" ;; memory.grow + "\80\80\80\80\00" ;; memory.grow reserved byte + "\1a" ;; drop + "\0b" ;; end + ) + "zero byte expected" +) + +;; memory.size reserved byte equal to zero. +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01\60\00\00" ;; Type section + "\03\02\01\00" ;; Function section + "\05\03\01\00\00" ;; Memory section + "\0a\07\01" ;; Code section + + ;; function 0 + "\05\00" + "\3f" ;; memory.size + "\01" ;; memory.size reserved byte is not equal to zero! + "\1a" ;; drop + "\0b" ;; end + ) + "zero byte expected" +) + +;; memory.size reserved byte should not be a "long" LEB128 zero. +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01\60\00\00" ;; Type section + "\03\02\01\00" ;; Function section + "\05\03\01\00\00" ;; Memory section + "\0a\08\01" ;; Code section + + ;; function 0 + "\06\00" + "\3f" ;; memory.size + "\80\00" ;; memory.size reserved byte + "\1a" ;; drop + "\0b" ;; end + ) + "zero byte expected" +) + +;; Same as above for 3, 4, and 5-byte zero encodings. +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01\60\00\00" ;; Type section + "\03\02\01\00" ;; Function section + "\05\03\01\00\00" ;; Memory section + "\0a\09\01" ;; Code section + + ;; function 0 + "\07\00" + "\3f" ;; memory.size + "\80\80\00" ;; memory.size reserved byte + "\1a" ;; drop + "\0b" ;; end + ) + "zero byte expected" +) + +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01\60\00\00" ;; Type section + "\03\02\01\00" ;; Function section + "\05\03\01\00\00" ;; Memory section + "\0a\0a\01" ;; Code section + + ;; function 0 + "\08\00" + "\3f" ;; memory.size + "\80\80\80\00" ;; memory.size reserved byte + "\1a" ;; drop + "\0b" ;; end + ) + "zero byte expected" +) + +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01\60\00\00" ;; Type section + "\03\02\01\00" ;; Function section + "\05\03\01\00\00" ;; Memory section + "\0a\0b\01" ;; Code section + + ;; function 0 + "\09\00" + "\3f" ;; memory.size + "\80\80\80\80\00" ;; memory.size reserved byte + "\1a" ;; drop + "\0b" ;; end + ) + "zero byte expected" +) + +;; Local number is unsigned 32 bit +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01\60\00\00" ;; Type section + "\03\02\01\00" ;; Function section + "\0a\0c\01" ;; Code section + + ;; function 0 + "\0a\02" + "\80\80\80\80\10\7f" ;; 0x100000000 i32 + "\02\7e" ;; 0x00000002 i64 + "\0b" ;; end + ) + "integer too large" +) + +;; Local number is unsigned 32 bit +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01\60\00\00" ;; Type section + "\03\02\01\00" ;; Function section + "\0a\0c\01" ;; Code section + + ;; function 0 + "\0a\02" + "\80\80\80\80\10\7f" ;; 0x100000000 i32 + "\02\7e" ;; 0x00000002 i64 + "\0b" ;; end + ) + "integer too large" +) + +;; No more than 2^32-1 locals. +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01\60\00\00" ;; Type section + "\03\02\01\00" ;; Function section + "\0a\0c\01" ;; Code section + + ;; function 0 + "\0a\02" + "\ff\ff\ff\ff\0f\7f" ;; 0xFFFFFFFF i32 + "\02\7e" ;; 0x00000002 i64 + "\0b" ;; end + ) + "too many locals" +) + +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\06\01\60\02\7f\7f\00" ;; Type section: (param i32 i32) + "\03\02\01\00" ;; Function section + "\0a\1c\01" ;; Code section + + ;; function 0 + "\1a\04" + "\80\80\80\80\04\7f" ;; 0x40000000 i32 + "\80\80\80\80\04\7e" ;; 0x40000000 i64 + "\80\80\80\80\04\7d" ;; 0x40000000 f32 + "\80\80\80\80\04\7c" ;; 0x40000000 f64 + "\0b" ;; end + ) + "too many locals" +) + +;; Local count can be 0. +(module binary + "\00asm" "\01\00\00\00" + "\01\04\01\60\00\00" ;; Type section + "\03\02\01\00" ;; Function section + "\0a\0a\01" ;; Code section + + ;; function 0 + "\08\03" + "\00\7f" ;; 0 i32 + "\00\7e" ;; 0 i64 + "\02\7d" ;; 2 f32 + "\0b" ;; end +) + +;; Function section has non-zero count, but code section is absent. +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01\60\00\00" ;; Type section + "\03\03\02\00\00" ;; Function section with 2 functions + ) + "function and code section have inconsistent lengths" +) + +;; Code section has non-zero count, but function section is absent. +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\0a\04\01\02\00\0b" ;; Code section with 1 empty function + ) + "function and code section have inconsistent lengths" +) + +;; Function section count > code section count +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01\60\00\00" ;; Type section + "\03\03\02\00\00" ;; Function section with 2 functions + "\0a\04\01\02\00\0b" ;; Code section with 1 empty function + ) + "function and code section have inconsistent lengths" +) + +;; Function section count < code section count +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01\60\00\00" ;; Type section + "\03\02\01\00" ;; Function section with 1 function + "\0a\07\02\02\00\0b\02\00\0b" ;; Code section with 2 empty functions + ) + "function and code section have inconsistent lengths" +) + +;; Function section has zero count, and code section is absent. +(module binary + "\00asm" "\01\00\00\00" + "\03\01\00" ;; Function section with 0 functions +) + +;; Code section has zero count, and function section is absent. +(module binary + "\00asm" "\01\00\00\00" + "\0a\01\00" ;; Code section with 0 functions +) + +;; Fewer passive segments than datacount +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\0c\01\03" ;; Datacount section with value "3" + "\0b\05\02" ;; Data section with two entries + "\01\00" ;; Passive data section + "\01\00") ;; Passive data section + "data count and data section have inconsistent lengths") + +;; More passive segments than datacount +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\0c\01\01" ;; Datacount section with value "1" + "\0b\05\02" ;; Data section with two entries + "\01\00" ;; Passive data section + "\01\00") ;; Passive data section + "data count and data section have inconsistent lengths") + +;; memory.init requires a datacount section +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + + "\01\04\01\60\00\00" ;; Type section + "\03\02\01\00" ;; Function section + "\05\03\01\00\00" ;; Memory section + "\0a\0e\01" ;; Code section + + ;; function 0 + "\0c\00" + "\41\00" ;; zero args + "\41\00" + "\41\00" + "\fc\08\00\00" ;; memory.init + "\0b" + + "\0b\03\01\01\00" ;; Data section + ) ;; end + "data count section required") + +;; data.drop requires a datacount section +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + + "\01\04\01\60\00\00" ;; Type section + "\03\02\01\00" ;; Function section + "\05\03\01\00\00" ;; Memory section + "\0a\07\01" ;; Code section + + ;; function 0 + "\05\00" + "\fc\09\00" ;; data.drop + "\0b" + + "\0b\03\01\01\00" ;; Data section + ) ;; end + "data count section required") + +;; passive element segment containing opcode other than ref.func or ref.null +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + + "\01\04\01\60\00\00" ;; Type section + + "\03\02\01\00" ;; Function section + + "\04\04\01" ;; Table section with 1 entry + "\70\00\00" ;; no max, minimum 0, funcref + + "\05\03\01\00\00" ;; Memory section + + "\09\07\01" ;; Element section with one segment + "\05\70" ;; Passive, funcref + "\01" ;; 1 element + "\d3\00\0b" ;; bad opcode, index 0, end + + "\0a\04\01" ;; Code section + + ;; function 0 + "\02\00" + "\0b") ;; end + "illegal opcode") + +;; passive element segment containing type other than funcref +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + + "\01\04\01\60\00\00" ;; Type section + + "\03\02\01\00" ;; Function section + + "\04\04\01" ;; Table section with 1 entry + "\70\00\00" ;; no max, minimum 0, funcref + + "\05\03\01\00\00" ;; Memory section + + "\09\07\01" ;; Element section with one segment + "\05\7f" ;; Passive, i32 + "\01" ;; 1 element + "\d2\00\0b" ;; ref.func, index 0, end + + "\0a\04\01" ;; Code section + + ;; function 0 + "\02\00" + "\0b") ;; end + "malformed reference type") + +;; passive element segment containing opcode ref.func +(module binary + "\00asm" "\01\00\00\00" + + "\01\04\01\60\00\00" ;; Type section + + "\03\02\01\00" ;; Function section + + "\04\04\01" ;; Table section with 1 entry + "\70\00\00" ;; no max, minimum 0, funcref + + "\05\03\01\00\00" ;; Memory section + + "\09\07\01" ;; Element section with one segment + "\05\70" ;; Passive, funcref + "\01" ;; 1 element + "\d2\00\0b" ;; ref.func, index 0, end + + "\0a\04\01" ;; Code section + + ;; function 0 + "\02\00" + "\0b") ;; end + +;; passive element segment containing opcode ref.null +(module binary + "\00asm" "\01\00\00\00" + + "\01\04\01\60\00\00" ;; Type section + + "\03\02\01\00" ;; Function section + + "\04\04\01" ;; Table section with 1 entry + "\70\00\00" ;; no max, minimum 0, funcref + + "\05\03\01\00\00" ;; Memory section + + "\09\07\01" ;; Element section with one segment + "\05\70" ;; Passive, funcref + "\01" ;; 1 element + "\d0\70\0b" ;; ref.null, end + + "\0a\04\01" ;; Code section + + ;; function 0 + "\02\00" + "\0b") ;; end + + +;; Type count can be zero +(module binary + "\00asm" "\01\00\00\00" + "\01\01\00" ;; type count can be zero +) + +;; 2 type declared, 1 given +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\07\02" ;; type section with inconsistent count (2 declared, 1 given) + "\60\00\00" ;; 1st type + ;; "\60\00\00" ;; 2nd type (missed) + ) + "unexpected end of section or function" +) + +;; 1 type declared, 2 given +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\07\01" ;; type section with inconsistent count (1 declared, 2 given) + "\60\00\00" ;; 1st type + "\60\00\00" ;; 2nd type (redundant) + ) + "section size mismatch" +) + +;; Import count can be zero +(module binary + "\00asm" "\01\00\00\00" + "\01\05\01" ;; type section + "\60\01\7f\00" ;; type 0 + "\02\01\00" ;; import count can be zero +) + +;; Malformed import kind +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\04\01" ;; import section with single entry + "\00" ;; string length 0 + "\00" ;; string length 0 + "\04" ;; malformed import kind + ) + "malformed import kind" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\05\01" ;; import section with single entry + "\00" ;; string length 0 + "\00" ;; string length 0 + "\04" ;; malformed import kind + "\00" ;; dummy byte + ) + "malformed import kind" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\04\01" ;; import section with single entry + "\00" ;; string length 0 + "\00" ;; string length 0 + "\05" ;; malformed import kind + ) + "malformed import kind" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\05\01" ;; import section with single entry + "\00" ;; string length 0 + "\00" ;; string length 0 + "\05" ;; malformed import kind + "\00" ;; dummy byte + ) + "malformed import kind" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\04\01" ;; import section with single entry + "\00" ;; string length 0 + "\00" ;; string length 0 + "\80" ;; malformed import kind + ) + "malformed import kind" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\05\01" ;; import section with single entry + "\00" ;; string length 0 + "\00" ;; string length 0 + "\80" ;; malformed import kind + "\00" ;; dummy byte + ) + "malformed import kind" +) + +;; 2 import declared, 1 given +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\05\01" ;; type section + "\60\01\7f\00" ;; type 0 + "\02\16\02" ;; import section with inconsistent count (2 declared, 1 given) + ;; 1st import + "\08" ;; string length + "\73\70\65\63\74\65\73\74" ;; spectest + "\09" ;; string length + "\70\72\69\6e\74\5f\69\33\32" ;; print_i32 + "\00\00" ;; import kind, import signature index + ;; 2nd import + ;; (missed) + ) + "unexpected end of section or function" +) + +;; 1 import declared, 2 given +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\09\02" ;; type section + "\60\01\7f\00" ;; type 0 + "\60\01\7d\00" ;; type 1 + "\02\2b\01" ;; import section with inconsistent count (1 declared, 2 given) + ;; 1st import + "\08" ;; string length + "\73\70\65\63\74\65\73\74" ;; spectest + "\09" ;; string length + "\70\72\69\6e\74\5f\69\33\32" ;; print_i32 + "\00\00" ;; import kind, import signature index + ;; 2nd import + ;; (redundant) + "\08" ;; string length + "\73\70\65\63\74\65\73\74" ;; spectest + "\09" ;; string length + "\70\72\69\6e\74\5f\66\33\32" ;; print_f32 + "\00\01" ;; import kind, import signature index + ) + "section size mismatch" +) + +;; Table count can be zero +(module binary + "\00asm" "\01\00\00\00" + "\04\01\00" ;; table count can be zero +) + +;; 1 table declared, 0 given +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\04\01\01" ;; table section with inconsistent count (1 declared, 0 given) + ;; "\70\01\00\00" ;; table entity + ) + "unexpected end of section or function" +) + +;; Malformed table limits flag +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\05\03\01" ;; table section with one entry + "\70" ;; anyfunc + "\02" ;; malformed table limits flag + ) + "integer too large" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\05\04\01" ;; table section with one entry + "\70" ;; anyfunc + "\02" ;; malformed table limits flag + "\00" ;; dummy byte + ) + "integer too large" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\05\06\01" ;; table section with one entry + "\70" ;; anyfunc + "\81\00" ;; malformed table limits flag as LEB128 + "\00\00" ;; dummy bytes + ) + "integer too large" +) + +;; Memory count can be zero +(module binary + "\00asm" "\01\00\00\00" + "\05\01\00" ;; memory count can be zero +) + +;; 1 memory declared, 0 given +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\05\01\01" ;; memory section with inconsistent count (1 declared, 0 given) + ;; "\00\00" ;; memory 0 (missed) + ) + "unexpected end of section or function" +) + +;; Malformed memory limits flag +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\05\02\01" ;; memory section with one entry + "\02" ;; malformed memory limits flag + ) + "integer too large" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\05\03\01" ;; memory section with one entry + "\02" ;; malformed memory limits flag + "\00" ;; dummy byte + ) + "integer too large" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\05\05\01" ;; memory section with one entry + "\81\00" ;; malformed memory limits flag as LEB128 + "\00\00" ;; dummy bytes + ) + "integer representation too long" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\05\05\01" ;; memory section with one entry + "\81\01" ;; malformed memory limits flag as LEB128 + "\00\00" ;; dummy bytes + ) + "integer representation too long" +) + +;; Global count can be zero +(module binary + "\00asm" "\01\00\00\00" + "\06\01\00" ;; global count can be zero +) + +;; 2 global declared, 1 given +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\06\06\02" ;; global section with inconsistent count (2 declared, 1 given) + "\7f\00\41\00\0b" ;; global 0 + ;; "\7f\00\41\00\0b" ;; global 1 (missed) + ) + "unexpected end of section or function" +) + +;; 1 global declared, 2 given +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\06\0b\01" ;; global section with inconsistent count (1 declared, 2 given) + "\7f\00\41\00\0b" ;; global 0 + "\7f\00\41\00\0b" ;; global 1 (redundant) + ) + "section size mismatch" +) + +;; Export count can be 0 +(module binary + "\00asm" "\01\00\00\00" + "\01\04\01" ;; type section + "\60\00\00" ;; type 0 + "\03\03\02\00\00" ;; func section + "\07\01\00" ;; export count can be zero + "\0a\07\02" ;; code section + "\02\00\0b" ;; function body 0 + "\02\00\0b" ;; function body 1 +) + +;; 2 export declared, 1 given +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01" ;; type section + "\60\00\00" ;; type 0 + "\03\03\02\00\00" ;; func section + "\07\06\02" ;; export section with inconsistent count (2 declared, 1 given) + "\02" ;; export 0 + "\66\31" ;; export name + "\00\00" ;; export kind, export func index + ;; "\02" ;; export 1 (missed) + ;; "\66\32" ;; export name + ;; "\00\01" ;; export kind, export func index + "\0a\07\02" ;; code section + "\02\00\0b" ;; function body 0 + "\02\00\0b" ;; function body 1 + ) + "unexpected end of section or function" +) + +;; 1 export declared, 2 given +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01" ;; type section + "\60\00\00" ;; type 0 + "\03\03\02\00\00" ;; func section + "\07\0b\01" ;; export section with inconsistent count (1 declared, 2 given) + "\02" ;; export 0 + "\66\31" ;; export name + "\00\00" ;; export kind, export func index + "\02" ;; export 1 (redundant) + "\66\32" ;; export name + "\00\01" ;; export kind, export func index + "\0a\07\02" ;; code section + "\02\00\0b" ;; function body 0 + "\02\00\0b" ;; function body 1 + ) + "section size mismatch" +) + +;; elem segment count can be zero +(module binary + "\00asm" "\01\00\00\00" + "\01\04\01" ;; type section + "\60\00\00" ;; type 0 + "\03\02\01\00" ;; func section + "\04\04\01" ;; table section + "\70\00\01" ;; table 0 + "\09\01\00" ;; elem segment count can be zero + "\0a\04\01" ;; code section + "\02\00\0b" ;; function body +) + +;; 2 elem segment declared, 1 given +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01" ;; type section + "\60\00\00" ;; type 0 + "\03\02\01\00" ;; func section + "\04\04\01" ;; table section + "\70\00\01" ;; table 0 + "\09\07\02" ;; elem with inconsistent segment count (2 declared, 1 given) + "\00\41\00\0b\01\00" ;; elem 0 + ;; "\00\41\00\0b\01\00" ;; elem 1 (missed) + ) + "unexpected end" +) + +;; 2 elem segment declared, 1.5 given +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01" ;; type section + "\60\00\00" ;; type 0 + "\03\02\01\00" ;; func section + "\04\04\01" ;; table section + "\70\00\01" ;; table 0 + "\09\07\02" ;; elem with inconsistent segment count (2 declared, 1 given) + "\00\41\00\0b\01\00" ;; elem 0 + "\00\41\00" ;; elem 1 (partial) + ;; "\0b\01\00" ;; elem 1 (missing part) + ) + "unexpected end" +) + +;; 1 elem segment declared, 2 given +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01" ;; type section + "\60\00\00" ;; type 0 + "\03\02\01\00" ;; func section + "\04\04\01" ;; table section + "\70\00\01" ;; table 0 + "\09\0d\01" ;; elem with inconsistent segment count (1 declared, 2 given) + "\00\41\00\0b\01\00" ;; elem 0 + "\00\41\00\0b\01\00" ;; elem 1 (redundant) + "\0a\04\01" ;; code section + "\02\00\0b" ;; function body + ) + "section size mismatch" +) + +;; data segment count can be zero +(module binary + "\00asm" "\01\00\00\00" + "\05\03\01" ;; memory section + "\00\01" ;; memory 0 + "\0b\01\00" ;; data segment count can be zero +) + +;; 2 data segment declared, 1 given +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\05\03\01" ;; memory section + "\00\01" ;; memory 0 + "\0b\07\02" ;; data with inconsistent segment count (2 declared, 1 given) + "\00\41\00\0b\01\61" ;; data 0 + ;; "\00\41\01\0b\01\62" ;; data 1 (missed) + ) + "unexpected end of section or function" +) + +;; 1 data segment declared, 2 given +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\05\03\01" ;; memory section + "\00\01" ;; memory 0 + "\0b\0d\01" ;; data with inconsistent segment count (1 declared, 2 given) + "\00\41\00\0b\01\61" ;; data 0 + "\00\41\01\0b\01\62" ;; data 1 (redundant) + ) + "section size mismatch" +) + +;; data segment has 7 bytes declared, but 6 bytes given +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\05\03\01" ;; memory section + "\00\01" ;; memory 0 + "\0b\0c\01" ;; data section + "\00\41\03\0b" ;; data segment 0 + "\07" ;; data segment size with inconsistent lengths (7 declared, 6 given) + "\61\62\63\64\65\66" ;; 6 bytes given + ) + "unexpected end of section or function" +) + +;; data segment has 5 bytes declared, but 6 bytes given +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\05\03\01" ;; memory section + "\00\01" ;; memory 0 + "\0b\0c\01" ;; data section + "\00\41\00\0b" ;; data segment 0 + "\05" ;; data segment size with inconsistent lengths (5 declared, 6 given) + "\61\62\63\64\65\66" ;; 6 bytes given + ) + "section size mismatch" +) + +;; br_table target count can be zero +(module binary + "\00asm" "\01\00\00\00" + "\01\04\01" ;; type section + "\60\00\00" ;; type 0 + "\03\02\01\00" ;; func section + "\0a\11\01" ;; code section + "\0f\00" ;; func 0 + "\02\40" ;; block 0 + "\41\01" ;; condition of if 0 + "\04\40" ;; if 0 + "\41\01" ;; index of br_table element + "\0e\00" ;; br_table target count can be zero + "\02" ;; break depth for default + "\0b\0b\0b" ;; end +) + +;; 1 br_table target declared, 2 given +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01" ;; type section + "\60\00\00" ;; type 0 + "\03\02\01\00" ;; func section + "\0a\12\01" ;; code section + "\11\00" ;; func 0 + "\02\40" ;; block 0 + "\41\01" ;; condition of if 0 + "\04\40" ;; if 0 + "\41\01" ;; index of br_table element + "\0e\01" ;; br_table with inconsistent target count (1 declared, 2 given) + "\00" ;; break depth 0 + "\01" ;; break depth 1 + "\02" ;; break depth for default + "\0b\0b\0b" ;; end + ) + "unexpected end" +) + +;; Start section +(module binary + "\00asm" "\01\00\00\00" + "\01\04\01\60\00\00" ;; Type section + "\03\02\01\00" ;; Function section + "\08\01\00" ;; Start section: function 0 + + "\0a\04\01" ;; Code section + ;; function 0 + "\02\00" + "\0b" ;; end +) + +;; Multiple start sections +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01\60\00\00" ;; Type section + "\03\02\01\00" ;; Function section + "\08\01\00" ;; Start section: function 0 + "\08\01\00" ;; Start section: function 0 + + "\0a\04\01" ;; Code section + ;; function 0 + "\02\00" + "\0b" ;; end + ) + "junk after last section" +) diff --git a/runtime/near-vm/tests/wast/spec/block.wast b/runtime/near-vm/tests/wast/spec/block.wast new file mode 100644 index 00000000000..44915b991b6 --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/block.wast @@ -0,0 +1,1491 @@ +;; Test `block` operator + +(module + ;; Auxiliary definition + (memory 1) + + (func $dummy) + + (func (export "empty") + (block) + (block $l) + ) + + (func (export "singular") (result i32) + (block (nop)) + (block (result i32) (i32.const 7)) + ) + + (func (export "multi") (result i32) + (block (call $dummy) (call $dummy) (call $dummy) (call $dummy)) + (block (result i32) + (call $dummy) (call $dummy) (call $dummy) (i32.const 7) (call $dummy) + ) + (drop) + (block (result i32 i64 i32) + (call $dummy) (call $dummy) (call $dummy) (i32.const 8) (call $dummy) + (call $dummy) (call $dummy) (call $dummy) (i64.const 7) (call $dummy) + (call $dummy) (call $dummy) (call $dummy) (i32.const 9) (call $dummy) + ) + (drop) (drop) + ) + + (func (export "nested") (result i32) + (block (result i32) + (block (call $dummy) (block) (nop)) + (block (result i32) (call $dummy) (i32.const 9)) + ) + ) + + (func (export "deep") (result i32) + (block (result i32) (block (result i32) + (block (result i32) (block (result i32) + (block (result i32) (block (result i32) + (block (result i32) (block (result i32) + (block (result i32) (block (result i32) + (block (result i32) (block (result i32) + (block (result i32) (block (result i32) + (block (result i32) (block (result i32) + (block (result i32) (block (result i32) + (block (result i32) (block (result i32) + (block (result i32) (block (result i32) + (block (result i32) (block (result i32) + (block (result i32) (block (result i32) + (block (result i32) (block (result i32) + (block (result i32) (block (result i32) + (block (result i32) (block (result i32) + (block (result i32) (block (result i32) + (block (result i32) (block (result i32) + (block (result i32) (block (result i32) + (call $dummy) (i32.const 150) + )) + )) + )) + )) + )) + )) + )) + )) + )) + )) + )) + )) + )) + )) + )) + )) + )) + )) + )) + ) + + (func (export "as-select-first") (result i32) + (select (block (result i32) (i32.const 1)) (i32.const 2) (i32.const 3)) + ) + (func (export "as-select-mid") (result i32) + (select (i32.const 2) (block (result i32) (i32.const 1)) (i32.const 3)) + ) + (func (export "as-select-last") (result i32) + (select (i32.const 2) (i32.const 3) (block (result i32) (i32.const 1))) + ) + + (func (export "as-loop-first") (result i32) + (loop (result i32) (block (result i32) (i32.const 1)) (call $dummy) (call $dummy)) + ) + (func (export "as-loop-mid") (result i32) + (loop (result i32) (call $dummy) (block (result i32) (i32.const 1)) (call $dummy)) + ) + (func (export "as-loop-last") (result i32) + (loop (result i32) (call $dummy) (call $dummy) (block (result i32) (i32.const 1))) + ) + + (func (export "as-if-condition") + (block (result i32) (i32.const 1)) (if (then (call $dummy))) + ) + (func (export "as-if-then") (result i32) + (if (result i32) (i32.const 1) (then (block (result i32) (i32.const 1))) (else (i32.const 2))) + ) + (func (export "as-if-else") (result i32) + (if (result i32) (i32.const 1) (then (i32.const 2)) (else (block (result i32) (i32.const 1)))) + ) + + (func (export "as-br_if-first") (result i32) + (block (result i32) (br_if 0 (block (result i32) (i32.const 1)) (i32.const 2))) + ) + (func (export "as-br_if-last") (result i32) + (block (result i32) (br_if 0 (i32.const 2) (block (result i32) (i32.const 1)))) + ) + + (func (export "as-br_table-first") (result i32) + (block (result i32) (block (result i32) (i32.const 1)) (i32.const 2) (br_table 0 0)) + ) + (func (export "as-br_table-last") (result i32) + (block (result i32) (i32.const 2) (block (result i32) (i32.const 1)) (br_table 0 0)) + ) + + (func $func (param i32 i32) (result i32) (local.get 0)) + (type $check (func (param i32 i32) (result i32))) + (table funcref (elem $func)) + (func (export "as-call_indirect-first") (result i32) + (block (result i32) + (call_indirect (type $check) + (block (result i32) (i32.const 1)) (i32.const 2) (i32.const 0) + ) + ) + ) + (func (export "as-call_indirect-mid") (result i32) + (block (result i32) + (call_indirect (type $check) + (i32.const 2) (block (result i32) (i32.const 1)) (i32.const 0) + ) + ) + ) + (func (export "as-call_indirect-last") (result i32) + (block (result i32) + (call_indirect (type $check) + (i32.const 1) (i32.const 2) (block (result i32) (i32.const 0)) + ) + ) + ) + + (func (export "as-store-first") + (block (result i32) (i32.const 1)) (i32.const 1) (i32.store) + ) + (func (export "as-store-last") + (i32.const 10) (block (result i32) (i32.const 1)) (i32.store) + ) + + (func (export "as-memory.grow-value") (result i32) + (memory.grow (block (result i32) (i32.const 1))) + ) + + (func $f (param i32) (result i32) (local.get 0)) + + (func (export "as-call-value") (result i32) + (call $f (block (result i32) (i32.const 1))) + ) + (func (export "as-return-value") (result i32) + (block (result i32) (i32.const 1)) (return) + ) + (func (export "as-drop-operand") + (drop (block (result i32) (i32.const 1))) + ) + (func (export "as-br-value") (result i32) + (block (result i32) (br 0 (block (result i32) (i32.const 1)))) + ) + (func (export "as-local.set-value") (result i32) + (local i32) (local.set 0 (block (result i32) (i32.const 1))) (local.get 0) + ) + (func (export "as-local.tee-value") (result i32) + (local i32) (local.tee 0 (block (result i32) (i32.const 1))) + ) + (global $a (mut i32) (i32.const 10)) + (func (export "as-global.set-value") (result i32) + (global.set $a (block (result i32) (i32.const 1))) + (global.get $a) + ) + + (func (export "as-load-operand") (result i32) + (i32.load (block (result i32) (i32.const 1))) + ) + + (func (export "as-unary-operand") (result i32) + (i32.ctz (block (result i32) (call $dummy) (i32.const 13))) + ) + (func (export "as-binary-operand") (result i32) + (i32.mul + (block (result i32) (call $dummy) (i32.const 3)) + (block (result i32) (call $dummy) (i32.const 4)) + ) + ) + (func (export "as-test-operand") (result i32) + (i32.eqz (block (result i32) (call $dummy) (i32.const 13))) + ) + (func (export "as-compare-operand") (result i32) + (f32.gt + (block (result f32) (call $dummy) (f32.const 3)) + (block (result f32) (call $dummy) (f32.const 3)) + ) + ) + (func (export "as-binary-operands") (result i32) + (i32.mul + (block (result i32 i32) + (call $dummy) (i32.const 3) (call $dummy) (i32.const 4) + ) + ) + ) + (func (export "as-compare-operands") (result i32) + (f32.gt + (block (result f32 f32) + (call $dummy) (f32.const 3) (call $dummy) (f32.const 3) + ) + ) + ) + (func (export "as-mixed-operands") (result i32) + (block (result i32 i32) + (call $dummy) (i32.const 3) (call $dummy) (i32.const 4) + ) + (i32.const 5) + (i32.add) + (i32.mul) + ) + + (func (export "break-bare") (result i32) + (block (br 0) (unreachable)) + (block (br_if 0 (i32.const 1)) (unreachable)) + (block (br_table 0 (i32.const 0)) (unreachable)) + (block (br_table 0 0 0 (i32.const 1)) (unreachable)) + (i32.const 19) + ) + (func (export "break-value") (result i32) + (block (result i32) (br 0 (i32.const 18)) (i32.const 19)) + ) + (func (export "break-multi-value") (result i32 i32 i64) + (block (result i32 i32 i64) + (br 0 (i32.const 18) (i32.const -18) (i64.const 18)) + (i32.const 19) (i32.const -19) (i64.const 19) + ) + ) + (func (export "break-repeated") (result i32) + (block (result i32) + (br 0 (i32.const 18)) + (br 0 (i32.const 19)) + (drop (br_if 0 (i32.const 20) (i32.const 0))) + (drop (br_if 0 (i32.const 20) (i32.const 1))) + (br 0 (i32.const 21)) + (br_table 0 (i32.const 22) (i32.const 4)) + (br_table 0 0 0 (i32.const 23) (i32.const 1)) + (i32.const 21) + ) + ) + (func (export "break-inner") (result i32) + (local i32) + (local.set 0 (i32.const 0)) + (local.set 0 (i32.add (local.get 0) (block (result i32) (block (result i32) (br 1 (i32.const 0x1)))))) + (local.set 0 (i32.add (local.get 0) (block (result i32) (block (br 0)) (i32.const 0x2)))) + (local.set 0 + (i32.add (local.get 0) (block (result i32) (i32.ctz (br 0 (i32.const 0x4))))) + ) + (local.set 0 + (i32.add (local.get 0) (block (result i32) (i32.ctz (block (result i32) (br 1 (i32.const 0x8)))))) + ) + (local.get 0) + ) + + (func (export "param") (result i32) + (i32.const 1) + (block (param i32) (result i32) + (i32.const 2) + (i32.add) + ) + ) + (func (export "params") (result i32) + (i32.const 1) + (i32.const 2) + (block (param i32 i32) (result i32) + (i32.add) + ) + ) + (func (export "params-id") (result i32) + (i32.const 1) + (i32.const 2) + (block (param i32 i32) (result i32 i32)) + (i32.add) + ) + (func (export "param-break") (result i32) + (i32.const 1) + (block (param i32) (result i32) + (i32.const 2) + (i32.add) + (br 0) + ) + ) + (func (export "params-break") (result i32) + (i32.const 1) + (i32.const 2) + (block (param i32 i32) (result i32) + (i32.add) + (br 0) + ) + ) + (func (export "params-id-break") (result i32) + (i32.const 1) + (i32.const 2) + (block (param i32 i32) (result i32 i32) (br 0)) + (i32.add) + ) + + (func (export "effects") (result i32) + (local i32) + (block + (local.set 0 (i32.const 1)) + (local.set 0 (i32.mul (local.get 0) (i32.const 3))) + (local.set 0 (i32.sub (local.get 0) (i32.const 5))) + (local.set 0 (i32.mul (local.get 0) (i32.const 7))) + (br 0) + (local.set 0 (i32.mul (local.get 0) (i32.const 100))) + ) + (i32.eq (local.get 0) (i32.const -14)) + ) + + (type $block-sig-1 (func)) + (type $block-sig-2 (func (result i32))) + (type $block-sig-3 (func (param $x i32))) + (type $block-sig-4 (func (param i32 f64 i32) (result i32 f64 i32))) + + (func (export "type-use") + (block (type $block-sig-1)) + (block (type $block-sig-2) (i32.const 0)) + (block (type $block-sig-3) (drop)) + (i32.const 0) (f64.const 0) (i32.const 0) + (block (type $block-sig-4)) + (drop) (drop) (drop) + (block (type $block-sig-2) (result i32) (i32.const 0)) + (block (type $block-sig-3) (param i32) (drop)) + (i32.const 0) (f64.const 0) (i32.const 0) + (block (type $block-sig-4) + (param i32) (param f64 i32) (result i32 f64) (result i32) + ) + (drop) (drop) (drop) + ) +) + +(assert_return (invoke "empty")) +(assert_return (invoke "singular") (i32.const 7)) +(assert_return (invoke "multi") (i32.const 8)) +(assert_return (invoke "nested") (i32.const 9)) +(assert_return (invoke "deep") (i32.const 150)) + +(assert_return (invoke "as-select-first") (i32.const 1)) +(assert_return (invoke "as-select-mid") (i32.const 2)) +(assert_return (invoke "as-select-last") (i32.const 2)) + +(assert_return (invoke "as-loop-first") (i32.const 1)) +(assert_return (invoke "as-loop-mid") (i32.const 1)) +(assert_return (invoke "as-loop-last") (i32.const 1)) + +(assert_return (invoke "as-if-condition")) +(assert_return (invoke "as-if-then") (i32.const 1)) +(assert_return (invoke "as-if-else") (i32.const 2)) + +(assert_return (invoke "as-br_if-first") (i32.const 1)) +(assert_return (invoke "as-br_if-last") (i32.const 2)) + +(assert_return (invoke "as-br_table-first") (i32.const 1)) +(assert_return (invoke "as-br_table-last") (i32.const 2)) + +(assert_return (invoke "as-call_indirect-first") (i32.const 1)) +(assert_return (invoke "as-call_indirect-mid") (i32.const 2)) +(assert_return (invoke "as-call_indirect-last") (i32.const 1)) + +(assert_return (invoke "as-store-first")) +(assert_return (invoke "as-store-last")) + +(assert_return (invoke "as-memory.grow-value") (i32.const 1)) +(assert_return (invoke "as-call-value") (i32.const 1)) +(assert_return (invoke "as-return-value") (i32.const 1)) +(assert_return (invoke "as-drop-operand")) +(assert_return (invoke "as-br-value") (i32.const 1)) +(assert_return (invoke "as-local.set-value") (i32.const 1)) +(assert_return (invoke "as-local.tee-value") (i32.const 1)) +(assert_return (invoke "as-global.set-value") (i32.const 1)) +(assert_return (invoke "as-load-operand") (i32.const 1)) + +(assert_return (invoke "as-unary-operand") (i32.const 0)) +(assert_return (invoke "as-binary-operand") (i32.const 12)) +(assert_return (invoke "as-test-operand") (i32.const 0)) +(assert_return (invoke "as-compare-operand") (i32.const 0)) +(assert_return (invoke "as-binary-operands") (i32.const 12)) +(assert_return (invoke "as-compare-operands") (i32.const 0)) +(assert_return (invoke "as-mixed-operands") (i32.const 27)) + +(assert_return (invoke "break-bare") (i32.const 19)) +(assert_return (invoke "break-value") (i32.const 18)) +(assert_return (invoke "break-multi-value") + (i32.const 18) (i32.const -18) (i64.const 18) +) +(assert_return (invoke "break-repeated") (i32.const 18)) +(assert_return (invoke "break-inner") (i32.const 0xf)) + +(assert_return (invoke "param") (i32.const 3)) +(assert_return (invoke "params") (i32.const 3)) +(assert_return (invoke "params-id") (i32.const 3)) +(assert_return (invoke "param-break") (i32.const 3)) +(assert_return (invoke "params-break") (i32.const 3)) +(assert_return (invoke "params-id-break") (i32.const 3)) + +(assert_return (invoke "effects") (i32.const 1)) + +(assert_return (invoke "type-use")) + +(assert_malformed + (module quote + "(type $sig (func (param i32) (result i32)))" + "(func (i32.const 0) (block (type $sig) (result i32) (param i32)))" + ) + "unexpected token" +) +(assert_malformed + (module quote + "(type $sig (func (param i32) (result i32)))" + "(func (i32.const 0) (block (param i32) (type $sig) (result i32)))" + ) + "unexpected token" +) +(assert_malformed + (module quote + "(type $sig (func (param i32) (result i32)))" + "(func (i32.const 0) (block (param i32) (result i32) (type $sig)))" + ) + "unexpected token" +) +(assert_malformed + (module quote + "(type $sig (func (param i32) (result i32)))" + "(func (i32.const 0) (block (result i32) (type $sig) (param i32)))" + ) + "unexpected token" +) +(assert_malformed + (module quote + "(type $sig (func (param i32) (result i32)))" + "(func (i32.const 0) (block (result i32) (param i32) (type $sig)))" + ) + "unexpected token" +) +(assert_malformed + (module quote + "(func (i32.const 0) (block (result i32) (param i32)))" + ) + "unexpected token" +) + +(assert_malformed + (module quote "(func (i32.const 0) (block (param $x i32) (drop)))") + "unexpected token" +) +(assert_malformed + (module quote + "(type $sig (func))" + "(func (block (type $sig) (result i32) (i32.const 0)) (unreachable))" + ) + "inline function type" +) +(assert_malformed + (module quote + "(type $sig (func (param i32) (result i32)))" + "(func (block (type $sig) (result i32) (i32.const 0)) (unreachable))" + ) + "inline function type" +) +(assert_malformed + (module quote + "(type $sig (func (param i32) (result i32)))" + "(func (i32.const 0) (block (type $sig) (param i32) (drop)) (unreachable))" + ) + "inline function type" +) +(assert_malformed + (module quote + "(type $sig (func (param i32 i32) (result i32)))" + "(func (i32.const 0) (block (type $sig) (param i32) (result i32)) (unreachable))" + ) + "inline function type" +) + +(assert_invalid + (module + (type $sig (func)) + (func (block (type $sig) (i32.const 0))) + ) + "type mismatch" +) + +(assert_invalid + (module (func $type-empty-i32 (result i32) (block))) + "type mismatch" +) +(assert_invalid + (module (func $type-empty-i64 (result i64) (block))) + "type mismatch" +) +(assert_invalid + (module (func $type-empty-f32 (result f32) (block))) + "type mismatch" +) +(assert_invalid + (module (func $type-empty-f64 (result f64) (block))) + "type mismatch" +) + +(assert_invalid + (module (func $type-value-i32-vs-void + (block (i32.const 1)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-value-i64-vs-void + (block (i64.const 1)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-value-f32-vs-void + (block (f32.const 1.0)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-value-f64-vs-void + (block (f64.const 1.0)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-value-nums-vs-void + (block (i32.const 1) (i32.const 2)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-value-empty-vs-i32 (result i32) + (block (result i32)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-value-empty-vs-i64 (result i64) + (block (result i64)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-value-empty-vs-f32 (result f32) + (block (result f32)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-value-empty-vs-f64 (result f64) + (block (result f64)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-value-empty-vs-nums (result i32 i32) + (block (result i32 i32)) + )) + "type mismatch" +) + +(assert_invalid + (module + (func $type-value-empty-in-block + (i32.const 0) + (block (block (result i32)) (drop)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-value-empty-in-loop + (i32.const 0) + (loop (block (result i32)) (drop)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-value-empty-in-then + (i32.const 0) (i32.const 0) + (if (then (block (result i32)) (drop))) + ) + ) + "type mismatch" +) + +(assert_invalid + (module (func $type-value-void-vs-i32 (result i32) + (block (result i32) (nop)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-value-void-vs-i64 (result i64) + (block (result i64) (nop)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-value-void-vs-f32 (result f32) + (block (result f32) (nop)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-value-void-vs-f64 (result f64) + (block (result f64) (nop)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-value-void-vs-nums (result i32 i32) + (block (result i32 i32) (nop)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-value-i32-vs-i64 (result i32) + (block (result i32) (i64.const 0)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-value-i32-vs-f32 (result i32) + (block (result i32) (f32.const 0.0)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-value-i32-vs-f64 (result i32) + (block (result i32) (f64.const 0.0)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-value-i64-vs-i32 (result i64) + (block (result i64) (i32.const 0)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-value-i64-vs-f32 (result i64) + (block (result i64) (f32.const 0.0)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-value-i64-vs-f64 (result i64) + (block (result i64) (f64.const 0.0)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-value-f32-vs-i32 (result f32) + (block (result f32) (i32.const 0)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-value-f32-vs-i64 (result f32) + (block (result f32) (i64.const 0)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-value-f32-vs-f64 (result f32) + (block (result f32) (f64.const 0.0)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-value-f64-vs-i32 (result f64) + (block (result f64) (i32.const 0)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-value-f64-vs-i64 (result f64) + (block (result f64) (i64.const 0)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-value-f64-vs-f32 (result f32) + (block (result f64) (f32.const 0.0)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-value-num-vs-nums (result i32 i32) + (block (result i32 i32) (i32.const 0)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-value-partial-vs-nums (result i32 i32) + (i32.const 1) (block (result i32 i32) (i32.const 2)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-value-nums-vs-num (result i32) + (block (result i32) (i32.const 1) (i32.const 2)) + )) + "type mismatch" +) + +(assert_invalid + (module (func $type-value-unreached-select-i32-i64 (result i32) + (block (result i64) (select (unreachable) (unreachable) (unreachable))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-value-unreached-select-i32-f32 (result i32) + (block (result f32) (select (unreachable) (unreachable) (unreachable))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-value-unreached-select-i32-f64 (result i32) + (block (result f64) (select (unreachable) (unreachable) (unreachable))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-value-unreached-select-i64-i32 (result i64) + (block (result i32) (select (unreachable) (unreachable) (unreachable))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-value-unreached-select-i64-f32 (result i64) + (block (result f32) (select (unreachable) (unreachable) (unreachable))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-value-unreached-select-i64-f64 (result i64) + (block (result f64) (select (unreachable) (unreachable) (unreachable))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-value-unreached-select-f32-i32 (result f32) + (block (result i32) (select (unreachable) (unreachable) (unreachable))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-value-unreached-select-f32-i64 (result f32) + (block (result i64) (select (unreachable) (unreachable) (unreachable))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-value-unreached-select-f32-f64 (result f32) + (block (result f64) (select (unreachable) (unreachable) (unreachable))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-value-unreached-select-f64-i32 (result f64) + (block (result i32) (select (unreachable) (unreachable) (unreachable))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-value-unreached-select-f64-i64 (result f64) + (block (result i64) (select (unreachable) (unreachable) (unreachable))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-value-unreached-select-f64-f32 (result f64) + (block (result f32) (select (unreachable) (unreachable) (unreachable))) + )) + "type mismatch" +) + +(assert_invalid + (module (func $type-break-last-void-vs-i32 (result i32) + (block (result i32) (br 0)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-last-void-vs-i64 (result i64) + (block (result i64) (br 0)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-last-void-vs-f32 (result f32) + (block (result f32) (br 0)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-last-void-vs-f64 (result f64) + (block (result f64) (br 0)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-last-void-vs-nums (result i32 i32) + (block (result i32 i32) (br 0)) + )) + "type mismatch" +) + +(assert_invalid + (module (func $type-break-empty-vs-i32 (result i32) + (block (result i32) (br 0) (i32.const 1)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-empty-vs-i64 (result i64) + (block (result i64) (br 0) (i64.const 1)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-empty-vs-f32 (result f32) + (block (result f32) (br 0) (f32.const 1.0)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-empty-vs-f64 (result f64) + (block (result f64) (br 0) (f64.const 1.0)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-empty-vs-nums (result i32 i32) + (block (result i32 i32) (br 0) (i32.const 1) (i32.const 2)) + )) + "type mismatch" +) + +(assert_invalid + (module (func $type-break-void-vs-i32 (result i32) + (block (result i32) (br 0 (nop)) (i32.const 1)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-void-vs-i64 (result i64) + (block (result i64) (br 0 (nop)) (i64.const 1)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-void-vs-f32 (result f32) + (block (result f32) (br 0 (nop)) (f32.const 1.0)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-void-vs-f64 (result f64) + (block (result f64) (br 0 (nop)) (f64.const 1.0)) + )) + "type mismatch" +) + +(assert_invalid + (module (func $type-break-i32-vs-i64 (result i32) + (block (result i32) (br 0 (i64.const 1)) (i32.const 1)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-i32-vs-f32 (result i32) + (block (result i32) (br 0 (f32.const 1.0)) (i32.const 1)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-i32-vs-f64 (result i32) + (block (result i32) (br 0 (f64.const 1.0)) (i32.const 1)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-i64-vs-i32 (result i64) + (block (result i64) (br 0 (i32.const 1)) (i64.const 1)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-i64-vs-f32 (result i64) + (block (result i64) (br 0 (f32.const 1.0)) (i64.const 1)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-i64-vs-f64 (result i64) + (block (result i64) (br 0 (f64.const 1.0)) (i64.const 1)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-f32-vs-i32 (result f32) + (block (result f32) (br 0 (i32.const 1)) (f32.const 1.0)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-f32-vs-i64 (result f32) + (block (result f32) (br 0 (i64.const 1)) (f32.const 1.0)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-f32-vs-f64 (result f32) + (block (result f32) (br 0 (f64.const 1.0)) (f32.const 1.0)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-f64-vs-i32 (result f64) + (block (result i64) (br 0 (i32.const 1)) (f64.const 1.0)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-f64-vs-i64 (result f64) + (block (result f64) (br 0 (i64.const 1)) (f64.const 1.0)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-f64-vs-f32 (result f64) + (block (result f64) (br 0 (f32.const 1.0)) (f64.const 1)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-num-vs-nums (result i32 i32) + (block (result i32 i32) (br 0 (i32.const 0)) (i32.const 1) (i32.const 2)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-partial-vs-nums (result i32 i32) + (i32.const 1) (block (result i32 i32) (br 0 (i32.const 0)) (i32.const 2)) + )) + "type mismatch" +) + +(assert_invalid + (module (func $type-break-first-void-vs-i32 (result i32) + (block (result i32) (br 0 (nop)) (br 0 (i32.const 1))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-first-void-vs-i64 (result i64) + (block (result i64) (br 0 (nop)) (br 0 (i64.const 1))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-first-void-vs-f32 (result f32) + (block (result f32) (br 0 (nop)) (br 0 (f32.const 1.0))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-first-void-vs-f64 (result f64) + (block (result f64) (br 0 (nop)) (br 0 (f64.const 1.0))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-first-void-vs-nums (result i32 i32) + (block (result i32 i32) (br 0 (nop)) (br 0 (i32.const 1) (i32.const 2))) + )) + "type mismatch" +) + +(assert_invalid + (module (func $type-break-first-i32-vs-i64 (result i32) + (block (result i32) (br 0 (i64.const 1)) (br 0 (i32.const 1))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-first-i32-vs-f32 (result i32) + (block (result i32) (br 0 (f32.const 1.0)) (br 0 (i32.const 1))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-first-i32-vs-f64 (result i32) + (block (result i32) (br 0 (f64.const 1.0)) (br 0 (i32.const 1))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-first-i64-vs-i32 (result i64) + (block (result i64) (br 0 (i32.const 1)) (br 0 (i64.const 1))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-first-i64-vs-f32 (result i64) + (block (result i64) (br 0 (f32.const 1.0)) (br 0 (i64.const 1))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-first-i64-vs-f64 (result i64) + (block (result i64) (br 0 (f64.const 1.0)) (br 0 (i64.const 1))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-first-f32-vs-i32 (result f32) + (block (result f32) (br 0 (i32.const 1)) (br 0 (f32.const 1.0))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-first-f32-vs-i64 (result f32) + (block (result f32) (br 0 (i64.const 1)) (br 0 (f32.const 1.0))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-first-f32-vs-f64 (result f32) + (block (result f32) (br 0 (f64.const 1.0)) (br 0 (f32.const 1.0))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-first-f64-vs-i32 (result f64) + (block (result f64) (br 0 (i32.const 1)) (br 0 (f64.const 1.0))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-first-f64-vs-i64 (result f64) + (block (result f64) (br 0 (i64.const 1)) (br 0 (f64.const 1.0))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-first-f64-vs-f32 (result f64) + (block (result f64) (br 0 (f32.const 1.0)) (br 0 (f64.const 1.0))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-first-num-vs-nums (result i32 i32) + (block (result i32 i32) (br 0 (i32.const 0)) (br 0 (i32.const 1) (i32.const 2))) + )) + "type mismatch" +) + +(assert_invalid + (module (func $type-break-nested-i32-vs-void + (block (result i32) (block (result i32) (br 1 (i32.const 1))) (br 0)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-nested-i64-vs-void + (block (result i64) (block (result i64) (br 1 (i64.const 1))) (br 0)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-nested-f32-vs-void + (block (result f32) (block (result f32) (br 1 (f32.const 1.0))) (br 0)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-nested-f64-vs-void + (block (result f64) (block (result f64) (br 1 (f64.const 1.0))) (br 0)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-nested-nums-vs-void + (block (result i32 i32) (block (result i32 i32) (br 1 (i32.const 1) (i32.const 2))) (br 0)) + )) + "type mismatch" +) + +(assert_invalid + (module (func $type-break-nested-empty-vs-i32 (result i32) + (block (result i32) (block (br 1)) (br 0 (i32.const 1))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-nested-empty-vs-i64 (result i64) + (block (result i64) (block (br 1)) (br 0 (i64.const 1))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-nested-empty-vs-f32 (result f32) + (block (result f32) (block (br 1)) (br 0 (f32.const 1.0))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-nested-empty-vs-f64 (result f64) + (block (result f64) (block (br 1)) (br 0 (f64.const 1))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-nested-empty-vs-nums (result i32 i32) + (block (result i32 i32) (block (br 1)) (br 0 (i32.const 1) (i32.const 2))) + )) + "type mismatch" +) + +(assert_invalid + (module (func $type-break-nested-void-vs-i32 (result i32) + (block (result i32) (block (result i32) (br 1 (nop))) (br 0 (i32.const 1))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-nested-void-vs-i64 (result i64) + (block (result i64) (block (result i64) (br 1 (nop))) (br 0 (i64.const 1))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-nested-void-vs-f32 (result f32) + (block (result f32) (block (result f32) (br 1 (nop))) (br 0 (f32.const 1.0))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-nested-void-vs-f64 (result f64) + (block (result f64) (block (result f64) (br 1 (nop))) (br 0 (f64.const 1.0))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-nested-void-vs-nums (result i32 i32) + (block (result i32 i32) (block (result i32 i32) (br 1 (nop))) (br 0 (i32.const 1) (i32.const 2))) + )) + "type mismatch" +) + +(assert_invalid + (module (func $type-break-nested-i32-vs-i64 (result i32) + (block (result i32) + (block (result i32) (br 1 (i64.const 1))) (br 0 (i32.const 1)) + ) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-nested-i32-vs-f32 (result i32) + (block (result i32) + (block (result i32) (br 1 (f32.const 1.0))) (br 0 (i32.const 1)) + ) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-nested-i32-vs-f64 (result i32) + (block (result i32) + (block (result i32) (br 1 (f64.const 1.0))) (br 0 (i32.const 1)) + ) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-nested-i64-vs-i32 (result i64) + (block (result i64) + (block (result i64) (br 1 (i32.const 1))) (br 0 (i64.const 1)) + ) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-nested-i64-vs-f32 (result i64) + (block (result i64) + (block (result i64) (br 1 (f32.const 1.0))) (br 0 (i64.const 1)) + ) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-nested-i64-vs-f64 (result i64) + (block (result i64) + (block (result i64) (br 1 (f64.const 1.0))) (br 0 (i64.const 1)) + ) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-nested-f32-vs-i32 (result f32) + (block (result f32) + (block (result f32) (br 1 (i32.const 1))) (br 0 (f32.const 1.0)) + ) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-nested-f32-vs-i64 (result f32) + (block (result f32) + (block (result f32) (br 1 (i64.const 1))) (br 0 (f32.const 1.0)) + ) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-nested-f32-vs-f64 (result f32) + (block (result f32) + (block (result f32) (br 1 (f64.const 1.0))) (br 0 (f32.const 1.0)) + ) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-nested-f64-vs-i32 (result f64) + (block (result f64) + (block (result f64) (br 1 (i32.const 1))) (br 0 (f64.const 1.0)) + ) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-nested-f64-vs-i64 (result f64) + (block (result f64) + (block (result f64) (br 1 (i64.const 1))) (br 0 (f64.const 1.0)) + ) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-nested-f64-vs-f32 (result f64) + (block (result f64) + (block (result f64) (br 1 (f32.const 1.0))) (br 0 (f64.const 1.0)) + ) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-nested-num-vs-nums (result i32 i32) + (block (result i32 i32) + (block (result i32 i32) (br 1 (i32.const 0))) (br 0 (i32.const 1) (i32.const 2)) + ) + )) + "type mismatch" +) + +(assert_invalid + (module (func $type-break-operand-empty-vs-i32 (result i32) + (i32.ctz (block (br 0))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-operand-empty-vs-i64 (result i64) + (i64.ctz (block (br 0))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-operand-empty-vs-f32 (result f32) + (f32.floor (block (br 0))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-operand-empty-vs-f64 (result f64) + (f64.floor (block (br 0))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-operand-empty-vs-nums (result i32) + (i32.add (block (br 0))) + )) + "type mismatch" +) + +(assert_invalid + (module (func $type-break-operand-void-vs-i32 (result i32) + (i32.ctz (block (br 0 (nop)))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-operand-void-vs-i64 (result i64) + (i64.ctz (block (br 0 (nop)))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-operand-void-vs-f32 (result f32) + (f32.floor (block (br 0 (nop)))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-operand-void-vs-f64 (result f64) + (f64.floor (block (br 0 (nop)))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-operand-void-vs-nums (result i32) + (i32.add (block (br 0 (nop)))) + )) + "type mismatch" +) + +(assert_invalid + (module (func $type-break-operand-i32-vs-i64 (result i32) + (i64.ctz (block (br 0 (i64.const 9)))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-operand-i32-vs-f32 (result i32) + (f32.floor (block (br 0 (f32.const 9.0)))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-operand-i32-vs-f64 (result i32) + (f64.floor (block (br 0 (f64.const 9.0)))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-operand-i64-vs-i32 (result i64) + (i32.ctz (block (br 0 (i32.const 9)))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-operand-i64-vs-f32 (result i64) + (f32.floor (block (br 0 (f32.const 9.0)))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-operand-i64-vs-f64 (result i64) + (f64.floor (block (br 0 (f64.const 9.0)))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-operand-f32-vs-i32 (result f32) + (i32.ctz (block (br 0 (i32.const 9)))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-operand-f32-vs-i64 (result f32) + (i64.ctz (block (br 0 (i64.const 9)))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-operand-f32-vs-f64 (result f32) + (f64.floor (block (br 0 (f64.const 9.0)))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-operand-f64-vs-i32 (result f64) + (i32.ctz (block (br 0 (i32.const 9)))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-operand-f64-vs-i64 (result f64) + (i64.ctz (block (br 0 (i64.const 9)))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-operand-f64-vs-f32 (result f64) + (f32.floor (block (br 0 (f32.const 9.0)))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-operand-num-vs-nums (result i32) + (i32.add (block (br 0 (i64.const 9) (i32.const 10)))) + )) + "type mismatch" +) + +(assert_invalid + (module (func $type-param-void-vs-num + (block (param i32) (drop)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-param-void-vs-nums + (block (param i32 f64) (drop) (drop)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-param-num-vs-num + (f32.const 0) (block (param i32) (drop)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-param-num-vs-nums + (f32.const 0) (block (param f32 i32) (drop) (drop)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-param-nested-void-vs-num + (block (block (param i32) (drop))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-param-void-vs-nums + (block (block (param i32 f64) (drop) (drop))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-param-num-vs-num + (block (f32.const 0) (block (param i32) (drop))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-param-num-vs-nums + (block (f32.const 0) (block (param f32 i32) (drop) (drop))) + )) + "type mismatch" +) + +(assert_malformed + (module quote "(func (param i32) (result i32) block (param $x i32) end)") + "unexpected token" +) +(assert_malformed + (module quote "(func (param i32) (result i32) (block (param $x i32)))") + "unexpected token" +) + + +(assert_malformed + (module quote "(func block end $l)") + "mismatching label" +) +(assert_malformed + (module quote "(func block $a end $l)") + "mismatching label" +) diff --git a/runtime/near-vm/tests/wast/spec/br.wast b/runtime/near-vm/tests/wast/spec/br.wast new file mode 100644 index 00000000000..35f707c9222 --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/br.wast @@ -0,0 +1,657 @@ +;; Test `br` operator + +(module + ;; Auxiliary definition + (func $dummy) + + (func (export "type-i32") (block (drop (i32.ctz (br 0))))) + (func (export "type-i64") (block (drop (i64.ctz (br 0))))) + (func (export "type-f32") (block (drop (f32.neg (br 0))))) + (func (export "type-f64") (block (drop (f64.neg (br 0))))) + (func (export "type-i32-i32") (block (drop (i32.add (br 0))))) + (func (export "type-i64-i64") (block (drop (i64.add (br 0))))) + (func (export "type-f32-f32") (block (drop (f32.add (br 0))))) + (func (export "type-f64-f64") (block (drop (f64.add (br 0))))) + + (func (export "type-i32-value") (result i32) + (block (result i32) (i32.ctz (br 0 (i32.const 1)))) + ) + (func (export "type-i64-value") (result i64) + (block (result i64) (i64.ctz (br 0 (i64.const 2)))) + ) + (func (export "type-f32-value") (result f32) + (block (result f32) (f32.neg (br 0 (f32.const 3)))) + ) + (func (export "type-f64-value") (result f64) + (block (result f64) (f64.neg (br 0 (f64.const 4)))) + ) + (func (export "type-f64-f64-value") (result f64 f64) + (block (result f64 f64) + (f64.add (br 0 (f64.const 4) (f64.const 5))) (f64.const 6) + ) + ) + + (func (export "as-block-first") + (block (br 0) (call $dummy)) + ) + (func (export "as-block-mid") + (block (call $dummy) (br 0) (call $dummy)) + ) + (func (export "as-block-last") + (block (nop) (call $dummy) (br 0)) + ) + (func (export "as-block-value") (result i32) + (block (result i32) (nop) (call $dummy) (br 0 (i32.const 2))) + ) + + (func (export "as-loop-first") (result i32) + (block (result i32) (loop (result i32) (br 1 (i32.const 3)) (i32.const 2))) + ) + (func (export "as-loop-mid") (result i32) + (block (result i32) + (loop (result i32) (call $dummy) (br 1 (i32.const 4)) (i32.const 2)) + ) + ) + (func (export "as-loop-last") (result i32) + (block (result i32) + (loop (result i32) (nop) (call $dummy) (br 1 (i32.const 5))) + ) + ) + + (func (export "as-br-value") (result i32) + (block (result i32) (br 0 (br 0 (i32.const 9)))) + ) + + (func (export "as-br_if-cond") + (block (br_if 0 (br 0))) + ) + (func (export "as-br_if-value") (result i32) + (block (result i32) + (drop (br_if 0 (br 0 (i32.const 8)) (i32.const 1))) (i32.const 7) + ) + ) + (func (export "as-br_if-value-cond") (result i32) + (block (result i32) + (drop (br_if 0 (i32.const 6) (br 0 (i32.const 9)))) (i32.const 7) + ) + ) + + (func (export "as-br_table-index") + (block (br_table 0 0 0 (br 0))) + ) + (func (export "as-br_table-value") (result i32) + (block (result i32) + (br_table 0 0 0 (br 0 (i32.const 10)) (i32.const 1)) (i32.const 7) + ) + ) + (func (export "as-br_table-value-index") (result i32) + (block (result i32) + (br_table 0 0 (i32.const 6) (br 0 (i32.const 11))) (i32.const 7) + ) + ) + + (func (export "as-return-value") (result i64) + (block (result i64) (return (br 0 (i64.const 7)))) + ) + (func (export "as-return-values") (result i32 i64) + (i32.const 2) + (block (result i64) (return (br 0 (i32.const 1) (i64.const 7)))) + ) + + (func (export "as-if-cond") (result i32) + (block (result i32) + (if (result i32) (br 0 (i32.const 2)) + (then (i32.const 0)) + (else (i32.const 1)) + ) + ) + ) + (func (export "as-if-then") (param i32 i32) (result i32) + (block (result i32) + (if (result i32) (local.get 0) + (then (br 1 (i32.const 3))) + (else (local.get 1)) + ) + ) + ) + (func (export "as-if-else") (param i32 i32) (result i32) + (block (result i32) + (if (result i32) (local.get 0) + (then (local.get 1)) + (else (br 1 (i32.const 4))) + ) + ) + ) + + (func (export "as-select-first") (param i32 i32) (result i32) + (block (result i32) + (select (br 0 (i32.const 5)) (local.get 0) (local.get 1)) + ) + ) + (func (export "as-select-second") (param i32 i32) (result i32) + (block (result i32) + (select (local.get 0) (br 0 (i32.const 6)) (local.get 1)) + ) + ) + (func (export "as-select-cond") (result i32) + (block (result i32) + (select (i32.const 0) (i32.const 1) (br 0 (i32.const 7))) + ) + ) + (func (export "as-select-all") (result i32) + (block (result i32) (select (br 0 (i32.const 8)))) + ) + + (func $f (param i32 i32 i32) (result i32) (i32.const -1)) + (func (export "as-call-first") (result i32) + (block (result i32) + (call $f (br 0 (i32.const 12)) (i32.const 2) (i32.const 3)) + ) + ) + (func (export "as-call-mid") (result i32) + (block (result i32) + (call $f (i32.const 1) (br 0 (i32.const 13)) (i32.const 3)) + ) + ) + (func (export "as-call-last") (result i32) + (block (result i32) + (call $f (i32.const 1) (i32.const 2) (br 0 (i32.const 14))) + ) + ) + (func (export "as-call-all") (result i32) + (block (result i32) (call $f (br 0 (i32.const 15)))) + ) + + (type $sig (func (param i32 i32 i32) (result i32))) + (table funcref (elem $f)) + (func (export "as-call_indirect-func") (result i32) + (block (result i32) + (call_indirect (type $sig) + (br 0 (i32.const 20)) + (i32.const 1) (i32.const 2) (i32.const 3) + ) + ) + ) + (func (export "as-call_indirect-first") (result i32) + (block (result i32) + (call_indirect (type $sig) + (i32.const 0) + (br 0 (i32.const 21)) (i32.const 2) (i32.const 3) + ) + ) + ) + (func (export "as-call_indirect-mid") (result i32) + (block (result i32) + (call_indirect (type $sig) + (i32.const 0) + (i32.const 1) (br 0 (i32.const 22)) (i32.const 3) + ) + ) + ) + (func (export "as-call_indirect-last") (result i32) + (block (result i32) + (call_indirect (type $sig) + (i32.const 0) + (i32.const 1) (i32.const 2) (br 0 (i32.const 23)) + ) + ) + ) + (func (export "as-call_indirect-all") (result i32) + (block (result i32) (call_indirect (type $sig) (br 0 (i32.const 24)))) + ) + + (func (export "as-local.set-value") (result i32) (local f32) + (block (result i32) (local.set 0 (br 0 (i32.const 17))) (i32.const -1)) + ) + (func (export "as-local.tee-value") (result i32) (local i32) + (block (result i32) (local.tee 0 (br 0 (i32.const 1)))) + ) + (global $a (mut i32) (i32.const 10)) + (func (export "as-global.set-value") (result i32) + (block (result i32) (global.set $a (br 0 (i32.const 1)))) + ) + + (memory 1) + (func (export "as-load-address") (result f32) + (block (result f32) (f32.load (br 0 (f32.const 1.7)))) + ) + (func (export "as-loadN-address") (result i64) + (block (result i64) (i64.load8_s (br 0 (i64.const 30)))) + ) + + (func (export "as-store-address") (result i32) + (block (result i32) + (f64.store (br 0 (i32.const 30)) (f64.const 7)) (i32.const -1) + ) + ) + (func (export "as-store-value") (result i32) + (block (result i32) + (i64.store (i32.const 2) (br 0 (i32.const 31))) (i32.const -1) + ) + ) + (func (export "as-store-both") (result i32) + (block (result i32) + (i64.store (br 0 (i32.const 32))) (i32.const -1) + ) + ) + + (func (export "as-storeN-address") (result i32) + (block (result i32) + (i32.store8 (br 0 (i32.const 32)) (i32.const 7)) (i32.const -1) + ) + ) + (func (export "as-storeN-value") (result i32) + (block (result i32) + (i64.store16 (i32.const 2) (br 0 (i32.const 33))) (i32.const -1) + ) + ) + (func (export "as-storeN-both") (result i32) + (block (result i32) + (i64.store16 (br 0 (i32.const 34))) (i32.const -1) + ) + ) + + (func (export "as-unary-operand") (result f32) + (block (result f32) (f32.neg (br 0 (f32.const 3.4)))) + ) + + (func (export "as-binary-left") (result i32) + (block (result i32) (i32.add (br 0 (i32.const 3)) (i32.const 10))) + ) + (func (export "as-binary-right") (result i64) + (block (result i64) (i64.sub (i64.const 10) (br 0 (i64.const 45)))) + ) + (func (export "as-binary-both") (result i32) + (block (result i32) (i32.add (br 0 (i32.const 46)))) + ) + + (func (export "as-test-operand") (result i32) + (block (result i32) (i32.eqz (br 0 (i32.const 44)))) + ) + + (func (export "as-compare-left") (result i32) + (block (result i32) (f64.le (br 0 (i32.const 43)) (f64.const 10))) + ) + (func (export "as-compare-right") (result i32) + (block (result i32) (f32.ne (f32.const 10) (br 0 (i32.const 42)))) + ) + (func (export "as-compare-both") (result i32) + (block (result i32) (f64.le (br 0 (i32.const 44)))) + ) + + (func (export "as-convert-operand") (result i32) + (block (result i32) (i32.wrap_i64 (br 0 (i32.const 41)))) + ) + + (func (export "as-memory.grow-size") (result i32) + (block (result i32) (memory.grow (br 0 (i32.const 40)))) + ) + + (func (export "nested-block-value") (result i32) + (i32.add + (i32.const 1) + (block (result i32) + (call $dummy) + (i32.add (i32.const 4) (br 0 (i32.const 8))) + ) + ) + ) + + (func (export "nested-br-value") (result i32) + (i32.add + (i32.const 1) + (block (result i32) + (drop (i32.const 2)) + (drop + (block (result i32) + (drop (i32.const 4)) + (br 0 (br 1 (i32.const 8))) + ) + ) + (i32.const 16) + ) + ) + ) + + (func (export "nested-br_if-value") (result i32) + (i32.add + (i32.const 1) + (block (result i32) + (drop (i32.const 2)) + (drop + (block (result i32) + (drop (i32.const 4)) + (drop (br_if 0 (br 1 (i32.const 8)) (i32.const 1))) + (i32.const 32) + ) + ) + (i32.const 16) + ) + ) + ) + + (func (export "nested-br_if-value-cond") (result i32) + (i32.add + (i32.const 1) + (block (result i32) + (drop (i32.const 2)) + (drop (br_if 0 (i32.const 4) (br 0 (i32.const 8)))) + (i32.const 16) + ) + ) + ) + + (func (export "nested-br_table-value") (result i32) + (i32.add + (i32.const 1) + (block (result i32) + (drop (i32.const 2)) + (drop + (block (result i32) + (drop (i32.const 4)) + (br_table 0 (br 1 (i32.const 8)) (i32.const 1)) + ) + ) + (i32.const 16) + ) + ) + ) + + (func (export "nested-br_table-value-index") (result i32) + (i32.add + (i32.const 1) + (block (result i32) + (drop (i32.const 2)) + (br_table 0 (i32.const 4) (br 0 (i32.const 8))) + (i32.const 16) + ) + ) + ) +) + +(assert_return (invoke "type-i32")) +(assert_return (invoke "type-i64")) +(assert_return (invoke "type-f32")) +(assert_return (invoke "type-f64")) +(assert_return (invoke "type-i32-i32")) +(assert_return (invoke "type-i64-i64")) +(assert_return (invoke "type-f32-f32")) +(assert_return (invoke "type-f64-f64")) + +(assert_return (invoke "type-i32-value") (i32.const 1)) +(assert_return (invoke "type-i64-value") (i64.const 2)) +(assert_return (invoke "type-f32-value") (f32.const 3)) +(assert_return (invoke "type-f64-value") (f64.const 4)) +(assert_return (invoke "type-f64-f64-value") (f64.const 4) (f64.const 5)) + +(assert_return (invoke "as-block-first")) +(assert_return (invoke "as-block-mid")) +(assert_return (invoke "as-block-last")) +(assert_return (invoke "as-block-value") (i32.const 2)) + +(assert_return (invoke "as-loop-first") (i32.const 3)) +(assert_return (invoke "as-loop-mid") (i32.const 4)) +(assert_return (invoke "as-loop-last") (i32.const 5)) + +(assert_return (invoke "as-br-value") (i32.const 9)) + +(assert_return (invoke "as-br_if-cond")) +(assert_return (invoke "as-br_if-value") (i32.const 8)) +(assert_return (invoke "as-br_if-value-cond") (i32.const 9)) + +(assert_return (invoke "as-br_table-index")) +(assert_return (invoke "as-br_table-value") (i32.const 10)) +(assert_return (invoke "as-br_table-value-index") (i32.const 11)) + +(assert_return (invoke "as-return-value") (i64.const 7)) +(assert_return (invoke "as-return-values") (i32.const 2) (i64.const 7)) + +(assert_return (invoke "as-if-cond") (i32.const 2)) +(assert_return (invoke "as-if-then" (i32.const 1) (i32.const 6)) (i32.const 3)) +(assert_return (invoke "as-if-then" (i32.const 0) (i32.const 6)) (i32.const 6)) +(assert_return (invoke "as-if-else" (i32.const 0) (i32.const 6)) (i32.const 4)) +(assert_return (invoke "as-if-else" (i32.const 1) (i32.const 6)) (i32.const 6)) + +(assert_return (invoke "as-select-first" (i32.const 0) (i32.const 6)) (i32.const 5)) +(assert_return (invoke "as-select-first" (i32.const 1) (i32.const 6)) (i32.const 5)) +(assert_return (invoke "as-select-second" (i32.const 0) (i32.const 6)) (i32.const 6)) +(assert_return (invoke "as-select-second" (i32.const 1) (i32.const 6)) (i32.const 6)) +(assert_return (invoke "as-select-cond") (i32.const 7)) +(assert_return (invoke "as-select-all") (i32.const 8)) + +(assert_return (invoke "as-call-first") (i32.const 12)) +(assert_return (invoke "as-call-mid") (i32.const 13)) +(assert_return (invoke "as-call-last") (i32.const 14)) +(assert_return (invoke "as-call-all") (i32.const 15)) + +(assert_return (invoke "as-call_indirect-func") (i32.const 20)) +(assert_return (invoke "as-call_indirect-first") (i32.const 21)) +(assert_return (invoke "as-call_indirect-mid") (i32.const 22)) +(assert_return (invoke "as-call_indirect-last") (i32.const 23)) +(assert_return (invoke "as-call_indirect-all") (i32.const 24)) + +(assert_return (invoke "as-local.set-value") (i32.const 17)) +(assert_return (invoke "as-local.tee-value") (i32.const 1)) +(assert_return (invoke "as-global.set-value") (i32.const 1)) + +(assert_return (invoke "as-load-address") (f32.const 1.7)) +(assert_return (invoke "as-loadN-address") (i64.const 30)) + +(assert_return (invoke "as-store-address") (i32.const 30)) +(assert_return (invoke "as-store-value") (i32.const 31)) +(assert_return (invoke "as-store-both") (i32.const 32)) +(assert_return (invoke "as-storeN-address") (i32.const 32)) +(assert_return (invoke "as-storeN-value") (i32.const 33)) +(assert_return (invoke "as-storeN-both") (i32.const 34)) + +(assert_return (invoke "as-unary-operand") (f32.const 3.4)) + +(assert_return (invoke "as-binary-left") (i32.const 3)) +(assert_return (invoke "as-binary-right") (i64.const 45)) +(assert_return (invoke "as-binary-both") (i32.const 46)) + +(assert_return (invoke "as-test-operand") (i32.const 44)) + +(assert_return (invoke "as-compare-left") (i32.const 43)) +(assert_return (invoke "as-compare-right") (i32.const 42)) +(assert_return (invoke "as-compare-both") (i32.const 44)) + +(assert_return (invoke "as-convert-operand") (i32.const 41)) + +(assert_return (invoke "as-memory.grow-size") (i32.const 40)) + +(assert_return (invoke "nested-block-value") (i32.const 9)) +(assert_return (invoke "nested-br-value") (i32.const 9)) +(assert_return (invoke "nested-br_if-value") (i32.const 9)) +(assert_return (invoke "nested-br_if-value-cond") (i32.const 9)) +(assert_return (invoke "nested-br_table-value") (i32.const 9)) +(assert_return (invoke "nested-br_table-value-index") (i32.const 9)) + +(assert_invalid + (module (func $type-arg-empty-vs-num (result i32) + (block (result i32) (br 0) (i32.const 1)) + )) + "type mismatch" +) + +(assert_invalid + (module (func $type-arg-void-vs-num (result i32) + (block (result i32) (br 0 (nop)) (i32.const 1)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-arg-void-vs-num-nested (result i32) + (block (result i32) (i32.const 0) (block (br 1))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-arg-num-vs-num (result i32) + (block (result i32) (br 0 (i64.const 1)) (i32.const 1)) + )) + "type mismatch" +) + +(assert_invalid + (module + (func $type-arg-empty-in-br + (i32.const 0) + (block (result i32) (br 0 (br 0))) (i32.eqz) (drop) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-arg-empty-in-br_if + (i32.const 0) + (block (result i32) (br_if 0 (br 0) (i32.const 1))) (i32.eqz) (drop) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-arg-empty-in-br_table + (i32.const 0) + (block (result i32) (br_table 0 (br 0))) (i32.eqz) (drop) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-arg-empty-in-return + (block (result i32) + (return (br 0)) + ) + (i32.eqz) (drop) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-arg-empty-in-select + (block (result i32) + (select (br 0) (i32.const 1) (i32.const 2)) + ) + (i32.eqz) (drop) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-arg-empty-in-call + (block (result i32) + (call 1 (br 0)) + ) + (i32.eqz) (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-arg-empty-in-call_indirect + (block (result i32) + (call_indirect (type $sig) + (br 0) (i32.const 0) + ) + ) + (i32.eqz) (drop) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-arg-empty-in-local.set + (local i32) + (block (result i32) + (local.set 0 (br 0)) (local.get 0) + ) + (i32.eqz) (drop) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-arg-empty-in-local.tee + (local i32) + (block (result i32) + (local.tee 0 (br 0)) + ) + (i32.eqz) (drop) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (global $x (mut i32) (i32.const 0)) + (func $type-arg-empty-in-global.set + (block (result i32) + (global.set $x (br 0)) (global.get $x) + ) + (i32.eqz) (drop) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (memory 0) + (func $type-arg-empty-in-memory.grow + (block (result i32) + (memory.grow (br 0)) + ) + (i32.eqz) (drop) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (memory 1) + (func $type-arg-empty-in-load + (block (result i32) + (i32.load (br 0)) + ) + (i32.eqz) (drop) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (memory 1) + (func $type-arg-empty-in-store + (block (result i32) + (i32.store (br 0) (i32.const 0)) + ) + (i32.eqz) (drop) + ) + ) + "type mismatch" +) + +(assert_invalid + (module (func $unbound-label (br 1))) + "unknown label" +) +(assert_invalid + (module (func $unbound-nested-label (block (block (br 5))))) + "unknown label" +) +(assert_invalid + (module (func $large-label (br 0x10000001))) + "unknown label" +) diff --git a/runtime/near-vm/tests/wast/spec/br_if.wast b/runtime/near-vm/tests/wast/spec/br_if.wast new file mode 100644 index 00000000000..fba5deb9b3a --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/br_if.wast @@ -0,0 +1,665 @@ +;; Test `br_if` operator + +(module + (func $dummy) + + (func (export "type-i32") + (block (drop (i32.ctz (br_if 0 (i32.const 0) (i32.const 1))))) + ) + (func (export "type-i64") + (block (drop (i64.ctz (br_if 0 (i64.const 0) (i32.const 1))))) + ) + (func (export "type-f32") + (block (drop (f32.neg (br_if 0 (f32.const 0) (i32.const 1))))) + ) + (func (export "type-f64") + (block (drop (f64.neg (br_if 0 (f64.const 0) (i32.const 1))))) + ) + + (func (export "type-i32-value") (result i32) + (block (result i32) (i32.ctz (br_if 0 (i32.const 1) (i32.const 1)))) + ) + (func (export "type-i64-value") (result i64) + (block (result i64) (i64.ctz (br_if 0 (i64.const 2) (i32.const 1)))) + ) + (func (export "type-f32-value") (result f32) + (block (result f32) (f32.neg (br_if 0 (f32.const 3) (i32.const 1)))) + ) + (func (export "type-f64-value") (result f64) + (block (result f64) (f64.neg (br_if 0 (f64.const 4) (i32.const 1)))) + ) + + (func (export "as-block-first") (param i32) (result i32) + (block (br_if 0 (local.get 0)) (return (i32.const 2))) (i32.const 3) + ) + (func (export "as-block-mid") (param i32) (result i32) + (block (call $dummy) (br_if 0 (local.get 0)) (return (i32.const 2))) + (i32.const 3) + ) + (func (export "as-block-last") (param i32) + (block (call $dummy) (call $dummy) (br_if 0 (local.get 0))) + ) + (func (export "as-block-first-value") (param i32) (result i32) + (block (result i32) + (drop (br_if 0 (i32.const 10) (local.get 0))) (return (i32.const 11)) + ) + ) + (func (export "as-block-mid-value") (param i32) (result i32) + (block (result i32) + (call $dummy) + (drop (br_if 0 (i32.const 20) (local.get 0))) + (return (i32.const 21)) + ) + ) + (func (export "as-block-last-value") (param i32) (result i32) + (block (result i32) + (call $dummy) (call $dummy) (br_if 0 (i32.const 11) (local.get 0)) + ) + ) + + (func (export "as-loop-first") (param i32) (result i32) + (block (loop (br_if 1 (local.get 0)) (return (i32.const 2)))) (i32.const 3) + ) + (func (export "as-loop-mid") (param i32) (result i32) + (block (loop (call $dummy) (br_if 1 (local.get 0)) (return (i32.const 2)))) + (i32.const 4) + ) + (func (export "as-loop-last") (param i32) + (loop (call $dummy) (br_if 1 (local.get 0))) + ) + + (func (export "as-br-value") (result i32) + (block (result i32) (br 0 (br_if 0 (i32.const 1) (i32.const 2)))) + ) + + (func (export "as-br_if-cond") + (block (br_if 0 (br_if 0 (i32.const 1) (i32.const 1)))) + ) + (func (export "as-br_if-value") (result i32) + (block (result i32) + (drop (br_if 0 (br_if 0 (i32.const 1) (i32.const 2)) (i32.const 3))) + (i32.const 4) + ) + ) + (func (export "as-br_if-value-cond") (param i32) (result i32) + (block (result i32) + (drop (br_if 0 (i32.const 2) (br_if 0 (i32.const 1) (local.get 0)))) + (i32.const 4) + ) + ) + + (func (export "as-br_table-index") + (block (br_table 0 0 0 (br_if 0 (i32.const 1) (i32.const 2)))) + ) + (func (export "as-br_table-value") (result i32) + (block (result i32) + (br_table 0 0 0 (br_if 0 (i32.const 1) (i32.const 2)) (i32.const 3)) (i32.const 4) + ) + ) + (func (export "as-br_table-value-index") (result i32) + (block (result i32) + (br_table 0 0 (i32.const 2) (br_if 0 (i32.const 1) (i32.const 3))) (i32.const 4) + ) + ) + (func (export "as-return-value") (result i64) + (block (result i64) (return (br_if 0 (i64.const 1) (i32.const 2)))) + ) + + (func (export "as-if-cond") (param i32) (result i32) + (block (result i32) + (if (result i32) + (br_if 0 (i32.const 1) (local.get 0)) + (then (i32.const 2)) + (else (i32.const 3)) + ) + ) + ) + (func (export "as-if-then") (param i32 i32) + (block + (if (local.get 0) (then (br_if 1 (local.get 1))) (else (call $dummy))) + ) + ) + (func (export "as-if-else") (param i32 i32) + (block + (if (local.get 0) (then (call $dummy)) (else (br_if 1 (local.get 1)))) + ) + ) + + (func (export "as-select-first") (param i32) (result i32) + (block (result i32) + (select (br_if 0 (i32.const 3) (i32.const 10)) (i32.const 2) (local.get 0)) + ) + ) + (func (export "as-select-second") (param i32) (result i32) + (block (result i32) + (select (i32.const 1) (br_if 0 (i32.const 3) (i32.const 10)) (local.get 0)) + ) + ) + (func (export "as-select-cond") (result i32) + (block (result i32) + (select (i32.const 1) (i32.const 2) (br_if 0 (i32.const 3) (i32.const 10))) + ) + ) + + (func $f (param i32 i32 i32) (result i32) (i32.const -1)) + (func (export "as-call-first") (result i32) + (block (result i32) + (call $f + (br_if 0 (i32.const 12) (i32.const 1)) (i32.const 2) (i32.const 3) + ) + ) + ) + (func (export "as-call-mid") (result i32) + (block (result i32) + (call $f + (i32.const 1) (br_if 0 (i32.const 13) (i32.const 1)) (i32.const 3) + ) + ) + ) + (func (export "as-call-last") (result i32) + (block (result i32) + (call $f + (i32.const 1) (i32.const 2) (br_if 0 (i32.const 14) (i32.const 1)) + ) + ) + ) + + (func $func (param i32 i32 i32) (result i32) (local.get 0)) + (type $check (func (param i32 i32 i32) (result i32))) + (table funcref (elem $func)) + (func (export "as-call_indirect-func") (result i32) + (block (result i32) + (call_indirect (type $check) + (br_if 0 (i32.const 4) (i32.const 10)) + (i32.const 1) (i32.const 2) (i32.const 0) + ) + ) + ) + + (func (export "as-call_indirect-first") (result i32) + (block (result i32) + (call_indirect (type $check) + (i32.const 1) (br_if 0 (i32.const 4) (i32.const 10)) (i32.const 2) (i32.const 0) + ) + ) + ) + (func (export "as-call_indirect-mid") (result i32) + (block (result i32) + (call_indirect (type $check) + (i32.const 1) (i32.const 2) (br_if 0 (i32.const 4) (i32.const 10)) (i32.const 0) + ) + ) + ) + (func (export "as-call_indirect-last") (result i32) + (block (result i32) + (call_indirect (type $check) + (i32.const 1) (i32.const 2) (i32.const 3) (br_if 0 (i32.const 4) (i32.const 10)) + ) + ) + ) + + (func (export "as-local.set-value") (param i32) (result i32) + (local i32) + (block (result i32) + (local.set 0 (br_if 0 (i32.const 17) (local.get 0))) + (i32.const -1) + ) + ) + (func (export "as-local.tee-value") (param i32) (result i32) + (block (result i32) + (local.tee 0 (br_if 0 (i32.const 1) (local.get 0))) + (return (i32.const -1)) + ) + ) + (global $a (mut i32) (i32.const 10)) + (func (export "as-global.set-value") (param i32) (result i32) + (block (result i32) + (global.set $a (br_if 0 (i32.const 1) (local.get 0))) + (return (i32.const -1)) + ) + ) + + (memory 1) + (func (export "as-load-address") (result i32) + (block (result i32) (i32.load (br_if 0 (i32.const 1) (i32.const 1)))) + ) + (func (export "as-loadN-address") (result i32) + (block (result i32) (i32.load8_s (br_if 0 (i32.const 30) (i32.const 1)))) + ) + + (func (export "as-store-address") (result i32) + (block (result i32) + (i32.store (br_if 0 (i32.const 30) (i32.const 1)) (i32.const 7)) (i32.const -1) + ) + ) + (func (export "as-store-value") (result i32) + (block (result i32) + (i32.store (i32.const 2) (br_if 0 (i32.const 31) (i32.const 1))) (i32.const -1) + ) + ) + + (func (export "as-storeN-address") (result i32) + (block (result i32) + (i32.store8 (br_if 0 (i32.const 32) (i32.const 1)) (i32.const 7)) (i32.const -1) + ) + ) + (func (export "as-storeN-value") (result i32) + (block (result i32) + (i32.store16 (i32.const 2) (br_if 0 (i32.const 33) (i32.const 1))) (i32.const -1) + ) + ) + + (func (export "as-unary-operand") (result f64) + (block (result f64) (f64.neg (br_if 0 (f64.const 1.0) (i32.const 1)))) + ) + (func (export "as-binary-left") (result i32) + (block (result i32) (i32.add (br_if 0 (i32.const 1) (i32.const 1)) (i32.const 10))) + ) + (func (export "as-binary-right") (result i32) + (block (result i32) (i32.sub (i32.const 10) (br_if 0 (i32.const 1) (i32.const 1)))) + ) + (func (export "as-test-operand") (result i32) + (block (result i32) (i32.eqz (br_if 0 (i32.const 0) (i32.const 1)))) + ) + (func (export "as-compare-left") (result i32) + (block (result i32) (i32.le_u (br_if 0 (i32.const 1) (i32.const 1)) (i32.const 10))) + ) + (func (export "as-compare-right") (result i32) + (block (result i32) (i32.ne (i32.const 10) (br_if 0 (i32.const 1) (i32.const 42)))) + ) + + (func (export "as-memory.grow-size") (result i32) + (block (result i32) (memory.grow (br_if 0 (i32.const 1) (i32.const 1)))) + ) + + (func (export "nested-block-value") (param i32) (result i32) + (i32.add + (i32.const 1) + (block (result i32) + (drop (i32.const 2)) + (i32.add + (i32.const 4) + (block (result i32) + (drop (br_if 1 (i32.const 8) (local.get 0))) + (i32.const 16) + ) + ) + ) + ) + ) + + (func (export "nested-br-value") (param i32) (result i32) + (i32.add + (i32.const 1) + (block (result i32) + (drop (i32.const 2)) + (br 0 + (block (result i32) + (drop (br_if 1 (i32.const 8) (local.get 0))) (i32.const 4) + ) + ) + (i32.const 16) + ) + ) + ) + + (func (export "nested-br_if-value") (param i32) (result i32) + (i32.add + (i32.const 1) + (block (result i32) + (drop (i32.const 2)) + (drop (br_if 0 + (block (result i32) + (drop (br_if 1 (i32.const 8) (local.get 0))) (i32.const 4) + ) + (i32.const 1) + )) + (i32.const 16) + ) + ) + ) + + (func (export "nested-br_if-value-cond") (param i32) (result i32) + (i32.add + (i32.const 1) + (block (result i32) + (drop (i32.const 2)) + (drop (br_if 0 + (i32.const 4) + (block (result i32) + (drop (br_if 1 (i32.const 8) (local.get 0))) (i32.const 1) + ) + )) + (i32.const 16) + ) + ) + ) + + (func (export "nested-br_table-value") (param i32) (result i32) + (i32.add + (i32.const 1) + (block (result i32) + (drop (i32.const 2)) + (br_table 0 + (block (result i32) + (drop (br_if 1 (i32.const 8) (local.get 0))) (i32.const 4) + ) + (i32.const 1) + ) + (i32.const 16) + ) + ) + ) + + (func (export "nested-br_table-value-index") (param i32) (result i32) + (i32.add + (i32.const 1) + (block (result i32) + (drop (i32.const 2)) + (br_table 0 + (i32.const 4) + (block (result i32) + (drop (br_if 1 (i32.const 8) (local.get 0))) (i32.const 1) + ) + ) + (i32.const 16) + ) + ) + ) + +) + +(assert_return (invoke "type-i32")) +(assert_return (invoke "type-i64")) +(assert_return (invoke "type-f32")) +(assert_return (invoke "type-f64")) + +(assert_return (invoke "type-i32-value") (i32.const 1)) +(assert_return (invoke "type-i64-value") (i64.const 2)) +(assert_return (invoke "type-f32-value") (f32.const 3)) +(assert_return (invoke "type-f64-value") (f64.const 4)) + +(assert_return (invoke "as-block-first" (i32.const 0)) (i32.const 2)) +(assert_return (invoke "as-block-first" (i32.const 1)) (i32.const 3)) +(assert_return (invoke "as-block-mid" (i32.const 0)) (i32.const 2)) +(assert_return (invoke "as-block-mid" (i32.const 1)) (i32.const 3)) +(assert_return (invoke "as-block-last" (i32.const 0))) +(assert_return (invoke "as-block-last" (i32.const 1))) + +(assert_return (invoke "as-block-first-value" (i32.const 0)) (i32.const 11)) +(assert_return (invoke "as-block-first-value" (i32.const 1)) (i32.const 10)) +(assert_return (invoke "as-block-mid-value" (i32.const 0)) (i32.const 21)) +(assert_return (invoke "as-block-mid-value" (i32.const 1)) (i32.const 20)) +(assert_return (invoke "as-block-last-value" (i32.const 0)) (i32.const 11)) +(assert_return (invoke "as-block-last-value" (i32.const 1)) (i32.const 11)) + +(assert_return (invoke "as-loop-first" (i32.const 0)) (i32.const 2)) +(assert_return (invoke "as-loop-first" (i32.const 1)) (i32.const 3)) +(assert_return (invoke "as-loop-mid" (i32.const 0)) (i32.const 2)) +(assert_return (invoke "as-loop-mid" (i32.const 1)) (i32.const 4)) +(assert_return (invoke "as-loop-last" (i32.const 0))) +(assert_return (invoke "as-loop-last" (i32.const 1))) + +(assert_return (invoke "as-br-value") (i32.const 1)) + +(assert_return (invoke "as-br_if-cond")) +(assert_return (invoke "as-br_if-value") (i32.const 1)) +(assert_return (invoke "as-br_if-value-cond" (i32.const 0)) (i32.const 2)) +(assert_return (invoke "as-br_if-value-cond" (i32.const 1)) (i32.const 1)) + +(assert_return (invoke "as-br_table-index")) +(assert_return (invoke "as-br_table-value") (i32.const 1)) +(assert_return (invoke "as-br_table-value-index") (i32.const 1)) + +(assert_return (invoke "as-return-value") (i64.const 1)) + +(assert_return (invoke "as-if-cond" (i32.const 0)) (i32.const 2)) +(assert_return (invoke "as-if-cond" (i32.const 1)) (i32.const 1)) +(assert_return (invoke "as-if-then" (i32.const 0) (i32.const 0))) +(assert_return (invoke "as-if-then" (i32.const 4) (i32.const 0))) +(assert_return (invoke "as-if-then" (i32.const 0) (i32.const 1))) +(assert_return (invoke "as-if-then" (i32.const 4) (i32.const 1))) +(assert_return (invoke "as-if-else" (i32.const 0) (i32.const 0))) +(assert_return (invoke "as-if-else" (i32.const 3) (i32.const 0))) +(assert_return (invoke "as-if-else" (i32.const 0) (i32.const 1))) +(assert_return (invoke "as-if-else" (i32.const 3) (i32.const 1))) + +(assert_return (invoke "as-select-first" (i32.const 0)) (i32.const 3)) +(assert_return (invoke "as-select-first" (i32.const 1)) (i32.const 3)) +(assert_return (invoke "as-select-second" (i32.const 0)) (i32.const 3)) +(assert_return (invoke "as-select-second" (i32.const 1)) (i32.const 3)) +(assert_return (invoke "as-select-cond") (i32.const 3)) + +(assert_return (invoke "as-call-first") (i32.const 12)) +(assert_return (invoke "as-call-mid") (i32.const 13)) +(assert_return (invoke "as-call-last") (i32.const 14)) + +(assert_return (invoke "as-call_indirect-func") (i32.const 4)) +(assert_return (invoke "as-call_indirect-first") (i32.const 4)) +(assert_return (invoke "as-call_indirect-mid") (i32.const 4)) +(assert_return (invoke "as-call_indirect-last") (i32.const 4)) + +(assert_return (invoke "as-local.set-value" (i32.const 0)) (i32.const -1)) +(assert_return (invoke "as-local.set-value" (i32.const 1)) (i32.const 17)) + +(assert_return (invoke "as-local.tee-value" (i32.const 0)) (i32.const -1)) +(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 -1)) +(assert_return (invoke "as-global.set-value" (i32.const 1)) (i32.const 1)) + +(assert_return (invoke "as-load-address") (i32.const 1)) +(assert_return (invoke "as-loadN-address") (i32.const 30)) + +(assert_return (invoke "as-store-address") (i32.const 30)) +(assert_return (invoke "as-store-value") (i32.const 31)) +(assert_return (invoke "as-storeN-address") (i32.const 32)) +(assert_return (invoke "as-storeN-value") (i32.const 33)) + +(assert_return (invoke "as-unary-operand") (f64.const 1.0)) +(assert_return (invoke "as-binary-left") (i32.const 1)) +(assert_return (invoke "as-binary-right") (i32.const 1)) +(assert_return (invoke "as-test-operand") (i32.const 0)) +(assert_return (invoke "as-compare-left") (i32.const 1)) +(assert_return (invoke "as-compare-right") (i32.const 1)) +(assert_return (invoke "as-memory.grow-size") (i32.const 1)) + +(assert_return (invoke "nested-block-value" (i32.const 0)) (i32.const 21)) +(assert_return (invoke "nested-block-value" (i32.const 1)) (i32.const 9)) +(assert_return (invoke "nested-br-value" (i32.const 0)) (i32.const 5)) +(assert_return (invoke "nested-br-value" (i32.const 1)) (i32.const 9)) +(assert_return (invoke "nested-br_if-value" (i32.const 0)) (i32.const 5)) +(assert_return (invoke "nested-br_if-value" (i32.const 1)) (i32.const 9)) +(assert_return (invoke "nested-br_if-value-cond" (i32.const 0)) (i32.const 5)) +(assert_return (invoke "nested-br_if-value-cond" (i32.const 1)) (i32.const 9)) +(assert_return (invoke "nested-br_table-value" (i32.const 0)) (i32.const 5)) +(assert_return (invoke "nested-br_table-value" (i32.const 1)) (i32.const 9)) +(assert_return (invoke "nested-br_table-value-index" (i32.const 0)) (i32.const 5)) +(assert_return (invoke "nested-br_table-value-index" (i32.const 1)) (i32.const 9)) + +(assert_invalid + (module (func $type-false-i32 (block (i32.ctz (br_if 0 (i32.const 0)))))) + "type mismatch" +) +(assert_invalid + (module (func $type-false-i64 (block (i64.ctz (br_if 0 (i32.const 0)))))) + "type mismatch" +) +(assert_invalid + (module (func $type-false-f32 (block (f32.neg (br_if 0 (i32.const 0)))))) + "type mismatch" +) +(assert_invalid + (module (func $type-false-f64 (block (f64.neg (br_if 0 (i32.const 0)))))) + "type mismatch" +) + +(assert_invalid + (module (func $type-true-i32 (block (i32.ctz (br_if 0 (i32.const 1)))))) + "type mismatch" +) +(assert_invalid + (module (func $type-true-i64 (block (i64.ctz (br_if 0 (i64.const 1)))))) + "type mismatch" +) +(assert_invalid + (module (func $type-true-f32 (block (f32.neg (br_if 0 (f32.const 1)))))) + "type mismatch" +) +(assert_invalid + (module (func $type-true-f64 (block (f64.neg (br_if 0 (i64.const 1)))))) + "type mismatch" +) + +(assert_invalid + (module (func $type-false-arg-void-vs-num (result i32) + (block (result i32) (br_if 0 (i32.const 0)) (i32.const 1)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-true-arg-void-vs-num (result i32) + (block (result i32) (br_if 0 (i32.const 1)) (i32.const 1)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-false-arg-num-vs-void + (block (br_if 0 (i32.const 0) (i32.const 0))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-true-arg-num-vs-void + (block (br_if 0 (i32.const 0) (i32.const 1))) + )) + "type mismatch" +) + +(assert_invalid + (module (func $type-false-arg-void-vs-num (result i32) + (block (result i32) (br_if 0 (nop) (i32.const 0)) (i32.const 1)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-true-arg-void-vs-num (result i32) + (block (result i32) (br_if 0 (nop) (i32.const 1)) (i32.const 1)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-false-arg-num-vs-num (result i32) + (block (result i32) + (drop (br_if 0 (i64.const 1) (i32.const 0))) (i32.const 1) + ) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-true-arg-num-vs-num (result i32) + (block (result i32) + (drop (br_if 0 (i64.const 1) (i32.const 0))) (i32.const 1) + ) + )) + "type mismatch" +) + +(assert_invalid + (module (func $type-cond-empty-vs-i32 + (block (br_if 0)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-cond-void-vs-i32 + (block (br_if 0 (nop))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-cond-num-vs-i32 + (block (br_if 0 (i64.const 0))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-arg-cond-void-vs-i32 (result i32) + (block (result i32) (br_if 0 (i32.const 0) (nop)) (i32.const 1)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-arg-void-vs-num-nested (result i32) + (block (result i32) (i32.const 0) (block (br_if 1 (i32.const 1)))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-arg-cond-num-vs-i32 (result i32) + (block (result i32) (br_if 0 (i32.const 0) (i64.const 0)) (i32.const 1)) + )) + "type mismatch" +) + +(assert_invalid + (module + (func $type-1st-cond-empty-in-then + (block + (i32.const 0) (i32.const 0) + (if (result i32) (then (br_if 0))) + ) + (i32.eqz) (drop) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-2nd-cond-empty-in-then + (block + (i32.const 0) (i32.const 0) + (if (result i32) (then (br_if 0 (i32.const 1)))) + ) + (i32.eqz) (drop) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-1st-cond-empty-in-return + (block (result i32) + (return (br_if 0)) + ) + (i32.eqz) (drop) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-2nd-cond-empty-in-return + (block (result i32) + (return (br_if 0 (i32.const 1))) + ) + (i32.eqz) (drop) + ) + ) + "type mismatch" +) + + +(assert_invalid + (module (func $unbound-label (br_if 1 (i32.const 1)))) + "unknown label" +) +(assert_invalid + (module (func $unbound-nested-label (block (block (br_if 5 (i32.const 1)))))) + "unknown label" +) +(assert_invalid + (module (func $large-label (br_if 0x10000001 (i32.const 1)))) + "unknown label" +) + diff --git a/runtime/near-vm/tests/wast/spec/br_table.wast b/runtime/near-vm/tests/wast/spec/br_table.wast new file mode 100644 index 00000000000..b70c102da0b --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/br_table.wast @@ -0,0 +1,1668 @@ +;; Test `br_table` operator + +(module + ;; Auxiliary definition + (func $dummy) + + (func (export "type-i32") + (block (drop (i32.ctz (br_table 0 0 (i32.const 0))))) + ) + (func (export "type-i64") + (block (drop (i64.ctz (br_table 0 0 (i32.const 0))))) + ) + (func (export "type-f32") + (block (drop (f32.neg (br_table 0 0 (i32.const 0))))) + ) + (func (export "type-f64") + (block (drop (f64.neg (br_table 0 0 (i32.const 0))))) + ) + + (func (export "type-i32-value") (result i32) + (block (result i32) (i32.ctz (br_table 0 0 (i32.const 1) (i32.const 0)))) + ) + (func (export "type-i64-value") (result i64) + (block (result i64) (i64.ctz (br_table 0 0 (i64.const 2) (i32.const 0)))) + ) + (func (export "type-f32-value") (result f32) + (block (result f32) (f32.neg (br_table 0 0 (f32.const 3) (i32.const 0)))) + ) + (func (export "type-f64-value") (result f64) + (block (result f64) (f64.neg (br_table 0 0 (f64.const 4) (i32.const 0)))) + ) + + (func (export "empty") (param i32) (result i32) + (block (br_table 0 (local.get 0)) (return (i32.const 21))) + (i32.const 22) + ) + (func (export "empty-value") (param i32) (result i32) + (block (result i32) + (br_table 0 (i32.const 33) (local.get 0)) (i32.const 31) + ) + ) + + (func (export "singleton") (param i32) (result i32) + (block + (block + (br_table 1 0 (local.get 0)) + (return (i32.const 21)) + ) + (return (i32.const 20)) + ) + (i32.const 22) + ) + + (func (export "singleton-value") (param i32) (result i32) + (block (result i32) + (drop + (block (result i32) + (br_table 0 1 (i32.const 33) (local.get 0)) + (return (i32.const 31)) + ) + ) + (i32.const 32) + ) + ) + + (func (export "multiple") (param i32) (result i32) + (block + (block + (block + (block + (block + (br_table 3 2 1 0 4 (local.get 0)) + (return (i32.const 99)) + ) + (return (i32.const 100)) + ) + (return (i32.const 101)) + ) + (return (i32.const 102)) + ) + (return (i32.const 103)) + ) + (i32.const 104) + ) + + (func (export "multiple-value") (param i32) (result i32) + (local i32) + (local.set 1 (block (result i32) + (local.set 1 (block (result i32) + (local.set 1 (block (result i32) + (local.set 1 (block (result i32) + (local.set 1 (block (result i32) + (br_table 3 2 1 0 4 (i32.const 200) (local.get 0)) + (return (i32.add (local.get 1) (i32.const 99))) + )) + (return (i32.add (local.get 1) (i32.const 10))) + )) + (return (i32.add (local.get 1) (i32.const 11))) + )) + (return (i32.add (local.get 1) (i32.const 12))) + )) + (return (i32.add (local.get 1) (i32.const 13))) + )) + (i32.add (local.get 1) (i32.const 14)) + ) + + (func (export "large") (param i32) (result i32) + (block + (block + (br_table + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + (local.get 0) + ) + (return (i32.const -1)) + ) + (return (i32.const 0)) + ) + (return (i32.const 1)) + ) + + (func (export "as-block-first") + (block (br_table 0 0 0 (i32.const 0)) (call $dummy)) + ) + (func (export "as-block-mid") + (block (call $dummy) (br_table 0 0 0 (i32.const 0)) (call $dummy)) + ) + (func (export "as-block-last") + (block (nop) (call $dummy) (br_table 0 0 0 (i32.const 0))) + ) + (func (export "as-block-value") (result i32) + (block (result i32) + (nop) (call $dummy) (br_table 0 0 0 (i32.const 2) (i32.const 0)) + ) + ) + + (func (export "as-loop-first") (result i32) + (loop (result i32) (br_table 1 1 (i32.const 3) (i32.const 0)) (i32.const 1)) + ) + (func (export "as-loop-mid") (result i32) + (loop (result i32) + (call $dummy) + (br_table 1 1 1 (i32.const 4) (i32.const -1)) + (i32.const 2) + ) + ) + (func (export "as-loop-last") (result i32) + (loop (result i32) + (nop) (call $dummy) (br_table 1 1 1 (i32.const 5) (i32.const 1)) + ) + ) + + (func (export "as-br-value") (result i32) + (block (result i32) (br 0 (br_table 0 (i32.const 9) (i32.const 0)))) + ) + + (func (export "as-br_if-cond") + (block (br_if 0 (br_table 0 0 0 (i32.const 1)))) + ) + (func (export "as-br_if-value") (result i32) + (block (result i32) + (drop (br_if 0 (br_table 0 (i32.const 8) (i32.const 0)) (i32.const 1))) + (i32.const 7) + ) + ) + (func (export "as-br_if-value-cond") (result i32) + (block (result i32) + (drop (br_if 0 (i32.const 6) (br_table 0 0 (i32.const 9) (i32.const 0)))) + (i32.const 7) + ) + ) + + (func (export "as-br_table-index") + (block (br_table 0 0 0 (br_table 0 (i32.const 1)))) + ) + (func (export "as-br_table-value") (result i32) + (block (result i32) + (br_table 0 0 0 (br_table 0 (i32.const 10) (i32.const 0)) (i32.const 1)) + (i32.const 7) + ) + ) + (func (export "as-br_table-value-index") (result i32) + (block (result i32) + (br_table 0 0 (i32.const 6) (br_table 0 (i32.const 11) (i32.const 1))) + (i32.const 7) + ) + ) + + (func (export "as-return-value") (result i64) + (block (result i64) (return (br_table 0 (i64.const 7) (i32.const 0)))) + ) + + (func (export "as-if-cond") (result i32) + (block (result i32) + (if (result i32) + (br_table 0 (i32.const 2) (i32.const 0)) + (then (i32.const 0)) + (else (i32.const 1)) + ) + ) + ) + (func (export "as-if-then") (param i32 i32) (result i32) + (block (result i32) + (if (result i32) + (local.get 0) + (then (br_table 1 (i32.const 3) (i32.const 0))) + (else (local.get 1)) + ) + ) + ) + (func (export "as-if-else") (param i32 i32) (result i32) + (block (result i32) + (if (result i32) + (local.get 0) + (then (local.get 1)) + (else (br_table 1 0 (i32.const 4) (i32.const 0))) + ) + ) + ) + + (func (export "as-select-first") (param i32 i32) (result i32) + (block (result i32) + (select + (br_table 0 (i32.const 5) (i32.const 0)) (local.get 0) (local.get 1) + ) + ) + ) + (func (export "as-select-second") (param i32 i32) (result i32) + (block (result i32) + (select + (local.get 0) (br_table 0 (i32.const 6) (i32.const 1)) (local.get 1) + ) + ) + ) + (func (export "as-select-cond") (result i32) + (block (result i32) + (select + (i32.const 0) (i32.const 1) (br_table 0 (i32.const 7) (i32.const 1)) + ) + ) + ) + + (func $f (param i32 i32 i32) (result i32) (i32.const -1)) + (func (export "as-call-first") (result i32) + (block (result i32) + (call $f + (br_table 0 (i32.const 12) (i32.const 1)) (i32.const 2) (i32.const 3) + ) + ) + ) + (func (export "as-call-mid") (result i32) + (block (result i32) + (call $f + (i32.const 1) (br_table 0 (i32.const 13) (i32.const 1)) (i32.const 3) + ) + ) + ) + (func (export "as-call-last") (result i32) + (block (result i32) + (call $f + (i32.const 1) (i32.const 2) (br_table 0 (i32.const 14) (i32.const 1)) + ) + ) + ) + + (type $sig (func (param i32 i32 i32) (result i32))) + (table funcref (elem $f)) + (func (export "as-call_indirect-first") (result i32) + (block (result i32) + (call_indirect (type $sig) + (br_table 0 (i32.const 20) (i32.const 1)) (i32.const 1) (i32.const 2) + (i32.const 3) + ) + ) + ) + (func (export "as-call_indirect-mid") (result i32) + (block (result i32) + (call_indirect (type $sig) + (i32.const 0) (br_table 0 (i32.const 21) (i32.const 1)) (i32.const 2) + (i32.const 3) + ) + ) + ) + (func (export "as-call_indirect-last") (result i32) + (block (result i32) + (call_indirect (type $sig) + (i32.const 0) (i32.const 1) (br_table 0 (i32.const 22) (i32.const 1)) + (i32.const 3) + ) + ) + ) + (func (export "as-call_indirect-func") (result i32) + (block (result i32) + (call_indirect (type $sig) + (i32.const 0) (i32.const 1) (i32.const 2) + (br_table 0 (i32.const 23) (i32.const 1)) + ) + ) + ) + + (func (export "as-local.set-value") (result i32) + (local f32) + (block (result i32) + (local.set 0 (br_table 0 (i32.const 17) (i32.const 1))) + (i32.const -1) + ) + ) + (func (export "as-local.tee-value") (result i32) + (local i32) + (block (result i32) + (local.set 0 (br_table 0 (i32.const 1) (i32.const 1))) + (i32.const -1) + ) + ) + (global $a (mut i32) (i32.const 10)) + (func (export "as-global.set-value") (result i32) + (block (result i32) + (global.set $a (br_table 0 (i32.const 1) (i32.const 1))) + (i32.const -1) + ) + ) + + (memory 1) + (func (export "as-load-address") (result f32) + (block (result f32) (f32.load (br_table 0 (f32.const 1.7) (i32.const 1)))) + ) + (func (export "as-loadN-address") (result i64) + (block (result i64) (i64.load8_s (br_table 0 (i64.const 30) (i32.const 1)))) + ) + + (func (export "as-store-address") (result i32) + (block (result i32) + (f64.store (br_table 0 (i32.const 30) (i32.const 1)) (f64.const 7)) + (i32.const -1) + ) + ) + (func (export "as-store-value") (result i32) + (block (result i32) + (i64.store (i32.const 2) (br_table 0 (i32.const 31) (i32.const 1))) + (i32.const -1) + ) + ) + + (func (export "as-storeN-address") (result i32) + (block (result i32) + (i32.store8 (br_table 0 (i32.const 32) (i32.const 0)) (i32.const 7)) + (i32.const -1) + ) + ) + (func (export "as-storeN-value") (result i32) + (block (result i32) + (i64.store16 (i32.const 2) (br_table 0 (i32.const 33) (i32.const 0))) + (i32.const -1) + ) + ) + + (func (export "as-unary-operand") (result f32) + (block (result f32) (f32.neg (br_table 0 (f32.const 3.4) (i32.const 0)))) + ) + + (func (export "as-binary-left") (result i32) + (block (result i32) + (i32.add (br_table 0 0 (i32.const 3) (i32.const 0)) (i32.const 10)) + ) + ) + (func (export "as-binary-right") (result i64) + (block (result i64) + (i64.sub (i64.const 10) (br_table 0 (i64.const 45) (i32.const 0))) + ) + ) + + (func (export "as-test-operand") (result i32) + (block (result i32) (i32.eqz (br_table 0 (i32.const 44) (i32.const 0)))) + ) + + (func (export "as-compare-left") (result i32) + (block (result i32) + (f64.le (br_table 0 0 (i32.const 43) (i32.const 0)) (f64.const 10)) + ) + ) + (func (export "as-compare-right") (result i32) + (block (result i32) + (f32.ne (f32.const 10) (br_table 0 (i32.const 42) (i32.const 0))) + ) + ) + + (func (export "as-convert-operand") (result i32) + (block (result i32) + (i32.wrap_i64 (br_table 0 (i32.const 41) (i32.const 0))) + ) + ) + + (func (export "as-memory.grow-size") (result i32) + (block (result i32) (memory.grow (br_table 0 (i32.const 40) (i32.const 0)))) + ) + + (func (export "nested-block-value") (param i32) (result i32) + (block (result i32) + (drop (i32.const -1)) + (i32.add + (i32.const 1) + (block (result i32) + (i32.add + (i32.const 2) + (block (result i32) + (drop (i32.const 4)) + (i32.add + (i32.const 8) + (br_table 0 1 2 (i32.const 16) (local.get 0)) + ) + ) + ) + ) + ) + ) + ) + + (func (export "nested-br-value") (param i32) (result i32) + (block (result i32) + (i32.add + (i32.const 1) + (block (result i32) + (drop (i32.const 2)) + (drop + (block (result i32) + (drop (i32.const 4)) + (br 0 (br_table 2 1 0 (i32.const 8) (local.get 0))) + ) + ) + (i32.const 16) + ) + ) + ) + ) + + (func (export "nested-br_if-value") (param i32) (result i32) + (block (result i32) + (i32.add + (i32.const 1) + (block (result i32) + (drop (i32.const 2)) + (drop + (block (result i32) + (drop (i32.const 4)) + (drop + (br_if 0 + (br_table 0 1 2 (i32.const 8) (local.get 0)) + (i32.const 1) + ) + ) + (i32.const 32) + ) + ) + (i32.const 16) + ) + ) + ) + ) + + (func (export "nested-br_if-value-cond") (param i32) (result i32) + (block (result i32) + (i32.add + (i32.const 1) + (block (result i32) + (drop (i32.const 2)) + (drop + (br_if 0 (i32.const 4) (br_table 0 1 0 (i32.const 8) (local.get 0))) + ) + (i32.const 16) + ) + ) + ) + ) + + (func (export "nested-br_table-value") (param i32) (result i32) + (block (result i32) + (i32.add + (i32.const 1) + (block (result i32) + (drop (i32.const 2)) + (drop + (block (result i32) + (drop (i32.const 4)) + (br_table 0 (br_table 0 1 2 (i32.const 8) (local.get 0)) (i32.const 1)) + (i32.const 32) + ) + ) + (i32.const 16) + ) + ) + ) + ) + + (func (export "nested-br_table-value-index") (param i32) (result i32) + (block (result i32) + (i32.add + (i32.const 1) + (block (result i32) + (drop (i32.const 2)) + (br_table 0 (i32.const 4) (br_table 0 1 0 (i32.const 8) (local.get 0))) + (i32.const 16) + ) + ) + ) + ) + + (func (export "nested-br_table-loop-block") (param i32) (result i32) + (local.set 0 + (loop (result i32) + (block + (br_table 1 0 0 (local.get 0)) + ) + (i32.const 0) + ) + ) + (loop (result i32) + (block + (br_table 0 1 1 (local.get 0)) + ) + (i32.const 3) + ) + ) + + (func (export "meet-externref") (param i32) (param externref) (result externref) + (block $l1 (result externref) + (block $l2 (result externref) + (br_table $l1 $l2 $l1 (local.get 1) (local.get 0)) + ) + ) + ) + + ;; commenting this part out for now as it's a bit odd and we rely on wasmparser for + ;; wasm validation. Not meeting this requirement is okay for now + ;; (func (export "meet-bottom") + ;; (block (result f64) + ;; (block (result f32) + ;; (unreachable) + ;; (br_table 0 1 1 (i32.const 1)) + ;; ) + ;; (drop) + ;; (f64.const 0) + ;; ) + ;; (drop) + ;; ) +) + +(assert_return (invoke "type-i32")) +(assert_return (invoke "type-i64")) +(assert_return (invoke "type-f32")) +(assert_return (invoke "type-f64")) + +(assert_return (invoke "type-i32-value") (i32.const 1)) +(assert_return (invoke "type-i64-value") (i64.const 2)) +(assert_return (invoke "type-f32-value") (f32.const 3)) +(assert_return (invoke "type-f64-value") (f64.const 4)) + +(assert_return (invoke "empty" (i32.const 0)) (i32.const 22)) +(assert_return (invoke "empty" (i32.const 1)) (i32.const 22)) +(assert_return (invoke "empty" (i32.const 11)) (i32.const 22)) +(assert_return (invoke "empty" (i32.const -1)) (i32.const 22)) +(assert_return (invoke "empty" (i32.const -100)) (i32.const 22)) +(assert_return (invoke "empty" (i32.const 0xffffffff)) (i32.const 22)) + +(assert_return (invoke "empty-value" (i32.const 0)) (i32.const 33)) +(assert_return (invoke "empty-value" (i32.const 1)) (i32.const 33)) +(assert_return (invoke "empty-value" (i32.const 11)) (i32.const 33)) +(assert_return (invoke "empty-value" (i32.const -1)) (i32.const 33)) +(assert_return (invoke "empty-value" (i32.const -100)) (i32.const 33)) +(assert_return (invoke "empty-value" (i32.const 0xffffffff)) (i32.const 33)) + +(assert_return (invoke "singleton" (i32.const 0)) (i32.const 22)) +(assert_return (invoke "singleton" (i32.const 1)) (i32.const 20)) +(assert_return (invoke "singleton" (i32.const 11)) (i32.const 20)) +(assert_return (invoke "singleton" (i32.const -1)) (i32.const 20)) +(assert_return (invoke "singleton" (i32.const -100)) (i32.const 20)) +(assert_return (invoke "singleton" (i32.const 0xffffffff)) (i32.const 20)) + +(assert_return (invoke "singleton-value" (i32.const 0)) (i32.const 32)) +(assert_return (invoke "singleton-value" (i32.const 1)) (i32.const 33)) +(assert_return (invoke "singleton-value" (i32.const 11)) (i32.const 33)) +(assert_return (invoke "singleton-value" (i32.const -1)) (i32.const 33)) +(assert_return (invoke "singleton-value" (i32.const -100)) (i32.const 33)) +(assert_return (invoke "singleton-value" (i32.const 0xffffffff)) (i32.const 33)) + +(assert_return (invoke "multiple" (i32.const 0)) (i32.const 103)) +(assert_return (invoke "multiple" (i32.const 1)) (i32.const 102)) +(assert_return (invoke "multiple" (i32.const 2)) (i32.const 101)) +(assert_return (invoke "multiple" (i32.const 3)) (i32.const 100)) +(assert_return (invoke "multiple" (i32.const 4)) (i32.const 104)) +(assert_return (invoke "multiple" (i32.const 5)) (i32.const 104)) +(assert_return (invoke "multiple" (i32.const 6)) (i32.const 104)) +(assert_return (invoke "multiple" (i32.const 10)) (i32.const 104)) +(assert_return (invoke "multiple" (i32.const -1)) (i32.const 104)) +(assert_return (invoke "multiple" (i32.const 0xffffffff)) (i32.const 104)) + +(assert_return (invoke "multiple-value" (i32.const 0)) (i32.const 213)) +(assert_return (invoke "multiple-value" (i32.const 1)) (i32.const 212)) +(assert_return (invoke "multiple-value" (i32.const 2)) (i32.const 211)) +(assert_return (invoke "multiple-value" (i32.const 3)) (i32.const 210)) +(assert_return (invoke "multiple-value" (i32.const 4)) (i32.const 214)) +(assert_return (invoke "multiple-value" (i32.const 5)) (i32.const 214)) +(assert_return (invoke "multiple-value" (i32.const 6)) (i32.const 214)) +(assert_return (invoke "multiple-value" (i32.const 10)) (i32.const 214)) +(assert_return (invoke "multiple-value" (i32.const -1)) (i32.const 214)) +(assert_return (invoke "multiple-value" (i32.const 0xffffffff)) (i32.const 214)) + +(assert_return (invoke "large" (i32.const 0)) (i32.const 0)) +(assert_return (invoke "large" (i32.const 1)) (i32.const 1)) +(assert_return (invoke "large" (i32.const 100)) (i32.const 0)) +(assert_return (invoke "large" (i32.const 101)) (i32.const 1)) +(assert_return (invoke "large" (i32.const 10000)) (i32.const 0)) +(assert_return (invoke "large" (i32.const 10001)) (i32.const 1)) +(assert_return (invoke "large" (i32.const 1000000)) (i32.const 1)) +(assert_return (invoke "large" (i32.const 1000001)) (i32.const 1)) + +(assert_return (invoke "as-block-first")) +(assert_return (invoke "as-block-mid")) +(assert_return (invoke "as-block-last")) +(assert_return (invoke "as-block-value") (i32.const 2)) + +(assert_return (invoke "as-loop-first") (i32.const 3)) +(assert_return (invoke "as-loop-mid") (i32.const 4)) +(assert_return (invoke "as-loop-last") (i32.const 5)) + +(assert_return (invoke "as-br-value") (i32.const 9)) + +(assert_return (invoke "as-br_if-cond")) +(assert_return (invoke "as-br_if-value") (i32.const 8)) +(assert_return (invoke "as-br_if-value-cond") (i32.const 9)) + +(assert_return (invoke "as-br_table-index")) +(assert_return (invoke "as-br_table-value") (i32.const 10)) +(assert_return (invoke "as-br_table-value-index") (i32.const 11)) + +(assert_return (invoke "as-return-value") (i64.const 7)) + +(assert_return (invoke "as-if-cond") (i32.const 2)) +(assert_return (invoke "as-if-then" (i32.const 1) (i32.const 6)) (i32.const 3)) +(assert_return (invoke "as-if-then" (i32.const 0) (i32.const 6)) (i32.const 6)) +(assert_return (invoke "as-if-else" (i32.const 0) (i32.const 6)) (i32.const 4)) +(assert_return (invoke "as-if-else" (i32.const 1) (i32.const 6)) (i32.const 6)) + +(assert_return (invoke "as-select-first" (i32.const 0) (i32.const 6)) (i32.const 5)) +(assert_return (invoke "as-select-first" (i32.const 1) (i32.const 6)) (i32.const 5)) +(assert_return (invoke "as-select-second" (i32.const 0) (i32.const 6)) (i32.const 6)) +(assert_return (invoke "as-select-second" (i32.const 1) (i32.const 6)) (i32.const 6)) +(assert_return (invoke "as-select-cond") (i32.const 7)) + +(assert_return (invoke "as-call-first") (i32.const 12)) +(assert_return (invoke "as-call-mid") (i32.const 13)) +(assert_return (invoke "as-call-last") (i32.const 14)) + +(assert_return (invoke "as-call_indirect-first") (i32.const 20)) +(assert_return (invoke "as-call_indirect-mid") (i32.const 21)) +(assert_return (invoke "as-call_indirect-last") (i32.const 22)) +(assert_return (invoke "as-call_indirect-func") (i32.const 23)) + +(assert_return (invoke "as-local.set-value") (i32.const 17)) +(assert_return (invoke "as-local.tee-value") (i32.const 1)) +(assert_return (invoke "as-global.set-value") (i32.const 1)) + +(assert_return (invoke "as-load-address") (f32.const 1.7)) +(assert_return (invoke "as-loadN-address") (i64.const 30)) + +(assert_return (invoke "as-store-address") (i32.const 30)) +(assert_return (invoke "as-store-value") (i32.const 31)) +(assert_return (invoke "as-storeN-address") (i32.const 32)) +(assert_return (invoke "as-storeN-value") (i32.const 33)) + +(assert_return (invoke "as-unary-operand") (f32.const 3.4)) + +(assert_return (invoke "as-binary-left") (i32.const 3)) +(assert_return (invoke "as-binary-right") (i64.const 45)) + +(assert_return (invoke "as-test-operand") (i32.const 44)) + +(assert_return (invoke "as-compare-left") (i32.const 43)) +(assert_return (invoke "as-compare-right") (i32.const 42)) + +(assert_return (invoke "as-convert-operand") (i32.const 41)) + +(assert_return (invoke "as-memory.grow-size") (i32.const 40)) + +(assert_return (invoke "nested-block-value" (i32.const 0)) (i32.const 19)) +(assert_return (invoke "nested-block-value" (i32.const 1)) (i32.const 17)) +(assert_return (invoke "nested-block-value" (i32.const 2)) (i32.const 16)) +(assert_return (invoke "nested-block-value" (i32.const 10)) (i32.const 16)) +(assert_return (invoke "nested-block-value" (i32.const -1)) (i32.const 16)) +(assert_return (invoke "nested-block-value" (i32.const 100000)) (i32.const 16)) + +(assert_return (invoke "nested-br-value" (i32.const 0)) (i32.const 8)) +(assert_return (invoke "nested-br-value" (i32.const 1)) (i32.const 9)) +(assert_return (invoke "nested-br-value" (i32.const 2)) (i32.const 17)) +(assert_return (invoke "nested-br-value" (i32.const 11)) (i32.const 17)) +(assert_return (invoke "nested-br-value" (i32.const -4)) (i32.const 17)) +(assert_return (invoke "nested-br-value" (i32.const 10213210)) (i32.const 17)) + +(assert_return (invoke "nested-br_if-value" (i32.const 0)) (i32.const 17)) +(assert_return (invoke "nested-br_if-value" (i32.const 1)) (i32.const 9)) +(assert_return (invoke "nested-br_if-value" (i32.const 2)) (i32.const 8)) +(assert_return (invoke "nested-br_if-value" (i32.const 9)) (i32.const 8)) +(assert_return (invoke "nested-br_if-value" (i32.const -9)) (i32.const 8)) +(assert_return (invoke "nested-br_if-value" (i32.const 999999)) (i32.const 8)) + +(assert_return (invoke "nested-br_if-value-cond" (i32.const 0)) (i32.const 9)) +(assert_return (invoke "nested-br_if-value-cond" (i32.const 1)) (i32.const 8)) +(assert_return (invoke "nested-br_if-value-cond" (i32.const 2)) (i32.const 9)) +(assert_return (invoke "nested-br_if-value-cond" (i32.const 3)) (i32.const 9)) +(assert_return (invoke "nested-br_if-value-cond" (i32.const -1000000)) (i32.const 9)) +(assert_return (invoke "nested-br_if-value-cond" (i32.const 9423975)) (i32.const 9)) + +(assert_return (invoke "nested-br_table-value" (i32.const 0)) (i32.const 17)) +(assert_return (invoke "nested-br_table-value" (i32.const 1)) (i32.const 9)) +(assert_return (invoke "nested-br_table-value" (i32.const 2)) (i32.const 8)) +(assert_return (invoke "nested-br_table-value" (i32.const 9)) (i32.const 8)) +(assert_return (invoke "nested-br_table-value" (i32.const -9)) (i32.const 8)) +(assert_return (invoke "nested-br_table-value" (i32.const 999999)) (i32.const 8)) + +(assert_return (invoke "nested-br_table-value-index" (i32.const 0)) (i32.const 9)) +(assert_return (invoke "nested-br_table-value-index" (i32.const 1)) (i32.const 8)) +(assert_return (invoke "nested-br_table-value-index" (i32.const 2)) (i32.const 9)) +(assert_return (invoke "nested-br_table-value-index" (i32.const 3)) (i32.const 9)) +(assert_return (invoke "nested-br_table-value-index" (i32.const -1000000)) (i32.const 9)) +(assert_return (invoke "nested-br_table-value-index" (i32.const 9423975)) (i32.const 9)) + +(assert_return (invoke "nested-br_table-loop-block" (i32.const 1)) (i32.const 3)) + +(assert_return (invoke "meet-externref" (i32.const 0) (ref.extern 1)) (ref.extern 1)) +(assert_return (invoke "meet-externref" (i32.const 1) (ref.extern 1)) (ref.extern 1)) +(assert_return (invoke "meet-externref" (i32.const 2) (ref.extern 1)) (ref.extern 1)) + +(assert_invalid + (module (func $type-arg-void-vs-num (result i32) + (block (br_table 0 (i32.const 1)) (i32.const 1)) + )) + "type mismatch" +) + +(assert_invalid + (module (func $type-arg-empty-vs-num (result i32) + (block (br_table 0) (i32.const 1)) + )) + "type mismatch" +) + +(assert_invalid + (module (func $type-arg-void-vs-num (result i32) + (block (result i32) (br_table 0 (nop) (i32.const 1)) (i32.const 1)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-arg-num-vs-num (result i32) + (block (result i32) + (br_table 0 0 0 (i64.const 1) (i32.const 1)) (i32.const 1) + ) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-arg-num-vs-arg-num + (block + (block (result f32) + (br_table 0 1 (f32.const 0) (i32.const 0)) + ) + (drop) + ) + )) + "type mismatch" +) +(assert_invalid + (module (func + (block (result i32) + (block (result i64) + (br_table 0 1 (i32.const 0) (i32.const 0)) + ) + ) + )) + "type mismatch" +) + +(assert_invalid + (module (func $type-index-void-vs-i32 + (block (br_table 0 0 0 (nop))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-index-num-vs-i32 + (block (br_table 0 (i64.const 0))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-arg-index-void-vs-i32 (result i32) + (block (result i32) (br_table 0 0 (i32.const 0) (nop)) (i32.const 1)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-arg-void-vs-num-nested (result i32) + (block (result i32) (i32.const 0) (block (br_table 1 (i32.const 0)))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-arg-index-num-vs-i32 (result i32) + (block (result i32) + (br_table 0 0 (i32.const 0) (i64.const 0)) (i32.const 1) + ) + )) + "type mismatch" +) + +(assert_invalid + (module (func $type-arg-void-vs-num (result i32) + (block (br_table 0 (i32.const 1)) (i32.const 1)) + )) + "type mismatch" +) + +(assert_invalid + (module + (func $type-arg-index-empty-in-then + (block + (i32.const 0) (i32.const 0) + (if (result i32) (then (br_table 0))) + ) + (i32.eqz) (drop) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-arg-value-empty-in-then + (block + (i32.const 0) (i32.const 0) + (if (result i32) (then (br_table 0 (i32.const 1)))) + ) + (i32.eqz) (drop) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-arg-index-empty-in-return + (block (result i32) + (return (br_table 0)) + ) + (i32.eqz) (drop) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-arg-value-empty-in-return + (block (result i32) + (return (br_table 0 (i32.const 1))) + ) + (i32.eqz) (drop) + ) + ) + "type mismatch" +) + +(assert_invalid + (module + (func (param i32) (result i32) + (loop (result i32) + (block (result i32) + (br_table 0 1 (i32.const 1) (local.get 0)) + ) + ) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func (param i32) (result i32) + (block (result i32) + (loop (result i32) + (br_table 0 1 (i32.const 1) (local.get 0)) + ) + ) + ) + ) + "type mismatch" +) + + +(assert_invalid + (module (func $meet-bottom (param i32) (result externref) + (block $l1 (result externref) + (drop + (block $l2 (result i32) + (br_table $l2 $l1 $l2 (ref.null extern) (local.get 0)) + ) + ) + (ref.null extern) + ) + )) + "type mismatch" +) + +(assert_invalid + (module (func $unbound-label + (block (br_table 2 1 (i32.const 1))) + )) + "unknown label" +) +(assert_invalid + (module (func $unbound-nested-label + (block (block (br_table 0 5 (i32.const 1)))) + )) + "unknown label" +) +(assert_invalid + (module (func $large-label + (block (br_table 0 0x10000001 0 (i32.const 1))) + )) + "unknown label" +) + +(assert_invalid + (module (func $unbound-label-default + (block (br_table 1 2 (i32.const 1))) + )) + "unknown label" +) +(assert_invalid + (module (func $unbound-nested-label-default + (block (block (br_table 0 5 (i32.const 1)))) + )) + "unknown label" +) +(assert_invalid + (module (func $large-label-default + (block (br_table 0 0 0x10000001 (i32.const 1))) + )) + "unknown label" +) + diff --git a/runtime/near-vm/tests/wast/spec/bulk.wast b/runtime/near-vm/tests/wast/spec/bulk.wast new file mode 100644 index 00000000000..5dcac724cf1 --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/bulk.wast @@ -0,0 +1,351 @@ +;; segment syntax +(module + (memory 1) + (data "foo")) + +(module + (table 3 funcref) + (elem funcref (ref.func 0) (ref.null func) (ref.func 1)) + (func) + (func)) + +;; memory.fill +(module + (memory 1) + + (func (export "fill") (param i32 i32 i32) + (memory.fill + (local.get 0) + (local.get 1) + (local.get 2))) + + (func (export "load8_u") (param i32) (result i32) + (i32.load8_u (local.get 0))) +) + +;; Basic fill test. +(invoke "fill" (i32.const 1) (i32.const 0xff) (i32.const 3)) +(assert_return (invoke "load8_u" (i32.const 0)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 1)) (i32.const 0xff)) +(assert_return (invoke "load8_u" (i32.const 2)) (i32.const 0xff)) +(assert_return (invoke "load8_u" (i32.const 3)) (i32.const 0xff)) +(assert_return (invoke "load8_u" (i32.const 4)) (i32.const 0)) + +;; Fill value is stored as a byte. +(invoke "fill" (i32.const 0) (i32.const 0xbbaa) (i32.const 2)) +(assert_return (invoke "load8_u" (i32.const 0)) (i32.const 0xaa)) +(assert_return (invoke "load8_u" (i32.const 1)) (i32.const 0xaa)) + +;; Fill all of memory +(invoke "fill" (i32.const 0) (i32.const 0) (i32.const 0x10000)) + +;; Out-of-bounds writes trap, and nothing is written +(assert_trap (invoke "fill" (i32.const 0xff00) (i32.const 1) (i32.const 0x101)) + "out of bounds memory access") +(assert_return (invoke "load8_u" (i32.const 0xff00)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 0xffff)) (i32.const 0)) + +;; Succeed when writing 0 bytes at the end of the region. +(invoke "fill" (i32.const 0x10000) (i32.const 0) (i32.const 0)) + +;; Writing 0 bytes outside the memory traps. +(assert_trap (invoke "fill" (i32.const 0x10001) (i32.const 0) (i32.const 0)) + "out of bounds memory access") + + +;; memory.copy +(module + (memory (data "\aa\bb\cc\dd")) + + (func (export "copy") (param i32 i32 i32) + (memory.copy + (local.get 0) + (local.get 1) + (local.get 2))) + + (func (export "load8_u") (param i32) (result i32) + (i32.load8_u (local.get 0))) +) + +;; Non-overlapping copy. +(invoke "copy" (i32.const 10) (i32.const 0) (i32.const 4)) + +(assert_return (invoke "load8_u" (i32.const 9)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 10)) (i32.const 0xaa)) +(assert_return (invoke "load8_u" (i32.const 11)) (i32.const 0xbb)) +(assert_return (invoke "load8_u" (i32.const 12)) (i32.const 0xcc)) +(assert_return (invoke "load8_u" (i32.const 13)) (i32.const 0xdd)) +(assert_return (invoke "load8_u" (i32.const 14)) (i32.const 0)) + +;; Overlap, source > dest +(invoke "copy" (i32.const 8) (i32.const 10) (i32.const 4)) +(assert_return (invoke "load8_u" (i32.const 8)) (i32.const 0xaa)) +(assert_return (invoke "load8_u" (i32.const 9)) (i32.const 0xbb)) +(assert_return (invoke "load8_u" (i32.const 10)) (i32.const 0xcc)) +(assert_return (invoke "load8_u" (i32.const 11)) (i32.const 0xdd)) +(assert_return (invoke "load8_u" (i32.const 12)) (i32.const 0xcc)) +(assert_return (invoke "load8_u" (i32.const 13)) (i32.const 0xdd)) + +;; Overlap, source < dest +(invoke "copy" (i32.const 10) (i32.const 7) (i32.const 6)) +(assert_return (invoke "load8_u" (i32.const 10)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 11)) (i32.const 0xaa)) +(assert_return (invoke "load8_u" (i32.const 12)) (i32.const 0xbb)) +(assert_return (invoke "load8_u" (i32.const 13)) (i32.const 0xcc)) +(assert_return (invoke "load8_u" (i32.const 14)) (i32.const 0xdd)) +(assert_return (invoke "load8_u" (i32.const 15)) (i32.const 0xcc)) +(assert_return (invoke "load8_u" (i32.const 16)) (i32.const 0)) + +;; Copy ending at memory limit is ok. +(invoke "copy" (i32.const 0xff00) (i32.const 0) (i32.const 0x100)) +(invoke "copy" (i32.const 0xfe00) (i32.const 0xff00) (i32.const 0x100)) + +;; Succeed when copying 0 bytes at the end of the region. +(invoke "copy" (i32.const 0x10000) (i32.const 0) (i32.const 0)) +(invoke "copy" (i32.const 0) (i32.const 0x10000) (i32.const 0)) + +;; Copying 0 bytes outside the memory traps. +(assert_trap (invoke "copy" (i32.const 0x10001) (i32.const 0) (i32.const 0)) + "out of bounds memory access") +(assert_trap (invoke "copy" (i32.const 0) (i32.const 0x10001) (i32.const 0)) + "out of bounds memory access") + + +;; memory.init +(module + (memory 1) + (data "\aa\bb\cc\dd") + + (func (export "init") (param i32 i32 i32) + (memory.init 0 + (local.get 0) + (local.get 1) + (local.get 2))) + + (func (export "load8_u") (param i32) (result i32) + (i32.load8_u (local.get 0))) +) + +(invoke "init" (i32.const 0) (i32.const 1) (i32.const 2)) +(assert_return (invoke "load8_u" (i32.const 0)) (i32.const 0xbb)) +(assert_return (invoke "load8_u" (i32.const 1)) (i32.const 0xcc)) +(assert_return (invoke "load8_u" (i32.const 2)) (i32.const 0)) + +;; Init ending at memory limit and segment limit is ok. +(invoke "init" (i32.const 0xfffc) (i32.const 0) (i32.const 4)) + +;; Out-of-bounds writes trap, and nothing is written. +(assert_trap (invoke "init" (i32.const 0xfffe) (i32.const 0) (i32.const 3)) + "out of bounds memory access") +(assert_return (invoke "load8_u" (i32.const 0xfffe)) (i32.const 0xcc)) +(assert_return (invoke "load8_u" (i32.const 0xffff)) (i32.const 0xdd)) + +;; Succeed when writing 0 bytes at the end of either region. +(invoke "init" (i32.const 0x10000) (i32.const 0) (i32.const 0)) +(invoke "init" (i32.const 0) (i32.const 4) (i32.const 0)) + +;; Writing 0 bytes outside the memory traps. +(assert_trap (invoke "init" (i32.const 0x10001) (i32.const 0) (i32.const 0)) + "out of bounds memory access") +(assert_trap (invoke "init" (i32.const 0) (i32.const 5) (i32.const 0)) + "out of bounds memory access") + +;; data.drop +(module + (memory 1) + (data $p "x") + (data $a (memory 0) (i32.const 0) "x") + + (func (export "drop_passive") (data.drop $p)) + (func (export "init_passive") (param $len i32) + (memory.init $p (i32.const 0) (i32.const 0) (local.get $len))) + + (func (export "drop_active") (data.drop $a)) + (func (export "init_active") (param $len i32) + (memory.init $a (i32.const 0) (i32.const 0) (local.get $len))) +) + +(invoke "init_passive" (i32.const 1)) +(invoke "drop_passive") +(invoke "drop_passive") +(assert_return (invoke "init_passive" (i32.const 0))) +(assert_trap (invoke "init_passive" (i32.const 1)) "out of bounds memory access") +(invoke "init_passive" (i32.const 0)) +(invoke "drop_active") +(assert_return (invoke "init_active" (i32.const 0))) +(assert_trap (invoke "init_active" (i32.const 1)) "out of bounds memory access") +(invoke "init_active" (i32.const 0)) + +;; Test that the data segment index is properly encoded as an unsigned (not +;; signed) LEB. +(module + ;; 65 data segments. 64 is the smallest positive number that is encoded + ;; differently as a signed LEB. + (data "") (data "") (data "") (data "") (data "") (data "") (data "") (data "") + (data "") (data "") (data "") (data "") (data "") (data "") (data "") (data "") + (data "") (data "") (data "") (data "") (data "") (data "") (data "") (data "") + (data "") (data "") (data "") (data "") (data "") (data "") (data "") (data "") + (data "") (data "") (data "") (data "") (data "") (data "") (data "") (data "") + (data "") (data "") (data "") (data "") (data "") (data "") (data "") (data "") + (data "") (data "") (data "") (data "") (data "") (data "") (data "") (data "") + (data "") (data "") (data "") (data "") (data "") (data "") (data "") (data "") + (data "") + (func (data.drop 64))) + +;; No memory is required for the data.drop instruction. +(module (data "goodbye") (func (data.drop 0))) + +;; table.init +(module + (table 3 funcref) + (elem funcref + (ref.func $zero) (ref.func $one) (ref.func $zero) (ref.func $one)) + + (func $zero (result i32) (i32.const 0)) + (func $one (result i32) (i32.const 1)) + + (func (export "init") (param i32 i32 i32) + (table.init 0 + (local.get 0) + (local.get 1) + (local.get 2))) + + (func (export "call") (param i32) (result i32) + (call_indirect (result i32) + (local.get 0))) +) + +;; Out-of-bounds stores trap, and nothing is written. +(assert_trap (invoke "init" (i32.const 2) (i32.const 0) (i32.const 2)) + "out of bounds table access") +(assert_trap (invoke "call" (i32.const 2)) + "uninitialized element 2") + +(invoke "init" (i32.const 0) (i32.const 1) (i32.const 2)) +(assert_return (invoke "call" (i32.const 0)) (i32.const 1)) +(assert_return (invoke "call" (i32.const 1)) (i32.const 0)) +(assert_trap (invoke "call" (i32.const 2)) "uninitialized element") + +;; Init ending at table limit and segment limit is ok. +(invoke "init" (i32.const 1) (i32.const 2) (i32.const 2)) + +;; Succeed when storing 0 elements at the end of either region. +(invoke "init" (i32.const 3) (i32.const 0) (i32.const 0)) +(invoke "init" (i32.const 0) (i32.const 4) (i32.const 0)) + +;; Writing 0 elements outside the table traps. +(assert_trap (invoke "init" (i32.const 4) (i32.const 0) (i32.const 0)) + "out of bounds table access") +(assert_trap (invoke "init" (i32.const 0) (i32.const 5) (i32.const 0)) + "out of bounds table access") + + +;; elem.drop +(module + (table 1 funcref) + (func $f) + (elem $p funcref (ref.func $f)) + (elem $a (table 0) (i32.const 0) func $f) + + (func (export "drop_passive") (elem.drop $p)) + (func (export "init_passive") (param $len i32) + (table.init $p (i32.const 0) (i32.const 0) (local.get $len)) + ) + + (func (export "drop_active") (elem.drop $a)) + (func (export "init_active") (param $len i32) + (table.init $a (i32.const 0) (i32.const 0) (local.get $len)) + ) +) + +(invoke "init_passive" (i32.const 1)) +(invoke "drop_passive") +(invoke "drop_passive") +(assert_return (invoke "init_passive" (i32.const 0))) +(assert_trap (invoke "init_passive" (i32.const 1)) "out of bounds table access") +(invoke "init_passive" (i32.const 0)) +(invoke "drop_active") +(assert_return (invoke "init_active" (i32.const 0))) +(assert_trap (invoke "init_active" (i32.const 1)) "out of bounds table access") +(invoke "init_active" (i32.const 0)) + +;; Test that the elem segment index is properly encoded as an unsigned (not +;; signed) LEB. +(module + ;; 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 (elem.drop 64))) + +;; No table is required for the elem.drop instruction. +(module (elem funcref (ref.func 0)) (func (elem.drop 0))) + +;; table.copy +(module + (table 10 funcref) + (elem (i32.const 0) $zero $one $two) + (func $zero (result i32) (i32.const 0)) + (func $one (result i32) (i32.const 1)) + (func $two (result i32) (i32.const 2)) + + (func (export "copy") (param i32 i32 i32) + (table.copy + (local.get 0) + (local.get 1) + (local.get 2))) + + (func (export "call") (param i32) (result i32) + (call_indirect (result i32) + (local.get 0))) +) + +;; Non-overlapping copy. +(invoke "copy" (i32.const 3) (i32.const 0) (i32.const 3)) +;; Now [$zero, $one, $two, $zero, $one, $two, ...] +(assert_return (invoke "call" (i32.const 3)) (i32.const 0)) +(assert_return (invoke "call" (i32.const 4)) (i32.const 1)) +(assert_return (invoke "call" (i32.const 5)) (i32.const 2)) + +;; Overlap, source > dest +(invoke "copy" (i32.const 0) (i32.const 1) (i32.const 3)) +;; Now [$one, $two, $zero, $zero, $one, $two, ...] +(assert_return (invoke "call" (i32.const 0)) (i32.const 1)) +(assert_return (invoke "call" (i32.const 1)) (i32.const 2)) +(assert_return (invoke "call" (i32.const 2)) (i32.const 0)) + +;; Overlap, source < dest +(invoke "copy" (i32.const 2) (i32.const 0) (i32.const 3)) +;; Now [$one, $two, $one, $two, $zero, $two, ...] +(assert_return (invoke "call" (i32.const 2)) (i32.const 1)) +(assert_return (invoke "call" (i32.const 3)) (i32.const 2)) +(assert_return (invoke "call" (i32.const 4)) (i32.const 0)) + +;; Copy ending at table limit is ok. +(invoke "copy" (i32.const 6) (i32.const 8) (i32.const 2)) +(invoke "copy" (i32.const 8) (i32.const 6) (i32.const 2)) + +;; Succeed when copying 0 elements at the end of the region. +(invoke "copy" (i32.const 10) (i32.const 0) (i32.const 0)) +(invoke "copy" (i32.const 0) (i32.const 10) (i32.const 0)) + +;; Fail on out-of-bounds when copying 0 elements outside of table. +(assert_trap (invoke "copy" (i32.const 11) (i32.const 0) (i32.const 0)) + "out of bounds table access") +(assert_trap (invoke "copy" (i32.const 0) (i32.const 11) (i32.const 0)) + "out of bounds table access") diff --git a/runtime/near-vm/tests/wast/spec/call.wast b/runtime/near-vm/tests/wast/spec/call.wast new file mode 100644 index 00000000000..e4f854f7a55 --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/call.wast @@ -0,0 +1,518 @@ +;; Test `call` operator + +(module + ;; Auxiliary definitions + (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 $const-i32-i64 (result i32 i64) (i32.const 0x132) (i64.const 0x164)) + + (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 $id-i32-f64 (param i32 f64) (result i32 f64) + (local.get 0) (local.get 1) + ) + + (func $swap-i32-i32 (param i32 i32) (result i32 i32) + (local.get 1) (local.get 0) + ) + (func $swap-f32-f64 (param f32 f64) (result f64 f32) + (local.get 1) (local.get 0) + ) + (func $swap-f64-i32 (param f64 i32) (result i32 f64) + (local.get 1) (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)) + + ;; Typing + + (func (export "type-i32") (result i32) (call $const-i32)) + (func (export "type-i64") (result i64) (call $const-i64)) + (func (export "type-f32") (result f32) (call $const-f32)) + (func (export "type-f64") (result f64) (call $const-f64)) + (func (export "type-i32-i64") (result i32 i64) (call $const-i32-i64)) + + (func (export "type-first-i32") (result i32) (call $id-i32 (i32.const 32))) + (func (export "type-first-i64") (result i64) (call $id-i64 (i64.const 64))) + (func (export "type-first-f32") (result f32) (call $id-f32 (f32.const 1.32))) + (func (export "type-first-f64") (result f64) (call $id-f64 (f64.const 1.64))) + + (func (export "type-second-i32") (result i32) + (call $f32-i32 (f32.const 32.1) (i32.const 32)) + ) + (func (export "type-second-i64") (result i64) + (call $i32-i64 (i32.const 32) (i64.const 64)) + ) + (func (export "type-second-f32") (result f32) + (call $f64-f32 (f64.const 64) (f32.const 32)) + ) + (func (export "type-second-f64") (result f64) + (call $i64-f64 (i64.const 64) (f64.const 64.1)) + ) + + (func (export "type-all-i32-f64") (result i32 f64) + (call $id-i32-f64 (i32.const 32) (f64.const 1.64)) + ) + (func (export "type-all-i32-i32") (result i32 i32) + (call $swap-i32-i32 (i32.const 1) (i32.const 2)) + ) + (func (export "type-all-f32-f64") (result f64 f32) + (call $swap-f32-f64 (f32.const 1) (f64.const 2)) + ) + (func (export "type-all-f64-i32") (result i32 f64) + (call $swap-f64-i32 (f64.const 1) (i32.const 2)) + ) + + ;; Composition + + (func (export "as-binary-all-operands") (result i32) + (i32.add (call $swap-i32-i32 (i32.const 3) (i32.const 4))) + ) + + (func (export "as-mixed-operands") (result i32) + (call $swap-i32-i32 (i32.const 3) (i32.const 4)) + (i32.const 5) + (i32.add) + (i32.mul) + ) + + (func (export "as-call-all-operands") (result i32 i32) + (call $swap-i32-i32 (call $swap-i32-i32 (i32.const 3) (i32.const 4))) + ) + + ;; Recursion + + (func $fac (export "fac") (param i64) (result i64) + (if (result i64) (i64.eqz (local.get 0)) + (then (i64.const 1)) + (else + (i64.mul + (local.get 0) + (call $fac (i64.sub (local.get 0) (i64.const 1))) + ) + ) + ) + ) + + (func $fac-acc (export "fac-acc") (param i64 i64) (result i64) + (if (result i64) (i64.eqz (local.get 0)) + (then (local.get 1)) + (else + (call $fac-acc + (i64.sub (local.get 0) (i64.const 1)) + (i64.mul (local.get 0) (local.get 1)) + ) + ) + ) + ) + + (func $fib (export "fib") (param i64) (result i64) + (if (result i64) (i64.le_u (local.get 0) (i64.const 1)) + (then (i64.const 1)) + (else + (i64.add + (call $fib (i64.sub (local.get 0) (i64.const 2))) + (call $fib (i64.sub (local.get 0) (i64.const 1))) + ) + ) + ) + ) + + (func $even (export "even") (param i64) (result i32) + (if (result i32) (i64.eqz (local.get 0)) + (then (i32.const 44)) + (else (call $odd (i64.sub (local.get 0) (i64.const 1)))) + ) + ) + (func $odd (export "odd") (param i64) (result i32) + (if (result i32) (i64.eqz (local.get 0)) + (then (i32.const 99)) + (else (call $even (i64.sub (local.get 0) (i64.const 1)))) + ) + ) + + ;; Stack exhaustion + + ;; Implementations are required to have every call consume some abstract + ;; resource towards exhausting some abstract finite limit, such that + ;; infinitely recursive test cases reliably trap in finite time. This is + ;; because otherwise applications could come to depend on it on those + ;; implementations and be incompatible with implementations that don't do + ;; it (or don't do it under the same circumstances). + + (func $runaway (export "runaway") (call $runaway)) + + (func $mutual-runaway1 (export "mutual-runaway") (call $mutual-runaway2)) + (func $mutual-runaway2 (call $mutual-runaway1)) + + ;; As parameter of control constructs and instructions + + (memory 1) + + (func (export "as-select-first") (result i32) + (select (call $const-i32) (i32.const 2) (i32.const 3)) + ) + (func (export "as-select-mid") (result i32) + (select (i32.const 2) (call $const-i32) (i32.const 3)) + ) + (func (export "as-select-last") (result i32) + (select (i32.const 2) (i32.const 3) (call $const-i32)) + ) + + (func (export "as-if-condition") (result i32) + (if (result i32) (call $const-i32) (then (i32.const 1)) (else (i32.const 2))) + ) + + (func (export "as-br_if-first") (result i32) + (block (result i32) (br_if 0 (call $const-i32) (i32.const 2))) + ) + (func (export "as-br_if-last") (result i32) + (block (result i32) (br_if 0 (i32.const 2) (call $const-i32))) + ) + + (func (export "as-br_table-first") (result i32) + (block (result i32) (call $const-i32) (i32.const 2) (br_table 0 0)) + ) + (func (export "as-br_table-last") (result i32) + (block (result i32) (i32.const 2) (call $const-i32) (br_table 0 0)) + ) + + (func $func (param i32 i32) (result i32) (local.get 0)) + (type $check (func (param i32 i32) (result i32))) + (table funcref (elem $func)) + (func (export "as-call_indirect-first") (result i32) + (block (result i32) + (call_indirect (type $check) + (call $const-i32) (i32.const 2) (i32.const 0) + ) + ) + ) + (func (export "as-call_indirect-mid") (result i32) + (block (result i32) + (call_indirect (type $check) + (i32.const 2) (call $const-i32) (i32.const 0) + ) + ) + ) + (func (export "as-call_indirect-last") (result i32) + (block (result i32) + (call_indirect (type $check) + (i32.const 1) (i32.const 2) (call $const-i32) + ) + ) + ) + + (func (export "as-store-first") + (call $const-i32) (i32.const 1) (i32.store) + ) + (func (export "as-store-last") + (i32.const 10) (call $const-i32) (i32.store) + ) + + (func (export "as-memory.grow-value") (result i32) + (memory.grow (call $const-i32)) + ) + (func (export "as-return-value") (result i32) + (call $const-i32) (return) + ) + (func (export "as-drop-operand") + (call $const-i32) (drop) + ) + (func (export "as-br-value") (result i32) + (block (result i32) (br 0 (call $const-i32))) + ) + (func (export "as-local.set-value") (result i32) + (local i32) (local.set 0 (call $const-i32)) (local.get 0) + ) + (func (export "as-local.tee-value") (result i32) + (local i32) (local.tee 0 (call $const-i32)) + ) + (global $a (mut i32) (i32.const 10)) + (func (export "as-global.set-value") (result i32) + (global.set $a (call $const-i32)) + (global.get $a) + ) + (func (export "as-load-operand") (result i32) + (i32.load (call $const-i32)) + ) + + (func $dummy (param i32) (result i32) (local.get 0)) + (func $du (param f32) (result f32) (local.get 0)) + (func (export "as-unary-operand") (result f32) + (block (result f32) (f32.sqrt (call $du (f32.const 0x0p+0)))) + ) + + (func (export "as-binary-left") (result i32) + (block (result i32) (i32.add (call $dummy (i32.const 1)) (i32.const 10))) + ) + (func (export "as-binary-right") (result i32) + (block (result i32) (i32.sub (i32.const 10) (call $dummy (i32.const 1)))) + ) + + (func (export "as-test-operand") (result i32) + (block (result i32) (i32.eqz (call $dummy (i32.const 1)))) + ) + + (func (export "as-compare-left") (result i32) + (block (result i32) (i32.le_u (call $dummy (i32.const 1)) (i32.const 10))) + ) + (func (export "as-compare-right") (result i32) + (block (result i32) (i32.ne (i32.const 10) (call $dummy (i32.const 1)))) + ) + + (func (export "as-convert-operand") (result i64) + (block (result i64) (i64.extend_i32_s (call $dummy (i32.const 1)))) + ) + + ;; Test correct argument passing + + (func $return-from-long-argument-list-helper (param f32 i32 i32 f64 f32 f32 f32 f64 f32 i32 i32 f32 f64 i64 i64 i32 i64 i64 f32 i64 i64 i64 i32 f32 f32 f32 f64 f32 i32 i64 f32 f64 f64 f32 i32 f32 f32 f64 i64 f64 i32 i64 f32 f64 i32 i32 i32 i64 f64 i32 i64 i64 f64 f64 f64 f64 f64 f64 i32 f32 f64 f64 i32 i64 f32 f32 f32 i32 f64 f64 f64 f64 f64 f32 i64 i64 i32 i32 i32 f32 f64 i32 i64 f32 f32 f32 i32 i32 f32 f64 i64 f32 f64 f32 f32 f32 i32 f32 i64 i32) (result i32) + (local.get 99) + ) + + (func (export "return-from-long-argument-list") (param i32) (result i32) + (call $return-from-long-argument-list-helper (f32.const 0) (i32.const 0) (i32.const 0) (f64.const 0) (f32.const 0) (f32.const 0) (f32.const 0) (f64.const 0) (f32.const 0) (i32.const 0) (i32.const 0) (f32.const 0) (f64.const 0) (i64.const 0) (i64.const 0) (i32.const 0) (i64.const 0) (i64.const 0) (f32.const 0) (i64.const 0) (i64.const 0) (i64.const 0) (i32.const 0) (f32.const 0) (f32.const 0) (f32.const 0) (f64.const 0) (f32.const 0) (i32.const 0) (i64.const 0) (f32.const 0) (f64.const 0) (f64.const 0) (f32.const 0) (i32.const 0) (f32.const 0) (f32.const 0) (f64.const 0) (i64.const 0) (f64.const 0) (i32.const 0) (i64.const 0) (f32.const 0) (f64.const 0) (i32.const 0) (i32.const 0) (i32.const 0) (i64.const 0) (f64.const 0) (i32.const 0) (i64.const 0) (i64.const 0) (f64.const 0) (f64.const 0) (f64.const 0) (f64.const 0) (f64.const 0) (f64.const 0) (i32.const 0) (f32.const 0) (f64.const 0) (f64.const 0) (i32.const 0) (i64.const 0) (f32.const 0) (f32.const 0) (f32.const 0) (i32.const 0) (f64.const 0) (f64.const 0) (f64.const 0) (f64.const 0) (f64.const 0) (f32.const 0) (i64.const 0) (i64.const 0) (i32.const 0) (i32.const 0) (i32.const 0) (f32.const 0) (f64.const 0) (i32.const 0) (i64.const 0) (f32.const 0) (f32.const 0) (f32.const 0) (i32.const 0) (i32.const 0) (f32.const 0) (f64.const 0) (i64.const 0) (f32.const 0) (f64.const 0) (f32.const 0) (f32.const 0) (f32.const 0) (i32.const 0) (f32.const 0) (i64.const 0) (local.get 0)) + ) +) + +(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-i32-i64") (i32.const 0x132) (i64.const 0x164)) + +(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_return (invoke "type-all-i32-f64") (i32.const 32) (f64.const 1.64)) +(assert_return (invoke "type-all-i32-i32") (i32.const 2) (i32.const 1)) +(assert_return (invoke "type-all-f32-f64") (f64.const 2) (f32.const 1)) +(assert_return (invoke "type-all-f64-i32") (i32.const 2) (f64.const 1)) + +(assert_return (invoke "as-binary-all-operands") (i32.const 7)) +(assert_return (invoke "as-mixed-operands") (i32.const 32)) +(assert_return (invoke "as-call-all-operands") (i32.const 3) (i32.const 4)) + +(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)) (i32.const 44)) +(assert_return (invoke "even" (i64.const 1)) (i32.const 99)) +(assert_return (invoke "even" (i64.const 100)) (i32.const 44)) +(assert_return (invoke "even" (i64.const 77)) (i32.const 99)) +(assert_return (invoke "odd" (i64.const 0)) (i32.const 99)) +(assert_return (invoke "odd" (i64.const 1)) (i32.const 44)) +(assert_return (invoke "odd" (i64.const 200)) (i32.const 99)) +(assert_return (invoke "odd" (i64.const 77)) (i32.const 44)) + +(assert_exhaustion (invoke "runaway") "call stack exhausted") +(assert_exhaustion (invoke "mutual-runaway") "call stack exhausted") + +(assert_return (invoke "as-select-first") (i32.const 0x132)) +(assert_return (invoke "as-select-mid") (i32.const 2)) +(assert_return (invoke "as-select-last") (i32.const 2)) + +(assert_return (invoke "as-if-condition") (i32.const 1)) + +(assert_return (invoke "as-br_if-first") (i32.const 0x132)) +(assert_return (invoke "as-br_if-last") (i32.const 2)) + +(assert_return (invoke "as-br_table-first") (i32.const 0x132)) +(assert_return (invoke "as-br_table-last") (i32.const 2)) + +(assert_return (invoke "as-call_indirect-first") (i32.const 0x132)) +(assert_return (invoke "as-call_indirect-mid") (i32.const 2)) +(assert_trap (invoke "as-call_indirect-last") "undefined element") + +(assert_return (invoke "as-store-first")) +(assert_return (invoke "as-store-last")) + +(assert_return (invoke "as-memory.grow-value") (i32.const 1)) +(assert_return (invoke "as-return-value") (i32.const 0x132)) +(assert_return (invoke "as-drop-operand")) +(assert_return (invoke "as-br-value") (i32.const 0x132)) +(assert_return (invoke "as-local.set-value") (i32.const 0x132)) +(assert_return (invoke "as-local.tee-value") (i32.const 0x132)) +(assert_return (invoke "as-global.set-value") (i32.const 0x132)) +(assert_return (invoke "as-load-operand") (i32.const 1)) + +(assert_return (invoke "as-unary-operand") (f32.const 0x0p+0)) +(assert_return (invoke "as-binary-left") (i32.const 11)) +(assert_return (invoke "as-binary-right") (i32.const 9)) +(assert_return (invoke "as-test-operand") (i32.const 0)) +(assert_return (invoke "as-compare-left") (i32.const 1)) +(assert_return (invoke "as-compare-right") (i32.const 1)) +(assert_return (invoke "as-convert-operand") (i64.const 1)) + +(assert_return (invoke "return-from-long-argument-list" (i32.const 42)) (i32.const 42)) + +;; Invalid typing + +(assert_invalid + (module + (func $type-void-vs-num (i32.eqz (call 1))) + (func) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-num-vs-num (i32.eqz (call 1))) + (func (result i64) (i64.const 1)) + ) + "type mismatch" +) + +(assert_invalid + (module + (func $arity-0-vs-1 (call 1)) + (func (param i32)) + ) + "type mismatch" +) +(assert_invalid + (module + (func $arity-0-vs-2 (call 1)) + (func (param f64 i32)) + ) + "type mismatch" +) +(assert_invalid + (module + (func $arity-1-vs-0 (call 1 (i32.const 1))) + (func) + ) + "type mismatch" +) +(assert_invalid + (module + (func $arity-2-vs-0 (call 1 (f64.const 2) (i32.const 1))) + (func) + ) + "type mismatch" +) + +(assert_invalid + (module + (func $type-first-void-vs-num (call 1 (nop) (i32.const 1))) + (func (param i32 i32)) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-second-void-vs-num (call 1 (i32.const 1) (nop))) + (func (param i32 i32)) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-first-num-vs-num (call 1 (f64.const 1) (i32.const 1))) + (func (param i32 f64)) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-second-num-vs-num (call 1 (i32.const 1) (f64.const 1))) + (func (param f64 i32)) + ) + "type mismatch" +) + +(assert_invalid + (module + (func $type-first-empty-in-block + (block (call 1)) + ) + (func (param i32)) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-second-empty-in-block + (block (call 1 (i32.const 0))) + ) + (func (param i32 i32)) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-first-empty-in-loop + (loop (call 1)) + ) + (func (param i32)) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-second-empty-in-loop + (loop (call 1 (i32.const 0))) + ) + (func (param i32 i32)) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-first-empty-in-then + (if (i32.const 0) (then (call 1))) + ) + (func (param i32)) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-second-empty-in-then + (if (i32.const 0) (then (call 1 (i32.const 0)))) + ) + (func (param i32 i32)) + ) + "type mismatch" +) + + +;; Unbound function + +(assert_invalid + (module (func $unbound-func (call 1))) + "unknown function" +) +(assert_invalid + (module (func $large-func (call 1012321300))) + "unknown function" +) diff --git a/runtime/near-vm/tests/wast/spec/call_indirect.wast b/runtime/near-vm/tests/wast/spec/call_indirect.wast new file mode 100644 index 00000000000..1ecd9b7baf0 --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/call_indirect.wast @@ -0,0 +1,1017 @@ +;; Test `call_indirect` operator + +(module + ;; Auxiliary definitions + (type $proc (func)) + (type $out-i32 (func (result i32))) + (type $out-i64 (func (result i64))) + (type $out-f32 (func (result f32))) + (type $out-f64 (func (result f64))) + (type $out-f64-i32 (func (result f64 i32))) + (type $over-i32 (func (param i32) (result i32))) + (type $over-i64 (func (param i64) (result i64))) + (type $over-f32 (func (param f32) (result f32))) + (type $over-f64 (func (param f64) (result f64))) + (type $over-i32-f64 (func (param i32 f64) (result i32 f64))) + (type $swap-i32-i64 (func (param i32 i64) (result i64 i32))) + (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 $over-i32-duplicate (func (param i32) (result i32))) + (type $over-i64-duplicate (func (param i64) (result i64))) + (type $over-f32-duplicate (func (param f32) (result f32))) + (type $over-f64-duplicate (func (param f64) (result f64))) + + (func $const-i32 (type $out-i32) (i32.const 0x132)) + (func $const-i64 (type $out-i64) (i64.const 0x164)) + (func $const-f32 (type $out-f32) (f32.const 0xf32)) + (func $const-f64 (type $out-f64) (f64.const 0xf64)) + (func $const-f64-i32 (type $out-f64-i32) (f64.const 0xf64) (i32.const 32)) + + (func $id-i32 (type $over-i32) (local.get 0)) + (func $id-i64 (type $over-i64) (local.get 0)) + (func $id-f32 (type $over-f32) (local.get 0)) + (func $id-f64 (type $over-f64) (local.get 0)) + (func $id-i32-f64 (type $over-i32-f64) (local.get 0) (local.get 1)) + (func $swap-i32-i64 (type $swap-i32-i64) (local.get 1) (local.get 0)) + + (func $i32-i64 (type $i32-i64) (local.get 1)) + (func $i64-f64 (type $i64-f64) (local.get 1)) + (func $f32-i32 (type $f32-i32) (local.get 1)) + (func $f64-f32 (type $f64-f32) (local.get 1)) + + (func $over-i32-duplicate (type $over-i32-duplicate) (local.get 0)) + (func $over-i64-duplicate (type $over-i64-duplicate) (local.get 0)) + (func $over-f32-duplicate (type $over-f32-duplicate) (local.get 0)) + (func $over-f64-duplicate (type $over-f64-duplicate) (local.get 0)) + + (table funcref + (elem + $const-i32 $const-i64 $const-f32 $const-f64 ;; 0..3 + $id-i32 $id-i64 $id-f32 $id-f64 ;; 4..7 + $f32-i32 $i32-i64 $f64-f32 $i64-f64 ;; 9..11 + $fac-i64 $fib-i64 $even $odd ;; 12..15 + $runaway $mutual-runaway1 $mutual-runaway2 ;; 16..18 + $over-i32-duplicate $over-i64-duplicate ;; 19..20 + $over-f32-duplicate $over-f64-duplicate ;; 21..22 + $fac-i32 $fac-f32 $fac-f64 ;; 23..25 + $fib-i32 $fib-f32 $fib-f64 ;; 26..28 + $const-f64-i32 $id-i32-f64 $swap-i32-i64 ;; 29..31 + ) + ) + + ;; Syntax + + (func + (call_indirect (i32.const 0)) + (call_indirect (param i64) (i64.const 0) (i32.const 0)) + (call_indirect (param i64) (param) (param f64 i32 i64) + (i64.const 0) (f64.const 0) (i32.const 0) (i64.const 0) (i32.const 0) + ) + (call_indirect (result) (i32.const 0)) + (drop (i32.eqz (call_indirect (result i32) (i32.const 0)))) + (drop (i32.eqz (call_indirect (result i32) (result) (i32.const 0)))) + (drop (i32.eqz + (call_indirect (param i64) (result i32) (i64.const 0) (i32.const 0)) + )) + (drop (i32.eqz + (call_indirect + (param) (param i64) (param) (param f64 i32 i64) (param) (param) + (result) (result i32) (result) (result) + (i64.const 0) (f64.const 0) (i32.const 0) (i64.const 0) (i32.const 0) + ) + )) + (drop (i64.eqz + (call_indirect (type $over-i64) (param i64) (result i64) + (i64.const 0) (i32.const 0) + ) + )) + ) + + ;; Typing + + (func (export "type-i32") (result i32) + (call_indirect (type $out-i32) (i32.const 0)) + ) + (func (export "type-i64") (result i64) + (call_indirect (type $out-i64) (i32.const 1)) + ) + (func (export "type-f32") (result f32) + (call_indirect (type $out-f32) (i32.const 2)) + ) + (func (export "type-f64") (result f64) + (call_indirect (type $out-f64) (i32.const 3)) + ) + (func (export "type-f64-i32") (result f64 i32) + (call_indirect (type $out-f64-i32) (i32.const 29)) + ) + + (func (export "type-index") (result i64) + (call_indirect (type $over-i64) (i64.const 100) (i32.const 5)) + ) + + (func (export "type-first-i32") (result i32) + (call_indirect (type $over-i32) (i32.const 32) (i32.const 4)) + ) + (func (export "type-first-i64") (result i64) + (call_indirect (type $over-i64) (i64.const 64) (i32.const 5)) + ) + (func (export "type-first-f32") (result f32) + (call_indirect (type $over-f32) (f32.const 1.32) (i32.const 6)) + ) + (func (export "type-first-f64") (result f64) + (call_indirect (type $over-f64) (f64.const 1.64) (i32.const 7)) + ) + + (func (export "type-second-i32") (result i32) + (call_indirect (type $f32-i32) (f32.const 32.1) (i32.const 32) (i32.const 8)) + ) + (func (export "type-second-i64") (result i64) + (call_indirect (type $i32-i64) (i32.const 32) (i64.const 64) (i32.const 9)) + ) + (func (export "type-second-f32") (result f32) + (call_indirect (type $f64-f32) (f64.const 64) (f32.const 32) (i32.const 10)) + ) + (func (export "type-second-f64") (result f64) + (call_indirect (type $i64-f64) (i64.const 64) (f64.const 64.1) (i32.const 11)) + ) + + (func (export "type-all-f64-i32") (result f64 i32) + (call_indirect (type $out-f64-i32) (i32.const 29)) + ) + (func (export "type-all-i32-f64") (result i32 f64) + (call_indirect (type $over-i32-f64) + (i32.const 1) (f64.const 2) (i32.const 30) + ) + ) + (func (export "type-all-i32-i64") (result i64 i32) + (call_indirect (type $swap-i32-i64) + (i32.const 1) (i64.const 2) (i32.const 31) + ) + ) + + ;; Dispatch + + (func (export "dispatch") (param i32 i64) (result i64) + (call_indirect (type $over-i64) (local.get 1) (local.get 0)) + ) + + (func (export "dispatch-structural-i64") (param i32) (result i64) + (call_indirect (type $over-i64-duplicate) (i64.const 9) (local.get 0)) + ) + (func (export "dispatch-structural-i32") (param i32) (result i32) + (call_indirect (type $over-i32-duplicate) (i32.const 9) (local.get 0)) + ) + (func (export "dispatch-structural-f32") (param i32) (result f32) + (call_indirect (type $over-f32-duplicate) (f32.const 9.0) (local.get 0)) + ) + (func (export "dispatch-structural-f64") (param i32) (result f64) + (call_indirect (type $over-f64-duplicate) (f64.const 9.0) (local.get 0)) + ) + + ;; Recursion + + (func $fac-i64 (export "fac-i64") (type $over-i64) + (if (result i64) (i64.eqz (local.get 0)) + (then (i64.const 1)) + (else + (i64.mul + (local.get 0) + (call_indirect (type $over-i64) + (i64.sub (local.get 0) (i64.const 1)) + (i32.const 12) + ) + ) + ) + ) + ) + + (func $fib-i64 (export "fib-i64") (type $over-i64) + (if (result i64) (i64.le_u (local.get 0) (i64.const 1)) + (then (i64.const 1)) + (else + (i64.add + (call_indirect (type $over-i64) + (i64.sub (local.get 0) (i64.const 2)) + (i32.const 13) + ) + (call_indirect (type $over-i64) + (i64.sub (local.get 0) (i64.const 1)) + (i32.const 13) + ) + ) + ) + ) + ) + + (func $fac-i32 (export "fac-i32") (type $over-i32) + (if (result i32) (i32.eqz (local.get 0)) + (then (i32.const 1)) + (else + (i32.mul + (local.get 0) + (call_indirect (type $over-i32) + (i32.sub (local.get 0) (i32.const 1)) + (i32.const 23) + ) + ) + ) + ) + ) + + (func $fac-f32 (export "fac-f32") (type $over-f32) + (if (result f32) (f32.eq (local.get 0) (f32.const 0.0)) + (then (f32.const 1.0)) + (else + (f32.mul + (local.get 0) + (call_indirect (type $over-f32) + (f32.sub (local.get 0) (f32.const 1.0)) + (i32.const 24) + ) + ) + ) + ) + ) + + (func $fac-f64 (export "fac-f64") (type $over-f64) + (if (result f64) (f64.eq (local.get 0) (f64.const 0.0)) + (then (f64.const 1.0)) + (else + (f64.mul + (local.get 0) + (call_indirect (type $over-f64) + (f64.sub (local.get 0) (f64.const 1.0)) + (i32.const 25) + ) + ) + ) + ) + ) + + (func $fib-i32 (export "fib-i32") (type $over-i32) + (if (result i32) (i32.le_u (local.get 0) (i32.const 1)) + (then (i32.const 1)) + (else + (i32.add + (call_indirect (type $over-i32) + (i32.sub (local.get 0) (i32.const 2)) + (i32.const 26) + ) + (call_indirect (type $over-i32) + (i32.sub (local.get 0) (i32.const 1)) + (i32.const 26) + ) + ) + ) + ) + ) + + (func $fib-f32 (export "fib-f32") (type $over-f32) + (if (result f32) (f32.le (local.get 0) (f32.const 1.0)) + (then (f32.const 1.0)) + (else + (f32.add + (call_indirect (type $over-f32) + (f32.sub (local.get 0) (f32.const 2.0)) + (i32.const 27) + ) + (call_indirect (type $over-f32) + (f32.sub (local.get 0) (f32.const 1.0)) + (i32.const 27) + ) + ) + ) + ) + ) + + (func $fib-f64 (export "fib-f64") (type $over-f64) + (if (result f64) (f64.le (local.get 0) (f64.const 1.0)) + (then (f64.const 1.0)) + (else + (f64.add + (call_indirect (type $over-f64) + (f64.sub (local.get 0) (f64.const 2.0)) + (i32.const 28) + ) + (call_indirect (type $over-f64) + (f64.sub (local.get 0) (f64.const 1.0)) + (i32.const 28) + ) + ) + ) + ) + ) + + (func $even (export "even") (param i32) (result i32) + (if (result i32) (i32.eqz (local.get 0)) + (then (i32.const 44)) + (else + (call_indirect (type $over-i32) + (i32.sub (local.get 0) (i32.const 1)) + (i32.const 15) + ) + ) + ) + ) + (func $odd (export "odd") (param i32) (result i32) + (if (result i32) (i32.eqz (local.get 0)) + (then (i32.const 99)) + (else + (call_indirect (type $over-i32) + (i32.sub (local.get 0) (i32.const 1)) + (i32.const 14) + ) + ) + ) + ) + + ;; Stack exhaustion + + ;; Implementations are required to have every call consume some abstract + ;; resource towards exhausting some abstract finite limit, such that + ;; infinitely recursive test cases reliably trap in finite time. This is + ;; because otherwise applications could come to depend on it on those + ;; implementations and be incompatible with implementations that don't do + ;; it (or don't do it under the same circumstances). + + (func $runaway (export "runaway") (call_indirect (type $proc) (i32.const 16))) + + (func $mutual-runaway1 (export "mutual-runaway") (call_indirect (type $proc) (i32.const 18))) + (func $mutual-runaway2 (call_indirect (type $proc) (i32.const 17))) + + ;; As parameter of control constructs and instructions + + (memory 1) + + (func (export "as-select-first") (result i32) + (select (call_indirect (type $out-i32) (i32.const 0)) (i32.const 2) (i32.const 3)) + ) + (func (export "as-select-mid") (result i32) + (select (i32.const 2) (call_indirect (type $out-i32) (i32.const 0)) (i32.const 3)) + ) + (func (export "as-select-last") (result i32) + (select (i32.const 2) (i32.const 3) (call_indirect (type $out-i32) (i32.const 0))) + ) + + (func (export "as-if-condition") (result i32) + (if (result i32) (call_indirect (type $out-i32) (i32.const 0)) (then (i32.const 1)) (else (i32.const 2))) + ) + + (func (export "as-br_if-first") (result i64) + (block (result i64) (br_if 0 (call_indirect (type $out-i64) (i32.const 1)) (i32.const 2))) + ) + (func (export "as-br_if-last") (result i32) + (block (result i32) (br_if 0 (i32.const 2) (call_indirect (type $out-i32) (i32.const 0)))) + ) + + (func (export "as-br_table-first") (result f32) + (block (result f32) (call_indirect (type $out-f32) (i32.const 2)) (i32.const 2) (br_table 0 0)) + ) + (func (export "as-br_table-last") (result i32) + (block (result i32) (i32.const 2) (call_indirect (type $out-i32) (i32.const 0)) (br_table 0 0)) + ) + + (func (export "as-store-first") + (call_indirect (type $out-i32) (i32.const 0)) (i32.const 1) (i32.store) + ) + (func (export "as-store-last") + (i32.const 10) (call_indirect (type $out-f64) (i32.const 3)) (f64.store) + ) + + (func (export "as-memory.grow-value") (result i32) + (memory.grow (call_indirect (type $out-i32) (i32.const 0))) + ) + (func (export "as-return-value") (result i32) + (call_indirect (type $over-i32) (i32.const 1) (i32.const 4)) (return) + ) + (func (export "as-drop-operand") + (call_indirect (type $over-i64) (i64.const 1) (i32.const 5)) (drop) + ) + (func (export "as-br-value") (result f32) + (block (result f32) (br 0 (call_indirect (type $over-f32) (f32.const 1) (i32.const 6)))) + ) + (func (export "as-local.set-value") (result f64) + (local f64) (local.set 0 (call_indirect (type $over-f64) (f64.const 1) (i32.const 7))) (local.get 0) + ) + (func (export "as-local.tee-value") (result f64) + (local f64) (local.tee 0 (call_indirect (type $over-f64) (f64.const 1) (i32.const 7))) + ) + (global $a (mut f64) (f64.const 10.0)) + (func (export "as-global.set-value") (result f64) + (global.set $a (call_indirect (type $over-f64) (f64.const 1.0) (i32.const 7))) + (global.get $a) + ) + + (func (export "as-load-operand") (result i32) + (i32.load (call_indirect (type $out-i32) (i32.const 0))) + ) + + (func (export "as-unary-operand") (result f32) + (block (result f32) + (f32.sqrt + (call_indirect (type $over-f32) (f32.const 0x0p+0) (i32.const 6)) + ) + ) + ) + + (func (export "as-binary-left") (result i32) + (block (result i32) + (i32.add + (call_indirect (type $over-i32) (i32.const 1) (i32.const 4)) + (i32.const 10) + ) + ) + ) + (func (export "as-binary-right") (result i32) + (block (result i32) + (i32.sub + (i32.const 10) + (call_indirect (type $over-i32) (i32.const 1) (i32.const 4)) + ) + ) + ) + + (func (export "as-test-operand") (result i32) + (block (result i32) + (i32.eqz + (call_indirect (type $over-i32) (i32.const 1) (i32.const 4)) + ) + ) + ) + + (func (export "as-compare-left") (result i32) + (block (result i32) + (i32.le_u + (call_indirect (type $over-i32) (i32.const 1) (i32.const 4)) + (i32.const 10) + ) + ) + ) + (func (export "as-compare-right") (result i32) + (block (result i32) + (i32.ne + (i32.const 10) + (call_indirect (type $over-i32) (i32.const 1) (i32.const 4)) + ) + ) + ) + + (func (export "as-convert-operand") (result i64) + (block (result i64) + (i64.extend_i32_s + (call_indirect (type $over-i32) (i32.const 1) (i32.const 4)) + ) + ) + ) + +) + +(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-f64-i32") (f64.const 0xf64) (i32.const 32)) + +(assert_return (invoke "type-index") (i64.const 100)) + +(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_return (invoke "type-all-f64-i32") (f64.const 0xf64) (i32.const 32)) +(assert_return (invoke "type-all-i32-f64") (i32.const 1) (f64.const 2)) +(assert_return (invoke "type-all-i32-i64") (i64.const 2) (i32.const 1)) + +(assert_return (invoke "dispatch" (i32.const 5) (i64.const 2)) (i64.const 2)) +(assert_return (invoke "dispatch" (i32.const 5) (i64.const 5)) (i64.const 5)) +(assert_return (invoke "dispatch" (i32.const 12) (i64.const 5)) (i64.const 120)) +(assert_return (invoke "dispatch" (i32.const 13) (i64.const 5)) (i64.const 8)) +(assert_return (invoke "dispatch" (i32.const 20) (i64.const 2)) (i64.const 2)) +(assert_trap (invoke "dispatch" (i32.const 0) (i64.const 2)) "indirect call type mismatch") +(assert_trap (invoke "dispatch" (i32.const 15) (i64.const 2)) "indirect call type mismatch") +(assert_trap (invoke "dispatch" (i32.const 32) (i64.const 2)) "undefined element") +(assert_trap (invoke "dispatch" (i32.const -1) (i64.const 2)) "undefined element") +(assert_trap (invoke "dispatch" (i32.const 1213432423) (i64.const 2)) "undefined element") + +(assert_return (invoke "dispatch-structural-i64" (i32.const 5)) (i64.const 9)) +(assert_return (invoke "dispatch-structural-i64" (i32.const 12)) (i64.const 362880)) +(assert_return (invoke "dispatch-structural-i64" (i32.const 13)) (i64.const 55)) +(assert_return (invoke "dispatch-structural-i64" (i32.const 20)) (i64.const 9)) +(assert_trap (invoke "dispatch-structural-i64" (i32.const 11)) "indirect call type mismatch") +(assert_trap (invoke "dispatch-structural-i64" (i32.const 22)) "indirect call type mismatch") + +(assert_return (invoke "dispatch-structural-i32" (i32.const 4)) (i32.const 9)) +(assert_return (invoke "dispatch-structural-i32" (i32.const 23)) (i32.const 362880)) +(assert_return (invoke "dispatch-structural-i32" (i32.const 26)) (i32.const 55)) +(assert_return (invoke "dispatch-structural-i32" (i32.const 19)) (i32.const 9)) +(assert_trap (invoke "dispatch-structural-i32" (i32.const 9)) "indirect call type mismatch") +(assert_trap (invoke "dispatch-structural-i32" (i32.const 21)) "indirect call type mismatch") + +(assert_return (invoke "dispatch-structural-f32" (i32.const 6)) (f32.const 9.0)) +(assert_return (invoke "dispatch-structural-f32" (i32.const 24)) (f32.const 362880.0)) +(assert_return (invoke "dispatch-structural-f32" (i32.const 27)) (f32.const 55.0)) +(assert_return (invoke "dispatch-structural-f32" (i32.const 21)) (f32.const 9.0)) +(assert_trap (invoke "dispatch-structural-f32" (i32.const 8)) "indirect call type mismatch") +(assert_trap (invoke "dispatch-structural-f32" (i32.const 19)) "indirect call type mismatch") + +(assert_return (invoke "dispatch-structural-f64" (i32.const 7)) (f64.const 9.0)) +(assert_return (invoke "dispatch-structural-f64" (i32.const 25)) (f64.const 362880.0)) +(assert_return (invoke "dispatch-structural-f64" (i32.const 28)) (f64.const 55.0)) +(assert_return (invoke "dispatch-structural-f64" (i32.const 22)) (f64.const 9.0)) +(assert_trap (invoke "dispatch-structural-f64" (i32.const 10)) "indirect call type mismatch") +(assert_trap (invoke "dispatch-structural-f64" (i32.const 18)) "indirect call type mismatch") + +(assert_return (invoke "fac-i64" (i64.const 0)) (i64.const 1)) +(assert_return (invoke "fac-i64" (i64.const 1)) (i64.const 1)) +(assert_return (invoke "fac-i64" (i64.const 5)) (i64.const 120)) +(assert_return (invoke "fac-i64" (i64.const 25)) (i64.const 7034535277573963776)) + +(assert_return (invoke "fac-i32" (i32.const 0)) (i32.const 1)) +(assert_return (invoke "fac-i32" (i32.const 1)) (i32.const 1)) +(assert_return (invoke "fac-i32" (i32.const 5)) (i32.const 120)) +(assert_return (invoke "fac-i32" (i32.const 10)) (i32.const 3628800)) + +(assert_return (invoke "fac-f32" (f32.const 0.0)) (f32.const 1.0)) +(assert_return (invoke "fac-f32" (f32.const 1.0)) (f32.const 1.0)) +(assert_return (invoke "fac-f32" (f32.const 5.0)) (f32.const 120.0)) +(assert_return (invoke "fac-f32" (f32.const 10.0)) (f32.const 3628800.0)) + +(assert_return (invoke "fac-f64" (f64.const 0.0)) (f64.const 1.0)) +(assert_return (invoke "fac-f64" (f64.const 1.0)) (f64.const 1.0)) +(assert_return (invoke "fac-f64" (f64.const 5.0)) (f64.const 120.0)) +(assert_return (invoke "fac-f64" (f64.const 10.0)) (f64.const 3628800.0)) + +(assert_return (invoke "fib-i64" (i64.const 0)) (i64.const 1)) +(assert_return (invoke "fib-i64" (i64.const 1)) (i64.const 1)) +(assert_return (invoke "fib-i64" (i64.const 2)) (i64.const 2)) +(assert_return (invoke "fib-i64" (i64.const 5)) (i64.const 8)) +(assert_return (invoke "fib-i64" (i64.const 20)) (i64.const 10946)) + +(assert_return (invoke "fib-i32" (i32.const 0)) (i32.const 1)) +(assert_return (invoke "fib-i32" (i32.const 1)) (i32.const 1)) +(assert_return (invoke "fib-i32" (i32.const 2)) (i32.const 2)) +(assert_return (invoke "fib-i32" (i32.const 5)) (i32.const 8)) +(assert_return (invoke "fib-i32" (i32.const 20)) (i32.const 10946)) + +(assert_return (invoke "fib-f32" (f32.const 0.0)) (f32.const 1.0)) +(assert_return (invoke "fib-f32" (f32.const 1.0)) (f32.const 1.0)) +(assert_return (invoke "fib-f32" (f32.const 2.0)) (f32.const 2.0)) +(assert_return (invoke "fib-f32" (f32.const 5.0)) (f32.const 8.0)) +(assert_return (invoke "fib-f32" (f32.const 20.0)) (f32.const 10946.0)) + +(assert_return (invoke "fib-f64" (f64.const 0.0)) (f64.const 1.0)) +(assert_return (invoke "fib-f64" (f64.const 1.0)) (f64.const 1.0)) +(assert_return (invoke "fib-f64" (f64.const 2.0)) (f64.const 2.0)) +(assert_return (invoke "fib-f64" (f64.const 5.0)) (f64.const 8.0)) +(assert_return (invoke "fib-f64" (f64.const 20.0)) (f64.const 10946.0)) + +(assert_return (invoke "even" (i32.const 0)) (i32.const 44)) +(assert_return (invoke "even" (i32.const 1)) (i32.const 99)) +(assert_return (invoke "even" (i32.const 100)) (i32.const 44)) +(assert_return (invoke "even" (i32.const 77)) (i32.const 99)) +(assert_return (invoke "odd" (i32.const 0)) (i32.const 99)) +(assert_return (invoke "odd" (i32.const 1)) (i32.const 44)) +(assert_return (invoke "odd" (i32.const 200)) (i32.const 99)) +(assert_return (invoke "odd" (i32.const 77)) (i32.const 44)) + +(assert_exhaustion (invoke "runaway") "call stack exhausted") +(assert_exhaustion (invoke "mutual-runaway") "call stack exhausted") + +(assert_return (invoke "as-select-first") (i32.const 0x132)) +(assert_return (invoke "as-select-mid") (i32.const 2)) +(assert_return (invoke "as-select-last") (i32.const 2)) + +(assert_return (invoke "as-if-condition") (i32.const 1)) + +(assert_return (invoke "as-br_if-first") (i64.const 0x164)) +(assert_return (invoke "as-br_if-last") (i32.const 2)) + +(assert_return (invoke "as-br_table-first") (f32.const 0xf32)) +(assert_return (invoke "as-br_table-last") (i32.const 2)) + +(assert_return (invoke "as-store-first")) +(assert_return (invoke "as-store-last")) + +(assert_return (invoke "as-memory.grow-value") (i32.const 1)) +(assert_return (invoke "as-return-value") (i32.const 1)) +(assert_return (invoke "as-drop-operand")) +(assert_return (invoke "as-br-value") (f32.const 1)) +(assert_return (invoke "as-local.set-value") (f64.const 1)) +(assert_return (invoke "as-local.tee-value") (f64.const 1)) +(assert_return (invoke "as-global.set-value") (f64.const 1.0)) +(assert_return (invoke "as-load-operand") (i32.const 1)) + +(assert_return (invoke "as-unary-operand") (f32.const 0x0p+0)) +(assert_return (invoke "as-binary-left") (i32.const 11)) +(assert_return (invoke "as-binary-right") (i32.const 9)) +(assert_return (invoke "as-test-operand") (i32.const 0)) +(assert_return (invoke "as-compare-left") (i32.const 1)) +(assert_return (invoke "as-compare-right") (i32.const 1)) +(assert_return (invoke "as-convert-operand") (i64.const 1)) + + +;; Multiple tables + +(module + (type $ii-i (func (param i32 i32) (result i32))) + + (table $t1 funcref (elem $f $g)) + (table $t2 funcref (elem $h $i $j)) + (table $t3 4 funcref) + (elem (table $t3) (i32.const 0) func $g $h) + (elem (table $t3) (i32.const 3) func $z) + + (func $f (type $ii-i) (i32.add (local.get 0) (local.get 1))) + (func $g (type $ii-i) (i32.sub (local.get 0) (local.get 1))) + (func $h (type $ii-i) (i32.mul (local.get 0) (local.get 1))) + (func $i (type $ii-i) (i32.div_u (local.get 0) (local.get 1))) + (func $j (type $ii-i) (i32.rem_u (local.get 0) (local.get 1))) + (func $z) + + (func (export "call-1") (param i32 i32 i32) (result i32) + (call_indirect $t1 (type $ii-i) (local.get 0) (local.get 1) (local.get 2)) + ) + (func (export "call-2") (param i32 i32 i32) (result i32) + (call_indirect $t2 (type $ii-i) (local.get 0) (local.get 1) (local.get 2)) + ) + (func (export "call-3") (param i32 i32 i32) (result i32) + (call_indirect $t3 (type $ii-i) (local.get 0) (local.get 1) (local.get 2)) + ) +) + +(assert_return (invoke "call-1" (i32.const 2) (i32.const 3) (i32.const 0)) (i32.const 5)) +(assert_return (invoke "call-1" (i32.const 2) (i32.const 3) (i32.const 1)) (i32.const -1)) +(assert_trap (invoke "call-1" (i32.const 2) (i32.const 3) (i32.const 2)) "undefined element") + +(assert_return (invoke "call-2" (i32.const 2) (i32.const 3) (i32.const 0)) (i32.const 6)) +(assert_return (invoke "call-2" (i32.const 2) (i32.const 3) (i32.const 1)) (i32.const 0)) +(assert_return (invoke "call-2" (i32.const 2) (i32.const 3) (i32.const 2)) (i32.const 2)) +(assert_trap (invoke "call-2" (i32.const 2) (i32.const 3) (i32.const 3)) "undefined element") + +(assert_return (invoke "call-3" (i32.const 2) (i32.const 3) (i32.const 0)) (i32.const -1)) +(assert_return (invoke "call-3" (i32.const 2) (i32.const 3) (i32.const 1)) (i32.const 6)) +(assert_trap (invoke "call-3" (i32.const 2) (i32.const 3) (i32.const 2)) "uninitialized element") +(assert_trap (invoke "call-3" (i32.const 2) (i32.const 3) (i32.const 3)) "indirect call type mismatch") +(assert_trap (invoke "call-3" (i32.const 2) (i32.const 3) (i32.const 4)) "undefined element") + + +;; Invalid syntax + +(assert_malformed + (module quote + "(type $sig (func (param i32) (result i32)))" + "(table 0 funcref)" + "(func (result i32)" + " (call_indirect (type $sig) (result i32) (param i32)" + " (i32.const 0) (i32.const 0)" + " )" + ")" + ) + "unexpected token" +) +(assert_malformed + (module quote + "(type $sig (func (param i32) (result i32)))" + "(table 0 funcref)" + "(func (result i32)" + " (call_indirect (param i32) (type $sig) (result i32)" + " (i32.const 0) (i32.const 0)" + " )" + ")" + ) + "unexpected token" +) +(assert_malformed + (module quote + "(type $sig (func (param i32) (result i32)))" + "(table 0 funcref)" + "(func (result i32)" + " (call_indirect (param i32) (result i32) (type $sig)" + " (i32.const 0) (i32.const 0)" + " )" + ")" + ) + "unexpected token" +) +(assert_malformed + (module quote + "(type $sig (func (param i32) (result i32)))" + "(table 0 funcref)" + "(func (result i32)" + " (call_indirect (result i32) (type $sig) (param i32)" + " (i32.const 0) (i32.const 0)" + " )" + ")" + ) + "unexpected token" +) +(assert_malformed + (module quote + "(type $sig (func (param i32) (result i32)))" + "(table 0 funcref)" + "(func (result i32)" + " (call_indirect (result i32) (param i32) (type $sig)" + " (i32.const 0) (i32.const 0)" + " )" + ")" + ) + "unexpected token" +) +(assert_malformed + (module quote + "(table 0 funcref)" + "(func (result i32)" + " (call_indirect (result i32) (param i32) (i32.const 0) (i32.const 0))" + ")" + ) + "unexpected token" +) + +(assert_malformed + (module quote + "(table 0 funcref)" + "(func (call_indirect (param $x i32) (i32.const 0) (i32.const 0)))" + ) + "unexpected token" +) +(assert_malformed + (module quote + "(type $sig (func))" + "(table 0 funcref)" + "(func (result i32)" + " (call_indirect (type $sig) (result i32) (i32.const 0))" + ")" + ) + "inline function type" +) +(assert_malformed + (module quote + "(type $sig (func (param i32) (result i32)))" + "(table 0 funcref)" + "(func (result i32)" + " (call_indirect (type $sig) (result i32) (i32.const 0))" + ")" + ) + "inline function type" +) +(assert_malformed + (module quote + "(type $sig (func (param i32) (result i32)))" + "(table 0 funcref)" + "(func" + " (call_indirect (type $sig) (param i32) (i32.const 0) (i32.const 0))" + ")" + ) + "inline function type" +) +(assert_malformed + (module quote + "(type $sig (func (param i32 i32) (result i32)))" + "(table 0 funcref)" + "(func (result i32)" + " (call_indirect (type $sig) (param i32) (result i32)" + " (i32.const 0) (i32.const 0)" + " )" + ")" + ) + "inline function type" +) + +;; Invalid typing + +(assert_invalid + (module + (type (func)) + (func $no-table (call_indirect (type 0) (i32.const 0))) + ) + "unknown table" +) + +(assert_invalid + (module + (type (func)) + (table 0 funcref) + (func $type-void-vs-num (i32.eqz (call_indirect (type 0) (i32.const 0)))) + ) + "type mismatch" +) +(assert_invalid + (module + (type (func (result i64))) + (table 0 funcref) + (func $type-num-vs-num (i32.eqz (call_indirect (type 0) (i32.const 0)))) + ) + "type mismatch" +) + +(assert_invalid + (module + (type (func (param i32))) + (table 0 funcref) + (func $arity-0-vs-1 (call_indirect (type 0) (i32.const 0))) + ) + "type mismatch" +) +(assert_invalid + (module + (type (func (param f64 i32))) + (table 0 funcref) + (func $arity-0-vs-2 (call_indirect (type 0) (i32.const 0))) + ) + "type mismatch" +) +(assert_invalid + (module + (type (func)) + (table 0 funcref) + (func $arity-1-vs-0 (call_indirect (type 0) (i32.const 1) (i32.const 0))) + ) + "type mismatch" +) +(assert_invalid + (module + (type (func)) + (table 0 funcref) + (func $arity-2-vs-0 + (call_indirect (type 0) (f64.const 2) (i32.const 1) (i32.const 0)) + ) + ) + "type mismatch" +) + +(assert_invalid + (module + (type (func (param i32))) + (table 0 funcref) + (func $type-func-void-vs-i32 (call_indirect (type 0) (i32.const 1) (nop))) + ) + "type mismatch" +) +(assert_invalid + (module + (type (func (param i32))) + (table 0 funcref) + (func $type-func-num-vs-i32 (call_indirect (type 0) (i32.const 0) (i64.const 1))) + ) + "type mismatch" +) + +(assert_invalid + (module + (type (func (param i32 i32))) + (table 0 funcref) + (func $type-first-void-vs-num + (call_indirect (type 0) (nop) (i32.const 1) (i32.const 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (type (func (param i32 i32))) + (table 0 funcref) + (func $type-second-void-vs-num + (call_indirect (type 0) (i32.const 1) (nop) (i32.const 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (type (func (param i32 f64))) + (table 0 funcref) + (func $type-first-num-vs-num + (call_indirect (type 0) (f64.const 1) (i32.const 1) (i32.const 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (type (func (param f64 i32))) + (table 0 funcref) + (func $type-second-num-vs-num + (call_indirect (type 0) (i32.const 1) (f64.const 1) (i32.const 0)) + ) + ) + "type mismatch" +) + +(assert_invalid + (module + (func $f (param i32)) + (type $sig (func (param i32))) + (table funcref (elem $f)) + (func $type-first-empty-in-block + (block + (call_indirect (type $sig) (i32.const 0)) + ) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $f (param i32 i32)) + (type $sig (func (param i32 i32))) + (table funcref (elem $f)) + (func $type-second-empty-in-block + (block + (call_indirect (type $sig) (i32.const 0) (i32.const 0)) + ) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $f (param i32)) + (type $sig (func (param i32))) + (table funcref (elem $f)) + (func $type-first-empty-in-loop + (loop + (call_indirect (type $sig) (i32.const 0)) + ) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $f (param i32 i32)) + (type $sig (func (param i32 i32))) + (table funcref (elem $f)) + (func $type-second-empty-in-loop + (loop + (call_indirect (type $sig) (i32.const 0) (i32.const 0)) + ) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $f (param i32)) + (type $sig (func (param i32))) + (table funcref (elem $f)) + (func $type-first-empty-in-then + (i32.const 0) (i32.const 0) + (if + (then + (call_indirect (type $sig) (i32.const 0)) + ) + ) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $f (param i32 i32)) + (type $sig (func (param i32 i32))) + (table funcref (elem $f)) + (func $type-second-empty-in-then + (i32.const 0) (i32.const 0) + (if + (then + (call_indirect (type $sig) (i32.const 0) (i32.const 0)) + ) + ) + ) + ) + "type mismatch" +) + + +;; Unbound type + +(assert_invalid + (module + (table 0 funcref) + (func $unbound-type (call_indirect (type 1) (i32.const 0))) + ) + "unknown type" +) +(assert_invalid + (module + (table 0 funcref) + (func $large-type (call_indirect (type 1012321300) (i32.const 0))) + ) + "unknown type" +) + + +;; Unbound function in table + +(assert_invalid + (module (table funcref (elem 0 0))) + "unknown function" +) diff --git a/runtime/near-vm/tests/wast/spec/comments.wast b/runtime/near-vm/tests/wast/spec/comments.wast new file mode 100644 index 00000000000..90a64b42d9e Binary files /dev/null and b/runtime/near-vm/tests/wast/spec/comments.wast differ diff --git a/runtime/near-vm/tests/wast/spec/const.wast b/runtime/near-vm/tests/wast/spec/const.wast new file mode 100644 index 00000000000..56565029870 --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/const.wast @@ -0,0 +1,1061 @@ +;; Test t.const instructions + +;; Syntax error + +(module (func (i32.const 0_123_456_789) drop)) +(module (func (i32.const 0x0_9acf_fBDF) drop)) +(assert_malformed + (module quote "(func (i32.const) drop)") + "unexpected token" +) +(assert_malformed + (module quote "(func (i32.const 0x) drop)") + "unknown operator" +) +(assert_malformed + (module quote "(func (i32.const 1x) drop)") + "unknown operator" +) +(assert_malformed + (module quote "(func (i32.const 0xg) drop)") + "unknown operator" +) + +(module (func (i64.const 0_123_456_789) drop)) +(module (func (i64.const 0x0125_6789_ADEF_bcef) drop)) +(assert_malformed + (module quote "(func (i64.const) drop)") + "unexpected token" +) +(assert_malformed + (module quote "(func (i64.const 0x) drop)") + "unknown operator" +) +(assert_malformed + (module quote "(func (i64.const 1x) drop)") + "unknown operator" +) +(assert_malformed + (module quote "(func (i64.const 0xg) drop)") + "unknown operator" +) + +(module (func (f32.const 0123456789) drop)) +(module (func (f32.const 0123456789e019) drop)) +(module (func (f32.const 0123456789e+019) drop)) +(module (func (f32.const 0123456789e-019) drop)) +(module (func (f32.const 0123456789.) drop)) +(module (func (f32.const 0123456789.e019) drop)) +(module (func (f32.const 0123456789.e+019) drop)) +(module (func (f32.const 0123456789.e-019) drop)) +(module (func (f32.const 0123456789.0123456789) drop)) +(module (func (f32.const 0123456789.0123456789e019) drop)) +(module (func (f32.const 0123456789.0123456789e+019) drop)) +(module (func (f32.const 0123456789.0123456789e-019) drop)) +(module (func (f32.const 0x0123456789ABCDEF) drop)) +(module (func (f32.const 0x0123456789ABCDEFp019) drop)) +(module (func (f32.const 0x0123456789ABCDEFp+019) drop)) +(module (func (f32.const 0x0123456789ABCDEFp-019) drop)) +(module (func (f32.const 0x0123456789ABCDEF.) drop)) +(module (func (f32.const 0x0123456789ABCDEF.p019) drop)) +(module (func (f32.const 0x0123456789ABCDEF.p+019) drop)) +(module (func (f32.const 0x0123456789ABCDEF.p-019) drop)) +(module (func (f32.const 0x0123456789ABCDEF.019aF) drop)) +(module (func (f32.const 0x0123456789ABCDEF.019aFp019) drop)) +(module (func (f32.const 0x0123456789ABCDEF.019aFp+019) drop)) +(module (func (f32.const 0x0123456789ABCDEF.019aFp-019) drop)) +(assert_malformed + (module quote "(func (f32.const) drop)") + "unexpected token" +) +(assert_malformed + (module quote "(func (f32.const .0) drop)") + "unknown operator" +) +(assert_malformed + (module quote "(func (f32.const .0e0) drop)") + "unknown operator" +) +(assert_malformed + (module quote "(func (f32.const 0e) drop)") + "unknown operator" +) +(assert_malformed + (module quote "(func (f32.const 0e+) drop)") + "unknown operator" +) +(assert_malformed + (module quote "(func (f32.const 0.0e) drop)") + "unknown operator" +) +(assert_malformed + (module quote "(func (f32.const 0.0e-) drop)") + "unknown operator" +) +(assert_malformed + (module quote "(func (f32.const 0x) drop)") + "unknown operator" +) +(assert_malformed + (module quote "(func (f32.const 1x) drop)") + "unknown operator" +) +(assert_malformed + (module quote "(func (f32.const 0xg) drop)") + "unknown operator" +) +(assert_malformed + (module quote "(func (f32.const 0x.) drop)") + "unknown operator" +) +(assert_malformed + (module quote "(func (f32.const 0x0.g) drop)") + "unknown operator" +) +(assert_malformed + (module quote "(func (f32.const 0x0p) drop)") + "unknown operator" +) +(assert_malformed + (module quote "(func (f32.const 0x0p+) drop)") + "unknown operator" +) +(assert_malformed + (module quote "(func (f32.const 0x0p-) drop)") + "unknown operator" +) +(assert_malformed + (module quote "(func (f32.const 0x0.0p) drop)") + "unknown operator" +) +(assert_malformed + (module quote "(func (f32.const 0x0.0p+) drop)") + "unknown operator" +) +(assert_malformed + (module quote "(func (f32.const 0x0.0p-) drop)") + "unknown operator" +) +(assert_malformed + (module quote "(func (f32.const 0x0pA) drop)") + "unknown operator" +) + + +(module (func (f64.const 0123456789) drop)) +(module (func (f64.const 0123456789e019) drop)) +(module (func (f64.const 0123456789e+019) drop)) +(module (func (f64.const 0123456789e-019) drop)) +(module (func (f64.const 0123456789.) drop)) +(module (func (f64.const 0123456789.e019) drop)) +(module (func (f64.const 0123456789.e+019) drop)) +(module (func (f64.const 0123456789.e-019) drop)) +(module (func (f64.const 0123456789.0123456789) drop)) +(module (func (f64.const 0123456789.0123456789e019) drop)) +(module (func (f64.const 0123456789.0123456789e+019) drop)) +(module (func (f64.const 0123456789.0123456789e-019) drop)) +(module (func (f64.const 0_1_2_3_4_5_6_7_8_9) drop)) +(module (func (f64.const 0_1_2_3_4_5_6_7_8_9.) drop)) +(module (func (f64.const 0_1_2_3_4_5_6_7_8_9.0_1_2_3_4_5_6_7_8_9) drop)) +(module (func (f64.const 0_1_2_3_4_5_6_7_8_9e+0_1_9) drop)) +(module (func (f64.const 0_1_2_3_4_5_6_7_8_9.e+0_1_9) drop)) +(module (func (f64.const 0_1_2_3_4_5_6_7_8_9.0_1_2_3_4_5_6_7_8_9e0_1_9) drop)) + +(module (func (f64.const 0x0123456789ABCDEFabcdef) drop)) +(module (func (f64.const 0x0123456789ABCDEFabcdefp019) drop)) +(module (func (f64.const 0x0123456789ABCDEFabcdefp+019) drop)) +(module (func (f64.const 0x0123456789ABCDEFabcdefp-019) drop)) +(module (func (f64.const 0x0123456789ABCDEFabcdef.) drop)) +(module (func (f64.const 0x0123456789ABCDEFabcdef.p019) drop)) +(module (func (f64.const 0x0123456789ABCDEFabcdef.p+019) drop)) +(module (func (f64.const 0x0123456789ABCDEFabcdef.p-019) drop)) +(module (func (f64.const 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef) drop)) +(module (func (f64.const 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019) drop)) +(module (func (f64.const 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019) drop)) +(module (func (f64.const 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019) drop)) +(module (func (f64.const 0x0_1_2_3_4_5_6_7_8_9_A_B_C_D_E_F_a_b_c_d_e_f) drop)) +(module (func (f64.const 0x0_1_2_3_4_5_6_7_8_9_A_B_C_D_E_F_a_b_c_d_e_f.) drop)) +(module (func (f64.const 0x0_1_2_3_4_5_6_7_8_9_A_B_C_D_E_F_a_b_c_d_e_f.0_1_2_3_4_5_6_7_8_9_A_B_C_D_E_F_a_b_c_d_e_f) drop)) +(module (func (f64.const 0x0_1_2_3_4_5_6_7_8_9_A_B_C_D_E_F_a_b_c_d_e_fp0_1_9) drop)) +(module (func (f64.const 0x0_1_2_3_4_5_6_7_8_9_A_B_C_D_E_F_a_b_c_d_e_f.p0_1_9) drop)) +(module (func (f64.const 0x0_1_2_3_4_5_6_7_8_9_A_B_C_D_E_F_a_b_c_d_e_f.0_1_2_3_4_5_6_7_8_9_A_B_C_D_E_F_a_b_c_d_e_fp0_1_9) drop)) + + +(assert_malformed + (module quote "(func (f64.const) drop)") + "unexpected token" +) +(assert_malformed + (module quote "(func (f64.const .0) drop)") + "unknown operator" +) +(assert_malformed + (module quote "(func (f64.const .0e0) drop)") + "unknown operator" +) +(assert_malformed + (module quote "(func (f64.const 0e) drop)") + "unknown operator" +) +(assert_malformed + (module quote "(func (f64.const 0e+) drop)") + "unknown operator" +) +(assert_malformed + (module quote "(func (f64.const 0.0e) drop)") + "unknown operator" +) +(assert_malformed + (module quote "(func (f64.const 0.0e-) drop)") + "unknown operator" +) +(assert_malformed + (module quote "(func (f64.const 0x) drop)") + "unknown operator" +) +(assert_malformed + (module quote "(func (f64.const 1x) drop)") + "unknown operator" +) +(assert_malformed + (module quote "(func (f64.const 0xg) drop)") + "unknown operator" +) +(assert_malformed + (module quote "(func (f64.const 0x.) drop)") + "unknown operator" +) +(assert_malformed + (module quote "(func (f64.const 0x0.g) drop)") + "unknown operator" +) +(assert_malformed + (module quote "(func (f64.const 0x0p) drop)") + "unknown operator" +) +(assert_malformed + (module quote "(func (f64.const 0x0p+) drop)") + "unknown operator" +) +(assert_malformed + (module quote "(func (f64.const 0x0p-) drop)") + "unknown operator" +) +(assert_malformed + (module quote "(func (f64.const 0x0.0p) drop)") + "unknown operator" +) +(assert_malformed + (module quote "(func (f64.const 0x0.0p+) drop)") + "unknown operator" +) +(assert_malformed + (module quote "(func (f64.const 0x0.0p-) drop)") + "unknown operator" +) +(assert_malformed + (module quote "(func (f64.const 0x0pA) drop)") + "unknown operator" +) + + +;; Range error + +(module (func (i32.const 0xffffffff) drop)) +(module (func (i32.const -0x80000000) drop)) +(assert_malformed + (module quote "(func (i32.const 0x100000000) drop)") + "constant out of range" +) +(assert_malformed + (module quote "(func (i32.const -0x80000001) drop)") + "constant out of range" +) + +(module (func (i32.const 4294967295) drop)) +(module (func (i32.const -2147483648) drop)) +(assert_malformed + (module quote "(func (i32.const 4294967296) drop)") + "constant out of range" +) +(assert_malformed + (module quote "(func (i32.const -2147483649) drop)") + "constant out of range" +) + +(module (func (i64.const 0xffffffffffffffff) drop)) +(module (func (i64.const -0x8000000000000000) drop)) +(assert_malformed + (module quote "(func (i64.const 0x10000000000000000) drop)") + "constant out of range" +) +(assert_malformed + (module quote "(func (i64.const -0x8000000000000001) drop)") + "constant out of range" +) + +(module (func (i64.const 18446744073709551615) drop)) +(module (func (i64.const -9223372036854775808) drop)) +(assert_malformed + (module quote "(func (i64.const 18446744073709551616) drop)") + "constant out of range" +) +(assert_malformed + (module quote "(func (i64.const -9223372036854775809) drop)") + "constant out of range" +) + +(module (func (f32.const 0x1p127) drop)) +(module (func (f32.const -0x1p127) drop)) +(module (func (f32.const 0x1.fffffep127) drop)) +(module (func (f32.const -0x1.fffffep127) drop)) +(module (func (f32.const 0x1.fffffe7p127) drop)) +(module (func (f32.const -0x1.fffffe7p127) drop)) +(module (func (f32.const 0x1.fffffefffffff8000000p127) drop)) +(module (func (f32.const -0x1.fffffefffffff8000000p127) drop)) +(module (func (f32.const 0x1.fffffefffffffffffffp127) drop)) +(module (func (f32.const -0x1.fffffefffffffffffffp127) drop)) +(assert_malformed + (module quote "(func (f32.const 0x1p128) drop)") + "constant out of range" +) +(assert_malformed + (module quote "(func (f32.const -0x1p128) drop)") + "constant out of range" +) +(assert_malformed + (module quote "(func (f32.const 0x1.ffffffp127) drop)") + "constant out of range" +) +(assert_malformed + (module quote "(func (f32.const -0x1.ffffffp127) drop)") + "constant out of range" +) + +(module (func (f32.const 1e38) drop)) +(module (func (f32.const -1e38) drop)) +(assert_malformed + (module quote "(func (f32.const 1e39) drop)") + "constant out of range" +) +(assert_malformed + (module quote "(func (f32.const -1e39) drop)") + "constant out of range" +) + +(module (func (f32.const 340282356779733623858607532500980858880) drop)) +(module (func (f32.const -340282356779733623858607532500980858880) drop)) +(assert_malformed + (module quote "(func (f32.const 340282356779733661637539395458142568448) drop)") + "constant out of range" +) +(assert_malformed + (module quote "(func (f32.const -340282356779733661637539395458142568448) drop)") + "constant out of range" +) + +(module (func (f64.const 0x1p1023) drop)) +(module (func (f64.const -0x1p1023) drop)) +(module (func (f64.const 0x1.fffffffffffffp1023) drop)) +(module (func (f64.const -0x1.fffffffffffffp1023) drop)) +(module (func (f64.const 0x1.fffffffffffff7p1023) drop)) +(module (func (f64.const -0x1.fffffffffffff7p1023) drop)) +(module (func (f64.const 0x1.fffffffffffff7ffffffp1023) drop)) +(module (func (f64.const -0x1.fffffffffffff7ffffffp1023) drop)) +(assert_malformed + (module quote "(func (f64.const 0x1p1024) drop)") + "constant out of range" +) +(assert_malformed + (module quote "(func (f64.const -0x1p1024) drop)") + "constant out of range" +) +(assert_malformed + (module quote "(func (f64.const 0x1.fffffffffffff8p1023) drop)") + "constant out of range" +) +(assert_malformed + (module quote "(func (f64.const -0x1.fffffffffffff8p1023) drop)") + "constant out of range" +) + +(module (func (f64.const 1e308) drop)) +(module (func (f64.const -1e308) drop)) +(assert_malformed + (module quote "(func (f64.const 1e309) drop)") + "constant out of range" +) +(assert_malformed + (module quote "(func (f64.const -1e309) drop)") + "constant out of range" +) + +(module (func (f64.const 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368) drop)) +(module (func (f64.const -179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368) drop)) +(assert_malformed + (module quote "(func (f64.const 269653970229347356221791135597556535197105851288767494898376215204735891170042808140884337949150317257310688430271573696351481990334196274152701320055306275479074865864826923114368235135583993416113802762682700913456874855354834422248712838998185022412196739306217084753107265771378949821875606039276187287552) drop)") + "constant out of range" +) +(assert_malformed + (module quote "(func (f64.const -269653970229347356221791135597556535197105851288767494898376215204735891170042808140884337949150317257310688430271573696351481990334196274152701320055306275479074865864826923114368235135583993416113802762682700913456874855354834422248712838998185022412196739306217084753107265771378949821875606039276187287552) drop)") + "constant out of range" +) + +(module (func (f32.const nan:0x1) drop)) +(module (func (f64.const nan:0x1) drop)) +(module (func (f32.const nan:0x7f_ffff) drop)) +(module (func (f64.const nan:0xf_ffff_ffff_ffff) drop)) + +(assert_malformed + (module quote "(func (f32.const nan:1) drop)") + "unknown operator" +) +(assert_malformed + (module quote "(func (f64.const nan:1) drop)") + "unknown operator" +) + +(assert_malformed + (module quote "(func (f32.const nan:0x0) drop)") + "constant out of range" +) +(assert_malformed + (module quote "(func (f64.const nan:0x0) drop)") + "constant out of range" +) + +(assert_malformed + (module quote "(func (f32.const nan:0x80_0000) drop)") + "constant out of range" +) +(assert_malformed + (module quote "(func (f64.const nan:0x10_0000_0000_0000) drop)") + "constant out of range" +) + + +;; Rounding behaviour + +;; f32, small exponent +(module (func (export "f") (result f32) (f32.const +0x1.00000100000000000p-50))) +(assert_return (invoke "f") (f32.const +0x1.000000p-50)) +(module (func (export "f") (result f32) (f32.const -0x1.00000100000000000p-50))) +(assert_return (invoke "f") (f32.const -0x1.000000p-50)) +(module (func (export "f") (result f32) (f32.const +0x1.00000100000000001p-50))) +(assert_return (invoke "f") (f32.const +0x1.000002p-50)) +(module (func (export "f") (result f32) (f32.const -0x1.00000100000000001p-50))) +(assert_return (invoke "f") (f32.const -0x1.000002p-50)) +(module (func (export "f") (result f32) (f32.const +0x1.000001fffffffffffp-50))) +(assert_return (invoke "f") (f32.const +0x1.000002p-50)) +(module (func (export "f") (result f32) (f32.const -0x1.000001fffffffffffp-50))) +(assert_return (invoke "f") (f32.const -0x1.000002p-50)) +(module (func (export "f") (result f32) (f32.const +0x1.00000200000000000p-50))) +(assert_return (invoke "f") (f32.const +0x1.000002p-50)) +(module (func (export "f") (result f32) (f32.const -0x1.00000200000000000p-50))) +(assert_return (invoke "f") (f32.const -0x1.000002p-50)) +(module (func (export "f") (result f32) (f32.const +0x1.00000200000000001p-50))) +(assert_return (invoke "f") (f32.const +0x1.000002p-50)) +(module (func (export "f") (result f32) (f32.const -0x1.00000200000000001p-50))) +(assert_return (invoke "f") (f32.const -0x1.000002p-50)) +(module (func (export "f") (result f32) (f32.const +0x1.000002fffffffffffp-50))) +(assert_return (invoke "f") (f32.const +0x1.000002p-50)) +(module (func (export "f") (result f32) (f32.const -0x1.000002fffffffffffp-50))) +(assert_return (invoke "f") (f32.const -0x1.000002p-50)) +(module (func (export "f") (result f32) (f32.const +0x1.00000300000000000p-50))) +(assert_return (invoke "f") (f32.const +0x1.000004p-50)) +(module (func (export "f") (result f32) (f32.const -0x1.00000300000000000p-50))) +(assert_return (invoke "f") (f32.const -0x1.000004p-50)) +(module (func (export "f") (result f32) (f32.const +0x1.00000300000000001p-50))) +(assert_return (invoke "f") (f32.const +0x1.000004p-50)) +(module (func (export "f") (result f32) (f32.const -0x1.00000300000000001p-50))) +(assert_return (invoke "f") (f32.const -0x1.000004p-50)) +(module (func (export "f") (result f32) (f32.const +0x1.000003fffffffffffp-50))) +(assert_return (invoke "f") (f32.const +0x1.000004p-50)) +(module (func (export "f") (result f32) (f32.const -0x1.000003fffffffffffp-50))) +(assert_return (invoke "f") (f32.const -0x1.000004p-50)) +(module (func (export "f") (result f32) (f32.const +0x1.00000400000000000p-50))) +(assert_return (invoke "f") (f32.const +0x1.000004p-50)) +(module (func (export "f") (result f32) (f32.const -0x1.00000400000000000p-50))) +(assert_return (invoke "f") (f32.const -0x1.000004p-50)) +(module (func (export "f") (result f32) (f32.const +0x1.00000400000000001p-50))) +(assert_return (invoke "f") (f32.const +0x1.000004p-50)) +(module (func (export "f") (result f32) (f32.const -0x1.00000400000000001p-50))) +(assert_return (invoke "f") (f32.const -0x1.000004p-50)) +(module (func (export "f") (result f32) (f32.const +0x1.000004fffffffffffp-50))) +(assert_return (invoke "f") (f32.const +0x1.000004p-50)) +(module (func (export "f") (result f32) (f32.const -0x1.000004fffffffffffp-50))) +(assert_return (invoke "f") (f32.const -0x1.000004p-50)) +(module (func (export "f") (result f32) (f32.const +0x1.00000500000000000p-50))) +(assert_return (invoke "f") (f32.const +0x1.000004p-50)) +(module (func (export "f") (result f32) (f32.const -0x1.00000500000000000p-50))) +(assert_return (invoke "f") (f32.const -0x1.000004p-50)) +(module (func (export "f") (result f32) (f32.const +0x1.00000500000000001p-50))) +(assert_return (invoke "f") (f32.const +0x1.000006p-50)) +(module (func (export "f") (result f32) (f32.const -0x1.00000500000000001p-50))) +(assert_return (invoke "f") (f32.const -0x1.000006p-50)) + +(module (func (export "f") (result f32) (f32.const +0x4000.004000000p-64))) +(assert_return (invoke "f") (f32.const +0x1.000000p-50)) +(module (func (export "f") (result f32) (f32.const -0x4000.004000000p-64))) +(assert_return (invoke "f") (f32.const -0x1.000000p-50)) +(module (func (export "f") (result f32) (f32.const +0x4000.004000001p-64))) +(assert_return (invoke "f") (f32.const +0x1.000002p-50)) +(module (func (export "f") (result f32) (f32.const -0x4000.004000001p-64))) +(assert_return (invoke "f") (f32.const -0x1.000002p-50)) +(module (func (export "f") (result f32) (f32.const +0x4000.007ffffffp-64))) +(assert_return (invoke "f") (f32.const +0x1.000002p-50)) +(module (func (export "f") (result f32) (f32.const -0x4000.007ffffffp-64))) +(assert_return (invoke "f") (f32.const -0x1.000002p-50)) +(module (func (export "f") (result f32) (f32.const +0x4000.008000000p-64))) +(assert_return (invoke "f") (f32.const +0x1.000002p-50)) +(module (func (export "f") (result f32) (f32.const -0x4000.008000000p-64))) +(assert_return (invoke "f") (f32.const -0x1.000002p-50)) +(module (func (export "f") (result f32) (f32.const +0x4000.008000001p-64))) +(assert_return (invoke "f") (f32.const +0x1.000002p-50)) +(module (func (export "f") (result f32) (f32.const -0x4000.008000001p-64))) +(assert_return (invoke "f") (f32.const -0x1.000002p-50)) +(module (func (export "f") (result f32) (f32.const +0x4000.00bffffffp-64))) +(assert_return (invoke "f") (f32.const +0x1.000002p-50)) +(module (func (export "f") (result f32) (f32.const -0x4000.00bffffffp-64))) +(assert_return (invoke "f") (f32.const -0x1.000002p-50)) +(module (func (export "f") (result f32) (f32.const +0x4000.00c000000p-64))) +(assert_return (invoke "f") (f32.const +0x1.000004p-50)) +(module (func (export "f") (result f32) (f32.const -0x4000.00c000000p-64))) +(assert_return (invoke "f") (f32.const -0x1.000004p-50)) +(module (func (export "f") (result f32) (f32.const +0x4000.00c000001p-64))) +(assert_return (invoke "f") (f32.const +0x1.000004p-50)) +(module (func (export "f") (result f32) (f32.const -0x4000.00c000001p-64))) +(assert_return (invoke "f") (f32.const -0x1.000004p-50)) +(module (func (export "f") (result f32) (f32.const +0x4000.00fffffffp-64))) +(assert_return (invoke "f") (f32.const +0x1.000004p-50)) +(module (func (export "f") (result f32) (f32.const -0x4000.00fffffffp-64))) +(assert_return (invoke "f") (f32.const -0x1.000004p-50)) +(module (func (export "f") (result f32) (f32.const +0x4000.010000001p-64))) +(assert_return (invoke "f") (f32.const +0x1.000004p-50)) +(module (func (export "f") (result f32) (f32.const -0x4000.010000001p-64))) +(assert_return (invoke "f") (f32.const -0x1.000004p-50)) +(module (func (export "f") (result f32) (f32.const +0x4000.013ffffffp-64))) +(assert_return (invoke "f") (f32.const +0x1.000004p-50)) +(module (func (export "f") (result f32) (f32.const -0x4000.013ffffffp-64))) +(assert_return (invoke "f") (f32.const -0x1.000004p-50)) +(module (func (export "f") (result f32) (f32.const +0x4000.014000001p-64))) +(assert_return (invoke "f") (f32.const +0x1.000006p-50)) +(module (func (export "f") (result f32) (f32.const -0x4000.014000001p-64))) +(assert_return (invoke "f") (f32.const -0x1.000006p-50)) + +(module (func (export "f") (result f32) (f32.const +8.8817847263968443573e-16))) +(assert_return (invoke "f") (f32.const +0x1.000000p-50)) +(module (func (export "f") (result f32) (f32.const -8.8817847263968443573e-16))) +(assert_return (invoke "f") (f32.const -0x1.000000p-50)) +(module (func (export "f") (result f32) (f32.const +8.8817847263968443574e-16))) +(assert_return (invoke "f") (f32.const +0x1.000002p-50)) +(module (func (export "f") (result f32) (f32.const -8.8817847263968443574e-16))) +(assert_return (invoke "f") (f32.const -0x1.000002p-50)) +(module (func (export "f") (result f32) (f32.const +8.8817857851880284252e-16))) +(assert_return (invoke "f") (f32.const +0x1.000002p-50)) +(module (func (export "f") (result f32) (f32.const -8.8817857851880284252e-16))) +(assert_return (invoke "f") (f32.const -0x1.000002p-50)) +(module (func (export "f") (result f32) (f32.const +8.8817857851880284253e-16))) +(assert_return (invoke "f") (f32.const +0x1.000004p-50)) +(module (func (export "f") (result f32) (f32.const -8.8817857851880284253e-16))) +(assert_return (invoke "f") (f32.const -0x1.000004p-50)) + +;; f32, large exponent +(module (func (export "f") (result f32) (f32.const +0x1.00000100000000000p+50))) +(assert_return (invoke "f") (f32.const +0x1.000000p+50)) +(module (func (export "f") (result f32) (f32.const -0x1.00000100000000000p+50))) +(assert_return (invoke "f") (f32.const -0x1.000000p+50)) +(module (func (export "f") (result f32) (f32.const +0x1.00000100000000001p+50))) +(assert_return (invoke "f") (f32.const +0x1.000002p+50)) +(module (func (export "f") (result f32) (f32.const -0x1.00000100000000001p+50))) +(assert_return (invoke "f") (f32.const -0x1.000002p+50)) +(module (func (export "f") (result f32) (f32.const +0x1.000001fffffffffffp+50))) +(assert_return (invoke "f") (f32.const +0x1.000002p+50)) +(module (func (export "f") (result f32) (f32.const -0x1.000001fffffffffffp+50))) +(assert_return (invoke "f") (f32.const -0x1.000002p+50)) +(module (func (export "f") (result f32) (f32.const +0x1.00000200000000000p+50))) +(assert_return (invoke "f") (f32.const +0x1.000002p+50)) +(module (func (export "f") (result f32) (f32.const -0x1.00000200000000000p+50))) +(assert_return (invoke "f") (f32.const -0x1.000002p+50)) +(module (func (export "f") (result f32) (f32.const +0x1.00000200000000001p+50))) +(assert_return (invoke "f") (f32.const +0x1.000002p+50)) +(module (func (export "f") (result f32) (f32.const -0x1.00000200000000001p+50))) +(assert_return (invoke "f") (f32.const -0x1.000002p+50)) +(module (func (export "f") (result f32) (f32.const +0x1.000002fffffffffffp+50))) +(assert_return (invoke "f") (f32.const +0x1.000002p+50)) +(module (func (export "f") (result f32) (f32.const -0x1.000002fffffffffffp+50))) +(assert_return (invoke "f") (f32.const -0x1.000002p+50)) +(module (func (export "f") (result f32) (f32.const +0x1.00000300000000000p+50))) +(assert_return (invoke "f") (f32.const +0x1.000004p+50)) +(module (func (export "f") (result f32) (f32.const -0x1.00000300000000000p+50))) +(assert_return (invoke "f") (f32.const -0x1.000004p+50)) +(module (func (export "f") (result f32) (f32.const +0x1.00000300000000001p+50))) +(assert_return (invoke "f") (f32.const +0x1.000004p+50)) +(module (func (export "f") (result f32) (f32.const -0x1.00000300000000001p+50))) +(assert_return (invoke "f") (f32.const -0x1.000004p+50)) +(module (func (export "f") (result f32) (f32.const +0x1.000003fffffffffffp+50))) +(assert_return (invoke "f") (f32.const +0x1.000004p+50)) +(module (func (export "f") (result f32) (f32.const -0x1.000003fffffffffffp+50))) +(assert_return (invoke "f") (f32.const -0x1.000004p+50)) +(module (func (export "f") (result f32) (f32.const +0x1.00000400000000000p+50))) +(assert_return (invoke "f") (f32.const +0x1.000004p+50)) +(module (func (export "f") (result f32) (f32.const -0x1.00000400000000000p+50))) +(assert_return (invoke "f") (f32.const -0x1.000004p+50)) +(module (func (export "f") (result f32) (f32.const +0x1.00000400000000001p+50))) +(assert_return (invoke "f") (f32.const +0x1.000004p+50)) +(module (func (export "f") (result f32) (f32.const -0x1.00000400000000001p+50))) +(assert_return (invoke "f") (f32.const -0x1.000004p+50)) +(module (func (export "f") (result f32) (f32.const +0x1.000004fffffffffffp+50))) +(assert_return (invoke "f") (f32.const +0x1.000004p+50)) +(module (func (export "f") (result f32) (f32.const -0x1.000004fffffffffffp+50))) +(assert_return (invoke "f") (f32.const -0x1.000004p+50)) +(module (func (export "f") (result f32) (f32.const +0x1.00000500000000000p+50))) +(assert_return (invoke "f") (f32.const +0x1.000004p+50)) +(module (func (export "f") (result f32) (f32.const -0x1.00000500000000000p+50))) +(assert_return (invoke "f") (f32.const -0x1.000004p+50)) +(module (func (export "f") (result f32) (f32.const +0x1.00000500000000001p+50))) +(assert_return (invoke "f") (f32.const +0x1.000006p+50)) +(module (func (export "f") (result f32) (f32.const -0x1.00000500000000001p+50))) +(assert_return (invoke "f") (f32.const -0x1.000006p+50)) + +(module (func (export "f") (result f32) (f32.const +0x4000004000000))) +(assert_return (invoke "f") (f32.const +0x1.000000p+50)) +(module (func (export "f") (result f32) (f32.const -0x4000004000000))) +(assert_return (invoke "f") (f32.const -0x1.000000p+50)) +(module (func (export "f") (result f32) (f32.const +0x4000004000001))) +(assert_return (invoke "f") (f32.const +0x1.000002p+50)) +(module (func (export "f") (result f32) (f32.const -0x4000004000001))) +(assert_return (invoke "f") (f32.const -0x1.000002p+50)) +(module (func (export "f") (result f32) (f32.const +0x4000007ffffff))) +(assert_return (invoke "f") (f32.const +0x1.000002p+50)) +(module (func (export "f") (result f32) (f32.const -0x4000007ffffff))) +(assert_return (invoke "f") (f32.const -0x1.000002p+50)) +(module (func (export "f") (result f32) (f32.const +0x4000008000000))) +(assert_return (invoke "f") (f32.const +0x1.000002p+50)) +(module (func (export "f") (result f32) (f32.const -0x4000008000000))) +(assert_return (invoke "f") (f32.const -0x1.000002p+50)) +(module (func (export "f") (result f32) (f32.const +0x4000008000001))) +(assert_return (invoke "f") (f32.const +0x1.000002p+50)) +(module (func (export "f") (result f32) (f32.const -0x4000008000001))) +(assert_return (invoke "f") (f32.const -0x1.000002p+50)) +(module (func (export "f") (result f32) (f32.const +0x400000bffffff))) +(assert_return (invoke "f") (f32.const +0x1.000002p+50)) +(module (func (export "f") (result f32) (f32.const -0x400000bffffff))) +(assert_return (invoke "f") (f32.const -0x1.000002p+50)) +(module (func (export "f") (result f32) (f32.const +0x400000c000000))) +(assert_return (invoke "f") (f32.const +0x1.000004p+50)) +(module (func (export "f") (result f32) (f32.const -0x400000c000000))) +(assert_return (invoke "f") (f32.const -0x1.000004p+50)) + +(module (func (export "f") (result f32) (f32.const +1125899973951488))) +(assert_return (invoke "f") (f32.const +0x1.000000p+50)) +(module (func (export "f") (result f32) (f32.const -1125899973951488))) +(assert_return (invoke "f") (f32.const -0x1.000000p+50)) +(module (func (export "f") (result f32) (f32.const +1125899973951489))) +(assert_return (invoke "f") (f32.const +0x1.000002p+50)) +(module (func (export "f") (result f32) (f32.const -1125899973951489))) +(assert_return (invoke "f") (f32.const -0x1.000002p+50)) +(module (func (export "f") (result f32) (f32.const +1125900108169215))) +(assert_return (invoke "f") (f32.const +0x1.000002p+50)) +(module (func (export "f") (result f32) (f32.const -1125900108169215))) +(assert_return (invoke "f") (f32.const -0x1.000002p+50)) +(module (func (export "f") (result f32) (f32.const +1125900108169216))) +(assert_return (invoke "f") (f32.const +0x1.000004p+50)) +(module (func (export "f") (result f32) (f32.const -1125900108169216))) +(assert_return (invoke "f") (f32.const -0x1.000004p+50)) + +;; f32, subnormal +(module (func (export "f") (result f32) (f32.const +0x0.00000100000000000p-126))) +(assert_return (invoke "f") (f32.const +0x0.000000p-126)) +(module (func (export "f") (result f32) (f32.const -0x0.00000100000000000p-126))) +(assert_return (invoke "f") (f32.const -0x0.000000p-126)) +(module (func (export "f") (result f32) (f32.const +0x0.00000100000000001p-126))) +(assert_return (invoke "f") (f32.const +0x0.000002p-126)) +(module (func (export "f") (result f32) (f32.const -0x0.00000100000000001p-126))) +(assert_return (invoke "f") (f32.const -0x0.000002p-126)) +(module (func (export "f") (result f32) (f32.const +0x0.000001fffffffffffp-126))) +(assert_return (invoke "f") (f32.const +0x0.000002p-126)) +(module (func (export "f") (result f32) (f32.const -0x0.000001fffffffffffp-126))) +(assert_return (invoke "f") (f32.const -0x0.000002p-126)) +(module (func (export "f") (result f32) (f32.const +0x0.00000200000000000p-126))) +(assert_return (invoke "f") (f32.const +0x0.000002p-126)) +(module (func (export "f") (result f32) (f32.const -0x0.00000200000000000p-126))) +(assert_return (invoke "f") (f32.const -0x0.000002p-126)) +(module (func (export "f") (result f32) (f32.const +0x0.00000200000000001p-126))) +(assert_return (invoke "f") (f32.const +0x0.000002p-126)) +(module (func (export "f") (result f32) (f32.const -0x0.00000200000000001p-126))) +(assert_return (invoke "f") (f32.const -0x0.000002p-126)) +(module (func (export "f") (result f32) (f32.const +0x0.000002fffffffffffp-126))) +(assert_return (invoke "f") (f32.const +0x0.000002p-126)) +(module (func (export "f") (result f32) (f32.const -0x0.000002fffffffffffp-126))) +(assert_return (invoke "f") (f32.const -0x0.000002p-126)) +(module (func (export "f") (result f32) (f32.const +0x0.00000300000000000p-126))) +(assert_return (invoke "f") (f32.const +0x0.000004p-126)) +(module (func (export "f") (result f32) (f32.const -0x0.00000300000000000p-126))) +(assert_return (invoke "f") (f32.const -0x0.000004p-126)) +(module (func (export "f") (result f32) (f32.const +0x0.00000300000000001p-126))) +(assert_return (invoke "f") (f32.const +0x0.000004p-126)) +(module (func (export "f") (result f32) (f32.const -0x0.00000300000000001p-126))) +(assert_return (invoke "f") (f32.const -0x0.000004p-126)) +(module (func (export "f") (result f32) (f32.const +0x0.000003fffffffffffp-126))) +(assert_return (invoke "f") (f32.const +0x0.000004p-126)) +(module (func (export "f") (result f32) (f32.const -0x0.000003fffffffffffp-126))) +(assert_return (invoke "f") (f32.const -0x0.000004p-126)) +(module (func (export "f") (result f32) (f32.const +0x0.00000400000000000p-126))) +(assert_return (invoke "f") (f32.const +0x0.000004p-126)) +(module (func (export "f") (result f32) (f32.const -0x0.00000400000000000p-126))) +(assert_return (invoke "f") (f32.const -0x0.000004p-126)) +(module (func (export "f") (result f32) (f32.const +0x0.00000400000000001p-126))) +(assert_return (invoke "f") (f32.const +0x0.000004p-126)) +(module (func (export "f") (result f32) (f32.const -0x0.00000400000000001p-126))) +(assert_return (invoke "f") (f32.const -0x0.000004p-126)) +(module (func (export "f") (result f32) (f32.const +0x0.000004fffffffffffp-126))) +(assert_return (invoke "f") (f32.const +0x0.000004p-126)) +(module (func (export "f") (result f32) (f32.const -0x0.000004fffffffffffp-126))) +(assert_return (invoke "f") (f32.const -0x0.000004p-126)) +(module (func (export "f") (result f32) (f32.const +0x0.00000500000000000p-126))) +(assert_return (invoke "f") (f32.const +0x0.000004p-126)) +(module (func (export "f") (result f32) (f32.const -0x0.00000500000000000p-126))) +(assert_return (invoke "f") (f32.const -0x0.000004p-126)) +(module (func (export "f") (result f32) (f32.const +0x0.00000500000000001p-126))) +(assert_return (invoke "f") (f32.const +0x0.000006p-126)) +(module (func (export "f") (result f32) (f32.const -0x0.00000500000000001p-126))) +(assert_return (invoke "f") (f32.const -0x0.000006p-126)) + +;; f32, round down at limit to infinity +(module (func (export "f") (result f32) (f32.const +0x1.fffffe8p127))) +(assert_return (invoke "f") (f32.const +0x1.fffffep127)) +(module (func (export "f") (result f32) (f32.const -0x1.fffffe8p127))) +(assert_return (invoke "f") (f32.const -0x1.fffffep127)) +(module (func (export "f") (result f32) (f32.const +0x1.fffffefffffff8p127))) +(assert_return (invoke "f") (f32.const +0x1.fffffep127)) +(module (func (export "f") (result f32) (f32.const -0x1.fffffefffffff8p127))) +(assert_return (invoke "f") (f32.const -0x1.fffffep127)) +(module (func (export "f") (result f32) (f32.const +0x1.fffffefffffffffffp127))) +(assert_return (invoke "f") (f32.const +0x1.fffffep127)) +(module (func (export "f") (result f32) (f32.const -0x1.fffffefffffffffffp127))) +(assert_return (invoke "f") (f32.const -0x1.fffffep127)) + +;; f64, small exponent +(module (func (export "f") (result f64) (f64.const +0x1.000000000000080000000000p-600))) +(assert_return (invoke "f") (f64.const +0x1.0000000000000p-600)) +(module (func (export "f") (result f64) (f64.const -0x1.000000000000080000000000p-600))) +(assert_return (invoke "f") (f64.const -0x1.0000000000000p-600)) +(module (func (export "f") (result f64) (f64.const +0x1.000000000000080000000001p-600))) +(assert_return (invoke "f") (f64.const +0x1.0000000000001p-600)) +(module (func (export "f") (result f64) (f64.const -0x1.000000000000080000000001p-600))) +(assert_return (invoke "f") (f64.const -0x1.0000000000001p-600)) +(module (func (export "f") (result f64) (f64.const +0x1.0000000000000fffffffffffp-600))) +(assert_return (invoke "f") (f64.const +0x1.0000000000001p-600)) +(module (func (export "f") (result f64) (f64.const -0x1.0000000000000fffffffffffp-600))) +(assert_return (invoke "f") (f64.const -0x1.0000000000001p-600)) +(module (func (export "f") (result f64) (f64.const +0x1.000000000000100000000000p-600))) +(assert_return (invoke "f") (f64.const +0x1.0000000000001p-600)) +(module (func (export "f") (result f64) (f64.const -0x1.000000000000100000000000p-600))) +(assert_return (invoke "f") (f64.const -0x1.0000000000001p-600)) +(module (func (export "f") (result f64) (f64.const +0x1.000000000000100000000001p-600))) +(assert_return (invoke "f") (f64.const +0x1.0000000000001p-600)) +(module (func (export "f") (result f64) (f64.const -0x1.000000000000100000000001p-600))) +(assert_return (invoke "f") (f64.const -0x1.0000000000001p-600)) +(module (func (export "f") (result f64) (f64.const +0x1.00000000000017ffffffffffp-600))) +(assert_return (invoke "f") (f64.const +0x1.0000000000001p-600)) +(module (func (export "f") (result f64) (f64.const -0x1.00000000000017ffffffffffp-600))) +(assert_return (invoke "f") (f64.const -0x1.0000000000001p-600)) +(module (func (export "f") (result f64) (f64.const +0x1.000000000000180000000000p-600))) +(assert_return (invoke "f") (f64.const +0x1.0000000000002p-600)) +(module (func (export "f") (result f64) (f64.const -0x1.000000000000180000000000p-600))) +(assert_return (invoke "f") (f64.const -0x1.0000000000002p-600)) +(module (func (export "f") (result f64) (f64.const +0x1.000000000000180000000001p-600))) +(assert_return (invoke "f") (f64.const +0x1.0000000000002p-600)) +(module (func (export "f") (result f64) (f64.const -0x1.000000000000180000000001p-600))) +(assert_return (invoke "f") (f64.const -0x1.0000000000002p-600)) +(module (func (export "f") (result f64) (f64.const +0x1.0000000000001fffffffffffp-600))) +(assert_return (invoke "f") (f64.const +0x1.0000000000002p-600)) +(module (func (export "f") (result f64) (f64.const -0x1.0000000000001fffffffffffp-600))) +(assert_return (invoke "f") (f64.const -0x1.0000000000002p-600)) +(module (func (export "f") (result f64) (f64.const +0x1.000000000000200000000000p-600))) +(assert_return (invoke "f") (f64.const +0x1.0000000000002p-600)) +(module (func (export "f") (result f64) (f64.const -0x1.000000000000200000000000p-600))) +(assert_return (invoke "f") (f64.const -0x1.0000000000002p-600)) +(module (func (export "f") (result f64) (f64.const +0x1.000000000000200000000001p-600))) +(assert_return (invoke "f") (f64.const +0x1.0000000000002p-600)) +(module (func (export "f") (result f64) (f64.const -0x1.000000000000200000000001p-600))) +(assert_return (invoke "f") (f64.const -0x1.0000000000002p-600)) +(module (func (export "f") (result f64) (f64.const +0x1.00000000000027ffffffffffp-600))) +(assert_return (invoke "f") (f64.const +0x1.0000000000002p-600)) +(module (func (export "f") (result f64) (f64.const -0x1.00000000000027ffffffffffp-600))) +(assert_return (invoke "f") (f64.const -0x1.0000000000002p-600)) +(module (func (export "f") (result f64) (f64.const +0x1.000000000000280000000001p-600))) +(assert_return (invoke "f") (f64.const +0x1.0000000000003p-600)) +(module (func (export "f") (result f64) (f64.const -0x1.000000000000280000000001p-600))) +(assert_return (invoke "f") (f64.const -0x1.0000000000003p-600)) + +(module (func (export "f") (result f64) (f64.const +0x8000000.000000400000000000p-627))) +(assert_return (invoke "f") (f64.const +0x1.0000000000000p-600)) +(module (func (export "f") (result f64) (f64.const -0x8000000.000000400000000000p-627))) +(assert_return (invoke "f") (f64.const -0x1.0000000000000p-600)) +(module (func (export "f") (result f64) (f64.const +0x8000000.000000400000000001p-627))) +(assert_return (invoke "f") (f64.const +0x1.0000000000001p-600)) +(module (func (export "f") (result f64) (f64.const -0x8000000.000000400000000001p-627))) +(assert_return (invoke "f") (f64.const -0x1.0000000000001p-600)) +(module (func (export "f") (result f64) (f64.const +0x8000000.0000007fffffffffffp-627))) +(assert_return (invoke "f") (f64.const +0x1.0000000000001p-600)) +(module (func (export "f") (result f64) (f64.const -0x8000000.0000007fffffffffffp-627))) +(assert_return (invoke "f") (f64.const -0x1.0000000000001p-600)) +(module (func (export "f") (result f64) (f64.const +0x8000000.000000800000000000p-627))) +(assert_return (invoke "f") (f64.const +0x1.0000000000001p-600)) +(module (func (export "f") (result f64) (f64.const -0x8000000.000000800000000000p-627))) +(assert_return (invoke "f") (f64.const -0x1.0000000000001p-600)) +(module (func (export "f") (result f64) (f64.const +0x8000000.000000800000000001p-627))) +(assert_return (invoke "f") (f64.const +0x1.0000000000001p-600)) +(module (func (export "f") (result f64) (f64.const -0x8000000.000000800000000001p-627))) +(assert_return (invoke "f") (f64.const -0x1.0000000000001p-600)) +(module (func (export "f") (result f64) (f64.const +0x8000000.000000bfffffffffffp-627))) +(assert_return (invoke "f") (f64.const +0x1.0000000000001p-600)) +(module (func (export "f") (result f64) (f64.const -0x8000000.000000bfffffffffffp-627))) +(assert_return (invoke "f") (f64.const -0x1.0000000000001p-600)) +(module (func (export "f") (result f64) (f64.const +0x8000000.000000c00000000000p-627))) +(assert_return (invoke "f") (f64.const +0x1.0000000000002p-600)) +(module (func (export "f") (result f64) (f64.const -0x8000000.000000c00000000000p-627))) +(assert_return (invoke "f") (f64.const -0x1.0000000000002p-600)) +(module (func (export "f") (result f64) (f64.const +0x8000000.000000c00000000001p-627))) +(assert_return (invoke "f") (f64.const +0x1.0000000000002p-600)) +(module (func (export "f") (result f64) (f64.const -0x8000000.000000c00000000001p-627))) +(assert_return (invoke "f") (f64.const -0x1.0000000000002p-600)) +(module (func (export "f") (result f64) (f64.const +0x8000000.000000ffffffffffffp-627))) +(assert_return (invoke "f") (f64.const +0x1.0000000000002p-600)) +(module (func (export "f") (result f64) (f64.const -0x8000000.000000ffffffffffffp-627))) +(assert_return (invoke "f") (f64.const -0x1.0000000000002p-600)) +(module (func (export "f") (result f64) (f64.const +0x8000000.000001000000000000p-627))) +(assert_return (invoke "f") (f64.const +0x1.0000000000002p-600)) +(module (func (export "f") (result f64) (f64.const -0x8000000.000001000000000000p-627))) +(assert_return (invoke "f") (f64.const -0x1.0000000000002p-600)) +(module (func (export "f") (result f64) (f64.const +0x8000000.000001000000000001p-627))) +(assert_return (invoke "f") (f64.const +0x1.0000000000002p-600)) +(module (func (export "f") (result f64) (f64.const -0x8000000.000001000000000001p-627))) +(assert_return (invoke "f") (f64.const -0x1.0000000000002p-600)) +(module (func (export "f") (result f64) (f64.const +0x8000000.0000013fffffffffffp-627))) +(assert_return (invoke "f") (f64.const +0x1.0000000000002p-600)) +(module (func (export "f") (result f64) (f64.const -0x8000000.0000013fffffffffffp-627))) +(assert_return (invoke "f") (f64.const -0x1.0000000000002p-600)) +(module (func (export "f") (result f64) (f64.const +0x8000000.000001400000000001p-627))) +(assert_return (invoke "f") (f64.const +0x1.0000000000003p-600)) +(module (func (export "f") (result f64) (f64.const -0x8000000.000001400000000001p-627))) +(assert_return (invoke "f") (f64.const -0x1.0000000000003p-600)) + +(module (func (export "f") (result f64) (f64.const +5.3575430359313371995e+300))) +(assert_return (invoke "f") (f64.const +0x1.0000000000000p+999)) +(module (func (export "f") (result f64) (f64.const -5.3575430359313371995e+300))) +(assert_return (invoke "f") (f64.const -0x1.0000000000000p+999)) +(module (func (export "f") (result f64) (f64.const +5.3575430359313371996e+300))) +(assert_return (invoke "f") (f64.const +0x1.0000000000001p+999)) +(module (func (export "f") (result f64) (f64.const -5.3575430359313371996e+300))) +(assert_return (invoke "f") (f64.const -0x1.0000000000001p+999)) +(module (func (export "f") (result f64) (f64.const +5.3575430359313383891e+300))) +(assert_return (invoke "f") (f64.const +0x1.0000000000001p+999)) +(module (func (export "f") (result f64) (f64.const -5.3575430359313383891e+300))) +(assert_return (invoke "f") (f64.const -0x1.0000000000001p+999)) +(module (func (export "f") (result f64) (f64.const +5.3575430359313383892e+300))) +(assert_return (invoke "f") (f64.const +0x1.0000000000002p+999)) +(module (func (export "f") (result f64) (f64.const -5.3575430359313383892e+300))) +(assert_return (invoke "f") (f64.const -0x1.0000000000002p+999)) + +;; f64, large exponent +(module (func (export "f") (result f64) (f64.const +0x1.000000000000080000000000p+600))) +(assert_return (invoke "f") (f64.const +0x1.0000000000000p+600)) +(module (func (export "f") (result f64) (f64.const -0x1.000000000000080000000000p+600))) +(assert_return (invoke "f") (f64.const -0x1.0000000000000p+600)) +(module (func (export "f") (result f64) (f64.const +0x1.000000000000080000000001p+600))) +(assert_return (invoke "f") (f64.const +0x1.0000000000001p+600)) +(module (func (export "f") (result f64) (f64.const -0x1.000000000000080000000001p+600))) +(assert_return (invoke "f") (f64.const -0x1.0000000000001p+600)) +(module (func (export "f") (result f64) (f64.const +0x1.0000000000000fffffffffffp+600))) +(assert_return (invoke "f") (f64.const +0x1.0000000000001p+600)) +(module (func (export "f") (result f64) (f64.const -0x1.0000000000000fffffffffffp+600))) +(assert_return (invoke "f") (f64.const -0x1.0000000000001p+600)) +(module (func (export "f") (result f64) (f64.const +0x1.000000000000100000000000p+600))) +(assert_return (invoke "f") (f64.const +0x1.0000000000001p+600)) +(module (func (export "f") (result f64) (f64.const -0x1.000000000000100000000000p+600))) +(assert_return (invoke "f") (f64.const -0x1.0000000000001p+600)) +(module (func (export "f") (result f64) (f64.const +0x1.000000000000100000000001p+600))) +(assert_return (invoke "f") (f64.const +0x1.0000000000001p+600)) +(module (func (export "f") (result f64) (f64.const -0x1.000000000000100000000001p+600))) +(assert_return (invoke "f") (f64.const -0x1.0000000000001p+600)) +(module (func (export "f") (result f64) (f64.const +0x1.00000000000017ffffffffffp+600))) +(assert_return (invoke "f") (f64.const +0x1.0000000000001p+600)) +(module (func (export "f") (result f64) (f64.const -0x1.00000000000017ffffffffffp+600))) +(assert_return (invoke "f") (f64.const -0x1.0000000000001p+600)) +(module (func (export "f") (result f64) (f64.const +0x1.000000000000180000000000p+600))) +(assert_return (invoke "f") (f64.const +0x1.0000000000002p+600)) +(module (func (export "f") (result f64) (f64.const -0x1.000000000000180000000000p+600))) +(assert_return (invoke "f") (f64.const -0x1.0000000000002p+600)) +(module (func (export "f") (result f64) (f64.const +0x1.000000000000180000000001p+600))) +(assert_return (invoke "f") (f64.const +0x1.0000000000002p+600)) +(module (func (export "f") (result f64) (f64.const -0x1.000000000000180000000001p+600))) +(assert_return (invoke "f") (f64.const -0x1.0000000000002p+600)) +(module (func (export "f") (result f64) (f64.const +0x1.0000000000001fffffffffffp+600))) +(assert_return (invoke "f") (f64.const +0x1.0000000000002p+600)) +(module (func (export "f") (result f64) (f64.const -0x1.0000000000001fffffffffffp+600))) +(assert_return (invoke "f") (f64.const -0x1.0000000000002p+600)) +(module (func (export "f") (result f64) (f64.const +0x1.000000000000200000000000p+600))) +(assert_return (invoke "f") (f64.const +0x1.0000000000002p+600)) +(module (func (export "f") (result f64) (f64.const -0x1.000000000000200000000000p+600))) +(assert_return (invoke "f") (f64.const -0x1.0000000000002p+600)) +(module (func (export "f") (result f64) (f64.const +0x1.000000000000200000000001p+600))) +(assert_return (invoke "f") (f64.const +0x1.0000000000002p+600)) +(module (func (export "f") (result f64) (f64.const -0x1.000000000000200000000001p+600))) +(assert_return (invoke "f") (f64.const -0x1.0000000000002p+600)) +(module (func (export "f") (result f64) (f64.const +0x1.00000000000027ffffffffffp+600))) +(assert_return (invoke "f") (f64.const +0x1.0000000000002p+600)) +(module (func (export "f") (result f64) (f64.const -0x1.00000000000027ffffffffffp+600))) +(assert_return (invoke "f") (f64.const -0x1.0000000000002p+600)) +(module (func (export "f") (result f64) (f64.const +0x1.000000000000280000000000p+600))) +(assert_return (invoke "f") (f64.const +0x1.0000000000002p+600)) +(module (func (export "f") (result f64) (f64.const -0x1.000000000000280000000000p+600))) +(assert_return (invoke "f") (f64.const -0x1.0000000000002p+600)) +(module (func (export "f") (result f64) (f64.const +0x1.000000000000280000000001p+600))) +(assert_return (invoke "f") (f64.const +0x1.0000000000003p+600)) +(module (func (export "f") (result f64) (f64.const -0x1.000000000000280000000001p+600))) +(assert_return (invoke "f") (f64.const -0x1.0000000000003p+600)) + +(module (func (export "f") (result f64) (f64.const +0x2000000000000100000000000))) +(assert_return (invoke "f") (f64.const +0x1.0000000000000p+97)) +(module (func (export "f") (result f64) (f64.const -0x2000000000000100000000000))) +(assert_return (invoke "f") (f64.const -0x1.0000000000000p+97)) +(module (func (export "f") (result f64) (f64.const +0x2000000000000100000000001))) +(assert_return (invoke "f") (f64.const +0x1.0000000000001p+97)) +(module (func (export "f") (result f64) (f64.const -0x2000000000000100000000001))) +(assert_return (invoke "f") (f64.const -0x1.0000000000001p+97)) +(module (func (export "f") (result f64) (f64.const +0x20000000000001fffffffffff))) +(assert_return (invoke "f") (f64.const +0x1.0000000000001p+97)) +(module (func (export "f") (result f64) (f64.const -0x20000000000001fffffffffff))) +(assert_return (invoke "f") (f64.const -0x1.0000000000001p+97)) +(module (func (export "f") (result f64) (f64.const +0x2000000000000200000000000))) +(assert_return (invoke "f") (f64.const +0x1.0000000000001p+97)) +(module (func (export "f") (result f64) (f64.const -0x2000000000000200000000000))) +(assert_return (invoke "f") (f64.const -0x1.0000000000001p+97)) +(module (func (export "f") (result f64) (f64.const +0x2000000000000200000000001))) +(assert_return (invoke "f") (f64.const +0x1.0000000000001p+97)) +(module (func (export "f") (result f64) (f64.const -0x2000000000000200000000001))) +(assert_return (invoke "f") (f64.const -0x1.0000000000001p+97)) +(module (func (export "f") (result f64) (f64.const +0x20000000000002fffffffffff))) +(assert_return (invoke "f") (f64.const +0x1.0000000000001p+97)) +(module (func (export "f") (result f64) (f64.const -0x20000000000002fffffffffff))) +(assert_return (invoke "f") (f64.const -0x1.0000000000001p+97)) +(module (func (export "f") (result f64) (f64.const +0x2000000000000300000000000))) +(assert_return (invoke "f") (f64.const +0x1.0000000000002p+97)) +(module (func (export "f") (result f64) (f64.const -0x2000000000000300000000000))) +(assert_return (invoke "f") (f64.const -0x1.0000000000002p+97)) +(module (func (export "f") (result f64) (f64.const +0x2000000000000300000000001))) +(assert_return (invoke "f") (f64.const +0x1.0000000000002p+97)) +(module (func (export "f") (result f64) (f64.const -0x2000000000000300000000001))) +(assert_return (invoke "f") (f64.const -0x1.0000000000002p+97)) +(module (func (export "f") (result f64) (f64.const +0x20000000000003fffffffffff))) +(assert_return (invoke "f") (f64.const +0x1.0000000000002p+97)) +(module (func (export "f") (result f64) (f64.const -0x20000000000003fffffffffff))) +(assert_return (invoke "f") (f64.const -0x1.0000000000002p+97)) +(module (func (export "f") (result f64) (f64.const +0x2000000000000400000000000))) +(assert_return (invoke "f") (f64.const +0x1.0000000000002p+97)) +(module (func (export "f") (result f64) (f64.const -0x2000000000000400000000000))) +(assert_return (invoke "f") (f64.const -0x1.0000000000002p+97)) +(module (func (export "f") (result f64) (f64.const +0x2000000000000400000000001))) +(assert_return (invoke "f") (f64.const +0x1.0000000000002p+97)) +(module (func (export "f") (result f64) (f64.const -0x2000000000000400000000001))) +(assert_return (invoke "f") (f64.const -0x1.0000000000002p+97)) +(module (func (export "f") (result f64) (f64.const +0x20000000000004fffffffffff))) +(assert_return (invoke "f") (f64.const +0x1.0000000000002p+97)) +(module (func (export "f") (result f64) (f64.const -0x20000000000004fffffffffff))) +(assert_return (invoke "f") (f64.const -0x1.0000000000002p+97)) +(module (func (export "f") (result f64) (f64.const +0x2000000000000500000000000))) +(assert_return (invoke "f") (f64.const +0x1.0000000000002p+97)) +(module (func (export "f") (result f64) (f64.const -0x2000000000000500000000000))) +(assert_return (invoke "f") (f64.const -0x1.0000000000002p+97)) +(module (func (export "f") (result f64) (f64.const +0x2000000000000500000000001))) +(assert_return (invoke "f") (f64.const +0x1.0000000000003p+97)) +(module (func (export "f") (result f64) (f64.const -0x2000000000000500000000001))) +(assert_return (invoke "f") (f64.const -0x1.0000000000003p+97)) + +(module (func (export "f") (result f64) (f64.const +1152921504606847104))) +(assert_return (invoke "f") (f64.const +0x1.0000000000000p+60)) +(module (func (export "f") (result f64) (f64.const -1152921504606847104))) +(assert_return (invoke "f") (f64.const -0x1.0000000000000p+60)) +(module (func (export "f") (result f64) (f64.const +1152921504606847105))) +(assert_return (invoke "f") (f64.const +0x1.0000000000001p+60)) +(module (func (export "f") (result f64) (f64.const -1152921504606847105))) +(assert_return (invoke "f") (f64.const -0x1.0000000000001p+60)) +(module (func (export "f") (result f64) (f64.const +1152921504606847359))) +(assert_return (invoke "f") (f64.const +0x1.0000000000001p+60)) +(module (func (export "f") (result f64) (f64.const -1152921504606847359))) +(assert_return (invoke "f") (f64.const -0x1.0000000000001p+60)) +(module (func (export "f") (result f64) (f64.const +1152921504606847360))) +(assert_return (invoke "f") (f64.const +0x1.0000000000002p+60)) +(module (func (export "f") (result f64) (f64.const -1152921504606847360))) +(assert_return (invoke "f") (f64.const -0x1.0000000000002p+60)) + +;; f64, subnormal +(module (func (export "f") (result f64) (f64.const +0x0.000000000000080000000000p-1022))) +(assert_return (invoke "f") (f64.const +0x0.0000000000000p-1022)) +(module (func (export "f") (result f64) (f64.const -0x0.000000000000080000000000p-1022))) +(assert_return (invoke "f") (f64.const -0x0.0000000000000p-1022)) +(module (func (export "f") (result f64) (f64.const +0x0.000000000000080000000001p-1022))) +(assert_return (invoke "f") (f64.const +0x0.0000000000001p-1022)) +(module (func (export "f") (result f64) (f64.const -0x0.000000000000080000000001p-1022))) +(assert_return (invoke "f") (f64.const -0x0.0000000000001p-1022)) +(module (func (export "f") (result f64) (f64.const +0x0.0000000000000fffffffffffp-1022))) +(assert_return (invoke "f") (f64.const +0x0.0000000000001p-1022)) +(module (func (export "f") (result f64) (f64.const -0x0.0000000000000fffffffffffp-1022))) +(assert_return (invoke "f") (f64.const -0x0.0000000000001p-1022)) +(module (func (export "f") (result f64) (f64.const +0x0.000000000000100000000000p-1022))) +(assert_return (invoke "f") (f64.const +0x0.0000000000001p-1022)) +(module (func (export "f") (result f64) (f64.const -0x0.000000000000100000000000p-1022))) +(assert_return (invoke "f") (f64.const -0x0.0000000000001p-1022)) +(module (func (export "f") (result f64) (f64.const +0x0.000000000000100000000001p-1022))) +(assert_return (invoke "f") (f64.const +0x0.0000000000001p-1022)) +(module (func (export "f") (result f64) (f64.const -0x0.000000000000100000000001p-1022))) +(assert_return (invoke "f") (f64.const -0x0.0000000000001p-1022)) +(module (func (export "f") (result f64) (f64.const +0x0.00000000000017ffffffffffp-1022))) +(assert_return (invoke "f") (f64.const +0x0.0000000000001p-1022)) +(module (func (export "f") (result f64) (f64.const -0x0.00000000000017ffffffffffp-1022))) +(assert_return (invoke "f") (f64.const -0x0.0000000000001p-1022)) +(module (func (export "f") (result f64) (f64.const +0x0.000000000000180000000000p-1022))) +(assert_return (invoke "f") (f64.const +0x0.0000000000002p-1022)) +(module (func (export "f") (result f64) (f64.const -0x0.000000000000180000000000p-1022))) +(assert_return (invoke "f") (f64.const -0x0.0000000000002p-1022)) +(module (func (export "f") (result f64) (f64.const +0x0.000000000000180000000001p-1022))) +(assert_return (invoke "f") (f64.const +0x0.0000000000002p-1022)) +(module (func (export "f") (result f64) (f64.const -0x0.000000000000180000000001p-1022))) +(assert_return (invoke "f") (f64.const -0x0.0000000000002p-1022)) +(module (func (export "f") (result f64) (f64.const +0x0.0000000000001fffffffffffp-1022))) +(assert_return (invoke "f") (f64.const +0x0.0000000000002p-1022)) +(module (func (export "f") (result f64) (f64.const -0x0.0000000000001fffffffffffp-1022))) +(assert_return (invoke "f") (f64.const -0x0.0000000000002p-1022)) +(module (func (export "f") (result f64) (f64.const +0x0.000000000000200000000000p-1022))) +(assert_return (invoke "f") (f64.const +0x0.0000000000002p-1022)) +(module (func (export "f") (result f64) (f64.const -0x0.000000000000200000000000p-1022))) +(assert_return (invoke "f") (f64.const -0x0.0000000000002p-1022)) +(module (func (export "f") (result f64) (f64.const +0x0.000000000000200000000001p-1022))) +(assert_return (invoke "f") (f64.const +0x0.0000000000002p-1022)) +(module (func (export "f") (result f64) (f64.const -0x0.000000000000200000000001p-1022))) +(assert_return (invoke "f") (f64.const -0x0.0000000000002p-1022)) +(module (func (export "f") (result f64) (f64.const +0x0.00000000000027ffffffffffp-1022))) +(assert_return (invoke "f") (f64.const +0x0.0000000000002p-1022)) +(module (func (export "f") (result f64) (f64.const -0x0.00000000000027ffffffffffp-1022))) +(assert_return (invoke "f") (f64.const -0x0.0000000000002p-1022)) +(module (func (export "f") (result f64) (f64.const +0x0.000000000000280000000000p-1022))) +(assert_return (invoke "f") (f64.const +0x0.0000000000002p-1022)) +(module (func (export "f") (result f64) (f64.const -0x0.000000000000280000000000p-1022))) +(assert_return (invoke "f") (f64.const -0x0.0000000000002p-1022)) +(module (func (export "f") (result f64) (f64.const +0x1.000000000000280000000001p-1022))) +(assert_return (invoke "f") (f64.const +0x1.0000000000003p-1022)) +(module (func (export "f") (result f64) (f64.const -0x1.000000000000280000000001p-1022))) +(assert_return (invoke "f") (f64.const -0x1.0000000000003p-1022)) + +;; f64, round down at limit to infinity +(module (func (export "f") (result f64) (f64.const +0x1.fffffffffffff4p1023))) +(assert_return (invoke "f") (f64.const +0x1.fffffffffffffp1023)) +(module (func (export "f") (result f64) (f64.const -0x1.fffffffffffff4p1023))) +(assert_return (invoke "f") (f64.const -0x1.fffffffffffffp1023)) +(module (func (export "f") (result f64) (f64.const +0x1.fffffffffffff7ffffffp1023))) +(assert_return (invoke "f") (f64.const +0x1.fffffffffffffp1023)) +(module (func (export "f") (result f64) (f64.const -0x1.fffffffffffff7ffffffp1023))) +(assert_return (invoke "f") (f64.const -0x1.fffffffffffffp1023)) diff --git a/runtime/near-vm/tests/wast/spec/conversions.wast b/runtime/near-vm/tests/wast/spec/conversions.wast new file mode 100644 index 00000000000..65d09339cac --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/conversions.wast @@ -0,0 +1,702 @@ +(module + (func (export "i64.extend_i32_s") (param $x i32) (result i64) (i64.extend_i32_s (local.get $x))) + (func (export "i64.extend_i32_u") (param $x i32) (result i64) (i64.extend_i32_u (local.get $x))) + (func (export "i32.wrap_i64") (param $x i64) (result i32) (i32.wrap_i64 (local.get $x))) + (func (export "i32.trunc_f32_s") (param $x f32) (result i32) (i32.trunc_f32_s (local.get $x))) + (func (export "i32.trunc_f32_u") (param $x f32) (result i32) (i32.trunc_f32_u (local.get $x))) + (func (export "i32.trunc_f64_s") (param $x f64) (result i32) (i32.trunc_f64_s (local.get $x))) + (func (export "i32.trunc_f64_u") (param $x f64) (result i32) (i32.trunc_f64_u (local.get $x))) + (func (export "i64.trunc_f32_s") (param $x f32) (result i64) (i64.trunc_f32_s (local.get $x))) + (func (export "i64.trunc_f32_u") (param $x f32) (result i64) (i64.trunc_f32_u (local.get $x))) + (func (export "i64.trunc_f64_s") (param $x f64) (result i64) (i64.trunc_f64_s (local.get $x))) + (func (export "i64.trunc_f64_u") (param $x f64) (result i64) (i64.trunc_f64_u (local.get $x))) + (func (export "i32.trunc_sat_f32_s") (param $x f32) (result i32) (i32.trunc_sat_f32_s (local.get $x))) + (func (export "i32.trunc_sat_f32_u") (param $x f32) (result i32) (i32.trunc_sat_f32_u (local.get $x))) + (func (export "i32.trunc_sat_f64_s") (param $x f64) (result i32) (i32.trunc_sat_f64_s (local.get $x))) + (func (export "i32.trunc_sat_f64_u") (param $x f64) (result i32) (i32.trunc_sat_f64_u (local.get $x))) + (func (export "i64.trunc_sat_f32_s") (param $x f32) (result i64) (i64.trunc_sat_f32_s (local.get $x))) + (func (export "i64.trunc_sat_f32_u") (param $x f32) (result i64) (i64.trunc_sat_f32_u (local.get $x))) + (func (export "i64.trunc_sat_f64_s") (param $x f64) (result i64) (i64.trunc_sat_f64_s (local.get $x))) + (func (export "i64.trunc_sat_f64_u") (param $x f64) (result i64) (i64.trunc_sat_f64_u (local.get $x))) + (func (export "f32.convert_i32_s") (param $x i32) (result f32) (f32.convert_i32_s (local.get $x))) + (func (export "f32.convert_i64_s") (param $x i64) (result f32) (f32.convert_i64_s (local.get $x))) + (func (export "f64.convert_i32_s") (param $x i32) (result f64) (f64.convert_i32_s (local.get $x))) + (func (export "f64.convert_i64_s") (param $x i64) (result f64) (f64.convert_i64_s (local.get $x))) + (func (export "f32.convert_i32_u") (param $x i32) (result f32) (f32.convert_i32_u (local.get $x))) + (func (export "f32.convert_i64_u") (param $x i64) (result f32) (f32.convert_i64_u (local.get $x))) + (func (export "f64.convert_i32_u") (param $x i32) (result f64) (f64.convert_i32_u (local.get $x))) + (func (export "f64.convert_i64_u") (param $x i64) (result f64) (f64.convert_i64_u (local.get $x))) + (func (export "f64.promote_f32") (param $x f32) (result f64) (f64.promote_f32 (local.get $x))) + (func (export "f32.demote_f64") (param $x f64) (result f32) (f32.demote_f64 (local.get $x))) + (func (export "f32.reinterpret_i32") (param $x i32) (result f32) (f32.reinterpret_i32 (local.get $x))) + (func (export "f64.reinterpret_i64") (param $x i64) (result f64) (f64.reinterpret_i64 (local.get $x))) + (func (export "i32.reinterpret_f32") (param $x f32) (result i32) (i32.reinterpret_f32 (local.get $x))) + (func (export "i64.reinterpret_f64") (param $x f64) (result i64) (i64.reinterpret_f64 (local.get $x))) +) + +(assert_return (invoke "i64.extend_i32_s" (i32.const 0)) (i64.const 0)) +(assert_return (invoke "i64.extend_i32_s" (i32.const 10000)) (i64.const 10000)) +(assert_return (invoke "i64.extend_i32_s" (i32.const -10000)) (i64.const -10000)) +(assert_return (invoke "i64.extend_i32_s" (i32.const -1)) (i64.const -1)) +(assert_return (invoke "i64.extend_i32_s" (i32.const 0x7fffffff)) (i64.const 0x000000007fffffff)) +(assert_return (invoke "i64.extend_i32_s" (i32.const 0x80000000)) (i64.const 0xffffffff80000000)) + +(assert_return (invoke "i64.extend_i32_u" (i32.const 0)) (i64.const 0)) +(assert_return (invoke "i64.extend_i32_u" (i32.const 10000)) (i64.const 10000)) +(assert_return (invoke "i64.extend_i32_u" (i32.const -10000)) (i64.const 0x00000000ffffd8f0)) +(assert_return (invoke "i64.extend_i32_u" (i32.const -1)) (i64.const 0xffffffff)) +(assert_return (invoke "i64.extend_i32_u" (i32.const 0x7fffffff)) (i64.const 0x000000007fffffff)) +(assert_return (invoke "i64.extend_i32_u" (i32.const 0x80000000)) (i64.const 0x0000000080000000)) + +(assert_return (invoke "i32.wrap_i64" (i64.const -1)) (i32.const -1)) +(assert_return (invoke "i32.wrap_i64" (i64.const -100000)) (i32.const -100000)) +(assert_return (invoke "i32.wrap_i64" (i64.const 0x80000000)) (i32.const 0x80000000)) +(assert_return (invoke "i32.wrap_i64" (i64.const 0xffffffff7fffffff)) (i32.const 0x7fffffff)) +(assert_return (invoke "i32.wrap_i64" (i64.const 0xffffffff00000000)) (i32.const 0x00000000)) +(assert_return (invoke "i32.wrap_i64" (i64.const 0xfffffffeffffffff)) (i32.const 0xffffffff)) +(assert_return (invoke "i32.wrap_i64" (i64.const 0xffffffff00000001)) (i32.const 0x00000001)) +(assert_return (invoke "i32.wrap_i64" (i64.const 0)) (i32.const 0)) +(assert_return (invoke "i32.wrap_i64" (i64.const 1311768467463790320)) (i32.const 0x9abcdef0)) +(assert_return (invoke "i32.wrap_i64" (i64.const 0x00000000ffffffff)) (i32.const 0xffffffff)) +(assert_return (invoke "i32.wrap_i64" (i64.const 0x0000000100000000)) (i32.const 0x00000000)) +(assert_return (invoke "i32.wrap_i64" (i64.const 0x0000000100000001)) (i32.const 0x00000001)) + +(assert_return (invoke "i32.trunc_f32_s" (f32.const 0.0)) (i32.const 0)) +(assert_return (invoke "i32.trunc_f32_s" (f32.const -0.0)) (i32.const 0)) +(assert_return (invoke "i32.trunc_f32_s" (f32.const 0x1p-149)) (i32.const 0)) +(assert_return (invoke "i32.trunc_f32_s" (f32.const -0x1p-149)) (i32.const 0)) +(assert_return (invoke "i32.trunc_f32_s" (f32.const 1.0)) (i32.const 1)) +(assert_return (invoke "i32.trunc_f32_s" (f32.const 0x1.19999ap+0)) (i32.const 1)) +(assert_return (invoke "i32.trunc_f32_s" (f32.const 1.5)) (i32.const 1)) +(assert_return (invoke "i32.trunc_f32_s" (f32.const -1.0)) (i32.const -1)) +(assert_return (invoke "i32.trunc_f32_s" (f32.const -0x1.19999ap+0)) (i32.const -1)) +(assert_return (invoke "i32.trunc_f32_s" (f32.const -1.5)) (i32.const -1)) +(assert_return (invoke "i32.trunc_f32_s" (f32.const -1.9)) (i32.const -1)) +(assert_return (invoke "i32.trunc_f32_s" (f32.const -2.0)) (i32.const -2)) +(assert_return (invoke "i32.trunc_f32_s" (f32.const 2147483520.0)) (i32.const 2147483520)) +(assert_return (invoke "i32.trunc_f32_s" (f32.const -2147483648.0)) (i32.const -2147483648)) +(assert_trap (invoke "i32.trunc_f32_s" (f32.const 2147483648.0)) "integer overflow") +(assert_trap (invoke "i32.trunc_f32_s" (f32.const -2147483904.0)) "integer overflow") +(assert_trap (invoke "i32.trunc_f32_s" (f32.const inf)) "integer overflow") +(assert_trap (invoke "i32.trunc_f32_s" (f32.const -inf)) "integer overflow") +(assert_trap (invoke "i32.trunc_f32_s" (f32.const nan)) "invalid conversion to integer") +(assert_trap (invoke "i32.trunc_f32_s" (f32.const nan:0x200000)) "invalid conversion to integer") +(assert_trap (invoke "i32.trunc_f32_s" (f32.const -nan)) "invalid conversion to integer") +(assert_trap (invoke "i32.trunc_f32_s" (f32.const -nan:0x200000)) "invalid conversion to integer") + +(assert_return (invoke "i32.trunc_f32_u" (f32.const 0.0)) (i32.const 0)) +(assert_return (invoke "i32.trunc_f32_u" (f32.const -0.0)) (i32.const 0)) +(assert_return (invoke "i32.trunc_f32_u" (f32.const 0x1p-149)) (i32.const 0)) +(assert_return (invoke "i32.trunc_f32_u" (f32.const -0x1p-149)) (i32.const 0)) +(assert_return (invoke "i32.trunc_f32_u" (f32.const 1.0)) (i32.const 1)) +(assert_return (invoke "i32.trunc_f32_u" (f32.const 0x1.19999ap+0)) (i32.const 1)) +(assert_return (invoke "i32.trunc_f32_u" (f32.const 1.5)) (i32.const 1)) +(assert_return (invoke "i32.trunc_f32_u" (f32.const 1.9)) (i32.const 1)) +(assert_return (invoke "i32.trunc_f32_u" (f32.const 2.0)) (i32.const 2)) +(assert_return (invoke "i32.trunc_f32_u" (f32.const 2147483648)) (i32.const -2147483648)) ;; 0x1.00000p+31 -> 8000 0000 +(assert_return (invoke "i32.trunc_f32_u" (f32.const 4294967040.0)) (i32.const -256)) +(assert_return (invoke "i32.trunc_f32_u" (f32.const -0x1.ccccccp-1)) (i32.const 0)) +(assert_return (invoke "i32.trunc_f32_u" (f32.const -0x1.fffffep-1)) (i32.const 0)) +(assert_trap (invoke "i32.trunc_f32_u" (f32.const 4294967296.0)) "integer overflow") +(assert_trap (invoke "i32.trunc_f32_u" (f32.const -1.0)) "integer overflow") +(assert_trap (invoke "i32.trunc_f32_u" (f32.const inf)) "integer overflow") +(assert_trap (invoke "i32.trunc_f32_u" (f32.const -inf)) "integer overflow") +(assert_trap (invoke "i32.trunc_f32_u" (f32.const nan)) "invalid conversion to integer") +(assert_trap (invoke "i32.trunc_f32_u" (f32.const nan:0x200000)) "invalid conversion to integer") +(assert_trap (invoke "i32.trunc_f32_u" (f32.const -nan)) "invalid conversion to integer") +(assert_trap (invoke "i32.trunc_f32_u" (f32.const -nan:0x200000)) "invalid conversion to integer") + +(assert_return (invoke "i32.trunc_f64_s" (f64.const 0.0)) (i32.const 0)) +(assert_return (invoke "i32.trunc_f64_s" (f64.const -0.0)) (i32.const 0)) +(assert_return (invoke "i32.trunc_f64_s" (f64.const 0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "i32.trunc_f64_s" (f64.const -0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "i32.trunc_f64_s" (f64.const 1.0)) (i32.const 1)) +(assert_return (invoke "i32.trunc_f64_s" (f64.const 0x1.199999999999ap+0)) (i32.const 1)) +(assert_return (invoke "i32.trunc_f64_s" (f64.const 1.5)) (i32.const 1)) +(assert_return (invoke "i32.trunc_f64_s" (f64.const -1.0)) (i32.const -1)) +(assert_return (invoke "i32.trunc_f64_s" (f64.const -0x1.199999999999ap+0)) (i32.const -1)) +(assert_return (invoke "i32.trunc_f64_s" (f64.const -1.5)) (i32.const -1)) +(assert_return (invoke "i32.trunc_f64_s" (f64.const -1.9)) (i32.const -1)) +(assert_return (invoke "i32.trunc_f64_s" (f64.const -2.0)) (i32.const -2)) +(assert_return (invoke "i32.trunc_f64_s" (f64.const 2147483647.0)) (i32.const 2147483647)) +(assert_return (invoke "i32.trunc_f64_s" (f64.const -2147483648.0)) (i32.const -2147483648)) +(assert_return (invoke "i32.trunc_f64_s" (f64.const -2147483648.9)) (i32.const -2147483648)) +(assert_return (invoke "i32.trunc_f64_s" (f64.const 2147483647.9)) (i32.const 2147483647)) +(assert_trap (invoke "i32.trunc_f64_s" (f64.const 2147483648.0)) "integer overflow") +(assert_trap (invoke "i32.trunc_f64_s" (f64.const -2147483649.0)) "integer overflow") +(assert_trap (invoke "i32.trunc_f64_s" (f64.const inf)) "integer overflow") +(assert_trap (invoke "i32.trunc_f64_s" (f64.const -inf)) "integer overflow") +(assert_trap (invoke "i32.trunc_f64_s" (f64.const nan)) "invalid conversion to integer") +(assert_trap (invoke "i32.trunc_f64_s" (f64.const nan:0x4000000000000)) "invalid conversion to integer") +(assert_trap (invoke "i32.trunc_f64_s" (f64.const -nan)) "invalid conversion to integer") +(assert_trap (invoke "i32.trunc_f64_s" (f64.const -nan:0x4000000000000)) "invalid conversion to integer") + +(assert_return (invoke "i32.trunc_f64_u" (f64.const 0.0)) (i32.const 0)) +(assert_return (invoke "i32.trunc_f64_u" (f64.const -0.0)) (i32.const 0)) +(assert_return (invoke "i32.trunc_f64_u" (f64.const 0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "i32.trunc_f64_u" (f64.const -0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "i32.trunc_f64_u" (f64.const 1.0)) (i32.const 1)) +(assert_return (invoke "i32.trunc_f64_u" (f64.const 0x1.199999999999ap+0)) (i32.const 1)) +(assert_return (invoke "i32.trunc_f64_u" (f64.const 1.5)) (i32.const 1)) +(assert_return (invoke "i32.trunc_f64_u" (f64.const 1.9)) (i32.const 1)) +(assert_return (invoke "i32.trunc_f64_u" (f64.const 2.0)) (i32.const 2)) +(assert_return (invoke "i32.trunc_f64_u" (f64.const 2147483648)) (i32.const -2147483648)) ;; 0x1.00000p+31 -> 8000 0000 +(assert_return (invoke "i32.trunc_f64_u" (f64.const 4294967295.0)) (i32.const -1)) +(assert_return (invoke "i32.trunc_f64_u" (f64.const -0x1.ccccccccccccdp-1)) (i32.const 0)) +(assert_return (invoke "i32.trunc_f64_u" (f64.const -0x1.fffffffffffffp-1)) (i32.const 0)) +(assert_return (invoke "i32.trunc_f64_u" (f64.const 1e8)) (i32.const 100000000)) +(assert_return (invoke "i32.trunc_f64_u" (f64.const -0.9)) (i32.const 0)) +(assert_return (invoke "i32.trunc_f64_u" (f64.const 4294967295.9)) (i32.const 4294967295)) +(assert_trap (invoke "i32.trunc_f64_u" (f64.const 4294967296.0)) "integer overflow") +(assert_trap (invoke "i32.trunc_f64_u" (f64.const -1.0)) "integer overflow") +(assert_trap (invoke "i32.trunc_f64_u" (f64.const 1e16)) "integer overflow") +(assert_trap (invoke "i32.trunc_f64_u" (f64.const 1e30)) "integer overflow") +(assert_trap (invoke "i32.trunc_f64_u" (f64.const 9223372036854775808)) "integer overflow") +(assert_trap (invoke "i32.trunc_f64_u" (f64.const inf)) "integer overflow") +(assert_trap (invoke "i32.trunc_f64_u" (f64.const -inf)) "integer overflow") +(assert_trap (invoke "i32.trunc_f64_u" (f64.const nan)) "invalid conversion to integer") +(assert_trap (invoke "i32.trunc_f64_u" (f64.const nan:0x4000000000000)) "invalid conversion to integer") +(assert_trap (invoke "i32.trunc_f64_u" (f64.const -nan)) "invalid conversion to integer") +(assert_trap (invoke "i32.trunc_f64_u" (f64.const -nan:0x4000000000000)) "invalid conversion to integer") + +(assert_return (invoke "i64.trunc_f32_s" (f32.const 0.0)) (i64.const 0)) +(assert_return (invoke "i64.trunc_f32_s" (f32.const -0.0)) (i64.const 0)) +(assert_return (invoke "i64.trunc_f32_s" (f32.const 0x1p-149)) (i64.const 0)) +(assert_return (invoke "i64.trunc_f32_s" (f32.const -0x1p-149)) (i64.const 0)) +(assert_return (invoke "i64.trunc_f32_s" (f32.const 1.0)) (i64.const 1)) +(assert_return (invoke "i64.trunc_f32_s" (f32.const 0x1.19999ap+0)) (i64.const 1)) +(assert_return (invoke "i64.trunc_f32_s" (f32.const 1.5)) (i64.const 1)) +(assert_return (invoke "i64.trunc_f32_s" (f32.const -1.0)) (i64.const -1)) +(assert_return (invoke "i64.trunc_f32_s" (f32.const -0x1.19999ap+0)) (i64.const -1)) +(assert_return (invoke "i64.trunc_f32_s" (f32.const -1.5)) (i64.const -1)) +(assert_return (invoke "i64.trunc_f32_s" (f32.const -1.9)) (i64.const -1)) +(assert_return (invoke "i64.trunc_f32_s" (f32.const -2.0)) (i64.const -2)) +(assert_return (invoke "i64.trunc_f32_s" (f32.const 4294967296)) (i64.const 4294967296)) ;; 0x1.00000p+32 -> 1 0000 0000 +(assert_return (invoke "i64.trunc_f32_s" (f32.const -4294967296)) (i64.const -4294967296)) ;; -0x1.00000p+32 -> ffff ffff 0000 0000 +(assert_return (invoke "i64.trunc_f32_s" (f32.const 9223371487098961920.0)) (i64.const 9223371487098961920)) +(assert_return (invoke "i64.trunc_f32_s" (f32.const -9223372036854775808.0)) (i64.const -9223372036854775808)) +(assert_trap (invoke "i64.trunc_f32_s" (f32.const 9223372036854775808.0)) "integer overflow") +(assert_trap (invoke "i64.trunc_f32_s" (f32.const -9223373136366403584.0)) "integer overflow") +(assert_trap (invoke "i64.trunc_f32_s" (f32.const inf)) "integer overflow") +(assert_trap (invoke "i64.trunc_f32_s" (f32.const -inf)) "integer overflow") +(assert_trap (invoke "i64.trunc_f32_s" (f32.const nan)) "invalid conversion to integer") +(assert_trap (invoke "i64.trunc_f32_s" (f32.const nan:0x200000)) "invalid conversion to integer") +(assert_trap (invoke "i64.trunc_f32_s" (f32.const -nan)) "invalid conversion to integer") +(assert_trap (invoke "i64.trunc_f32_s" (f32.const -nan:0x200000)) "invalid conversion to integer") + +(assert_return (invoke "i64.trunc_f32_u" (f32.const 0.0)) (i64.const 0)) +(assert_return (invoke "i64.trunc_f32_u" (f32.const -0.0)) (i64.const 0)) +(assert_return (invoke "i64.trunc_f32_u" (f32.const 0x1p-149)) (i64.const 0)) +(assert_return (invoke "i64.trunc_f32_u" (f32.const -0x1p-149)) (i64.const 0)) +(assert_return (invoke "i64.trunc_f32_u" (f32.const 1.0)) (i64.const 1)) +(assert_return (invoke "i64.trunc_f32_u" (f32.const 0x1.19999ap+0)) (i64.const 1)) +(assert_return (invoke "i64.trunc_f32_u" (f32.const 1.5)) (i64.const 1)) +(assert_return (invoke "i64.trunc_f32_u" (f32.const 4294967296)) (i64.const 4294967296)) +(assert_return (invoke "i64.trunc_f32_u" (f32.const 18446742974197923840.0)) (i64.const -1099511627776)) +(assert_return (invoke "i64.trunc_f32_u" (f32.const -0x1.ccccccp-1)) (i64.const 0)) +(assert_return (invoke "i64.trunc_f32_u" (f32.const -0x1.fffffep-1)) (i64.const 0)) +(assert_trap (invoke "i64.trunc_f32_u" (f32.const 18446744073709551616.0)) "integer overflow") +(assert_trap (invoke "i64.trunc_f32_u" (f32.const -1.0)) "integer overflow") +(assert_trap (invoke "i64.trunc_f32_u" (f32.const inf)) "integer overflow") +(assert_trap (invoke "i64.trunc_f32_u" (f32.const -inf)) "integer overflow") +(assert_trap (invoke "i64.trunc_f32_u" (f32.const nan)) "invalid conversion to integer") +(assert_trap (invoke "i64.trunc_f32_u" (f32.const nan:0x200000)) "invalid conversion to integer") +(assert_trap (invoke "i64.trunc_f32_u" (f32.const -nan)) "invalid conversion to integer") +(assert_trap (invoke "i64.trunc_f32_u" (f32.const -nan:0x200000)) "invalid conversion to integer") + +(assert_return (invoke "i64.trunc_f64_s" (f64.const 0.0)) (i64.const 0)) +(assert_return (invoke "i64.trunc_f64_s" (f64.const -0.0)) (i64.const 0)) +(assert_return (invoke "i64.trunc_f64_s" (f64.const 0x0.0000000000001p-1022)) (i64.const 0)) +(assert_return (invoke "i64.trunc_f64_s" (f64.const -0x0.0000000000001p-1022)) (i64.const 0)) +(assert_return (invoke "i64.trunc_f64_s" (f64.const 1.0)) (i64.const 1)) +(assert_return (invoke "i64.trunc_f64_s" (f64.const 0x1.199999999999ap+0)) (i64.const 1)) +(assert_return (invoke "i64.trunc_f64_s" (f64.const 1.5)) (i64.const 1)) +(assert_return (invoke "i64.trunc_f64_s" (f64.const -1.0)) (i64.const -1)) +(assert_return (invoke "i64.trunc_f64_s" (f64.const -0x1.199999999999ap+0)) (i64.const -1)) +(assert_return (invoke "i64.trunc_f64_s" (f64.const -1.5)) (i64.const -1)) +(assert_return (invoke "i64.trunc_f64_s" (f64.const -1.9)) (i64.const -1)) +(assert_return (invoke "i64.trunc_f64_s" (f64.const -2.0)) (i64.const -2)) +(assert_return (invoke "i64.trunc_f64_s" (f64.const 4294967296)) (i64.const 4294967296)) ;; 0x1.00000p+32 -> 1 0000 0000 +(assert_return (invoke "i64.trunc_f64_s" (f64.const -4294967296)) (i64.const -4294967296)) ;; -0x1.00000p+32 -> ffff ffff 0000 0000 +(assert_return (invoke "i64.trunc_f64_s" (f64.const 9223372036854774784.0)) (i64.const 9223372036854774784)) +(assert_return (invoke "i64.trunc_f64_s" (f64.const -9223372036854775808.0)) (i64.const -9223372036854775808)) +(assert_trap (invoke "i64.trunc_f64_s" (f64.const 9223372036854775808.0)) "integer overflow") +(assert_trap (invoke "i64.trunc_f64_s" (f64.const -9223372036854777856.0)) "integer overflow") +(assert_trap (invoke "i64.trunc_f64_s" (f64.const inf)) "integer overflow") +(assert_trap (invoke "i64.trunc_f64_s" (f64.const -inf)) "integer overflow") +(assert_trap (invoke "i64.trunc_f64_s" (f64.const nan)) "invalid conversion to integer") +(assert_trap (invoke "i64.trunc_f64_s" (f64.const nan:0x4000000000000)) "invalid conversion to integer") +(assert_trap (invoke "i64.trunc_f64_s" (f64.const -nan)) "invalid conversion to integer") +(assert_trap (invoke "i64.trunc_f64_s" (f64.const -nan:0x4000000000000)) "invalid conversion to integer") + +(assert_return (invoke "i64.trunc_f64_u" (f64.const 0.0)) (i64.const 0)) +(assert_return (invoke "i64.trunc_f64_u" (f64.const -0.0)) (i64.const 0)) +(assert_return (invoke "i64.trunc_f64_u" (f64.const 0x0.0000000000001p-1022)) (i64.const 0)) +(assert_return (invoke "i64.trunc_f64_u" (f64.const -0x0.0000000000001p-1022)) (i64.const 0)) +(assert_return (invoke "i64.trunc_f64_u" (f64.const 1.0)) (i64.const 1)) +(assert_return (invoke "i64.trunc_f64_u" (f64.const 0x1.199999999999ap+0)) (i64.const 1)) +(assert_return (invoke "i64.trunc_f64_u" (f64.const 1.5)) (i64.const 1)) +(assert_return (invoke "i64.trunc_f64_u" (f64.const 4294967295)) (i64.const 0xffffffff)) +(assert_return (invoke "i64.trunc_f64_u" (f64.const 4294967296)) (i64.const 0x100000000)) +(assert_return (invoke "i64.trunc_f64_u" (f64.const 18446744073709549568.0)) (i64.const -2048)) +(assert_return (invoke "i64.trunc_f64_u" (f64.const -0x1.ccccccccccccdp-1)) (i64.const 0)) +(assert_return (invoke "i64.trunc_f64_u" (f64.const -0x1.fffffffffffffp-1)) (i64.const 0)) +(assert_return (invoke "i64.trunc_f64_u" (f64.const 1e8)) (i64.const 100000000)) +(assert_return (invoke "i64.trunc_f64_u" (f64.const 1e16)) (i64.const 10000000000000000)) +(assert_return (invoke "i64.trunc_f64_u" (f64.const 9223372036854775808)) (i64.const -9223372036854775808)) +(assert_trap (invoke "i64.trunc_f64_u" (f64.const 18446744073709551616.0)) "integer overflow") +(assert_trap (invoke "i64.trunc_f64_u" (f64.const -1.0)) "integer overflow") +(assert_trap (invoke "i64.trunc_f64_u" (f64.const inf)) "integer overflow") +(assert_trap (invoke "i64.trunc_f64_u" (f64.const -inf)) "integer overflow") +(assert_trap (invoke "i64.trunc_f64_u" (f64.const nan)) "invalid conversion to integer") +(assert_trap (invoke "i64.trunc_f64_u" (f64.const nan:0x4000000000000)) "invalid conversion to integer") +(assert_trap (invoke "i64.trunc_f64_u" (f64.const -nan)) "invalid conversion to integer") +(assert_trap (invoke "i64.trunc_f64_u" (f64.const -nan:0x4000000000000)) "invalid conversion to integer") + +(assert_return (invoke "f32.convert_i32_s" (i32.const 1)) (f32.const 1.0)) +(assert_return (invoke "f32.convert_i32_s" (i32.const -1)) (f32.const -1.0)) +(assert_return (invoke "f32.convert_i32_s" (i32.const 0)) (f32.const 0.0)) +(assert_return (invoke "f32.convert_i32_s" (i32.const 2147483647)) (f32.const 2147483648)) +(assert_return (invoke "f32.convert_i32_s" (i32.const -2147483648)) (f32.const -2147483648)) +(assert_return (invoke "f32.convert_i32_s" (i32.const 1234567890)) (f32.const 0x1.26580cp+30)) + +;; Saturating conversions: test all the same values as the non-saturating conversions. + +(assert_return (invoke "i32.trunc_sat_f32_s" (f32.const 0.0)) (i32.const 0)) +(assert_return (invoke "i32.trunc_sat_f32_s" (f32.const -0.0)) (i32.const 0)) +(assert_return (invoke "i32.trunc_sat_f32_s" (f32.const 0x1p-149)) (i32.const 0)) +(assert_return (invoke "i32.trunc_sat_f32_s" (f32.const -0x1p-149)) (i32.const 0)) +(assert_return (invoke "i32.trunc_sat_f32_s" (f32.const 1.0)) (i32.const 1)) +(assert_return (invoke "i32.trunc_sat_f32_s" (f32.const 0x1.19999ap+0)) (i32.const 1)) +(assert_return (invoke "i32.trunc_sat_f32_s" (f32.const 1.5)) (i32.const 1)) +(assert_return (invoke "i32.trunc_sat_f32_s" (f32.const -1.0)) (i32.const -1)) +(assert_return (invoke "i32.trunc_sat_f32_s" (f32.const -0x1.19999ap+0)) (i32.const -1)) +(assert_return (invoke "i32.trunc_sat_f32_s" (f32.const -1.5)) (i32.const -1)) +(assert_return (invoke "i32.trunc_sat_f32_s" (f32.const -1.9)) (i32.const -1)) +(assert_return (invoke "i32.trunc_sat_f32_s" (f32.const -2.0)) (i32.const -2)) +(assert_return (invoke "i32.trunc_sat_f32_s" (f32.const 2147483520.0)) (i32.const 2147483520)) +(assert_return (invoke "i32.trunc_sat_f32_s" (f32.const -2147483648.0)) (i32.const -2147483648)) +(assert_return (invoke "i32.trunc_sat_f32_s" (f32.const 2147483648.0)) (i32.const 0x7fffffff)) +(assert_return (invoke "i32.trunc_sat_f32_s" (f32.const -2147483904.0)) (i32.const 0x80000000)) +(assert_return (invoke "i32.trunc_sat_f32_s" (f32.const inf)) (i32.const 0x7fffffff)) +(assert_return (invoke "i32.trunc_sat_f32_s" (f32.const -inf)) (i32.const 0x80000000)) +(assert_return (invoke "i32.trunc_sat_f32_s" (f32.const nan)) (i32.const 0)) +(assert_return (invoke "i32.trunc_sat_f32_s" (f32.const nan:0x200000)) (i32.const 0)) +(assert_return (invoke "i32.trunc_sat_f32_s" (f32.const -nan)) (i32.const 0)) +(assert_return (invoke "i32.trunc_sat_f32_s" (f32.const -nan:0x200000)) (i32.const 0)) + +(assert_return (invoke "i32.trunc_sat_f32_u" (f32.const 0.0)) (i32.const 0)) +(assert_return (invoke "i32.trunc_sat_f32_u" (f32.const -0.0)) (i32.const 0)) +(assert_return (invoke "i32.trunc_sat_f32_u" (f32.const 0x1p-149)) (i32.const 0)) +(assert_return (invoke "i32.trunc_sat_f32_u" (f32.const -0x1p-149)) (i32.const 0)) +(assert_return (invoke "i32.trunc_sat_f32_u" (f32.const 1.0)) (i32.const 1)) +(assert_return (invoke "i32.trunc_sat_f32_u" (f32.const 0x1.19999ap+0)) (i32.const 1)) +(assert_return (invoke "i32.trunc_sat_f32_u" (f32.const 1.5)) (i32.const 1)) +(assert_return (invoke "i32.trunc_sat_f32_u" (f32.const 1.9)) (i32.const 1)) +(assert_return (invoke "i32.trunc_sat_f32_u" (f32.const 2.0)) (i32.const 2)) +(assert_return (invoke "i32.trunc_sat_f32_u" (f32.const 2147483648)) (i32.const -2147483648)) ;; 0x1.00000p+31 -> 8000 0000 +(assert_return (invoke "i32.trunc_sat_f32_u" (f32.const 4294967040.0)) (i32.const -256)) +(assert_return (invoke "i32.trunc_sat_f32_u" (f32.const -0x1.ccccccp-1)) (i32.const 0)) +(assert_return (invoke "i32.trunc_sat_f32_u" (f32.const -0x1.fffffep-1)) (i32.const 0)) +(assert_return (invoke "i32.trunc_sat_f32_u" (f32.const 4294967296.0)) (i32.const 0xffffffff)) +(assert_return (invoke "i32.trunc_sat_f32_u" (f32.const -1.0)) (i32.const 0x00000000)) +(assert_return (invoke "i32.trunc_sat_f32_u" (f32.const inf)) (i32.const 0xffffffff)) +(assert_return (invoke "i32.trunc_sat_f32_u" (f32.const -inf)) (i32.const 0x00000000)) +(assert_return (invoke "i32.trunc_sat_f32_u" (f32.const nan)) (i32.const 0)) +(assert_return (invoke "i32.trunc_sat_f32_u" (f32.const nan:0x200000)) (i32.const 0)) +(assert_return (invoke "i32.trunc_sat_f32_u" (f32.const -nan)) (i32.const 0)) +(assert_return (invoke "i32.trunc_sat_f32_u" (f32.const -nan:0x200000)) (i32.const 0)) + +(assert_return (invoke "i32.trunc_sat_f64_s" (f64.const 0.0)) (i32.const 0)) +(assert_return (invoke "i32.trunc_sat_f64_s" (f64.const -0.0)) (i32.const 0)) +(assert_return (invoke "i32.trunc_sat_f64_s" (f64.const 0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "i32.trunc_sat_f64_s" (f64.const -0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "i32.trunc_sat_f64_s" (f64.const 1.0)) (i32.const 1)) +(assert_return (invoke "i32.trunc_sat_f64_s" (f64.const 0x1.199999999999ap+0)) (i32.const 1)) +(assert_return (invoke "i32.trunc_sat_f64_s" (f64.const 1.5)) (i32.const 1)) +(assert_return (invoke "i32.trunc_sat_f64_s" (f64.const -1.0)) (i32.const -1)) +(assert_return (invoke "i32.trunc_sat_f64_s" (f64.const -0x1.199999999999ap+0)) (i32.const -1)) +(assert_return (invoke "i32.trunc_sat_f64_s" (f64.const -1.5)) (i32.const -1)) +(assert_return (invoke "i32.trunc_sat_f64_s" (f64.const -1.9)) (i32.const -1)) +(assert_return (invoke "i32.trunc_sat_f64_s" (f64.const -2.0)) (i32.const -2)) +(assert_return (invoke "i32.trunc_sat_f64_s" (f64.const 2147483647.0)) (i32.const 2147483647)) +(assert_return (invoke "i32.trunc_sat_f64_s" (f64.const -2147483648.0)) (i32.const -2147483648)) +(assert_return (invoke "i32.trunc_sat_f64_s" (f64.const 2147483648.0)) (i32.const 0x7fffffff)) +(assert_return (invoke "i32.trunc_sat_f64_s" (f64.const -2147483649.0)) (i32.const 0x80000000)) +(assert_return (invoke "i32.trunc_sat_f64_s" (f64.const inf)) (i32.const 0x7fffffff)) +(assert_return (invoke "i32.trunc_sat_f64_s" (f64.const -inf)) (i32.const 0x80000000)) +(assert_return (invoke "i32.trunc_sat_f64_s" (f64.const nan)) (i32.const 0)) +(assert_return (invoke "i32.trunc_sat_f64_s" (f64.const nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "i32.trunc_sat_f64_s" (f64.const -nan)) (i32.const 0)) +(assert_return (invoke "i32.trunc_sat_f64_s" (f64.const -nan:0x4000000000000)) (i32.const 0)) + +(assert_return (invoke "i32.trunc_sat_f64_u" (f64.const 0.0)) (i32.const 0)) +(assert_return (invoke "i32.trunc_sat_f64_u" (f64.const -0.0)) (i32.const 0)) +(assert_return (invoke "i32.trunc_sat_f64_u" (f64.const 0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "i32.trunc_sat_f64_u" (f64.const -0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "i32.trunc_sat_f64_u" (f64.const 1.0)) (i32.const 1)) +(assert_return (invoke "i32.trunc_sat_f64_u" (f64.const 0x1.199999999999ap+0)) (i32.const 1)) +(assert_return (invoke "i32.trunc_sat_f64_u" (f64.const 1.5)) (i32.const 1)) +(assert_return (invoke "i32.trunc_sat_f64_u" (f64.const 1.9)) (i32.const 1)) +(assert_return (invoke "i32.trunc_sat_f64_u" (f64.const 2.0)) (i32.const 2)) +(assert_return (invoke "i32.trunc_sat_f64_u" (f64.const 2147483648)) (i32.const -2147483648)) ;; 0x1.00000p+31 -> 8000 0000 +(assert_return (invoke "i32.trunc_sat_f64_u" (f64.const 4294967295.0)) (i32.const -1)) +(assert_return (invoke "i32.trunc_sat_f64_u" (f64.const -0x1.ccccccccccccdp-1)) (i32.const 0)) +(assert_return (invoke "i32.trunc_sat_f64_u" (f64.const -0x1.fffffffffffffp-1)) (i32.const 0)) +(assert_return (invoke "i32.trunc_sat_f64_u" (f64.const 1e8)) (i32.const 100000000)) +(assert_return (invoke "i32.trunc_sat_f64_u" (f64.const 4294967296.0)) (i32.const 0xffffffff)) +(assert_return (invoke "i32.trunc_sat_f64_u" (f64.const -1.0)) (i32.const 0x00000000)) +(assert_return (invoke "i32.trunc_sat_f64_u" (f64.const 1e16)) (i32.const 0xffffffff)) +(assert_return (invoke "i32.trunc_sat_f64_u" (f64.const 1e30)) (i32.const 0xffffffff)) +(assert_return (invoke "i32.trunc_sat_f64_u" (f64.const 9223372036854775808)) (i32.const 0xffffffff)) +(assert_return (invoke "i32.trunc_sat_f64_u" (f64.const inf)) (i32.const 0xffffffff)) +(assert_return (invoke "i32.trunc_sat_f64_u" (f64.const -inf)) (i32.const 0x00000000)) +(assert_return (invoke "i32.trunc_sat_f64_u" (f64.const nan)) (i32.const 0)) +(assert_return (invoke "i32.trunc_sat_f64_u" (f64.const nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "i32.trunc_sat_f64_u" (f64.const -nan)) (i32.const 0)) +(assert_return (invoke "i32.trunc_sat_f64_u" (f64.const -nan:0x4000000000000)) (i32.const 0)) + +(assert_return (invoke "i64.trunc_sat_f32_s" (f32.const 0.0)) (i64.const 0)) +(assert_return (invoke "i64.trunc_sat_f32_s" (f32.const -0.0)) (i64.const 0)) +(assert_return (invoke "i64.trunc_sat_f32_s" (f32.const 0x1p-149)) (i64.const 0)) +(assert_return (invoke "i64.trunc_sat_f32_s" (f32.const -0x1p-149)) (i64.const 0)) +(assert_return (invoke "i64.trunc_sat_f32_s" (f32.const 1.0)) (i64.const 1)) +(assert_return (invoke "i64.trunc_sat_f32_s" (f32.const 0x1.19999ap+0)) (i64.const 1)) +(assert_return (invoke "i64.trunc_sat_f32_s" (f32.const 1.5)) (i64.const 1)) +(assert_return (invoke "i64.trunc_sat_f32_s" (f32.const -1.0)) (i64.const -1)) +(assert_return (invoke "i64.trunc_sat_f32_s" (f32.const -0x1.19999ap+0)) (i64.const -1)) +(assert_return (invoke "i64.trunc_sat_f32_s" (f32.const -1.5)) (i64.const -1)) +(assert_return (invoke "i64.trunc_sat_f32_s" (f32.const -1.9)) (i64.const -1)) +(assert_return (invoke "i64.trunc_sat_f32_s" (f32.const -2.0)) (i64.const -2)) +(assert_return (invoke "i64.trunc_sat_f32_s" (f32.const 4294967296)) (i64.const 4294967296)) ;; 0x1.00000p+32 -> 1 0000 0000 +(assert_return (invoke "i64.trunc_sat_f32_s" (f32.const -4294967296)) (i64.const -4294967296)) ;; -0x1.00000p+32 -> ffff ffff 0000 0000 +(assert_return (invoke "i64.trunc_sat_f32_s" (f32.const 9223371487098961920.0)) (i64.const 9223371487098961920)) +(assert_return (invoke "i64.trunc_sat_f32_s" (f32.const -9223372036854775808.0)) (i64.const -9223372036854775808)) +(assert_return (invoke "i64.trunc_sat_f32_s" (f32.const 9223372036854775808.0)) (i64.const 0x7fffffffffffffff)) +(assert_return (invoke "i64.trunc_sat_f32_s" (f32.const -9223373136366403584.0)) (i64.const 0x8000000000000000)) +(assert_return (invoke "i64.trunc_sat_f32_s" (f32.const inf)) (i64.const 0x7fffffffffffffff)) +(assert_return (invoke "i64.trunc_sat_f32_s" (f32.const -inf)) (i64.const 0x8000000000000000)) +(assert_return (invoke "i64.trunc_sat_f32_s" (f32.const nan)) (i64.const 0)) +(assert_return (invoke "i64.trunc_sat_f32_s" (f32.const nan:0x200000)) (i64.const 0)) +(assert_return (invoke "i64.trunc_sat_f32_s" (f32.const -nan)) (i64.const 0)) +(assert_return (invoke "i64.trunc_sat_f32_s" (f32.const -nan:0x200000)) (i64.const 0)) + +(assert_return (invoke "i64.trunc_sat_f32_u" (f32.const 0.0)) (i64.const 0)) +(assert_return (invoke "i64.trunc_sat_f32_u" (f32.const -0.0)) (i64.const 0)) +(assert_return (invoke "i64.trunc_sat_f32_u" (f32.const 0x1p-149)) (i64.const 0)) +(assert_return (invoke "i64.trunc_sat_f32_u" (f32.const -0x1p-149)) (i64.const 0)) +(assert_return (invoke "i64.trunc_sat_f32_u" (f32.const 1.0)) (i64.const 1)) +(assert_return (invoke "i64.trunc_sat_f32_u" (f32.const 0x1.19999ap+0)) (i64.const 1)) +(assert_return (invoke "i64.trunc_sat_f32_u" (f32.const 1.5)) (i64.const 1)) +(assert_return (invoke "i64.trunc_sat_f32_u" (f32.const 4294967296)) (i64.const 4294967296)) +(assert_return (invoke "i64.trunc_sat_f32_u" (f32.const 18446742974197923840.0)) (i64.const -1099511627776)) +(assert_return (invoke "i64.trunc_sat_f32_u" (f32.const -0x1.ccccccp-1)) (i64.const 0)) +(assert_return (invoke "i64.trunc_sat_f32_u" (f32.const -0x1.fffffep-1)) (i64.const 0)) +(assert_return (invoke "i64.trunc_sat_f32_u" (f32.const 18446744073709551616.0)) (i64.const 0xffffffffffffffff)) +(assert_return (invoke "i64.trunc_sat_f32_u" (f32.const -1.0)) (i64.const 0x0000000000000000)) +(assert_return (invoke "i64.trunc_sat_f32_u" (f32.const inf)) (i64.const 0xffffffffffffffff)) +(assert_return (invoke "i64.trunc_sat_f32_u" (f32.const -inf)) (i64.const 0x0000000000000000)) +(assert_return (invoke "i64.trunc_sat_f32_u" (f32.const nan)) (i64.const 0)) +(assert_return (invoke "i64.trunc_sat_f32_u" (f32.const nan:0x200000)) (i64.const 0)) +(assert_return (invoke "i64.trunc_sat_f32_u" (f32.const -nan)) (i64.const 0)) +(assert_return (invoke "i64.trunc_sat_f32_u" (f32.const -nan:0x200000)) (i64.const 0)) + +(assert_return (invoke "i64.trunc_sat_f64_s" (f64.const 0.0)) (i64.const 0)) +(assert_return (invoke "i64.trunc_sat_f64_s" (f64.const -0.0)) (i64.const 0)) +(assert_return (invoke "i64.trunc_sat_f64_s" (f64.const 0x0.0000000000001p-1022)) (i64.const 0)) +(assert_return (invoke "i64.trunc_sat_f64_s" (f64.const -0x0.0000000000001p-1022)) (i64.const 0)) +(assert_return (invoke "i64.trunc_sat_f64_s" (f64.const 1.0)) (i64.const 1)) +(assert_return (invoke "i64.trunc_sat_f64_s" (f64.const 0x1.199999999999ap+0)) (i64.const 1)) +(assert_return (invoke "i64.trunc_sat_f64_s" (f64.const 1.5)) (i64.const 1)) +(assert_return (invoke "i64.trunc_sat_f64_s" (f64.const -1.0)) (i64.const -1)) +(assert_return (invoke "i64.trunc_sat_f64_s" (f64.const -0x1.199999999999ap+0)) (i64.const -1)) +(assert_return (invoke "i64.trunc_sat_f64_s" (f64.const -1.5)) (i64.const -1)) +(assert_return (invoke "i64.trunc_sat_f64_s" (f64.const -1.9)) (i64.const -1)) +(assert_return (invoke "i64.trunc_sat_f64_s" (f64.const -2.0)) (i64.const -2)) +(assert_return (invoke "i64.trunc_sat_f64_s" (f64.const 4294967296)) (i64.const 4294967296)) ;; 0x1.00000p+32 -> 1 0000 0000 +(assert_return (invoke "i64.trunc_sat_f64_s" (f64.const -4294967296)) (i64.const -4294967296)) ;; -0x1.00000p+32 -> ffff ffff 0000 0000 +(assert_return (invoke "i64.trunc_sat_f64_s" (f64.const 9223372036854774784.0)) (i64.const 9223372036854774784)) +(assert_return (invoke "i64.trunc_sat_f64_s" (f64.const -9223372036854775808.0)) (i64.const -9223372036854775808)) +(assert_return (invoke "i64.trunc_sat_f64_s" (f64.const 9223372036854775808.0)) (i64.const 0x7fffffffffffffff)) +(assert_return (invoke "i64.trunc_sat_f64_s" (f64.const -9223372036854777856.0)) (i64.const 0x8000000000000000)) +(assert_return (invoke "i64.trunc_sat_f64_s" (f64.const inf)) (i64.const 0x7fffffffffffffff)) +(assert_return (invoke "i64.trunc_sat_f64_s" (f64.const -inf)) (i64.const 0x8000000000000000)) +(assert_return (invoke "i64.trunc_sat_f64_s" (f64.const nan)) (i64.const 0)) +(assert_return (invoke "i64.trunc_sat_f64_s" (f64.const nan:0x4000000000000)) (i64.const 0)) +(assert_return (invoke "i64.trunc_sat_f64_s" (f64.const -nan)) (i64.const 0)) +(assert_return (invoke "i64.trunc_sat_f64_s" (f64.const -nan:0x4000000000000)) (i64.const 0)) + +(assert_return (invoke "i64.trunc_sat_f64_u" (f64.const 0.0)) (i64.const 0)) +(assert_return (invoke "i64.trunc_sat_f64_u" (f64.const -0.0)) (i64.const 0)) +(assert_return (invoke "i64.trunc_sat_f64_u" (f64.const 0x0.0000000000001p-1022)) (i64.const 0)) +(assert_return (invoke "i64.trunc_sat_f64_u" (f64.const -0x0.0000000000001p-1022)) (i64.const 0)) +(assert_return (invoke "i64.trunc_sat_f64_u" (f64.const 1.0)) (i64.const 1)) +(assert_return (invoke "i64.trunc_sat_f64_u" (f64.const 0x1.199999999999ap+0)) (i64.const 1)) +(assert_return (invoke "i64.trunc_sat_f64_u" (f64.const 1.5)) (i64.const 1)) +(assert_return (invoke "i64.trunc_sat_f64_u" (f64.const 4294967295)) (i64.const 0xffffffff)) +(assert_return (invoke "i64.trunc_sat_f64_u" (f64.const 4294967296)) (i64.const 0x100000000)) +(assert_return (invoke "i64.trunc_sat_f64_u" (f64.const 18446744073709549568.0)) (i64.const -2048)) +(assert_return (invoke "i64.trunc_sat_f64_u" (f64.const -0x1.ccccccccccccdp-1)) (i64.const 0)) +(assert_return (invoke "i64.trunc_sat_f64_u" (f64.const -0x1.fffffffffffffp-1)) (i64.const 0)) +(assert_return (invoke "i64.trunc_sat_f64_u" (f64.const 1e8)) (i64.const 100000000)) +(assert_return (invoke "i64.trunc_sat_f64_u" (f64.const 1e16)) (i64.const 10000000000000000)) +(assert_return (invoke "i64.trunc_sat_f64_u" (f64.const 9223372036854775808)) (i64.const -9223372036854775808)) +(assert_return (invoke "i64.trunc_sat_f64_u" (f64.const 18446744073709551616.0)) (i64.const 0xffffffffffffffff)) +(assert_return (invoke "i64.trunc_sat_f64_u" (f64.const -1.0)) (i64.const 0x0000000000000000)) +(assert_return (invoke "i64.trunc_sat_f64_u" (f64.const inf)) (i64.const 0xffffffffffffffff)) +(assert_return (invoke "i64.trunc_sat_f64_u" (f64.const -inf)) (i64.const 0x0000000000000000)) +(assert_return (invoke "i64.trunc_sat_f64_u" (f64.const nan)) (i64.const 0)) +(assert_return (invoke "i64.trunc_sat_f64_u" (f64.const nan:0x4000000000000)) (i64.const 0)) +(assert_return (invoke "i64.trunc_sat_f64_u" (f64.const -nan)) (i64.const 0)) +(assert_return (invoke "i64.trunc_sat_f64_u" (f64.const -nan:0x4000000000000)) (i64.const 0)) + +;; Test rounding directions. +(assert_return (invoke "f32.convert_i32_s" (i32.const 16777217)) (f32.const 16777216.0)) +(assert_return (invoke "f32.convert_i32_s" (i32.const -16777217)) (f32.const -16777216.0)) +(assert_return (invoke "f32.convert_i32_s" (i32.const 16777219)) (f32.const 16777220.0)) +(assert_return (invoke "f32.convert_i32_s" (i32.const -16777219)) (f32.const -16777220.0)) + +(assert_return (invoke "f32.convert_i64_s" (i64.const 1)) (f32.const 1.0)) +(assert_return (invoke "f32.convert_i64_s" (i64.const -1)) (f32.const -1.0)) +(assert_return (invoke "f32.convert_i64_s" (i64.const 0)) (f32.const 0.0)) +(assert_return (invoke "f32.convert_i64_s" (i64.const 9223372036854775807)) (f32.const 9223372036854775807)) +(assert_return (invoke "f32.convert_i64_s" (i64.const -9223372036854775808)) (f32.const -9223372036854775808)) +(assert_return (invoke "f32.convert_i64_s" (i64.const 314159265358979)) (f32.const 0x1.1db9e8p+48)) ;; PI +;; Test rounding directions. +(assert_return (invoke "f32.convert_i64_s" (i64.const 16777217)) (f32.const 16777216.0)) +(assert_return (invoke "f32.convert_i64_s" (i64.const -16777217)) (f32.const -16777216.0)) +(assert_return (invoke "f32.convert_i64_s" (i64.const 16777219)) (f32.const 16777220.0)) +(assert_return (invoke "f32.convert_i64_s" (i64.const -16777219)) (f32.const -16777220.0)) + +(assert_return (invoke "f32.convert_i64_s" (i64.const 0x7fffff4000000001)) (f32.const 0x1.fffffep+62)) +(assert_return (invoke "f32.convert_i64_s" (i64.const 0x8000004000000001)) (f32.const -0x1.fffffep+62)) +(assert_return (invoke "f32.convert_i64_s" (i64.const 0x0020000020000001)) (f32.const 0x1.000002p+53)) +(assert_return (invoke "f32.convert_i64_s" (i64.const 0xffdfffffdfffffff)) (f32.const -0x1.000002p+53)) + +(assert_return (invoke "f64.convert_i32_s" (i32.const 1)) (f64.const 1.0)) +(assert_return (invoke "f64.convert_i32_s" (i32.const -1)) (f64.const -1.0)) +(assert_return (invoke "f64.convert_i32_s" (i32.const 0)) (f64.const 0.0)) +(assert_return (invoke "f64.convert_i32_s" (i32.const 2147483647)) (f64.const 2147483647)) +(assert_return (invoke "f64.convert_i32_s" (i32.const -2147483648)) (f64.const -2147483648)) +(assert_return (invoke "f64.convert_i32_s" (i32.const 987654321)) (f64.const 987654321)) + +(assert_return (invoke "f64.convert_i64_s" (i64.const 1)) (f64.const 1.0)) +(assert_return (invoke "f64.convert_i64_s" (i64.const -1)) (f64.const -1.0)) +(assert_return (invoke "f64.convert_i64_s" (i64.const 0)) (f64.const 0.0)) +(assert_return (invoke "f64.convert_i64_s" (i64.const 9223372036854775807)) (f64.const 9223372036854775807)) +(assert_return (invoke "f64.convert_i64_s" (i64.const -9223372036854775808)) (f64.const -9223372036854775808)) +(assert_return (invoke "f64.convert_i64_s" (i64.const 4669201609102990)) (f64.const 4669201609102990)) ;; Feigenbaum +;; Test rounding directions. +(assert_return (invoke "f64.convert_i64_s" (i64.const 9007199254740993)) (f64.const 9007199254740992)) +(assert_return (invoke "f64.convert_i64_s" (i64.const -9007199254740993)) (f64.const -9007199254740992)) +(assert_return (invoke "f64.convert_i64_s" (i64.const 9007199254740995)) (f64.const 9007199254740996)) +(assert_return (invoke "f64.convert_i64_s" (i64.const -9007199254740995)) (f64.const -9007199254740996)) + +(assert_return (invoke "f32.convert_i32_u" (i32.const 1)) (f32.const 1.0)) +(assert_return (invoke "f32.convert_i32_u" (i32.const 0)) (f32.const 0.0)) +(assert_return (invoke "f32.convert_i32_u" (i32.const 2147483647)) (f32.const 2147483648)) +(assert_return (invoke "f32.convert_i32_u" (i32.const -2147483648)) (f32.const 2147483648)) +(assert_return (invoke "f32.convert_i32_u" (i32.const 0x12345678)) (f32.const 0x1.234568p+28)) +(assert_return (invoke "f32.convert_i32_u" (i32.const 0xffffffff)) (f32.const 4294967296.0)) +(assert_return (invoke "f32.convert_i32_u" (i32.const 0x80000080)) (f32.const 0x1.000000p+31)) +(assert_return (invoke "f32.convert_i32_u" (i32.const 0x80000081)) (f32.const 0x1.000002p+31)) +(assert_return (invoke "f32.convert_i32_u" (i32.const 0x80000082)) (f32.const 0x1.000002p+31)) +(assert_return (invoke "f32.convert_i32_u" (i32.const 0xfffffe80)) (f32.const 0x1.fffffcp+31)) +(assert_return (invoke "f32.convert_i32_u" (i32.const 0xfffffe81)) (f32.const 0x1.fffffep+31)) +(assert_return (invoke "f32.convert_i32_u" (i32.const 0xfffffe82)) (f32.const 0x1.fffffep+31)) +;; Test rounding directions. +(assert_return (invoke "f32.convert_i32_u" (i32.const 16777217)) (f32.const 16777216.0)) +(assert_return (invoke "f32.convert_i32_u" (i32.const 16777219)) (f32.const 16777220.0)) + +(assert_return (invoke "f32.convert_i64_u" (i64.const 1)) (f32.const 1.0)) +(assert_return (invoke "f32.convert_i64_u" (i64.const 0)) (f32.const 0.0)) +(assert_return (invoke "f32.convert_i64_u" (i64.const 9223372036854775807)) (f32.const 9223372036854775807)) +(assert_return (invoke "f32.convert_i64_u" (i64.const -9223372036854775808)) (f32.const 9223372036854775808)) +(assert_return (invoke "f32.convert_i64_u" (i64.const 0xffffffffffffffff)) (f32.const 18446744073709551616.0)) +;; Test rounding directions. +(assert_return (invoke "f32.convert_i64_u" (i64.const 16777217)) (f32.const 16777216.0)) +(assert_return (invoke "f32.convert_i64_u" (i64.const 16777219)) (f32.const 16777220.0)) + +(assert_return (invoke "f32.convert_i64_u" (i64.const 0x0020000020000001)) (f32.const 0x1.000002p+53)) +(assert_return (invoke "f32.convert_i64_u" (i64.const 0x7fffffbfffffffff)) (f32.const 0x1.fffffep+62)) +(assert_return (invoke "f32.convert_i64_u" (i64.const 0x8000008000000001)) (f32.const 0x1.000002p+63)) +(assert_return (invoke "f32.convert_i64_u" (i64.const 0xfffffe8000000001)) (f32.const 0x1.fffffep+63)) + +(assert_return (invoke "f64.convert_i32_u" (i32.const 1)) (f64.const 1.0)) +(assert_return (invoke "f64.convert_i32_u" (i32.const 0)) (f64.const 0.0)) +(assert_return (invoke "f64.convert_i32_u" (i32.const 2147483647)) (f64.const 2147483647)) +(assert_return (invoke "f64.convert_i32_u" (i32.const -2147483648)) (f64.const 2147483648)) +(assert_return (invoke "f64.convert_i32_u" (i32.const 0xffffffff)) (f64.const 4294967295.0)) + +(assert_return (invoke "f64.convert_i64_u" (i64.const 1)) (f64.const 1.0)) +(assert_return (invoke "f64.convert_i64_u" (i64.const 0)) (f64.const 0.0)) +(assert_return (invoke "f64.convert_i64_u" (i64.const 9223372036854775807)) (f64.const 9223372036854775807)) +(assert_return (invoke "f64.convert_i64_u" (i64.const -9223372036854775808)) (f64.const 9223372036854775808)) +(assert_return (invoke "f64.convert_i64_u" (i64.const 0xffffffffffffffff)) (f64.const 18446744073709551616.0)) +(assert_return (invoke "f64.convert_i64_u" (i64.const 0x8000000000000400)) (f64.const 0x1.0000000000000p+63)) +(assert_return (invoke "f64.convert_i64_u" (i64.const 0x8000000000000401)) (f64.const 0x1.0000000000001p+63)) +(assert_return (invoke "f64.convert_i64_u" (i64.const 0x8000000000000402)) (f64.const 0x1.0000000000001p+63)) +(assert_return (invoke "f64.convert_i64_u" (i64.const 0xfffffffffffff400)) (f64.const 0x1.ffffffffffffep+63)) +(assert_return (invoke "f64.convert_i64_u" (i64.const 0xfffffffffffff401)) (f64.const 0x1.fffffffffffffp+63)) +(assert_return (invoke "f64.convert_i64_u" (i64.const 0xfffffffffffff402)) (f64.const 0x1.fffffffffffffp+63)) +;; Test rounding directions. +(assert_return (invoke "f64.convert_i64_u" (i64.const 9007199254740993)) (f64.const 9007199254740992)) +(assert_return (invoke "f64.convert_i64_u" (i64.const 9007199254740995)) (f64.const 9007199254740996)) + +(assert_return (invoke "f64.promote_f32" (f32.const 0.0)) (f64.const 0.0)) +(assert_return (invoke "f64.promote_f32" (f32.const -0.0)) (f64.const -0.0)) +(assert_return (invoke "f64.promote_f32" (f32.const 0x1p-149)) (f64.const 0x1p-149)) +(assert_return (invoke "f64.promote_f32" (f32.const -0x1p-149)) (f64.const -0x1p-149)) +(assert_return (invoke "f64.promote_f32" (f32.const 1.0)) (f64.const 1.0)) +(assert_return (invoke "f64.promote_f32" (f32.const -1.0)) (f64.const -1.0)) +(assert_return (invoke "f64.promote_f32" (f32.const -0x1.fffffep+127)) (f64.const -0x1.fffffep+127)) +(assert_return (invoke "f64.promote_f32" (f32.const 0x1.fffffep+127)) (f64.const 0x1.fffffep+127)) +;; Generated randomly by picking a random int and reinterpret it to float. +(assert_return (invoke "f64.promote_f32" (f32.const 0x1p-119)) (f64.const 0x1p-119)) +;; Generated randomly by picking a random float. +(assert_return (invoke "f64.promote_f32" (f32.const 0x1.8f867ep+125)) (f64.const 6.6382536710104395e+37)) +(assert_return (invoke "f64.promote_f32" (f32.const inf)) (f64.const inf)) +(assert_return (invoke "f64.promote_f32" (f32.const -inf)) (f64.const -inf)) +(assert_return (invoke "f64.promote_f32" (f32.const nan)) (f64.const nan:canonical)) +(assert_return (invoke "f64.promote_f32" (f32.const nan:0x200000)) (f64.const nan:arithmetic)) +(assert_return (invoke "f64.promote_f32" (f32.const -nan)) (f64.const nan:canonical)) +(assert_return (invoke "f64.promote_f32" (f32.const -nan:0x200000)) (f64.const nan:arithmetic)) + +(assert_return (invoke "f32.demote_f64" (f64.const 0.0)) (f32.const 0.0)) +(assert_return (invoke "f32.demote_f64" (f64.const -0.0)) (f32.const -0.0)) +(assert_return (invoke "f32.demote_f64" (f64.const 0x0.0000000000001p-1022)) (f32.const 0.0)) +(assert_return (invoke "f32.demote_f64" (f64.const -0x0.0000000000001p-1022)) (f32.const -0.0)) +(assert_return (invoke "f32.demote_f64" (f64.const 1.0)) (f32.const 1.0)) +(assert_return (invoke "f32.demote_f64" (f64.const -1.0)) (f32.const -1.0)) +(assert_return (invoke "f32.demote_f64" (f64.const 0x1.fffffe0000000p-127)) (f32.const 0x1p-126)) +(assert_return (invoke "f32.demote_f64" (f64.const -0x1.fffffe0000000p-127)) (f32.const -0x1p-126)) +(assert_return (invoke "f32.demote_f64" (f64.const 0x1.fffffdfffffffp-127)) (f32.const 0x1.fffffcp-127)) +(assert_return (invoke "f32.demote_f64" (f64.const -0x1.fffffdfffffffp-127)) (f32.const -0x1.fffffcp-127)) +(assert_return (invoke "f32.demote_f64" (f64.const 0x1p-149)) (f32.const 0x1p-149)) +(assert_return (invoke "f32.demote_f64" (f64.const -0x1p-149)) (f32.const -0x1p-149)) +(assert_return (invoke "f32.demote_f64" (f64.const 0x1.fffffd0000000p+127)) (f32.const 0x1.fffffcp+127)) +(assert_return (invoke "f32.demote_f64" (f64.const -0x1.fffffd0000000p+127)) (f32.const -0x1.fffffcp+127)) +(assert_return (invoke "f32.demote_f64" (f64.const 0x1.fffffd0000001p+127)) (f32.const 0x1.fffffep+127)) +(assert_return (invoke "f32.demote_f64" (f64.const -0x1.fffffd0000001p+127)) (f32.const -0x1.fffffep+127)) +(assert_return (invoke "f32.demote_f64" (f64.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127)) +(assert_return (invoke "f32.demote_f64" (f64.const -0x1.fffffep+127)) (f32.const -0x1.fffffep+127)) +(assert_return (invoke "f32.demote_f64" (f64.const 0x1.fffffefffffffp+127)) (f32.const 0x1.fffffep+127)) +(assert_return (invoke "f32.demote_f64" (f64.const -0x1.fffffefffffffp+127)) (f32.const -0x1.fffffep+127)) +(assert_return (invoke "f32.demote_f64" (f64.const 0x1.ffffffp+127)) (f32.const inf)) +(assert_return (invoke "f32.demote_f64" (f64.const -0x1.ffffffp+127)) (f32.const -inf)) +(assert_return (invoke "f32.demote_f64" (f64.const 0x1p-119)) (f32.const 0x1p-119)) +(assert_return (invoke "f32.demote_f64" (f64.const 0x1.8f867ep+125)) (f32.const 0x1.8f867ep+125)) +(assert_return (invoke "f32.demote_f64" (f64.const inf)) (f32.const inf)) +(assert_return (invoke "f32.demote_f64" (f64.const -inf)) (f32.const -inf)) +(assert_return (invoke "f32.demote_f64" (f64.const 0x1.0000000000001p+0)) (f32.const 1.0)) +(assert_return (invoke "f32.demote_f64" (f64.const 0x1.fffffffffffffp-1)) (f32.const 1.0)) +(assert_return (invoke "f32.demote_f64" (f64.const 0x1.0000010000000p+0)) (f32.const 0x1.000000p+0)) +(assert_return (invoke "f32.demote_f64" (f64.const 0x1.0000010000001p+0)) (f32.const 0x1.000002p+0)) +(assert_return (invoke "f32.demote_f64" (f64.const 0x1.000002fffffffp+0)) (f32.const 0x1.000002p+0)) +(assert_return (invoke "f32.demote_f64" (f64.const 0x1.0000030000000p+0)) (f32.const 0x1.000004p+0)) +(assert_return (invoke "f32.demote_f64" (f64.const 0x1.0000050000000p+0)) (f32.const 0x1.000004p+0)) +(assert_return (invoke "f32.demote_f64" (f64.const 0x1.0000010000000p+24)) (f32.const 0x1.0p+24)) +(assert_return (invoke "f32.demote_f64" (f64.const 0x1.0000010000001p+24)) (f32.const 0x1.000002p+24)) +(assert_return (invoke "f32.demote_f64" (f64.const 0x1.000002fffffffp+24)) (f32.const 0x1.000002p+24)) +(assert_return (invoke "f32.demote_f64" (f64.const 0x1.0000030000000p+24)) (f32.const 0x1.000004p+24)) +(assert_return (invoke "f32.demote_f64" (f64.const 0x1.4eae4f7024c7p+108)) (f32.const 0x1.4eae5p+108)) +(assert_return (invoke "f32.demote_f64" (f64.const 0x1.a12e71e358685p-113)) (f32.const 0x1.a12e72p-113)) +(assert_return (invoke "f32.demote_f64" (f64.const 0x1.cb98354d521ffp-127)) (f32.const 0x1.cb9834p-127)) +(assert_return (invoke "f32.demote_f64" (f64.const -0x1.6972b30cfb562p+1)) (f32.const -0x1.6972b4p+1)) +(assert_return (invoke "f32.demote_f64" (f64.const -0x1.bedbe4819d4c4p+112)) (f32.const -0x1.bedbe4p+112)) +(assert_return (invoke "f32.demote_f64" (f64.const nan)) (f32.const nan:canonical)) +(assert_return (invoke "f32.demote_f64" (f64.const nan:0x4000000000000)) (f32.const nan:arithmetic)) +(assert_return (invoke "f32.demote_f64" (f64.const -nan)) (f32.const nan:canonical)) +(assert_return (invoke "f32.demote_f64" (f64.const -nan:0x4000000000000)) (f32.const nan:arithmetic)) +(assert_return (invoke "f32.demote_f64" (f64.const 0x1p-1022)) (f32.const 0.0)) +(assert_return (invoke "f32.demote_f64" (f64.const -0x1p-1022)) (f32.const -0.0)) +(assert_return (invoke "f32.demote_f64" (f64.const 0x1.0p-150)) (f32.const 0.0)) +(assert_return (invoke "f32.demote_f64" (f64.const -0x1.0p-150)) (f32.const -0.0)) +(assert_return (invoke "f32.demote_f64" (f64.const 0x1.0000000000001p-150)) (f32.const 0x1p-149)) +(assert_return (invoke "f32.demote_f64" (f64.const -0x1.0000000000001p-150)) (f32.const -0x1p-149)) + +(assert_return (invoke "f32.reinterpret_i32" (i32.const 0)) (f32.const 0.0)) +(assert_return (invoke "f32.reinterpret_i32" (i32.const 0x80000000)) (f32.const -0.0)) +(assert_return (invoke "f32.reinterpret_i32" (i32.const 1)) (f32.const 0x1p-149)) +(assert_return (invoke "f32.reinterpret_i32" (i32.const -1)) (f32.const -nan:0x7fffff)) +(assert_return (invoke "f32.reinterpret_i32" (i32.const 123456789)) (f32.const 0x1.b79a2ap-113)) +(assert_return (invoke "f32.reinterpret_i32" (i32.const -2147483647)) (f32.const -0x1p-149)) +(assert_return (invoke "f32.reinterpret_i32" (i32.const 0x7f800000)) (f32.const inf)) +(assert_return (invoke "f32.reinterpret_i32" (i32.const 0xff800000)) (f32.const -inf)) +(assert_return (invoke "f32.reinterpret_i32" (i32.const 0x7fc00000)) (f32.const nan)) +(assert_return (invoke "f32.reinterpret_i32" (i32.const 0xffc00000)) (f32.const -nan)) +(assert_return (invoke "f32.reinterpret_i32" (i32.const 0x7fa00000)) (f32.const nan:0x200000)) +(assert_return (invoke "f32.reinterpret_i32" (i32.const 0xffa00000)) (f32.const -nan:0x200000)) + +(assert_return (invoke "f64.reinterpret_i64" (i64.const 0)) (f64.const 0.0)) +(assert_return (invoke "f64.reinterpret_i64" (i64.const 1)) (f64.const 0x0.0000000000001p-1022)) +(assert_return (invoke "f64.reinterpret_i64" (i64.const -1)) (f64.const -nan:0xfffffffffffff)) +(assert_return (invoke "f64.reinterpret_i64" (i64.const 0x8000000000000000)) (f64.const -0.0)) +(assert_return (invoke "f64.reinterpret_i64" (i64.const 1234567890)) (f64.const 0x0.00000499602d2p-1022)) +(assert_return (invoke "f64.reinterpret_i64" (i64.const -9223372036854775807)) (f64.const -0x0.0000000000001p-1022)) +(assert_return (invoke "f64.reinterpret_i64" (i64.const 0x7ff0000000000000)) (f64.const inf)) +(assert_return (invoke "f64.reinterpret_i64" (i64.const 0xfff0000000000000)) (f64.const -inf)) +(assert_return (invoke "f64.reinterpret_i64" (i64.const 0x7ff8000000000000)) (f64.const nan)) +(assert_return (invoke "f64.reinterpret_i64" (i64.const 0xfff8000000000000)) (f64.const -nan)) +(assert_return (invoke "f64.reinterpret_i64" (i64.const 0x7ff4000000000000)) (f64.const nan:0x4000000000000)) +(assert_return (invoke "f64.reinterpret_i64" (i64.const 0xfff4000000000000)) (f64.const -nan:0x4000000000000)) + +(assert_return (invoke "i32.reinterpret_f32" (f32.const 0.0)) (i32.const 0)) +(assert_return (invoke "i32.reinterpret_f32" (f32.const -0.0)) (i32.const 0x80000000)) +(assert_return (invoke "i32.reinterpret_f32" (f32.const 0x1p-149)) (i32.const 1)) +(assert_return (invoke "i32.reinterpret_f32" (f32.const -nan:0x7fffff)) (i32.const -1)) +(assert_return (invoke "i32.reinterpret_f32" (f32.const -0x1p-149)) (i32.const 0x80000001)) +(assert_return (invoke "i32.reinterpret_f32" (f32.const 1.0)) (i32.const 1065353216)) +(assert_return (invoke "i32.reinterpret_f32" (f32.const 3.1415926)) (i32.const 1078530010)) +(assert_return (invoke "i32.reinterpret_f32" (f32.const 0x1.fffffep+127)) (i32.const 2139095039)) +(assert_return (invoke "i32.reinterpret_f32" (f32.const -0x1.fffffep+127)) (i32.const -8388609)) +(assert_return (invoke "i32.reinterpret_f32" (f32.const inf)) (i32.const 0x7f800000)) +(assert_return (invoke "i32.reinterpret_f32" (f32.const -inf)) (i32.const 0xff800000)) +(assert_return (invoke "i32.reinterpret_f32" (f32.const nan)) (i32.const 0x7fc00000)) +(assert_return (invoke "i32.reinterpret_f32" (f32.const -nan)) (i32.const 0xffc00000)) +(assert_return (invoke "i32.reinterpret_f32" (f32.const nan:0x200000)) (i32.const 0x7fa00000)) +(assert_return (invoke "i32.reinterpret_f32" (f32.const -nan:0x200000)) (i32.const 0xffa00000)) + +(assert_return (invoke "i64.reinterpret_f64" (f64.const 0.0)) (i64.const 0)) +(assert_return (invoke "i64.reinterpret_f64" (f64.const -0.0)) (i64.const 0x8000000000000000)) +(assert_return (invoke "i64.reinterpret_f64" (f64.const 0x0.0000000000001p-1022)) (i64.const 1)) +(assert_return (invoke "i64.reinterpret_f64" (f64.const -nan:0xfffffffffffff)) (i64.const -1)) +(assert_return (invoke "i64.reinterpret_f64" (f64.const -0x0.0000000000001p-1022)) (i64.const 0x8000000000000001)) +(assert_return (invoke "i64.reinterpret_f64" (f64.const 1.0)) (i64.const 4607182418800017408)) +(assert_return (invoke "i64.reinterpret_f64" (f64.const 3.14159265358979)) (i64.const 4614256656552045841)) +(assert_return (invoke "i64.reinterpret_f64" (f64.const 0x1.fffffffffffffp+1023)) (i64.const 9218868437227405311)) +(assert_return (invoke "i64.reinterpret_f64" (f64.const -0x1.fffffffffffffp+1023)) (i64.const -4503599627370497)) +(assert_return (invoke "i64.reinterpret_f64" (f64.const inf)) (i64.const 0x7ff0000000000000)) +(assert_return (invoke "i64.reinterpret_f64" (f64.const -inf)) (i64.const 0xfff0000000000000)) +(assert_return (invoke "i64.reinterpret_f64" (f64.const nan)) (i64.const 0x7ff8000000000000)) +(assert_return (invoke "i64.reinterpret_f64" (f64.const -nan)) (i64.const 0xfff8000000000000)) +(assert_return (invoke "i64.reinterpret_f64" (f64.const nan:0x4000000000000)) (i64.const 0x7ff4000000000000)) +(assert_return (invoke "i64.reinterpret_f64" (f64.const -nan:0x4000000000000)) (i64.const 0xfff4000000000000)) + +;; Type check + +(assert_invalid (module (func (result i32) (i32.wrap_i64 (f32.const 0)))) "type mismatch") +(assert_invalid (module (func (result i32) (i32.trunc_f32_s (i64.const 0)))) "type mismatch") +(assert_invalid (module (func (result i32) (i32.trunc_f32_u (i64.const 0)))) "type mismatch") +(assert_invalid (module (func (result i32) (i32.trunc_f64_s (i64.const 0)))) "type mismatch") +(assert_invalid (module (func (result i32) (i32.trunc_f64_u (i64.const 0)))) "type mismatch") +(assert_invalid (module (func (result i32) (i32.reinterpret_f32 (i64.const 0)))) "type mismatch") +(assert_invalid (module (func (result i64) (i64.extend_i32_s (f32.const 0)))) "type mismatch") +(assert_invalid (module (func (result i64) (i64.extend_i32_u (f32.const 0)))) "type mismatch") +(assert_invalid (module (func (result i64) (i64.trunc_f32_s (i32.const 0)))) "type mismatch") +(assert_invalid (module (func (result i64) (i64.trunc_f32_u (i32.const 0)))) "type mismatch") +(assert_invalid (module (func (result i64) (i64.trunc_f64_s (i32.const 0)))) "type mismatch") +(assert_invalid (module (func (result i64) (i64.trunc_f64_u (i32.const 0)))) "type mismatch") +(assert_invalid (module (func (result i64) (i64.reinterpret_f64 (i32.const 0)))) "type mismatch") +(assert_invalid (module (func (result f32) (f32.convert_i32_s (i64.const 0)))) "type mismatch") +(assert_invalid (module (func (result f32) (f32.convert_i32_u (i64.const 0)))) "type mismatch") +(assert_invalid (module (func (result f32) (f32.convert_i64_s (i32.const 0)))) "type mismatch") +(assert_invalid (module (func (result f32) (f32.convert_i64_u (i32.const 0)))) "type mismatch") +(assert_invalid (module (func (result f32) (f32.demote_f64 (i32.const 0)))) "type mismatch") +(assert_invalid (module (func (result f32) (f32.reinterpret_i32 (i64.const 0)))) "type mismatch") +(assert_invalid (module (func (result f64) (f64.convert_i32_s (i64.const 0)))) "type mismatch") +(assert_invalid (module (func (result f64) (f64.convert_i32_u (i64.const 0)))) "type mismatch") +(assert_invalid (module (func (result f64) (f64.convert_i64_s (i32.const 0)))) "type mismatch") +(assert_invalid (module (func (result f64) (f64.convert_i64_u (i32.const 0)))) "type mismatch") +(assert_invalid (module (func (result f64) (f64.promote_f32 (i32.const 0)))) "type mismatch") +(assert_invalid (module (func (result f64) (f64.reinterpret_i64 (i32.const 0)))) "type mismatch") diff --git a/runtime/near-vm/tests/wast/spec/custom.wast b/runtime/near-vm/tests/wast/spec/custom.wast new file mode 100644 index 00000000000..b2394f5e3ba --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/custom.wast @@ -0,0 +1,130 @@ +(module binary + "\00asm" "\01\00\00\00" + "\00\24\10" "a custom section" "this is the payload" + "\00\20\10" "a custom section" "this is payload" + "\00\11\10" "a custom section" "" + "\00\10\00" "" "this is payload" + "\00\01\00" "" "" + "\00\24\10" "\00\00custom sectio\00" "this is the payload" + "\00\24\10" "\ef\bb\bfa custom sect" "this is the payload" + "\00\24\10" "a custom sect\e2\8c\a3" "this is the payload" + "\00\1f\16" "module within a module" "\00asm" "\01\00\00\00" +) + +(module binary + "\00asm" "\01\00\00\00" + "\00\0e\06" "custom" "payload" + "\00\0e\06" "custom" "payload" + "\01\01\00" ;; type section + "\00\0e\06" "custom" "payload" + "\00\0e\06" "custom" "payload" + "\02\01\00" ;; import section + "\00\0e\06" "custom" "payload" + "\00\0e\06" "custom" "payload" + "\03\01\00" ;; function section + "\00\0e\06" "custom" "payload" + "\00\0e\06" "custom" "payload" + "\04\01\00" ;; table section + "\00\0e\06" "custom" "payload" + "\00\0e\06" "custom" "payload" + "\05\01\00" ;; memory section + "\00\0e\06" "custom" "payload" + "\00\0e\06" "custom" "payload" + "\06\01\00" ;; global section + "\00\0e\06" "custom" "payload" + "\00\0e\06" "custom" "payload" + "\07\01\00" ;; export section + "\00\0e\06" "custom" "payload" + "\00\0e\06" "custom" "payload" + "\09\01\00" ;; element section + "\00\0e\06" "custom" "payload" + "\00\0e\06" "custom" "payload" + "\0a\01\00" ;; code section + "\00\0e\06" "custom" "payload" + "\00\0e\06" "custom" "payload" + "\0b\01\00" ;; data section + "\00\0e\06" "custom" "payload" + "\00\0e\06" "custom" "payload" +) + +(module binary + "\00asm" "\01\00\00\00" + "\01\07\01\60\02\7f\7f\01\7f" ;; type section + "\00\1a\06" "custom" "this is the payload" ;; custom section + "\03\02\01\00" ;; function section + "\07\0a\01\06\61\64\64\54\77\6f\00\00" ;; export section + "\0a\09\01\07\00\20\00\20\01\6a\0b" ;; code section + "\00\1b\07" "custom2" "this is the payload" ;; custom section +) + +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00" + ) + "unexpected end" +) + +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\00" + ) + "unexpected end" +) + +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\00\00\05\01\00\07\00\00" + ) + "unexpected end" +) + +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\26\10" "a custom section" "this is the payload" + ) + "unexpected end" +) + +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\25\10" "a custom section" "this is the payload" + "\00\24\10" "a custom section" "this is the payload" + ) + "malformed section id" +) + +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\07\01\60\02\7f\7f\01\7f" ;; type section + "\00\25\10" "a custom section" "this is the payload" ;; wrong length! + "\03\02\01\00" ;; function section + "\0a\09\01\07\00\20\00\20\01\6a\0b" ;; code section + "\00\1b\07" "custom2" "this is the payload" ;; custom section + ) + "function and code section have inconsistent lengths" +) + +;; Test concatenated modules. +(assert_malformed + (module binary + "\00asm\01\00\00\00" + "\00asm\01\00\00\00" + ) + "length out of bounds" +) + +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\05\03\01\00\01" ;; memory section + "\0c\01\02" ;; data count section (2 segments) + "\0b\06\01\00\41\00\0b\00" ;; data section (1 segment) + ) + "data count and data section have inconsistent lengths" +) diff --git a/runtime/near-vm/tests/wast/spec/data.wast b/runtime/near-vm/tests/wast/spec/data.wast new file mode 100644 index 00000000000..f7d1f09bca6 --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/data.wast @@ -0,0 +1,481 @@ +;; Test the data section + +;; Syntax + +(module + (memory $m 1) + (data (i32.const 0)) + (data (i32.const 1) "a" "" "bcd") + (data (offset (i32.const 0))) + (data (offset (i32.const 0)) "" "a" "bc" "") + (data (memory 0) (i32.const 0)) + (data (memory 0x0) (i32.const 1) "a" "" "bcd") + (data (memory 0x000) (offset (i32.const 0))) + (data (memory 0) (offset (i32.const 0)) "" "a" "bc" "") + (data (memory $m) (i32.const 0)) + (data (memory $m) (i32.const 1) "a" "" "bcd") + (data (memory $m) (offset (i32.const 0))) + (data (memory $m) (offset (i32.const 0)) "" "a" "bc" "") + (data $d1 (i32.const 0)) + (data $d2 (i32.const 1) "a" "" "bcd") + (data $d3 (offset (i32.const 0))) + (data $d4 (offset (i32.const 0)) "" "a" "bc" "") + (data $d5 (memory 0) (i32.const 0)) + (data $d6 (memory 0x0) (i32.const 1) "a" "" "bcd") + (data $d7 (memory 0x000) (offset (i32.const 0))) + (data $d8 (memory 0) (offset (i32.const 0)) "" "a" "bc" "") + (data $d9 (memory $m) (i32.const 0)) + (data $d10 (memory $m) (i32.const 1) "a" "" "bcd") + (data $d11 (memory $m) (offset (i32.const 0))) + (data $d12 (memory $m) (offset (i32.const 0)) "" "a" "bc" "") +) + +;; Basic use + +(module + (memory 1) + (data (i32.const 0) "a") +) +(module + (import "spectest" "memory" (memory 1)) + (data (i32.const 0) "a") +) + +(module + (memory 1) + (data (i32.const 0) "a") + (data (i32.const 3) "b") + (data (i32.const 100) "cde") + (data (i32.const 5) "x") + (data (i32.const 3) "c") +) +(module + (import "spectest" "memory" (memory 1)) + (data (i32.const 0) "a") + (data (i32.const 1) "b") + (data (i32.const 2) "cde") + (data (i32.const 3) "f") + (data (i32.const 2) "g") + (data (i32.const 1) "h") +) + +(module + (global (import "spectest" "global_i32") i32) + (memory 1) + (data (global.get 0) "a") +) +(module + (global (import "spectest" "global_i32") i32) + (import "spectest" "memory" (memory 1)) + (data (global.get 0) "a") +) + +(module + (global $g (import "spectest" "global_i32") i32) + (memory 1) + (data (global.get $g) "a") +) +(module + (global $g (import "spectest" "global_i32") i32) + (import "spectest" "memory" (memory 1)) + (data (global.get $g) "a") +) + +;; Use of internal globals in constant expressions is not allowed in MVP. +;; (module (memory 1) (data (global.get 0) "a") (global i32 (i32.const 0))) +;; (module (memory 1) (data (global.get $g) "a") (global $g i32 (i32.const 0))) + +;; Corner cases + +(module + (memory 1) + (data (i32.const 0) "a") + (data (i32.const 0xffff) "b") +) +(module + (import "spectest" "memory" (memory 1)) + (data (i32.const 0) "a") + (data (i32.const 0xffff) "b") +) + +(module + (memory 2) + (data (i32.const 0x1_ffff) "a") +) + +(module + (memory 0) + (data (i32.const 0)) +) +(module + (import "spectest" "memory" (memory 0)) + (data (i32.const 0)) +) + +(module + (memory 0 0) + (data (i32.const 0)) +) + +(module + (memory 1) + (data (i32.const 0x1_0000) "") +) + +(module + (memory 0) + (data (i32.const 0) "" "") +) +(module + (import "spectest" "memory" (memory 0)) + (data (i32.const 0) "" "") +) + +(module + (memory 0 0) + (data (i32.const 0) "" "") +) + +(module + (import "spectest" "memory" (memory 0)) + (data (i32.const 0) "a") +) + +(module + (import "spectest" "memory" (memory 0 3)) + (data (i32.const 0) "a") +) + +(module + (global (import "spectest" "global_i32") i32) + (import "spectest" "memory" (memory 0)) + (data (global.get 0) "a") +) + +(module + (global (import "spectest" "global_i32") i32) + (import "spectest" "memory" (memory 0 3)) + (data (global.get 0) "a") +) + +(module + (import "spectest" "memory" (memory 0)) + (data (i32.const 1) "a") +) + +(module + (import "spectest" "memory" (memory 0 3)) + (data (i32.const 1) "a") +) + +;; Invalid bounds for data + +(assert_trap + (module + (memory 0) + (data (i32.const 0) "a") + ) + "out of bounds memory access" +) + +(assert_trap + (module + (memory 0 0) + (data (i32.const 0) "a") + ) + "out of bounds memory access" +) + +(assert_trap + (module + (memory 0 1) + (data (i32.const 0) "a") + ) + "out of bounds memory access" +) +(assert_trap + (module + (memory 0) + (data (i32.const 1)) + ) + "out of bounds memory access" +) +(assert_trap + (module + (memory 0 1) + (data (i32.const 1)) + ) + "out of bounds memory access" +) + +;; This seems to cause a time-out on Travis. +(;assert_unlinkable + (module + (memory 0x10000) + (data (i32.const 0xffffffff) "ab") + ) + "" ;; either out of memory or out of bounds +;) + +(assert_trap + (module + (global (import "spectest" "global_i32") i32) + (memory 0) + (data (global.get 0) "a") + ) + "out of bounds memory access" +) + +(assert_trap + (module + (memory 1 2) + (data (i32.const 0x1_0000) "a") + ) + "out of bounds memory access" +) +(assert_trap + (module + (import "spectest" "memory" (memory 1)) + (data (i32.const 0x1_0000) "a") + ) + "out of bounds memory access" +) + +(assert_trap + (module + (memory 2) + (data (i32.const 0x2_0000) "a") + ) + "out of bounds memory access" +) + +(assert_trap + (module + (memory 2 3) + (data (i32.const 0x2_0000) "a") + ) + "out of bounds memory access" +) + +(assert_trap + (module + (memory 1) + (data (i32.const -1) "a") + ) + "out of bounds memory access" +) +(assert_trap + (module + (import "spectest" "memory" (memory 1)) + (data (i32.const -1) "a") + ) + "out of bounds memory access" +) + +(assert_trap + (module + (memory 2) + (data (i32.const -100) "a") + ) + "out of bounds memory access" +) +(assert_trap + (module + (import "spectest" "memory" (memory 1)) + (data (i32.const -100) "a") + ) + "out of bounds memory access" +) + +;; Data without memory + +(assert_invalid + (module + (data (i32.const 0) "") + ) + "unknown memory" +) + +;; Data segment with memory index 1 (only memory 0 available) +(assert_invalid + (module binary + "\00asm" "\01\00\00\00" + "\05\03\01" ;; memory section + "\00\00" ;; memory 0 + "\0b\07\01" ;; data section + "\02\01\41\00\0b" ;; active data segment 0 for memory 1 + "\00" ;; empty vec(byte) + ) + "unknown memory 1" +) + +;; Data segment with memory index 0 (no memory section) +(assert_invalid + (module binary + "\00asm" "\01\00\00\00" + "\0b\06\01" ;; data section + "\00\41\00\0b" ;; active data segment 0 for memory 0 + "\00" ;; empty vec(byte) + ) + "unknown memory 0" +) + +;; Data segment with memory index 1 (no memory section) +(assert_invalid + (module binary + "\00asm" "\01\00\00\00" + "\0b\07\01" ;; data section + "\02\01\41\00\0b" ;; active data segment 0 for memory 1 + "\00" ;; empty vec(byte) + ) + "unknown memory 1" +) + +;; Data segment with memory index 1 and vec(byte) as above, +;; only memory 0 available. +(assert_invalid + (module binary + "\00asm" "\01\00\00\00" + "\05\03\01" ;; memory section + "\00\00" ;; memory 0 + "\0b\45\01" ;; data section + "\02" ;; active segment + "\01" ;; memory index + "\41\00\0b" ;; offset constant expression + "\3e" ;; vec(byte) length + "\00\01\02\03\04\05\06\07\08\09\0a\0b\0c\0d\0e\0f" + "\10\11\12\13\14\15\16\17\18\19\1a\1b\1c\1d\1e\1f" + "\20\21\22\23\24\25\26\27\28\29\2a\2b\2c\2d\2e\2f" + "\30\31\32\33\34\35\36\37\38\39\3a\3b\3c\3d" + ) + "unknown memory 1" +) + +;; Data segment with memory index 1 and specially crafted vec(byte) after. +;; This is to detect incorrect validation where memory index is interpreted +;; as a flag followed by "\41" interpreted as the size of vec(byte) +;; with the expected number of bytes following. +(assert_invalid + (module binary + "\00asm" "\01\00\00\00" + "\0b\45\01" ;; data section + "\02" ;; active segment + "\01" ;; memory index + "\41\00\0b" ;; offset constant expression + "\3e" ;; vec(byte) length + "\00\01\02\03\04\05\06\07\08\09\0a\0b\0c\0d\0e\0f" + "\10\11\12\13\14\15\16\17\18\19\1a\1b\1c\1d\1e\1f" + "\20\21\22\23\24\25\26\27\28\29\2a\2b\2c\2d\2e\2f" + "\30\31\32\33\34\35\36\37\38\39\3a\3b\3c\3d" + ) + "unknown memory 1" +) + + +;; Invalid offsets + +(assert_invalid + (module + (memory 1) + (data (i64.const 0)) + ) + "type mismatch" +) + +(assert_invalid + (module + (memory 1) + (data (offset (;empty instruction sequence;))) + ) + "type mismatch" +) + +(assert_invalid + (module + (memory 1) + (data (offset (i32.const 0) (i32.const 0))) + ) + "type mismatch" +) + +(assert_invalid + (module + (global (import "test" "global-i32") i32) + (memory 1) + (data (offset (global.get 0) (global.get 0))) + ) + "type mismatch" +) + +(assert_invalid + (module + (global (import "test" "global-i32") i32) + (memory 1) + (data (offset (global.get 0) (i32.const 0))) + ) + "type mismatch" +) + +(assert_invalid + (module + (memory 1) + (data (i32.ctz (i32.const 0))) + ) + "constant expression required" +) + +(assert_invalid + (module + (memory 1) + (data (nop)) + ) + "constant expression required" +) + +(assert_invalid + (module + (memory 1) + (data (offset (nop) (i32.const 0))) + ) + "constant expression required" +) + +(assert_invalid + (module + (memory 1) + (data (offset (i32.const 0) (nop))) + ) + "constant expression required" +) + +;; Use of internal globals in constant expressions is not allowed in MVP. +;; (assert_invalid +;; (module (memory 1) (data (global.get $g)) (global $g (mut i32) (i32.const 0))) +;; "constant expression required" +;; ) + +(assert_invalid + (module + (memory 1) + (data (global.get 0)) + ) + "unknown global 0" +) + +(assert_invalid + (module + (global (import "test" "global-i32") i32) + (memory 1) + (data (global.get 1)) + ) + "unknown global 1" +) + +(assert_invalid + (module + (global (import "test" "global-mut-i32") (mut i32)) + (memory 1) + (data (global.get 0)) + ) + "constant expression required" +) diff --git a/runtime/near-vm/tests/wast/spec/elem.wast b/runtime/near-vm/tests/wast/spec/elem.wast new file mode 100644 index 00000000000..19b5fe92058 --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/elem.wast @@ -0,0 +1,529 @@ +;; Test the element section + +;; Syntax +(module + (table $t 10 funcref) + (func $f) + (func $g) + + ;; Passive + (elem funcref) + (elem funcref (ref.func $f) (item ref.func $f) (item (ref.null func)) (ref.func $g)) + (elem func) + (elem func $f $f $g $g) + + (elem $p1 funcref) + (elem $p2 funcref (ref.func $f) (ref.func $f) (ref.null func) (ref.func $g)) + (elem $p3 func) + (elem $p4 func $f $f $g $g) + + ;; Active + (elem (table $t) (i32.const 0) funcref) + (elem (table $t) (i32.const 0) funcref (ref.func $f) (ref.null func)) + (elem (table $t) (i32.const 0) func) + (elem (table $t) (i32.const 0) func $f $g) + (elem (table $t) (offset (i32.const 0)) funcref) + (elem (table $t) (offset (i32.const 0)) func $f $g) + (elem (table 0) (i32.const 0) func) + (elem (table 0x0) (i32.const 0) func $f $f) + (elem (table 0x000) (offset (i32.const 0)) func) + (elem (table 0) (offset (i32.const 0)) func $f $f) + (elem (table $t) (i32.const 0) func) + (elem (table $t) (i32.const 0) func $f $f) + (elem (table $t) (offset (i32.const 0)) func) + (elem (table $t) (offset (i32.const 0)) func $f $f) + (elem (offset (i32.const 0))) + (elem (offset (i32.const 0)) funcref (ref.func $f) (ref.null func)) + (elem (offset (i32.const 0)) func $f $f) + (elem (offset (i32.const 0)) $f $f) + (elem (i32.const 0)) + (elem (i32.const 0) funcref (ref.func $f) (ref.null func)) + (elem (i32.const 0) func $f $f) + (elem (i32.const 0) $f $f) + + (elem $a1 (table $t) (i32.const 0) funcref) + (elem $a2 (table $t) (i32.const 0) funcref (ref.func $f) (ref.null func)) + (elem $a3 (table $t) (i32.const 0) func) + (elem $a4 (table $t) (i32.const 0) func $f $g) + (elem $a9 (table $t) (offset (i32.const 0)) funcref) + (elem $a10 (table $t) (offset (i32.const 0)) func $f $g) + (elem $a11 (table 0) (i32.const 0) func) + (elem $a12 (table 0x0) (i32.const 0) func $f $f) + (elem $a13 (table 0x000) (offset (i32.const 0)) func) + (elem $a14 (table 0) (offset (i32.const 0)) func $f $f) + (elem $a15 (table $t) (i32.const 0) func) + (elem $a16 (table $t) (i32.const 0) func $f $f) + (elem $a17 (table $t) (offset (i32.const 0)) func) + (elem $a18 (table $t) (offset (i32.const 0)) func $f $f) + (elem $a19 (offset (i32.const 0))) + (elem $a20 (offset (i32.const 0)) funcref (ref.func $f) (ref.null func)) + (elem $a21 (offset (i32.const 0)) func $f $f) + (elem $a22 (offset (i32.const 0)) $f $f) + (elem $a23 (i32.const 0)) + (elem $a24 (i32.const 0) funcref (ref.func $f) (ref.null func)) + (elem $a25 (i32.const 0) func $f $f) + (elem $a26 (i32.const 0) $f $f) + + ;; Declarative + (elem declare funcref) + (elem declare funcref (ref.func $f) (ref.func $f) (ref.null func) (ref.func $g)) + (elem declare func) + (elem declare func $f $f $g $g) + + (elem $d1 declare funcref) + (elem $d2 declare funcref (ref.func $f) (ref.func $f) (ref.null func) (ref.func $g)) + (elem $d3 declare func) + (elem $d4 declare func $f $f $g $g) +) + +(module + (func $f) + (func $g) + + (table $t funcref (elem (ref.func $f) (ref.null func) (ref.func $g))) +) + + +;; Basic use + +(module + (table 10 funcref) + (func $f) + (elem (i32.const 0) $f) +) +(module + (import "spectest" "table" (table 10 funcref)) + (func $f) + (elem (i32.const 0) $f) +) + +(module + (table 10 funcref) + (func $f) + (elem (i32.const 0) $f) + (elem (i32.const 3) $f) + (elem (i32.const 7) $f) + (elem (i32.const 5) $f) + (elem (i32.const 3) $f) +) +(module + (import "spectest" "table" (table 10 funcref)) + (func $f) + (elem (i32.const 9) $f) + (elem (i32.const 3) $f) + (elem (i32.const 7) $f) + (elem (i32.const 3) $f) + (elem (i32.const 5) $f) +) + +(module + (global (import "spectest" "global_i32") i32) + (table 1000 funcref) + (func $f) + (elem (global.get 0) $f) +) + +(module + (global $g (import "spectest" "global_i32") i32) + (table 1000 funcref) + (func $f) + (elem (global.get $g) $f) +) + +(module + (type $out-i32 (func (result i32))) + (table 10 funcref) + (elem (i32.const 7) $const-i32-a) + (elem (i32.const 9) $const-i32-b) + (func $const-i32-a (type $out-i32) (i32.const 65)) + (func $const-i32-b (type $out-i32) (i32.const 66)) + (func (export "call-7") (type $out-i32) + (call_indirect (type $out-i32) (i32.const 7)) + ) + (func (export "call-9") (type $out-i32) + (call_indirect (type $out-i32) (i32.const 9)) + ) +) +(assert_return (invoke "call-7") (i32.const 65)) +(assert_return (invoke "call-9") (i32.const 66)) + +;; Corner cases + +(module + (table 10 funcref) + (func $f) + (elem (i32.const 9) $f) +) +(module + (import "spectest" "table" (table 10 funcref)) + (func $f) + (elem (i32.const 9) $f) +) + +(module + (table 0 funcref) + (elem (i32.const 0)) +) +(module + (import "spectest" "table" (table 0 funcref)) + (elem (i32.const 0)) +) + +(module + (table 0 0 funcref) + (elem (i32.const 0)) +) + +(module + (table 20 funcref) + (elem (i32.const 20)) +) + +(module + (import "spectest" "table" (table 0 funcref)) + (func $f) + (elem (i32.const 0) $f) +) + +(module + (import "spectest" "table" (table 0 100 funcref)) + (func $f) + (elem (i32.const 0) $f) +) + +(module + (import "spectest" "table" (table 0 funcref)) + (func $f) + (elem (i32.const 1) $f) +) + +(module + (import "spectest" "table" (table 0 30 funcref)) + (func $f) + (elem (i32.const 1) $f) +) + +;; Invalid bounds for elements + +(assert_trap + (module + (table 0 funcref) + (func $f) + (elem (i32.const 0) $f) + ) + "out of bounds table access" +) + +(assert_trap + (module + (table 0 0 funcref) + (func $f) + (elem (i32.const 0) $f) + ) + "out of bounds table access" +) + +(assert_trap + (module + (table 0 1 funcref) + (func $f) + (elem (i32.const 0) $f) + ) + "out of bounds table access" +) + +(assert_trap + (module + (table 0 funcref) + (elem (i32.const 1)) + ) + "out of bounds table access" +) +(assert_trap + (module + (table 10 funcref) + (func $f) + (elem (i32.const 10) $f) + ) + "out of bounds table access" +) +(assert_trap + (module + (import "spectest" "table" (table 10 funcref)) + (func $f) + (elem (i32.const 10) $f) + ) + "out of bounds table access" +) + +(assert_trap + (module + (table 10 20 funcref) + (func $f) + (elem (i32.const 10) $f) + ) + "out of bounds table access" +) +(assert_trap + (module + (import "spectest" "table" (table 10 funcref)) + (func $f) + (elem (i32.const 10) $f) + ) + "out of bounds table access" +) + +(assert_trap + (module + (table 10 funcref) + (func $f) + (elem (i32.const -1) $f) + ) + "out of bounds table access" +) +(assert_trap + (module + (import "spectest" "table" (table 10 funcref)) + (func $f) + (elem (i32.const -1) $f) + ) + "out of bounds table access" +) + +(assert_trap + (module + (table 10 funcref) + (func $f) + (elem (i32.const -10) $f) + ) + "out of bounds table access" +) +(assert_trap + (module + (import "spectest" "table" (table 10 funcref)) + (func $f) + (elem (i32.const -10) $f) + ) + "out of bounds table access" +) + +;; Implicitly dropped elements + +(module + (table 10 funcref) + (elem $e (i32.const 0) func $f) + (func $f) + (func (export "init") + (table.init $e (i32.const 0) (i32.const 0) (i32.const 1)) + ) +) +(assert_trap (invoke "init") "out of bounds table access") + +(module + (table 10 funcref) + (elem $e declare func $f) + (func $f) + (func (export "init") + (table.init $e (i32.const 0) (i32.const 0) (i32.const 1)) + ) +) +(assert_trap (invoke "init") "out of bounds table access") + +;; Element without table + +(assert_invalid + (module + (func $f) + (elem (i32.const 0) $f) + ) + "unknown table" +) + +;; Invalid offsets + +(assert_invalid + (module + (table 1 funcref) + (elem (i64.const 0)) + ) + "type mismatch" +) + +(assert_invalid + (module + (table 1 funcref) + (elem (offset (;empty instruction sequence;))) + ) + "type mismatch" +) + +(assert_invalid + (module + (table 1 funcref) + (elem (offset (i32.const 0) (i32.const 0))) + ) + "type mismatch" +) + +(assert_invalid + (module + (global (import "test" "global-i32") i32) + (table 1 funcref) + (elem (offset (global.get 0) (global.get 0))) + ) + "type mismatch" +) + +(assert_invalid + (module + (global (import "test" "global-i32") i32) + (table 1 funcref) + (elem (offset (global.get 0) (i32.const 0))) + ) + "type mismatch" +) + + +(assert_invalid + (module + (table 1 funcref) + (elem (i32.ctz (i32.const 0))) + ) + "constant expression required" +) + +(assert_invalid + (module + (table 1 funcref) + (elem (nop)) + ) + "constant expression required" +) + +(assert_invalid + (module + (table 1 funcref) + (elem (offset (nop) (i32.const 0))) + ) + "constant expression required" +) + +(assert_invalid + (module + (table 1 funcref) + (elem (offset (i32.const 0) (nop))) + ) + "constant expression required" +) + +;; Use of internal globals in constant expressions is not allowed in MVP. +;; (assert_invalid +;; (module (memory 1) (data (global.get $g)) (global $g (mut i32) (i32.const 0))) +;; "constant expression required" +;; ) + +(assert_invalid + (module + (table 1 funcref) + (elem (global.get 0)) + ) + "unknown global 0" +) + +(assert_invalid + (module + (global (import "test" "global-i32") i32) + (table 1 funcref) + (elem (global.get 1)) + ) + "unknown global 1" +) + +(assert_invalid + (module + (global (import "test" "global-mut-i32") (mut i32)) + (table 1 funcref) + (elem (global.get 0)) + ) + "constant expression required" +) + +;; Two elements target the same slot + +(module + (type $out-i32 (func (result i32))) + (table 10 funcref) + (elem (i32.const 9) $const-i32-a) + (elem (i32.const 9) $const-i32-b) + (func $const-i32-a (type $out-i32) (i32.const 65)) + (func $const-i32-b (type $out-i32) (i32.const 66)) + (func (export "call-overwritten") (type $out-i32) + (call_indirect (type $out-i32) (i32.const 9)) + ) +) +(assert_return (invoke "call-overwritten") (i32.const 66)) + +(module + (type $out-i32 (func (result i32))) + (import "spectest" "table" (table 10 funcref)) + (elem (i32.const 9) $const-i32-a) + (elem (i32.const 9) $const-i32-b) + (func $const-i32-a (type $out-i32) (i32.const 65)) + (func $const-i32-b (type $out-i32) (i32.const 66)) + (func (export "call-overwritten-element") (type $out-i32) + (call_indirect (type $out-i32) (i32.const 9)) + ) +) +(assert_return (invoke "call-overwritten-element") (i32.const 66)) + +;; Element sections across multiple modules change the same table + +(module $module1 + (type $out-i32 (func (result i32))) + (table (export "shared-table") 10 funcref) + (elem (i32.const 8) $const-i32-a) + (elem (i32.const 9) $const-i32-b) + (func $const-i32-a (type $out-i32) (i32.const 65)) + (func $const-i32-b (type $out-i32) (i32.const 66)) + (func (export "call-7") (type $out-i32) + (call_indirect (type $out-i32) (i32.const 7)) + ) + (func (export "call-8") (type $out-i32) + (call_indirect (type $out-i32) (i32.const 8)) + ) + (func (export "call-9") (type $out-i32) + (call_indirect (type $out-i32) (i32.const 9)) + ) +) + +(register "module1" $module1) + +(assert_trap (invoke $module1 "call-7") "uninitialized element") +(assert_return (invoke $module1 "call-8") (i32.const 65)) +(assert_return (invoke $module1 "call-9") (i32.const 66)) + +(module $module2 + (type $out-i32 (func (result i32))) + (import "module1" "shared-table" (table 10 funcref)) + (elem (i32.const 7) $const-i32-c) + (elem (i32.const 8) $const-i32-d) + (func $const-i32-c (type $out-i32) (i32.const 67)) + (func $const-i32-d (type $out-i32) (i32.const 68)) +) + +(assert_return (invoke $module1 "call-7") (i32.const 67)) +(assert_return (invoke $module1 "call-8") (i32.const 68)) +(assert_return (invoke $module1 "call-9") (i32.const 66)) + +(module $module3 + (type $out-i32 (func (result i32))) + (import "module1" "shared-table" (table 10 funcref)) + (elem (i32.const 8) $const-i32-e) + (elem (i32.const 9) $const-i32-f) + (func $const-i32-e (type $out-i32) (i32.const 69)) + (func $const-i32-f (type $out-i32) (i32.const 70)) +) + +(assert_return (invoke $module1 "call-7") (i32.const 67)) +(assert_return (invoke $module1 "call-8") (i32.const 69)) +(assert_return (invoke $module1 "call-9") (i32.const 70)) diff --git a/runtime/near-vm/tests/wast/spec/endianness.wast b/runtime/near-vm/tests/wast/spec/endianness.wast new file mode 100644 index 00000000000..4f28a168f2a --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/endianness.wast @@ -0,0 +1,217 @@ +(module + (memory 1) + + ;; Stores an i16 value in little-endian-format + (func $i16_store_little (param $address i32) (param $value i32) + (i32.store8 (local.get $address) (local.get $value)) + (i32.store8 (i32.add (local.get $address) (i32.const 1)) (i32.shr_u (local.get $value) (i32.const 8))) + ) + + ;; Stores an i32 value in little-endian format + (func $i32_store_little (param $address i32) (param $value i32) + (call $i16_store_little (local.get $address) (local.get $value)) + (call $i16_store_little (i32.add (local.get $address) (i32.const 2)) (i32.shr_u (local.get $value) (i32.const 16))) + ) + + ;; Stores an i64 value in little-endian format + (func $i64_store_little (param $address i32) (param $value i64) + (call $i32_store_little (local.get $address) (i32.wrap_i64 (local.get $value))) + (call $i32_store_little (i32.add (local.get $address) (i32.const 4)) (i32.wrap_i64 (i64.shr_u (local.get $value) (i64.const 32)))) + ) + + ;; Loads an i16 value in little-endian format + (func $i16_load_little (param $address i32) (result i32) + (i32.or + (i32.load8_u (local.get $address)) + (i32.shl (i32.load8_u (i32.add (local.get $address) (i32.const 1))) (i32.const 8)) + ) + ) + + ;; Loads an i32 value in little-endian format + (func $i32_load_little (param $address i32) (result i32) + (i32.or + (call $i16_load_little (local.get $address)) + (i32.shl (call $i16_load_little (i32.add (local.get $address) (i32.const 2))) (i32.const 16)) + ) + ) + + ;; Loads an i64 value in little-endian format + (func $i64_load_little (param $address i32) (result i64) + (i64.or + (i64.extend_i32_u (call $i32_load_little (local.get $address))) + (i64.shl (i64.extend_i32_u (call $i32_load_little (i32.add (local.get $address) (i32.const 4)))) (i64.const 32)) + ) + ) + + (func (export "i32_load16_s") (param $value i32) (result i32) + (call $i16_store_little (i32.const 0) (local.get $value)) + (i32.load16_s (i32.const 0)) + ) + + (func (export "i32_load16_u") (param $value i32) (result i32) + (call $i16_store_little (i32.const 0) (local.get $value)) + (i32.load16_u (i32.const 0)) + ) + + (func (export "i32_load") (param $value i32) (result i32) + (call $i32_store_little (i32.const 0) (local.get $value)) + (i32.load (i32.const 0)) + ) + + (func (export "i64_load16_s") (param $value i64) (result i64) + (call $i16_store_little (i32.const 0) (i32.wrap_i64 (local.get $value))) + (i64.load16_s (i32.const 0)) + ) + + (func (export "i64_load16_u") (param $value i64) (result i64) + (call $i16_store_little (i32.const 0) (i32.wrap_i64 (local.get $value))) + (i64.load16_u (i32.const 0)) + ) + + (func (export "i64_load32_s") (param $value i64) (result i64) + (call $i32_store_little (i32.const 0) (i32.wrap_i64 (local.get $value))) + (i64.load32_s (i32.const 0)) + ) + + (func (export "i64_load32_u") (param $value i64) (result i64) + (call $i32_store_little (i32.const 0) (i32.wrap_i64 (local.get $value))) + (i64.load32_u (i32.const 0)) + ) + + (func (export "i64_load") (param $value i64) (result i64) + (call $i64_store_little (i32.const 0) (local.get $value)) + (i64.load (i32.const 0)) + ) + + (func (export "f32_load") (param $value f32) (result f32) + (call $i32_store_little (i32.const 0) (i32.reinterpret_f32 (local.get $value))) + (f32.load (i32.const 0)) + ) + + (func (export "f64_load") (param $value f64) (result f64) + (call $i64_store_little (i32.const 0) (i64.reinterpret_f64 (local.get $value))) + (f64.load (i32.const 0)) + ) + + + (func (export "i32_store16") (param $value i32) (result i32) + (i32.store16 (i32.const 0) (local.get $value)) + (call $i16_load_little (i32.const 0)) + ) + + (func (export "i32_store") (param $value i32) (result i32) + (i32.store (i32.const 0) (local.get $value)) + (call $i32_load_little (i32.const 0)) + ) + + (func (export "i64_store16") (param $value i64) (result i64) + (i64.store16 (i32.const 0) (local.get $value)) + (i64.extend_i32_u (call $i16_load_little (i32.const 0))) + ) + + (func (export "i64_store32") (param $value i64) (result i64) + (i64.store32 (i32.const 0) (local.get $value)) + (i64.extend_i32_u (call $i32_load_little (i32.const 0))) + ) + + (func (export "i64_store") (param $value i64) (result i64) + (i64.store (i32.const 0) (local.get $value)) + (call $i64_load_little (i32.const 0)) + ) + + (func (export "f32_store") (param $value f32) (result f32) + (f32.store (i32.const 0) (local.get $value)) + (f32.reinterpret_i32 (call $i32_load_little (i32.const 0))) + ) + + (func (export "f64_store") (param $value f64) (result f64) + (f64.store (i32.const 0) (local.get $value)) + (f64.reinterpret_i64 (call $i64_load_little (i32.const 0))) + ) +) + +(assert_return (invoke "i32_load16_s" (i32.const -1)) (i32.const -1)) +(assert_return (invoke "i32_load16_s" (i32.const -4242)) (i32.const -4242)) +(assert_return (invoke "i32_load16_s" (i32.const 42)) (i32.const 42)) +(assert_return (invoke "i32_load16_s" (i32.const 0x3210)) (i32.const 0x3210)) + +(assert_return (invoke "i32_load16_u" (i32.const -1)) (i32.const 0xFFFF)) +(assert_return (invoke "i32_load16_u" (i32.const -4242)) (i32.const 61294)) +(assert_return (invoke "i32_load16_u" (i32.const 42)) (i32.const 42)) +(assert_return (invoke "i32_load16_u" (i32.const 0xCAFE)) (i32.const 0xCAFE)) + +(assert_return (invoke "i32_load" (i32.const -1)) (i32.const -1)) +(assert_return (invoke "i32_load" (i32.const -42424242)) (i32.const -42424242)) +(assert_return (invoke "i32_load" (i32.const 42424242)) (i32.const 42424242)) +(assert_return (invoke "i32_load" (i32.const 0xABAD1DEA)) (i32.const 0xABAD1DEA)) + +(assert_return (invoke "i64_load16_s" (i64.const -1)) (i64.const -1)) +(assert_return (invoke "i64_load16_s" (i64.const -4242)) (i64.const -4242)) +(assert_return (invoke "i64_load16_s" (i64.const 42)) (i64.const 42)) +(assert_return (invoke "i64_load16_s" (i64.const 0x3210)) (i64.const 0x3210)) + +(assert_return (invoke "i64_load16_u" (i64.const -1)) (i64.const 0xFFFF)) +(assert_return (invoke "i64_load16_u" (i64.const -4242)) (i64.const 61294)) +(assert_return (invoke "i64_load16_u" (i64.const 42)) (i64.const 42)) +(assert_return (invoke "i64_load16_u" (i64.const 0xCAFE)) (i64.const 0xCAFE)) + +(assert_return (invoke "i64_load32_s" (i64.const -1)) (i64.const -1)) +(assert_return (invoke "i64_load32_s" (i64.const -42424242)) (i64.const -42424242)) +(assert_return (invoke "i64_load32_s" (i64.const 42424242)) (i64.const 42424242)) +(assert_return (invoke "i64_load32_s" (i64.const 0x12345678)) (i64.const 0x12345678)) + +(assert_return (invoke "i64_load32_u" (i64.const -1)) (i64.const 0xFFFFFFFF)) +(assert_return (invoke "i64_load32_u" (i64.const -42424242)) (i64.const 4252543054)) +(assert_return (invoke "i64_load32_u" (i64.const 42424242)) (i64.const 42424242)) +(assert_return (invoke "i64_load32_u" (i64.const 0xABAD1DEA)) (i64.const 0xABAD1DEA)) + +(assert_return (invoke "i64_load" (i64.const -1)) (i64.const -1)) +(assert_return (invoke "i64_load" (i64.const -42424242)) (i64.const -42424242)) +(assert_return (invoke "i64_load" (i64.const 0xABAD1DEA)) (i64.const 0xABAD1DEA)) +(assert_return (invoke "i64_load" (i64.const 0xABADCAFEDEAD1DEA)) (i64.const 0xABADCAFEDEAD1DEA)) + +(assert_return (invoke "f32_load" (f32.const -1)) (f32.const -1)) +(assert_return (invoke "f32_load" (f32.const 1234e-5)) (f32.const 1234e-5)) +(assert_return (invoke "f32_load" (f32.const 4242.4242)) (f32.const 4242.4242)) +(assert_return (invoke "f32_load" (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127)) + +(assert_return (invoke "f64_load" (f64.const -1)) (f64.const -1)) +(assert_return (invoke "f64_load" (f64.const 123456789e-5)) (f64.const 123456789e-5)) +(assert_return (invoke "f64_load" (f64.const 424242.424242)) (f64.const 424242.424242)) +(assert_return (invoke "f64_load" (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023)) + + +(assert_return (invoke "i32_store16" (i32.const -1)) (i32.const 0xFFFF)) +(assert_return (invoke "i32_store16" (i32.const -4242)) (i32.const 61294)) +(assert_return (invoke "i32_store16" (i32.const 42)) (i32.const 42)) +(assert_return (invoke "i32_store16" (i32.const 0xCAFE)) (i32.const 0xCAFE)) + +(assert_return (invoke "i32_store" (i32.const -1)) (i32.const -1)) +(assert_return (invoke "i32_store" (i32.const -4242)) (i32.const -4242)) +(assert_return (invoke "i32_store" (i32.const 42424242)) (i32.const 42424242)) +(assert_return (invoke "i32_store" (i32.const 0xDEADCAFE)) (i32.const 0xDEADCAFE)) + +(assert_return (invoke "i64_store16" (i64.const -1)) (i64.const 0xFFFF)) +(assert_return (invoke "i64_store16" (i64.const -4242)) (i64.const 61294)) +(assert_return (invoke "i64_store16" (i64.const 42)) (i64.const 42)) +(assert_return (invoke "i64_store16" (i64.const 0xCAFE)) (i64.const 0xCAFE)) + +(assert_return (invoke "i64_store32" (i64.const -1)) (i64.const 0xFFFFFFFF)) +(assert_return (invoke "i64_store32" (i64.const -4242)) (i64.const 4294963054)) +(assert_return (invoke "i64_store32" (i64.const 42424242)) (i64.const 42424242)) +(assert_return (invoke "i64_store32" (i64.const 0xDEADCAFE)) (i64.const 0xDEADCAFE)) + +(assert_return (invoke "i64_store" (i64.const -1)) (i64.const -1)) +(assert_return (invoke "i64_store" (i64.const -42424242)) (i64.const -42424242)) +(assert_return (invoke "i64_store" (i64.const 0xABAD1DEA)) (i64.const 0xABAD1DEA)) +(assert_return (invoke "i64_store" (i64.const 0xABADCAFEDEAD1DEA)) (i64.const 0xABADCAFEDEAD1DEA)) + +(assert_return (invoke "f32_store" (f32.const -1)) (f32.const -1)) +(assert_return (invoke "f32_store" (f32.const 1234e-5)) (f32.const 1234e-5)) +(assert_return (invoke "f32_store" (f32.const 4242.4242)) (f32.const 4242.4242)) +(assert_return (invoke "f32_store" (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127)) + +(assert_return (invoke "f64_store" (f64.const -1)) (f64.const -1)) +(assert_return (invoke "f64_store" (f64.const 123456789e-5)) (f64.const 123456789e-5)) +(assert_return (invoke "f64_store" (f64.const 424242.424242)) (f64.const 424242.424242)) +(assert_return (invoke "f64_store" (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023)) diff --git a/runtime/near-vm/tests/wast/spec/exports.wast b/runtime/near-vm/tests/wast/spec/exports.wast new file mode 100644 index 00000000000..80d3ae07426 --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/exports.wast @@ -0,0 +1,238 @@ +;; Functions + +(module (func) (export "a" (func 0))) +(module (func) (export "a" (func 0)) (export "b" (func 0))) +(module (func) (func) (export "a" (func 0)) (export "b" (func 1))) + +(module (func (export "a"))) +(module (func (export "a") (export "b") (export "c"))) +(module (func (export "a") (export "b") (param i32))) +(module (func) (export "a" (func 0))) +(module (func $a (export "a"))) +(module (func $a) (export "a" (func $a))) +(module (export "a" (func 0)) (func)) +(module (export "a" (func $a)) (func $a)) + +(module $Func + (export "e" (func $f)) + (func $f (param $n i32) (result i32) + (return (i32.add (local.get $n) (i32.const 1))) + ) +) +(assert_return (invoke "e" (i32.const 42)) (i32.const 43)) +(assert_return (invoke $Func "e" (i32.const 42)) (i32.const 43)) +(module) +(module $Other1) +(assert_return (invoke $Func "e" (i32.const 42)) (i32.const 43)) + +(module + (type (;0;) (func (result i32))) + (func (;0;) (type 0) (result i32) i32.const 42) + (export "a" (func 0)) + (export "b" (func 0)) + (export "c" (func 0))) +(assert_return (invoke "a") (i32.const 42)) +(assert_return (invoke "b") (i32.const 42)) +(assert_return (invoke "c") (i32.const 42)) + +(assert_invalid + (module (export "a" (func 0))) + "unknown function" +) +(assert_invalid + (module (func) (export "a" (func 1))) + "unknown function" +) +(assert_invalid + (module (import "spectest" "print_i32" (func (param i32))) (export "a" (func 1))) + "unknown function" +) +(assert_invalid + (module (func) (export "a" (func 0)) (export "a" (func 0))) + "duplicate export name" +) +(assert_invalid + (module (func) (func) (export "a" (func 0)) (export "a" (func 1))) + "duplicate export name" +) +(assert_invalid + (module (func) (global i32 (i32.const 0)) (export "a" (func 0)) (export "a" (global 0))) + "duplicate export name" +) +(assert_invalid + (module (func) (table 0 funcref) (export "a" (func 0)) (export "a" (table 0))) + "duplicate export name" +) +(assert_invalid + (module (func) (memory 0) (export "a" (func 0)) (export "a" (memory 0))) + "duplicate export name" +) + + +;; Globals + +(module (global i32 (i32.const 0)) (export "a" (global 0))) +(module (global i32 (i32.const 0)) (export "a" (global 0)) (export "b" (global 0))) +(module (global i32 (i32.const 0)) (global i32 (i32.const 0)) (export "a" (global 0)) (export "b" (global 1))) + +(module (global (export "a") i32 (i32.const 0))) +(module (global i32 (i32.const 0)) (export "a" (global 0))) +(module (global $a (export "a") i32 (i32.const 0))) +(module (global $a i32 (i32.const 0)) (export "a" (global $a))) +(module (export "a" (global 0)) (global i32 (i32.const 0))) +(module (export "a" (global $a)) (global $a i32 (i32.const 0))) + +(module $Global + (export "e" (global $g)) + (global $g i32 (i32.const 42)) +) +(assert_return (get "e") (i32.const 42)) +(assert_return (get $Global "e") (i32.const 42)) +(module) +(module $Other2) +(assert_return (get $Global "e") (i32.const 42)) + +(assert_invalid + (module (export "a" (global 0))) + "unknown global" +) +(assert_invalid + (module (global i32 (i32.const 0)) (export "a" (global 1))) + "unknown global" +) +(assert_invalid + (module (import "spectest" "global_i32" (global i32)) (export "a" (global 1))) + "unknown global" +) +(assert_invalid + (module (global i32 (i32.const 0)) (export "a" (global 0)) (export "a" (global 0))) + "duplicate export name" +) +(assert_invalid + (module (global i32 (i32.const 0)) (global i32 (i32.const 0)) (export "a" (global 0)) (export "a" (global 1))) + "duplicate export name" +) +(assert_invalid + (module (global i32 (i32.const 0)) (func) (export "a" (global 0)) (export "a" (func 0))) + "duplicate export name" +) +(assert_invalid + (module (global i32 (i32.const 0)) (table 0 funcref) (export "a" (global 0)) (export "a" (table 0))) + "duplicate export name" +) +(assert_invalid + (module (global i32 (i32.const 0)) (memory 0) (export "a" (global 0)) (export "a" (memory 0))) + "duplicate export name" +) + + +;; Tables + +(module (table 0 funcref) (export "a" (table 0))) +(module (table 0 funcref) (export "a" (table 0)) (export "b" (table 0))) +(module (table 0 funcref) (table 0 funcref) (export "a" (table 0)) (export "b" (table 1))) + +(module (table (export "a") 0 funcref)) +(module (table (export "a") 0 1 funcref)) +(module (table 0 funcref) (export "a" (table 0))) +(module (table 0 1 funcref) (export "a" (table 0))) +(module (table $a (export "a") 0 funcref)) +(module (table $a (export "a") 0 1 funcref)) +(module (table $a 0 funcref) (export "a" (table $a))) +(module (table $a 0 1 funcref) (export "a" (table $a))) +(module (export "a" (table 0)) (table 0 funcref)) +(module (export "a" (table 0)) (table 0 1 funcref)) +(module (export "a" (table $a)) (table $a 0 funcref)) +(module (export "a" (table $a)) (table $a 0 1 funcref)) + +(; TODO: access table ;) + +(assert_invalid + (module (export "a" (table 0))) + "unknown table" +) +(assert_invalid + (module (table 0 funcref) (export "a" (table 1))) + "unknown table" +) +(assert_invalid + (module (import "spectest" "table" (table 10 20 funcref)) (export "a" (table 1))) + "unknown table" +) +(assert_invalid + (module (table 0 funcref) (export "a" (table 0)) (export "a" (table 0))) + "duplicate export name" +) +(assert_invalid + (module (table 0 funcref) (table 0 funcref) (export "a" (table 0)) (export "a" (table 1))) + "duplicate export name" +) +(assert_invalid + (module (table 0 funcref) (func) (export "a" (table 0)) (export "a" (func 0))) + "duplicate export name" +) +(assert_invalid + (module (table 0 funcref) (global i32 (i32.const 0)) (export "a" (table 0)) (export "a" (global 0))) + "duplicate export name" +) +(assert_invalid + (module (table 0 funcref) (memory 0) (export "a" (table 0)) (export "a" (memory 0))) + "duplicate export name" +) + + +;; Memories + +(module (memory 0) (export "a" (memory 0))) +(module (memory 0) (export "a" (memory 0)) (export "b" (memory 0))) +;; No multiple memories yet. +;; (module (memory 0) (memory 0) (export "a" (memory 0)) (export "b" (memory 1))) + +(module (memory (export "a") 0)) +(module (memory (export "a") 0 1)) +(module (memory 0) (export "a" (memory 0))) +(module (memory 0 1) (export "a" (memory 0))) +(module (memory $a (export "a") 0)) +(module (memory $a (export "a") 0 1)) +(module (memory $a 0) (export "a" (memory $a))) +(module (memory $a 0 1) (export "a" (memory $a))) +(module (export "a" (memory 0)) (memory 0)) +(module (export "a" (memory 0)) (memory 0 1)) +(module (export "a" (memory $a)) (memory $a 0)) +(module (export "a" (memory $a)) (memory $a 0 1)) + +(; TODO: access memory ;) + +(assert_invalid + (module (export "a" (memory 0))) + "unknown memory" +) +(assert_invalid + (module (memory 0) (export "a" (memory 1))) + "unknown memory" +) +(assert_invalid + (module (import "spectest" "memory" (memory 1 2)) (export "a" (memory 1))) + "unknown memory" +) +(assert_invalid + (module (memory 0) (export "a" (memory 0)) (export "a" (memory 0))) + "duplicate export name" +) +;; No multiple memories yet. +;; (assert_invalid +;; (module (memory 0) (memory 0) (export "a" (memory 0)) (export "a" (memory 1))) +;; "duplicate export name" +;; ) +(assert_invalid + (module (memory 0) (func) (export "a" (memory 0)) (export "a" (func 0))) + "duplicate export name" +) +(assert_invalid + (module (memory 0) (global i32 (i32.const 0)) (export "a" (memory 0)) (export "a" (global 0))) + "duplicate export name" +) +(assert_invalid + (module (memory 0) (table 0 funcref) (export "a" (memory 0)) (export "a" (table 0))) + "duplicate export name" +) diff --git a/runtime/near-vm/tests/wast/spec/extract-parts.sh b/runtime/near-vm/tests/wast/spec/extract-parts.sh new file mode 100755 index 00000000000..6aac1d083b5 --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/extract-parts.sh @@ -0,0 +1,35 @@ +#!/bin/bash +set -e +set -u +set -o pipefail + +# This script extracts the modules from the testsuite test files into +# individual files in the following directories: +# - valid - valid wasm modules +# - invalid - wasm modules that fail to validate +# - malformed - wasm text tests that fail to parse + +wabt="../wabt" +wabtbin="$wabt/bin" + +mkdir -p valid invalid malformed +rm -f valid/*.wasm +rm -f invalid/*.wasm +rm -f malformed/*.wat + +for wast in *.wast; do + base="${wast##*/}" + json="invalid/${base%.wast}.json" + "$wabtbin/wast2json" "$wast" -o "$json" + rm "$json" +done + +mv invalid/*.wat malformed + +for wasm in invalid/*.wasm; do + if "$wabtbin/wasm2wat" "$wasm" -o invalid/t.wat 2>/dev/null && \ + "$wabtbin/wat2wasm" invalid/t.wat -o /dev/null 2>/dev/null ; then + mv "$wasm" valid + fi +done +rm invalid/t.wat diff --git a/runtime/near-vm/tests/wast/spec/f32.wast b/runtime/near-vm/tests/wast/spec/f32.wast new file mode 100644 index 00000000000..36d81a05bf8 --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/f32.wast @@ -0,0 +1,2533 @@ +;; Test all the f32 operators on major boundary values and all special +;; values (except comparison and bitwise operators, which are tested in +;; f32_bitwise.wast and f32_cmp.wast). + +(module + (func (export "add") (param $x f32) (param $y f32) (result f32) (f32.add (local.get $x) (local.get $y))) + (func (export "sub") (param $x f32) (param $y f32) (result f32) (f32.sub (local.get $x) (local.get $y))) + (func (export "mul") (param $x f32) (param $y f32) (result f32) (f32.mul (local.get $x) (local.get $y))) + (func (export "div") (param $x f32) (param $y f32) (result f32) (f32.div (local.get $x) (local.get $y))) + (func (export "sqrt") (param $x f32) (result f32) (f32.sqrt (local.get $x))) + (func (export "min") (param $x f32) (param $y f32) (result f32) (f32.min (local.get $x) (local.get $y))) + (func (export "max") (param $x f32) (param $y f32) (result f32) (f32.max (local.get $x) (local.get $y))) + (func (export "ceil") (param $x f32) (result f32) (f32.ceil (local.get $x))) + (func (export "floor") (param $x f32) (result f32) (f32.floor (local.get $x))) + (func (export "trunc") (param $x f32) (result f32) (f32.trunc (local.get $x))) + (func (export "nearest") (param $x f32) (result f32) (f32.nearest (local.get $x))) +) + +(assert_return (invoke "add" (f32.const -0x0p+0) (f32.const -0x0p+0)) (f32.const -0x0p+0)) +(assert_return (invoke "add" (f32.const -0x0p+0) (f32.const 0x0p+0)) (f32.const 0x0p+0)) +(assert_return (invoke "add" (f32.const 0x0p+0) (f32.const -0x0p+0)) (f32.const 0x0p+0)) +(assert_return (invoke "add" (f32.const 0x0p+0) (f32.const 0x0p+0)) (f32.const 0x0p+0)) +(assert_return (invoke "add" (f32.const -0x0p+0) (f32.const -0x1p-149)) (f32.const -0x1p-149)) +(assert_return (invoke "add" (f32.const -0x0p+0) (f32.const 0x1p-149)) (f32.const 0x1p-149)) +(assert_return (invoke "add" (f32.const 0x0p+0) (f32.const -0x1p-149)) (f32.const -0x1p-149)) +(assert_return (invoke "add" (f32.const 0x0p+0) (f32.const 0x1p-149)) (f32.const 0x1p-149)) +(assert_return (invoke "add" (f32.const -0x0p+0) (f32.const -0x1p-126)) (f32.const -0x1p-126)) +(assert_return (invoke "add" (f32.const -0x0p+0) (f32.const 0x1p-126)) (f32.const 0x1p-126)) +(assert_return (invoke "add" (f32.const 0x0p+0) (f32.const -0x1p-126)) (f32.const -0x1p-126)) +(assert_return (invoke "add" (f32.const 0x0p+0) (f32.const 0x1p-126)) (f32.const 0x1p-126)) +(assert_return (invoke "add" (f32.const -0x0p+0) (f32.const -0x1p-1)) (f32.const -0x1p-1)) +(assert_return (invoke "add" (f32.const -0x0p+0) (f32.const 0x1p-1)) (f32.const 0x1p-1)) +(assert_return (invoke "add" (f32.const 0x0p+0) (f32.const -0x1p-1)) (f32.const -0x1p-1)) +(assert_return (invoke "add" (f32.const 0x0p+0) (f32.const 0x1p-1)) (f32.const 0x1p-1)) +(assert_return (invoke "add" (f32.const -0x0p+0) (f32.const -0x1p+0)) (f32.const -0x1p+0)) +(assert_return (invoke "add" (f32.const -0x0p+0) (f32.const 0x1p+0)) (f32.const 0x1p+0)) +(assert_return (invoke "add" (f32.const 0x0p+0) (f32.const -0x1p+0)) (f32.const -0x1p+0)) +(assert_return (invoke "add" (f32.const 0x0p+0) (f32.const 0x1p+0)) (f32.const 0x1p+0)) +(assert_return (invoke "add" (f32.const -0x0p+0) (f32.const -0x1.921fb6p+2)) (f32.const -0x1.921fb6p+2)) +(assert_return (invoke "add" (f32.const -0x0p+0) (f32.const 0x1.921fb6p+2)) (f32.const 0x1.921fb6p+2)) +(assert_return (invoke "add" (f32.const 0x0p+0) (f32.const -0x1.921fb6p+2)) (f32.const -0x1.921fb6p+2)) +(assert_return (invoke "add" (f32.const 0x0p+0) (f32.const 0x1.921fb6p+2)) (f32.const 0x1.921fb6p+2)) +(assert_return (invoke "add" (f32.const -0x0p+0) (f32.const -0x1.fffffep+127)) (f32.const -0x1.fffffep+127)) +(assert_return (invoke "add" (f32.const -0x0p+0) (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127)) +(assert_return (invoke "add" (f32.const 0x0p+0) (f32.const -0x1.fffffep+127)) (f32.const -0x1.fffffep+127)) +(assert_return (invoke "add" (f32.const 0x0p+0) (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127)) +(assert_return (invoke "add" (f32.const -0x0p+0) (f32.const -inf)) (f32.const -inf)) +(assert_return (invoke "add" (f32.const -0x0p+0) (f32.const inf)) (f32.const inf)) +(assert_return (invoke "add" (f32.const 0x0p+0) (f32.const -inf)) (f32.const -inf)) +(assert_return (invoke "add" (f32.const 0x0p+0) (f32.const inf)) (f32.const inf)) +(assert_return (invoke "add" (f32.const -0x0p+0) (f32.const -nan)) (f32.const nan:canonical)) +(assert_return (invoke "add" (f32.const -0x0p+0) (f32.const -nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "add" (f32.const -0x0p+0) (f32.const nan)) (f32.const nan:canonical)) +(assert_return (invoke "add" (f32.const -0x0p+0) (f32.const nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "add" (f32.const 0x0p+0) (f32.const -nan)) (f32.const nan:canonical)) +(assert_return (invoke "add" (f32.const 0x0p+0) (f32.const -nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "add" (f32.const 0x0p+0) (f32.const nan)) (f32.const nan:canonical)) +(assert_return (invoke "add" (f32.const 0x0p+0) (f32.const nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "add" (f32.const -0x1p-149) (f32.const -0x0p+0)) (f32.const -0x1p-149)) +(assert_return (invoke "add" (f32.const -0x1p-149) (f32.const 0x0p+0)) (f32.const -0x1p-149)) +(assert_return (invoke "add" (f32.const 0x1p-149) (f32.const -0x0p+0)) (f32.const 0x1p-149)) +(assert_return (invoke "add" (f32.const 0x1p-149) (f32.const 0x0p+0)) (f32.const 0x1p-149)) +(assert_return (invoke "add" (f32.const -0x1p-149) (f32.const -0x1p-149)) (f32.const -0x1p-148)) +(assert_return (invoke "add" (f32.const -0x1p-149) (f32.const 0x1p-149)) (f32.const 0x0p+0)) +(assert_return (invoke "add" (f32.const 0x1p-149) (f32.const -0x1p-149)) (f32.const 0x0p+0)) +(assert_return (invoke "add" (f32.const 0x1p-149) (f32.const 0x1p-149)) (f32.const 0x1p-148)) +(assert_return (invoke "add" (f32.const -0x1p-149) (f32.const -0x1p-126)) (f32.const -0x1.000002p-126)) +(assert_return (invoke "add" (f32.const -0x1p-149) (f32.const 0x1p-126)) (f32.const 0x1.fffffcp-127)) +(assert_return (invoke "add" (f32.const 0x1p-149) (f32.const -0x1p-126)) (f32.const -0x1.fffffcp-127)) +(assert_return (invoke "add" (f32.const 0x1p-149) (f32.const 0x1p-126)) (f32.const 0x1.000002p-126)) +(assert_return (invoke "add" (f32.const -0x1p-149) (f32.const -0x1p-1)) (f32.const -0x1p-1)) +(assert_return (invoke "add" (f32.const -0x1p-149) (f32.const 0x1p-1)) (f32.const 0x1p-1)) +(assert_return (invoke "add" (f32.const 0x1p-149) (f32.const -0x1p-1)) (f32.const -0x1p-1)) +(assert_return (invoke "add" (f32.const 0x1p-149) (f32.const 0x1p-1)) (f32.const 0x1p-1)) +(assert_return (invoke "add" (f32.const -0x1p-149) (f32.const -0x1p+0)) (f32.const -0x1p+0)) +(assert_return (invoke "add" (f32.const -0x1p-149) (f32.const 0x1p+0)) (f32.const 0x1p+0)) +(assert_return (invoke "add" (f32.const 0x1p-149) (f32.const -0x1p+0)) (f32.const -0x1p+0)) +(assert_return (invoke "add" (f32.const 0x1p-149) (f32.const 0x1p+0)) (f32.const 0x1p+0)) +(assert_return (invoke "add" (f32.const -0x1p-149) (f32.const -0x1.921fb6p+2)) (f32.const -0x1.921fb6p+2)) +(assert_return (invoke "add" (f32.const -0x1p-149) (f32.const 0x1.921fb6p+2)) (f32.const 0x1.921fb6p+2)) +(assert_return (invoke "add" (f32.const 0x1p-149) (f32.const -0x1.921fb6p+2)) (f32.const -0x1.921fb6p+2)) +(assert_return (invoke "add" (f32.const 0x1p-149) (f32.const 0x1.921fb6p+2)) (f32.const 0x1.921fb6p+2)) +(assert_return (invoke "add" (f32.const -0x1p-149) (f32.const -0x1.fffffep+127)) (f32.const -0x1.fffffep+127)) +(assert_return (invoke "add" (f32.const -0x1p-149) (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127)) +(assert_return (invoke "add" (f32.const 0x1p-149) (f32.const -0x1.fffffep+127)) (f32.const -0x1.fffffep+127)) +(assert_return (invoke "add" (f32.const 0x1p-149) (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127)) +(assert_return (invoke "add" (f32.const -0x1p-149) (f32.const -inf)) (f32.const -inf)) +(assert_return (invoke "add" (f32.const -0x1p-149) (f32.const inf)) (f32.const inf)) +(assert_return (invoke "add" (f32.const 0x1p-149) (f32.const -inf)) (f32.const -inf)) +(assert_return (invoke "add" (f32.const 0x1p-149) (f32.const inf)) (f32.const inf)) +(assert_return (invoke "add" (f32.const -0x1p-149) (f32.const -nan)) (f32.const nan:canonical)) +(assert_return (invoke "add" (f32.const -0x1p-149) (f32.const -nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "add" (f32.const -0x1p-149) (f32.const nan)) (f32.const nan:canonical)) +(assert_return (invoke "add" (f32.const -0x1p-149) (f32.const nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "add" (f32.const 0x1p-149) (f32.const -nan)) (f32.const nan:canonical)) +(assert_return (invoke "add" (f32.const 0x1p-149) (f32.const -nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "add" (f32.const 0x1p-149) (f32.const nan)) (f32.const nan:canonical)) +(assert_return (invoke "add" (f32.const 0x1p-149) (f32.const nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "add" (f32.const -0x1p-126) (f32.const -0x0p+0)) (f32.const -0x1p-126)) +(assert_return (invoke "add" (f32.const -0x1p-126) (f32.const 0x0p+0)) (f32.const -0x1p-126)) +(assert_return (invoke "add" (f32.const 0x1p-126) (f32.const -0x0p+0)) (f32.const 0x1p-126)) +(assert_return (invoke "add" (f32.const 0x1p-126) (f32.const 0x0p+0)) (f32.const 0x1p-126)) +(assert_return (invoke "add" (f32.const -0x1p-126) (f32.const -0x1p-149)) (f32.const -0x1.000002p-126)) +(assert_return (invoke "add" (f32.const -0x1p-126) (f32.const 0x1p-149)) (f32.const -0x1.fffffcp-127)) +(assert_return (invoke "add" (f32.const 0x1p-126) (f32.const -0x1p-149)) (f32.const 0x1.fffffcp-127)) +(assert_return (invoke "add" (f32.const 0x1p-126) (f32.const 0x1p-149)) (f32.const 0x1.000002p-126)) +(assert_return (invoke "add" (f32.const -0x1p-126) (f32.const -0x1p-126)) (f32.const -0x1p-125)) +(assert_return (invoke "add" (f32.const -0x1p-126) (f32.const 0x1p-126)) (f32.const 0x0p+0)) +(assert_return (invoke "add" (f32.const 0x1p-126) (f32.const -0x1p-126)) (f32.const 0x0p+0)) +(assert_return (invoke "add" (f32.const 0x1p-126) (f32.const 0x1p-126)) (f32.const 0x1p-125)) +(assert_return (invoke "add" (f32.const -0x1p-126) (f32.const -0x1p-1)) (f32.const -0x1p-1)) +(assert_return (invoke "add" (f32.const -0x1p-126) (f32.const 0x1p-1)) (f32.const 0x1p-1)) +(assert_return (invoke "add" (f32.const 0x1p-126) (f32.const -0x1p-1)) (f32.const -0x1p-1)) +(assert_return (invoke "add" (f32.const 0x1p-126) (f32.const 0x1p-1)) (f32.const 0x1p-1)) +(assert_return (invoke "add" (f32.const -0x1p-126) (f32.const -0x1p+0)) (f32.const -0x1p+0)) +(assert_return (invoke "add" (f32.const -0x1p-126) (f32.const 0x1p+0)) (f32.const 0x1p+0)) +(assert_return (invoke "add" (f32.const 0x1p-126) (f32.const -0x1p+0)) (f32.const -0x1p+0)) +(assert_return (invoke "add" (f32.const 0x1p-126) (f32.const 0x1p+0)) (f32.const 0x1p+0)) +(assert_return (invoke "add" (f32.const -0x1p-126) (f32.const -0x1.921fb6p+2)) (f32.const -0x1.921fb6p+2)) +(assert_return (invoke "add" (f32.const -0x1p-126) (f32.const 0x1.921fb6p+2)) (f32.const 0x1.921fb6p+2)) +(assert_return (invoke "add" (f32.const 0x1p-126) (f32.const -0x1.921fb6p+2)) (f32.const -0x1.921fb6p+2)) +(assert_return (invoke "add" (f32.const 0x1p-126) (f32.const 0x1.921fb6p+2)) (f32.const 0x1.921fb6p+2)) +(assert_return (invoke "add" (f32.const -0x1p-126) (f32.const -0x1.fffffep+127)) (f32.const -0x1.fffffep+127)) +(assert_return (invoke "add" (f32.const -0x1p-126) (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127)) +(assert_return (invoke "add" (f32.const 0x1p-126) (f32.const -0x1.fffffep+127)) (f32.const -0x1.fffffep+127)) +(assert_return (invoke "add" (f32.const 0x1p-126) (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127)) +(assert_return (invoke "add" (f32.const -0x1p-126) (f32.const -inf)) (f32.const -inf)) +(assert_return (invoke "add" (f32.const -0x1p-126) (f32.const inf)) (f32.const inf)) +(assert_return (invoke "add" (f32.const 0x1p-126) (f32.const -inf)) (f32.const -inf)) +(assert_return (invoke "add" (f32.const 0x1p-126) (f32.const inf)) (f32.const inf)) +(assert_return (invoke "add" (f32.const -0x1p-126) (f32.const -nan)) (f32.const nan:canonical)) +(assert_return (invoke "add" (f32.const -0x1p-126) (f32.const -nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "add" (f32.const -0x1p-126) (f32.const nan)) (f32.const nan:canonical)) +(assert_return (invoke "add" (f32.const -0x1p-126) (f32.const nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "add" (f32.const 0x1p-126) (f32.const -nan)) (f32.const nan:canonical)) +(assert_return (invoke "add" (f32.const 0x1p-126) (f32.const -nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "add" (f32.const 0x1p-126) (f32.const nan)) (f32.const nan:canonical)) +(assert_return (invoke "add" (f32.const 0x1p-126) (f32.const nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "add" (f32.const -0x1p-1) (f32.const -0x0p+0)) (f32.const -0x1p-1)) +(assert_return (invoke "add" (f32.const -0x1p-1) (f32.const 0x0p+0)) (f32.const -0x1p-1)) +(assert_return (invoke "add" (f32.const 0x1p-1) (f32.const -0x0p+0)) (f32.const 0x1p-1)) +(assert_return (invoke "add" (f32.const 0x1p-1) (f32.const 0x0p+0)) (f32.const 0x1p-1)) +(assert_return (invoke "add" (f32.const -0x1p-1) (f32.const -0x1p-149)) (f32.const -0x1p-1)) +(assert_return (invoke "add" (f32.const -0x1p-1) (f32.const 0x1p-149)) (f32.const -0x1p-1)) +(assert_return (invoke "add" (f32.const 0x1p-1) (f32.const -0x1p-149)) (f32.const 0x1p-1)) +(assert_return (invoke "add" (f32.const 0x1p-1) (f32.const 0x1p-149)) (f32.const 0x1p-1)) +(assert_return (invoke "add" (f32.const -0x1p-1) (f32.const -0x1p-126)) (f32.const -0x1p-1)) +(assert_return (invoke "add" (f32.const -0x1p-1) (f32.const 0x1p-126)) (f32.const -0x1p-1)) +(assert_return (invoke "add" (f32.const 0x1p-1) (f32.const -0x1p-126)) (f32.const 0x1p-1)) +(assert_return (invoke "add" (f32.const 0x1p-1) (f32.const 0x1p-126)) (f32.const 0x1p-1)) +(assert_return (invoke "add" (f32.const -0x1p-1) (f32.const -0x1p-1)) (f32.const -0x1p+0)) +(assert_return (invoke "add" (f32.const -0x1p-1) (f32.const 0x1p-1)) (f32.const 0x0p+0)) +(assert_return (invoke "add" (f32.const 0x1p-1) (f32.const -0x1p-1)) (f32.const 0x0p+0)) +(assert_return (invoke "add" (f32.const 0x1p-1) (f32.const 0x1p-1)) (f32.const 0x1p+0)) +(assert_return (invoke "add" (f32.const -0x1p-1) (f32.const -0x1p+0)) (f32.const -0x1.8p+0)) +(assert_return (invoke "add" (f32.const -0x1p-1) (f32.const 0x1p+0)) (f32.const 0x1p-1)) +(assert_return (invoke "add" (f32.const 0x1p-1) (f32.const -0x1p+0)) (f32.const -0x1p-1)) +(assert_return (invoke "add" (f32.const 0x1p-1) (f32.const 0x1p+0)) (f32.const 0x1.8p+0)) +(assert_return (invoke "add" (f32.const -0x1p-1) (f32.const -0x1.921fb6p+2)) (f32.const -0x1.b21fb6p+2)) +(assert_return (invoke "add" (f32.const -0x1p-1) (f32.const 0x1.921fb6p+2)) (f32.const 0x1.721fb6p+2)) +(assert_return (invoke "add" (f32.const 0x1p-1) (f32.const -0x1.921fb6p+2)) (f32.const -0x1.721fb6p+2)) +(assert_return (invoke "add" (f32.const 0x1p-1) (f32.const 0x1.921fb6p+2)) (f32.const 0x1.b21fb6p+2)) +(assert_return (invoke "add" (f32.const -0x1p-1) (f32.const -0x1.fffffep+127)) (f32.const -0x1.fffffep+127)) +(assert_return (invoke "add" (f32.const -0x1p-1) (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127)) +(assert_return (invoke "add" (f32.const 0x1p-1) (f32.const -0x1.fffffep+127)) (f32.const -0x1.fffffep+127)) +(assert_return (invoke "add" (f32.const 0x1p-1) (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127)) +(assert_return (invoke "add" (f32.const -0x1p-1) (f32.const -inf)) (f32.const -inf)) +(assert_return (invoke "add" (f32.const -0x1p-1) (f32.const inf)) (f32.const inf)) +(assert_return (invoke "add" (f32.const 0x1p-1) (f32.const -inf)) (f32.const -inf)) +(assert_return (invoke "add" (f32.const 0x1p-1) (f32.const inf)) (f32.const inf)) +(assert_return (invoke "add" (f32.const -0x1p-1) (f32.const -nan)) (f32.const nan:canonical)) +(assert_return (invoke "add" (f32.const -0x1p-1) (f32.const -nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "add" (f32.const -0x1p-1) (f32.const nan)) (f32.const nan:canonical)) +(assert_return (invoke "add" (f32.const -0x1p-1) (f32.const nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "add" (f32.const 0x1p-1) (f32.const -nan)) (f32.const nan:canonical)) +(assert_return (invoke "add" (f32.const 0x1p-1) (f32.const -nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "add" (f32.const 0x1p-1) (f32.const nan)) (f32.const nan:canonical)) +(assert_return (invoke "add" (f32.const 0x1p-1) (f32.const nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "add" (f32.const -0x1p+0) (f32.const -0x0p+0)) (f32.const -0x1p+0)) +(assert_return (invoke "add" (f32.const -0x1p+0) (f32.const 0x0p+0)) (f32.const -0x1p+0)) +(assert_return (invoke "add" (f32.const 0x1p+0) (f32.const -0x0p+0)) (f32.const 0x1p+0)) +(assert_return (invoke "add" (f32.const 0x1p+0) (f32.const 0x0p+0)) (f32.const 0x1p+0)) +(assert_return (invoke "add" (f32.const -0x1p+0) (f32.const -0x1p-149)) (f32.const -0x1p+0)) +(assert_return (invoke "add" (f32.const -0x1p+0) (f32.const 0x1p-149)) (f32.const -0x1p+0)) +(assert_return (invoke "add" (f32.const 0x1p+0) (f32.const -0x1p-149)) (f32.const 0x1p+0)) +(assert_return (invoke "add" (f32.const 0x1p+0) (f32.const 0x1p-149)) (f32.const 0x1p+0)) +(assert_return (invoke "add" (f32.const -0x1p+0) (f32.const -0x1p-126)) (f32.const -0x1p+0)) +(assert_return (invoke "add" (f32.const -0x1p+0) (f32.const 0x1p-126)) (f32.const -0x1p+0)) +(assert_return (invoke "add" (f32.const 0x1p+0) (f32.const -0x1p-126)) (f32.const 0x1p+0)) +(assert_return (invoke "add" (f32.const 0x1p+0) (f32.const 0x1p-126)) (f32.const 0x1p+0)) +(assert_return (invoke "add" (f32.const -0x1p+0) (f32.const -0x1p-1)) (f32.const -0x1.8p+0)) +(assert_return (invoke "add" (f32.const -0x1p+0) (f32.const 0x1p-1)) (f32.const -0x1p-1)) +(assert_return (invoke "add" (f32.const 0x1p+0) (f32.const -0x1p-1)) (f32.const 0x1p-1)) +(assert_return (invoke "add" (f32.const 0x1p+0) (f32.const 0x1p-1)) (f32.const 0x1.8p+0)) +(assert_return (invoke "add" (f32.const -0x1p+0) (f32.const -0x1p+0)) (f32.const -0x1p+1)) +(assert_return (invoke "add" (f32.const -0x1p+0) (f32.const 0x1p+0)) (f32.const 0x0p+0)) +(assert_return (invoke "add" (f32.const 0x1p+0) (f32.const -0x1p+0)) (f32.const 0x0p+0)) +(assert_return (invoke "add" (f32.const 0x1p+0) (f32.const 0x1p+0)) (f32.const 0x1p+1)) +(assert_return (invoke "add" (f32.const -0x1p+0) (f32.const -0x1.921fb6p+2)) (f32.const -0x1.d21fb6p+2)) +(assert_return (invoke "add" (f32.const -0x1p+0) (f32.const 0x1.921fb6p+2)) (f32.const 0x1.521fb6p+2)) +(assert_return (invoke "add" (f32.const 0x1p+0) (f32.const -0x1.921fb6p+2)) (f32.const -0x1.521fb6p+2)) +(assert_return (invoke "add" (f32.const 0x1p+0) (f32.const 0x1.921fb6p+2)) (f32.const 0x1.d21fb6p+2)) +(assert_return (invoke "add" (f32.const -0x1p+0) (f32.const -0x1.fffffep+127)) (f32.const -0x1.fffffep+127)) +(assert_return (invoke "add" (f32.const -0x1p+0) (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127)) +(assert_return (invoke "add" (f32.const 0x1p+0) (f32.const -0x1.fffffep+127)) (f32.const -0x1.fffffep+127)) +(assert_return (invoke "add" (f32.const 0x1p+0) (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127)) +(assert_return (invoke "add" (f32.const -0x1p+0) (f32.const -inf)) (f32.const -inf)) +(assert_return (invoke "add" (f32.const -0x1p+0) (f32.const inf)) (f32.const inf)) +(assert_return (invoke "add" (f32.const 0x1p+0) (f32.const -inf)) (f32.const -inf)) +(assert_return (invoke "add" (f32.const 0x1p+0) (f32.const inf)) (f32.const inf)) +(assert_return (invoke "add" (f32.const -0x1p+0) (f32.const -nan)) (f32.const nan:canonical)) +(assert_return (invoke "add" (f32.const -0x1p+0) (f32.const -nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "add" (f32.const -0x1p+0) (f32.const nan)) (f32.const nan:canonical)) +(assert_return (invoke "add" (f32.const -0x1p+0) (f32.const nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "add" (f32.const 0x1p+0) (f32.const -nan)) (f32.const nan:canonical)) +(assert_return (invoke "add" (f32.const 0x1p+0) (f32.const -nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "add" (f32.const 0x1p+0) (f32.const nan)) (f32.const nan:canonical)) +(assert_return (invoke "add" (f32.const 0x1p+0) (f32.const nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "add" (f32.const -0x1.921fb6p+2) (f32.const -0x0p+0)) (f32.const -0x1.921fb6p+2)) +(assert_return (invoke "add" (f32.const -0x1.921fb6p+2) (f32.const 0x0p+0)) (f32.const -0x1.921fb6p+2)) +(assert_return (invoke "add" (f32.const 0x1.921fb6p+2) (f32.const -0x0p+0)) (f32.const 0x1.921fb6p+2)) +(assert_return (invoke "add" (f32.const 0x1.921fb6p+2) (f32.const 0x0p+0)) (f32.const 0x1.921fb6p+2)) +(assert_return (invoke "add" (f32.const -0x1.921fb6p+2) (f32.const -0x1p-149)) (f32.const -0x1.921fb6p+2)) +(assert_return (invoke "add" (f32.const -0x1.921fb6p+2) (f32.const 0x1p-149)) (f32.const -0x1.921fb6p+2)) +(assert_return (invoke "add" (f32.const 0x1.921fb6p+2) (f32.const -0x1p-149)) (f32.const 0x1.921fb6p+2)) +(assert_return (invoke "add" (f32.const 0x1.921fb6p+2) (f32.const 0x1p-149)) (f32.const 0x1.921fb6p+2)) +(assert_return (invoke "add" (f32.const -0x1.921fb6p+2) (f32.const -0x1p-126)) (f32.const -0x1.921fb6p+2)) +(assert_return (invoke "add" (f32.const -0x1.921fb6p+2) (f32.const 0x1p-126)) (f32.const -0x1.921fb6p+2)) +(assert_return (invoke "add" (f32.const 0x1.921fb6p+2) (f32.const -0x1p-126)) (f32.const 0x1.921fb6p+2)) +(assert_return (invoke "add" (f32.const 0x1.921fb6p+2) (f32.const 0x1p-126)) (f32.const 0x1.921fb6p+2)) +(assert_return (invoke "add" (f32.const -0x1.921fb6p+2) (f32.const -0x1p-1)) (f32.const -0x1.b21fb6p+2)) +(assert_return (invoke "add" (f32.const -0x1.921fb6p+2) (f32.const 0x1p-1)) (f32.const -0x1.721fb6p+2)) +(assert_return (invoke "add" (f32.const 0x1.921fb6p+2) (f32.const -0x1p-1)) (f32.const 0x1.721fb6p+2)) +(assert_return (invoke "add" (f32.const 0x1.921fb6p+2) (f32.const 0x1p-1)) (f32.const 0x1.b21fb6p+2)) +(assert_return (invoke "add" (f32.const -0x1.921fb6p+2) (f32.const -0x1p+0)) (f32.const -0x1.d21fb6p+2)) +(assert_return (invoke "add" (f32.const -0x1.921fb6p+2) (f32.const 0x1p+0)) (f32.const -0x1.521fb6p+2)) +(assert_return (invoke "add" (f32.const 0x1.921fb6p+2) (f32.const -0x1p+0)) (f32.const 0x1.521fb6p+2)) +(assert_return (invoke "add" (f32.const 0x1.921fb6p+2) (f32.const 0x1p+0)) (f32.const 0x1.d21fb6p+2)) +(assert_return (invoke "add" (f32.const -0x1.921fb6p+2) (f32.const -0x1.921fb6p+2)) (f32.const -0x1.921fb6p+3)) +(assert_return (invoke "add" (f32.const -0x1.921fb6p+2) (f32.const 0x1.921fb6p+2)) (f32.const 0x0p+0)) +(assert_return (invoke "add" (f32.const 0x1.921fb6p+2) (f32.const -0x1.921fb6p+2)) (f32.const 0x0p+0)) +(assert_return (invoke "add" (f32.const 0x1.921fb6p+2) (f32.const 0x1.921fb6p+2)) (f32.const 0x1.921fb6p+3)) +(assert_return (invoke "add" (f32.const -0x1.921fb6p+2) (f32.const -0x1.fffffep+127)) (f32.const -0x1.fffffep+127)) +(assert_return (invoke "add" (f32.const -0x1.921fb6p+2) (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127)) +(assert_return (invoke "add" (f32.const 0x1.921fb6p+2) (f32.const -0x1.fffffep+127)) (f32.const -0x1.fffffep+127)) +(assert_return (invoke "add" (f32.const 0x1.921fb6p+2) (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127)) +(assert_return (invoke "add" (f32.const -0x1.921fb6p+2) (f32.const -inf)) (f32.const -inf)) +(assert_return (invoke "add" (f32.const -0x1.921fb6p+2) (f32.const inf)) (f32.const inf)) +(assert_return (invoke "add" (f32.const 0x1.921fb6p+2) (f32.const -inf)) (f32.const -inf)) +(assert_return (invoke "add" (f32.const 0x1.921fb6p+2) (f32.const inf)) (f32.const inf)) +(assert_return (invoke "add" (f32.const -0x1.921fb6p+2) (f32.const -nan)) (f32.const nan:canonical)) +(assert_return (invoke "add" (f32.const -0x1.921fb6p+2) (f32.const -nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "add" (f32.const -0x1.921fb6p+2) (f32.const nan)) (f32.const nan:canonical)) +(assert_return (invoke "add" (f32.const -0x1.921fb6p+2) (f32.const nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "add" (f32.const 0x1.921fb6p+2) (f32.const -nan)) (f32.const nan:canonical)) +(assert_return (invoke "add" (f32.const 0x1.921fb6p+2) (f32.const -nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "add" (f32.const 0x1.921fb6p+2) (f32.const nan)) (f32.const nan:canonical)) +(assert_return (invoke "add" (f32.const 0x1.921fb6p+2) (f32.const nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "add" (f32.const -0x1.fffffep+127) (f32.const -0x0p+0)) (f32.const -0x1.fffffep+127)) +(assert_return (invoke "add" (f32.const -0x1.fffffep+127) (f32.const 0x0p+0)) (f32.const -0x1.fffffep+127)) +(assert_return (invoke "add" (f32.const 0x1.fffffep+127) (f32.const -0x0p+0)) (f32.const 0x1.fffffep+127)) +(assert_return (invoke "add" (f32.const 0x1.fffffep+127) (f32.const 0x0p+0)) (f32.const 0x1.fffffep+127)) +(assert_return (invoke "add" (f32.const -0x1.fffffep+127) (f32.const -0x1p-149)) (f32.const -0x1.fffffep+127)) +(assert_return (invoke "add" (f32.const -0x1.fffffep+127) (f32.const 0x1p-149)) (f32.const -0x1.fffffep+127)) +(assert_return (invoke "add" (f32.const 0x1.fffffep+127) (f32.const -0x1p-149)) (f32.const 0x1.fffffep+127)) +(assert_return (invoke "add" (f32.const 0x1.fffffep+127) (f32.const 0x1p-149)) (f32.const 0x1.fffffep+127)) +(assert_return (invoke "add" (f32.const -0x1.fffffep+127) (f32.const -0x1p-126)) (f32.const -0x1.fffffep+127)) +(assert_return (invoke "add" (f32.const -0x1.fffffep+127) (f32.const 0x1p-126)) (f32.const -0x1.fffffep+127)) +(assert_return (invoke "add" (f32.const 0x1.fffffep+127) (f32.const -0x1p-126)) (f32.const 0x1.fffffep+127)) +(assert_return (invoke "add" (f32.const 0x1.fffffep+127) (f32.const 0x1p-126)) (f32.const 0x1.fffffep+127)) +(assert_return (invoke "add" (f32.const -0x1.fffffep+127) (f32.const -0x1p-1)) (f32.const -0x1.fffffep+127)) +(assert_return (invoke "add" (f32.const -0x1.fffffep+127) (f32.const 0x1p-1)) (f32.const -0x1.fffffep+127)) +(assert_return (invoke "add" (f32.const 0x1.fffffep+127) (f32.const -0x1p-1)) (f32.const 0x1.fffffep+127)) +(assert_return (invoke "add" (f32.const 0x1.fffffep+127) (f32.const 0x1p-1)) (f32.const 0x1.fffffep+127)) +(assert_return (invoke "add" (f32.const -0x1.fffffep+127) (f32.const -0x1p+0)) (f32.const -0x1.fffffep+127)) +(assert_return (invoke "add" (f32.const -0x1.fffffep+127) (f32.const 0x1p+0)) (f32.const -0x1.fffffep+127)) +(assert_return (invoke "add" (f32.const 0x1.fffffep+127) (f32.const -0x1p+0)) (f32.const 0x1.fffffep+127)) +(assert_return (invoke "add" (f32.const 0x1.fffffep+127) (f32.const 0x1p+0)) (f32.const 0x1.fffffep+127)) +(assert_return (invoke "add" (f32.const -0x1.fffffep+127) (f32.const -0x1.921fb6p+2)) (f32.const -0x1.fffffep+127)) +(assert_return (invoke "add" (f32.const -0x1.fffffep+127) (f32.const 0x1.921fb6p+2)) (f32.const -0x1.fffffep+127)) +(assert_return (invoke "add" (f32.const 0x1.fffffep+127) (f32.const -0x1.921fb6p+2)) (f32.const 0x1.fffffep+127)) +(assert_return (invoke "add" (f32.const 0x1.fffffep+127) (f32.const 0x1.921fb6p+2)) (f32.const 0x1.fffffep+127)) +(assert_return (invoke "add" (f32.const -0x1.fffffep+127) (f32.const -0x1.fffffep+127)) (f32.const -inf)) +(assert_return (invoke "add" (f32.const -0x1.fffffep+127) (f32.const 0x1.fffffep+127)) (f32.const 0x0p+0)) +(assert_return (invoke "add" (f32.const 0x1.fffffep+127) (f32.const -0x1.fffffep+127)) (f32.const 0x0p+0)) +(assert_return (invoke "add" (f32.const 0x1.fffffep+127) (f32.const 0x1.fffffep+127)) (f32.const inf)) +(assert_return (invoke "add" (f32.const -0x1.fffffep+127) (f32.const -inf)) (f32.const -inf)) +(assert_return (invoke "add" (f32.const -0x1.fffffep+127) (f32.const inf)) (f32.const inf)) +(assert_return (invoke "add" (f32.const 0x1.fffffep+127) (f32.const -inf)) (f32.const -inf)) +(assert_return (invoke "add" (f32.const 0x1.fffffep+127) (f32.const inf)) (f32.const inf)) +(assert_return (invoke "add" (f32.const -0x1.fffffep+127) (f32.const -nan)) (f32.const nan:canonical)) +(assert_return (invoke "add" (f32.const -0x1.fffffep+127) (f32.const -nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "add" (f32.const -0x1.fffffep+127) (f32.const nan)) (f32.const nan:canonical)) +(assert_return (invoke "add" (f32.const -0x1.fffffep+127) (f32.const nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "add" (f32.const 0x1.fffffep+127) (f32.const -nan)) (f32.const nan:canonical)) +(assert_return (invoke "add" (f32.const 0x1.fffffep+127) (f32.const -nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "add" (f32.const 0x1.fffffep+127) (f32.const nan)) (f32.const nan:canonical)) +(assert_return (invoke "add" (f32.const 0x1.fffffep+127) (f32.const nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "add" (f32.const -inf) (f32.const -0x0p+0)) (f32.const -inf)) +(assert_return (invoke "add" (f32.const -inf) (f32.const 0x0p+0)) (f32.const -inf)) +(assert_return (invoke "add" (f32.const inf) (f32.const -0x0p+0)) (f32.const inf)) +(assert_return (invoke "add" (f32.const inf) (f32.const 0x0p+0)) (f32.const inf)) +(assert_return (invoke "add" (f32.const -inf) (f32.const -0x1p-149)) (f32.const -inf)) +(assert_return (invoke "add" (f32.const -inf) (f32.const 0x1p-149)) (f32.const -inf)) +(assert_return (invoke "add" (f32.const inf) (f32.const -0x1p-149)) (f32.const inf)) +(assert_return (invoke "add" (f32.const inf) (f32.const 0x1p-149)) (f32.const inf)) +(assert_return (invoke "add" (f32.const -inf) (f32.const -0x1p-126)) (f32.const -inf)) +(assert_return (invoke "add" (f32.const -inf) (f32.const 0x1p-126)) (f32.const -inf)) +(assert_return (invoke "add" (f32.const inf) (f32.const -0x1p-126)) (f32.const inf)) +(assert_return (invoke "add" (f32.const inf) (f32.const 0x1p-126)) (f32.const inf)) +(assert_return (invoke "add" (f32.const -inf) (f32.const -0x1p-1)) (f32.const -inf)) +(assert_return (invoke "add" (f32.const -inf) (f32.const 0x1p-1)) (f32.const -inf)) +(assert_return (invoke "add" (f32.const inf) (f32.const -0x1p-1)) (f32.const inf)) +(assert_return (invoke "add" (f32.const inf) (f32.const 0x1p-1)) (f32.const inf)) +(assert_return (invoke "add" (f32.const -inf) (f32.const -0x1p+0)) (f32.const -inf)) +(assert_return (invoke "add" (f32.const -inf) (f32.const 0x1p+0)) (f32.const -inf)) +(assert_return (invoke "add" (f32.const inf) (f32.const -0x1p+0)) (f32.const inf)) +(assert_return (invoke "add" (f32.const inf) (f32.const 0x1p+0)) (f32.const inf)) +(assert_return (invoke "add" (f32.const -inf) (f32.const -0x1.921fb6p+2)) (f32.const -inf)) +(assert_return (invoke "add" (f32.const -inf) (f32.const 0x1.921fb6p+2)) (f32.const -inf)) +(assert_return (invoke "add" (f32.const inf) (f32.const -0x1.921fb6p+2)) (f32.const inf)) +(assert_return (invoke "add" (f32.const inf) (f32.const 0x1.921fb6p+2)) (f32.const inf)) +(assert_return (invoke "add" (f32.const -inf) (f32.const -0x1.fffffep+127)) (f32.const -inf)) +(assert_return (invoke "add" (f32.const -inf) (f32.const 0x1.fffffep+127)) (f32.const -inf)) +(assert_return (invoke "add" (f32.const inf) (f32.const -0x1.fffffep+127)) (f32.const inf)) +(assert_return (invoke "add" (f32.const inf) (f32.const 0x1.fffffep+127)) (f32.const inf)) +(assert_return (invoke "add" (f32.const -inf) (f32.const -inf)) (f32.const -inf)) +(assert_return (invoke "add" (f32.const -inf) (f32.const inf)) (f32.const nan:canonical)) +(assert_return (invoke "add" (f32.const inf) (f32.const -inf)) (f32.const nan:canonical)) +(assert_return (invoke "add" (f32.const inf) (f32.const inf)) (f32.const inf)) +(assert_return (invoke "add" (f32.const -inf) (f32.const -nan)) (f32.const nan:canonical)) +(assert_return (invoke "add" (f32.const -inf) (f32.const -nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "add" (f32.const -inf) (f32.const nan)) (f32.const nan:canonical)) +(assert_return (invoke "add" (f32.const -inf) (f32.const nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "add" (f32.const inf) (f32.const -nan)) (f32.const nan:canonical)) +(assert_return (invoke "add" (f32.const inf) (f32.const -nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "add" (f32.const inf) (f32.const nan)) (f32.const nan:canonical)) +(assert_return (invoke "add" (f32.const inf) (f32.const nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "add" (f32.const -nan) (f32.const -0x0p+0)) (f32.const nan:canonical)) +(assert_return (invoke "add" (f32.const -nan:0x200000) (f32.const -0x0p+0)) (f32.const nan:arithmetic)) +(assert_return (invoke "add" (f32.const -nan) (f32.const 0x0p+0)) (f32.const nan:canonical)) +(assert_return (invoke "add" (f32.const -nan:0x200000) (f32.const 0x0p+0)) (f32.const nan:arithmetic)) +(assert_return (invoke "add" (f32.const nan) (f32.const -0x0p+0)) (f32.const nan:canonical)) +(assert_return (invoke "add" (f32.const nan:0x200000) (f32.const -0x0p+0)) (f32.const nan:arithmetic)) +(assert_return (invoke "add" (f32.const nan) (f32.const 0x0p+0)) (f32.const nan:canonical)) +(assert_return (invoke "add" (f32.const nan:0x200000) (f32.const 0x0p+0)) (f32.const nan:arithmetic)) +(assert_return (invoke "add" (f32.const -nan) (f32.const -0x1p-149)) (f32.const nan:canonical)) +(assert_return (invoke "add" (f32.const -nan:0x200000) (f32.const -0x1p-149)) (f32.const nan:arithmetic)) +(assert_return (invoke "add" (f32.const -nan) (f32.const 0x1p-149)) (f32.const nan:canonical)) +(assert_return (invoke "add" (f32.const -nan:0x200000) (f32.const 0x1p-149)) (f32.const nan:arithmetic)) +(assert_return (invoke "add" (f32.const nan) (f32.const -0x1p-149)) (f32.const nan:canonical)) +(assert_return (invoke "add" (f32.const nan:0x200000) (f32.const -0x1p-149)) (f32.const nan:arithmetic)) +(assert_return (invoke "add" (f32.const nan) (f32.const 0x1p-149)) (f32.const nan:canonical)) +(assert_return (invoke "add" (f32.const nan:0x200000) (f32.const 0x1p-149)) (f32.const nan:arithmetic)) +(assert_return (invoke "add" (f32.const -nan) (f32.const -0x1p-126)) (f32.const nan:canonical)) +(assert_return (invoke "add" (f32.const -nan:0x200000) (f32.const -0x1p-126)) (f32.const nan:arithmetic)) +(assert_return (invoke "add" (f32.const -nan) (f32.const 0x1p-126)) (f32.const nan:canonical)) +(assert_return (invoke "add" (f32.const -nan:0x200000) (f32.const 0x1p-126)) (f32.const nan:arithmetic)) +(assert_return (invoke "add" (f32.const nan) (f32.const -0x1p-126)) (f32.const nan:canonical)) +(assert_return (invoke "add" (f32.const nan:0x200000) (f32.const -0x1p-126)) (f32.const nan:arithmetic)) +(assert_return (invoke "add" (f32.const nan) (f32.const 0x1p-126)) (f32.const nan:canonical)) +(assert_return (invoke "add" (f32.const nan:0x200000) (f32.const 0x1p-126)) (f32.const nan:arithmetic)) +(assert_return (invoke "add" (f32.const -nan) (f32.const -0x1p-1)) (f32.const nan:canonical)) +(assert_return (invoke "add" (f32.const -nan:0x200000) (f32.const -0x1p-1)) (f32.const nan:arithmetic)) +(assert_return (invoke "add" (f32.const -nan) (f32.const 0x1p-1)) (f32.const nan:canonical)) +(assert_return (invoke "add" (f32.const -nan:0x200000) (f32.const 0x1p-1)) (f32.const nan:arithmetic)) +(assert_return (invoke "add" (f32.const nan) (f32.const -0x1p-1)) (f32.const nan:canonical)) +(assert_return (invoke "add" (f32.const nan:0x200000) (f32.const -0x1p-1)) (f32.const nan:arithmetic)) +(assert_return (invoke "add" (f32.const nan) (f32.const 0x1p-1)) (f32.const nan:canonical)) +(assert_return (invoke "add" (f32.const nan:0x200000) (f32.const 0x1p-1)) (f32.const nan:arithmetic)) +(assert_return (invoke "add" (f32.const -nan) (f32.const -0x1p+0)) (f32.const nan:canonical)) +(assert_return (invoke "add" (f32.const -nan:0x200000) (f32.const -0x1p+0)) (f32.const nan:arithmetic)) +(assert_return (invoke "add" (f32.const -nan) (f32.const 0x1p+0)) (f32.const nan:canonical)) +(assert_return (invoke "add" (f32.const -nan:0x200000) (f32.const 0x1p+0)) (f32.const nan:arithmetic)) +(assert_return (invoke "add" (f32.const nan) (f32.const -0x1p+0)) (f32.const nan:canonical)) +(assert_return (invoke "add" (f32.const nan:0x200000) (f32.const -0x1p+0)) (f32.const nan:arithmetic)) +(assert_return (invoke "add" (f32.const nan) (f32.const 0x1p+0)) (f32.const nan:canonical)) +(assert_return (invoke "add" (f32.const nan:0x200000) (f32.const 0x1p+0)) (f32.const nan:arithmetic)) +(assert_return (invoke "add" (f32.const -nan) (f32.const -0x1.921fb6p+2)) (f32.const nan:canonical)) +(assert_return (invoke "add" (f32.const -nan:0x200000) (f32.const -0x1.921fb6p+2)) (f32.const nan:arithmetic)) +(assert_return (invoke "add" (f32.const -nan) (f32.const 0x1.921fb6p+2)) (f32.const nan:canonical)) +(assert_return (invoke "add" (f32.const -nan:0x200000) (f32.const 0x1.921fb6p+2)) (f32.const nan:arithmetic)) +(assert_return (invoke "add" (f32.const nan) (f32.const -0x1.921fb6p+2)) (f32.const nan:canonical)) +(assert_return (invoke "add" (f32.const nan:0x200000) (f32.const -0x1.921fb6p+2)) (f32.const nan:arithmetic)) +(assert_return (invoke "add" (f32.const nan) (f32.const 0x1.921fb6p+2)) (f32.const nan:canonical)) +(assert_return (invoke "add" (f32.const nan:0x200000) (f32.const 0x1.921fb6p+2)) (f32.const nan:arithmetic)) +(assert_return (invoke "add" (f32.const -nan) (f32.const -0x1.fffffep+127)) (f32.const nan:canonical)) +(assert_return (invoke "add" (f32.const -nan:0x200000) (f32.const -0x1.fffffep+127)) (f32.const nan:arithmetic)) +(assert_return (invoke "add" (f32.const -nan) (f32.const 0x1.fffffep+127)) (f32.const nan:canonical)) +(assert_return (invoke "add" (f32.const -nan:0x200000) (f32.const 0x1.fffffep+127)) (f32.const nan:arithmetic)) +(assert_return (invoke "add" (f32.const nan) (f32.const -0x1.fffffep+127)) (f32.const nan:canonical)) +(assert_return (invoke "add" (f32.const nan:0x200000) (f32.const -0x1.fffffep+127)) (f32.const nan:arithmetic)) +(assert_return (invoke "add" (f32.const nan) (f32.const 0x1.fffffep+127)) (f32.const nan:canonical)) +(assert_return (invoke "add" (f32.const nan:0x200000) (f32.const 0x1.fffffep+127)) (f32.const nan:arithmetic)) +(assert_return (invoke "add" (f32.const -nan) (f32.const -inf)) (f32.const nan:canonical)) +(assert_return (invoke "add" (f32.const -nan:0x200000) (f32.const -inf)) (f32.const nan:arithmetic)) +(assert_return (invoke "add" (f32.const -nan) (f32.const inf)) (f32.const nan:canonical)) +(assert_return (invoke "add" (f32.const -nan:0x200000) (f32.const inf)) (f32.const nan:arithmetic)) +(assert_return (invoke "add" (f32.const nan) (f32.const -inf)) (f32.const nan:canonical)) +(assert_return (invoke "add" (f32.const nan:0x200000) (f32.const -inf)) (f32.const nan:arithmetic)) +(assert_return (invoke "add" (f32.const nan) (f32.const inf)) (f32.const nan:canonical)) +(assert_return (invoke "add" (f32.const nan:0x200000) (f32.const inf)) (f32.const nan:arithmetic)) +(assert_return (invoke "add" (f32.const -nan) (f32.const -nan)) (f32.const nan:canonical)) +(assert_return (invoke "add" (f32.const -nan:0x200000) (f32.const -nan)) (f32.const nan:arithmetic)) +(assert_return (invoke "add" (f32.const -nan) (f32.const -nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "add" (f32.const -nan:0x200000) (f32.const -nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "add" (f32.const -nan) (f32.const nan)) (f32.const nan:canonical)) +(assert_return (invoke "add" (f32.const -nan:0x200000) (f32.const nan)) (f32.const nan:arithmetic)) +(assert_return (invoke "add" (f32.const -nan) (f32.const nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "add" (f32.const -nan:0x200000) (f32.const nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "add" (f32.const nan) (f32.const -nan)) (f32.const nan:canonical)) +(assert_return (invoke "add" (f32.const nan:0x200000) (f32.const -nan)) (f32.const nan:arithmetic)) +(assert_return (invoke "add" (f32.const nan) (f32.const -nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "add" (f32.const nan:0x200000) (f32.const -nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "add" (f32.const nan) (f32.const nan)) (f32.const nan:canonical)) +(assert_return (invoke "add" (f32.const nan:0x200000) (f32.const nan)) (f32.const nan:arithmetic)) +(assert_return (invoke "add" (f32.const nan) (f32.const nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "add" (f32.const nan:0x200000) (f32.const nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "sub" (f32.const -0x0p+0) (f32.const -0x0p+0)) (f32.const 0x0p+0)) +(assert_return (invoke "sub" (f32.const -0x0p+0) (f32.const 0x0p+0)) (f32.const -0x0p+0)) +(assert_return (invoke "sub" (f32.const 0x0p+0) (f32.const -0x0p+0)) (f32.const 0x0p+0)) +(assert_return (invoke "sub" (f32.const 0x0p+0) (f32.const 0x0p+0)) (f32.const 0x0p+0)) +(assert_return (invoke "sub" (f32.const -0x0p+0) (f32.const -0x1p-149)) (f32.const 0x1p-149)) +(assert_return (invoke "sub" (f32.const -0x0p+0) (f32.const 0x1p-149)) (f32.const -0x1p-149)) +(assert_return (invoke "sub" (f32.const 0x0p+0) (f32.const -0x1p-149)) (f32.const 0x1p-149)) +(assert_return (invoke "sub" (f32.const 0x0p+0) (f32.const 0x1p-149)) (f32.const -0x1p-149)) +(assert_return (invoke "sub" (f32.const -0x0p+0) (f32.const -0x1p-126)) (f32.const 0x1p-126)) +(assert_return (invoke "sub" (f32.const -0x0p+0) (f32.const 0x1p-126)) (f32.const -0x1p-126)) +(assert_return (invoke "sub" (f32.const 0x0p+0) (f32.const -0x1p-126)) (f32.const 0x1p-126)) +(assert_return (invoke "sub" (f32.const 0x0p+0) (f32.const 0x1p-126)) (f32.const -0x1p-126)) +(assert_return (invoke "sub" (f32.const -0x0p+0) (f32.const -0x1p-1)) (f32.const 0x1p-1)) +(assert_return (invoke "sub" (f32.const -0x0p+0) (f32.const 0x1p-1)) (f32.const -0x1p-1)) +(assert_return (invoke "sub" (f32.const 0x0p+0) (f32.const -0x1p-1)) (f32.const 0x1p-1)) +(assert_return (invoke "sub" (f32.const 0x0p+0) (f32.const 0x1p-1)) (f32.const -0x1p-1)) +(assert_return (invoke "sub" (f32.const -0x0p+0) (f32.const -0x1p+0)) (f32.const 0x1p+0)) +(assert_return (invoke "sub" (f32.const -0x0p+0) (f32.const 0x1p+0)) (f32.const -0x1p+0)) +(assert_return (invoke "sub" (f32.const 0x0p+0) (f32.const -0x1p+0)) (f32.const 0x1p+0)) +(assert_return (invoke "sub" (f32.const 0x0p+0) (f32.const 0x1p+0)) (f32.const -0x1p+0)) +(assert_return (invoke "sub" (f32.const -0x0p+0) (f32.const -0x1.921fb6p+2)) (f32.const 0x1.921fb6p+2)) +(assert_return (invoke "sub" (f32.const -0x0p+0) (f32.const 0x1.921fb6p+2)) (f32.const -0x1.921fb6p+2)) +(assert_return (invoke "sub" (f32.const 0x0p+0) (f32.const -0x1.921fb6p+2)) (f32.const 0x1.921fb6p+2)) +(assert_return (invoke "sub" (f32.const 0x0p+0) (f32.const 0x1.921fb6p+2)) (f32.const -0x1.921fb6p+2)) +(assert_return (invoke "sub" (f32.const -0x0p+0) (f32.const -0x1.fffffep+127)) (f32.const 0x1.fffffep+127)) +(assert_return (invoke "sub" (f32.const -0x0p+0) (f32.const 0x1.fffffep+127)) (f32.const -0x1.fffffep+127)) +(assert_return (invoke "sub" (f32.const 0x0p+0) (f32.const -0x1.fffffep+127)) (f32.const 0x1.fffffep+127)) +(assert_return (invoke "sub" (f32.const 0x0p+0) (f32.const 0x1.fffffep+127)) (f32.const -0x1.fffffep+127)) +(assert_return (invoke "sub" (f32.const -0x0p+0) (f32.const -inf)) (f32.const inf)) +(assert_return (invoke "sub" (f32.const -0x0p+0) (f32.const inf)) (f32.const -inf)) +(assert_return (invoke "sub" (f32.const 0x0p+0) (f32.const -inf)) (f32.const inf)) +(assert_return (invoke "sub" (f32.const 0x0p+0) (f32.const inf)) (f32.const -inf)) +(assert_return (invoke "sub" (f32.const -0x0p+0) (f32.const -nan)) (f32.const nan:canonical)) +(assert_return (invoke "sub" (f32.const -0x0p+0) (f32.const -nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "sub" (f32.const -0x0p+0) (f32.const nan)) (f32.const nan:canonical)) +(assert_return (invoke "sub" (f32.const -0x0p+0) (f32.const nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "sub" (f32.const 0x0p+0) (f32.const -nan)) (f32.const nan:canonical)) +(assert_return (invoke "sub" (f32.const 0x0p+0) (f32.const -nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "sub" (f32.const 0x0p+0) (f32.const nan)) (f32.const nan:canonical)) +(assert_return (invoke "sub" (f32.const 0x0p+0) (f32.const nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "sub" (f32.const -0x1p-149) (f32.const -0x0p+0)) (f32.const -0x1p-149)) +(assert_return (invoke "sub" (f32.const -0x1p-149) (f32.const 0x0p+0)) (f32.const -0x1p-149)) +(assert_return (invoke "sub" (f32.const 0x1p-149) (f32.const -0x0p+0)) (f32.const 0x1p-149)) +(assert_return (invoke "sub" (f32.const 0x1p-149) (f32.const 0x0p+0)) (f32.const 0x1p-149)) +(assert_return (invoke "sub" (f32.const -0x1p-149) (f32.const -0x1p-149)) (f32.const 0x0p+0)) +(assert_return (invoke "sub" (f32.const -0x1p-149) (f32.const 0x1p-149)) (f32.const -0x1p-148)) +(assert_return (invoke "sub" (f32.const 0x1p-149) (f32.const -0x1p-149)) (f32.const 0x1p-148)) +(assert_return (invoke "sub" (f32.const 0x1p-149) (f32.const 0x1p-149)) (f32.const 0x0p+0)) +(assert_return (invoke "sub" (f32.const -0x1p-149) (f32.const -0x1p-126)) (f32.const 0x1.fffffcp-127)) +(assert_return (invoke "sub" (f32.const -0x1p-149) (f32.const 0x1p-126)) (f32.const -0x1.000002p-126)) +(assert_return (invoke "sub" (f32.const 0x1p-149) (f32.const -0x1p-126)) (f32.const 0x1.000002p-126)) +(assert_return (invoke "sub" (f32.const 0x1p-149) (f32.const 0x1p-126)) (f32.const -0x1.fffffcp-127)) +(assert_return (invoke "sub" (f32.const -0x1p-149) (f32.const -0x1p-1)) (f32.const 0x1p-1)) +(assert_return (invoke "sub" (f32.const -0x1p-149) (f32.const 0x1p-1)) (f32.const -0x1p-1)) +(assert_return (invoke "sub" (f32.const 0x1p-149) (f32.const -0x1p-1)) (f32.const 0x1p-1)) +(assert_return (invoke "sub" (f32.const 0x1p-149) (f32.const 0x1p-1)) (f32.const -0x1p-1)) +(assert_return (invoke "sub" (f32.const -0x1p-149) (f32.const -0x1p+0)) (f32.const 0x1p+0)) +(assert_return (invoke "sub" (f32.const -0x1p-149) (f32.const 0x1p+0)) (f32.const -0x1p+0)) +(assert_return (invoke "sub" (f32.const 0x1p-149) (f32.const -0x1p+0)) (f32.const 0x1p+0)) +(assert_return (invoke "sub" (f32.const 0x1p-149) (f32.const 0x1p+0)) (f32.const -0x1p+0)) +(assert_return (invoke "sub" (f32.const -0x1p-149) (f32.const -0x1.921fb6p+2)) (f32.const 0x1.921fb6p+2)) +(assert_return (invoke "sub" (f32.const -0x1p-149) (f32.const 0x1.921fb6p+2)) (f32.const -0x1.921fb6p+2)) +(assert_return (invoke "sub" (f32.const 0x1p-149) (f32.const -0x1.921fb6p+2)) (f32.const 0x1.921fb6p+2)) +(assert_return (invoke "sub" (f32.const 0x1p-149) (f32.const 0x1.921fb6p+2)) (f32.const -0x1.921fb6p+2)) +(assert_return (invoke "sub" (f32.const -0x1p-149) (f32.const -0x1.fffffep+127)) (f32.const 0x1.fffffep+127)) +(assert_return (invoke "sub" (f32.const -0x1p-149) (f32.const 0x1.fffffep+127)) (f32.const -0x1.fffffep+127)) +(assert_return (invoke "sub" (f32.const 0x1p-149) (f32.const -0x1.fffffep+127)) (f32.const 0x1.fffffep+127)) +(assert_return (invoke "sub" (f32.const 0x1p-149) (f32.const 0x1.fffffep+127)) (f32.const -0x1.fffffep+127)) +(assert_return (invoke "sub" (f32.const -0x1p-149) (f32.const -inf)) (f32.const inf)) +(assert_return (invoke "sub" (f32.const -0x1p-149) (f32.const inf)) (f32.const -inf)) +(assert_return (invoke "sub" (f32.const 0x1p-149) (f32.const -inf)) (f32.const inf)) +(assert_return (invoke "sub" (f32.const 0x1p-149) (f32.const inf)) (f32.const -inf)) +(assert_return (invoke "sub" (f32.const -0x1p-149) (f32.const -nan)) (f32.const nan:canonical)) +(assert_return (invoke "sub" (f32.const -0x1p-149) (f32.const -nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "sub" (f32.const -0x1p-149) (f32.const nan)) (f32.const nan:canonical)) +(assert_return (invoke "sub" (f32.const -0x1p-149) (f32.const nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "sub" (f32.const 0x1p-149) (f32.const -nan)) (f32.const nan:canonical)) +(assert_return (invoke "sub" (f32.const 0x1p-149) (f32.const -nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "sub" (f32.const 0x1p-149) (f32.const nan)) (f32.const nan:canonical)) +(assert_return (invoke "sub" (f32.const 0x1p-149) (f32.const nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "sub" (f32.const -0x1p-126) (f32.const -0x0p+0)) (f32.const -0x1p-126)) +(assert_return (invoke "sub" (f32.const -0x1p-126) (f32.const 0x0p+0)) (f32.const -0x1p-126)) +(assert_return (invoke "sub" (f32.const 0x1p-126) (f32.const -0x0p+0)) (f32.const 0x1p-126)) +(assert_return (invoke "sub" (f32.const 0x1p-126) (f32.const 0x0p+0)) (f32.const 0x1p-126)) +(assert_return (invoke "sub" (f32.const -0x1p-126) (f32.const -0x1p-149)) (f32.const -0x1.fffffcp-127)) +(assert_return (invoke "sub" (f32.const -0x1p-126) (f32.const 0x1p-149)) (f32.const -0x1.000002p-126)) +(assert_return (invoke "sub" (f32.const 0x1p-126) (f32.const -0x1p-149)) (f32.const 0x1.000002p-126)) +(assert_return (invoke "sub" (f32.const 0x1p-126) (f32.const 0x1p-149)) (f32.const 0x1.fffffcp-127)) +(assert_return (invoke "sub" (f32.const -0x1p-126) (f32.const -0x1p-126)) (f32.const 0x0p+0)) +(assert_return (invoke "sub" (f32.const -0x1p-126) (f32.const 0x1p-126)) (f32.const -0x1p-125)) +(assert_return (invoke "sub" (f32.const 0x1p-126) (f32.const -0x1p-126)) (f32.const 0x1p-125)) +(assert_return (invoke "sub" (f32.const 0x1p-126) (f32.const 0x1p-126)) (f32.const 0x0p+0)) +(assert_return (invoke "sub" (f32.const -0x1p-126) (f32.const -0x1p-1)) (f32.const 0x1p-1)) +(assert_return (invoke "sub" (f32.const -0x1p-126) (f32.const 0x1p-1)) (f32.const -0x1p-1)) +(assert_return (invoke "sub" (f32.const 0x1p-126) (f32.const -0x1p-1)) (f32.const 0x1p-1)) +(assert_return (invoke "sub" (f32.const 0x1p-126) (f32.const 0x1p-1)) (f32.const -0x1p-1)) +(assert_return (invoke "sub" (f32.const -0x1p-126) (f32.const -0x1p+0)) (f32.const 0x1p+0)) +(assert_return (invoke "sub" (f32.const -0x1p-126) (f32.const 0x1p+0)) (f32.const -0x1p+0)) +(assert_return (invoke "sub" (f32.const 0x1p-126) (f32.const -0x1p+0)) (f32.const 0x1p+0)) +(assert_return (invoke "sub" (f32.const 0x1p-126) (f32.const 0x1p+0)) (f32.const -0x1p+0)) +(assert_return (invoke "sub" (f32.const -0x1p-126) (f32.const -0x1.921fb6p+2)) (f32.const 0x1.921fb6p+2)) +(assert_return (invoke "sub" (f32.const -0x1p-126) (f32.const 0x1.921fb6p+2)) (f32.const -0x1.921fb6p+2)) +(assert_return (invoke "sub" (f32.const 0x1p-126) (f32.const -0x1.921fb6p+2)) (f32.const 0x1.921fb6p+2)) +(assert_return (invoke "sub" (f32.const 0x1p-126) (f32.const 0x1.921fb6p+2)) (f32.const -0x1.921fb6p+2)) +(assert_return (invoke "sub" (f32.const -0x1p-126) (f32.const -0x1.fffffep+127)) (f32.const 0x1.fffffep+127)) +(assert_return (invoke "sub" (f32.const -0x1p-126) (f32.const 0x1.fffffep+127)) (f32.const -0x1.fffffep+127)) +(assert_return (invoke "sub" (f32.const 0x1p-126) (f32.const -0x1.fffffep+127)) (f32.const 0x1.fffffep+127)) +(assert_return (invoke "sub" (f32.const 0x1p-126) (f32.const 0x1.fffffep+127)) (f32.const -0x1.fffffep+127)) +(assert_return (invoke "sub" (f32.const -0x1p-126) (f32.const -inf)) (f32.const inf)) +(assert_return (invoke "sub" (f32.const -0x1p-126) (f32.const inf)) (f32.const -inf)) +(assert_return (invoke "sub" (f32.const 0x1p-126) (f32.const -inf)) (f32.const inf)) +(assert_return (invoke "sub" (f32.const 0x1p-126) (f32.const inf)) (f32.const -inf)) +(assert_return (invoke "sub" (f32.const -0x1p-126) (f32.const -nan)) (f32.const nan:canonical)) +(assert_return (invoke "sub" (f32.const -0x1p-126) (f32.const -nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "sub" (f32.const -0x1p-126) (f32.const nan)) (f32.const nan:canonical)) +(assert_return (invoke "sub" (f32.const -0x1p-126) (f32.const nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "sub" (f32.const 0x1p-126) (f32.const -nan)) (f32.const nan:canonical)) +(assert_return (invoke "sub" (f32.const 0x1p-126) (f32.const -nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "sub" (f32.const 0x1p-126) (f32.const nan)) (f32.const nan:canonical)) +(assert_return (invoke "sub" (f32.const 0x1p-126) (f32.const nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "sub" (f32.const -0x1p-1) (f32.const -0x0p+0)) (f32.const -0x1p-1)) +(assert_return (invoke "sub" (f32.const -0x1p-1) (f32.const 0x0p+0)) (f32.const -0x1p-1)) +(assert_return (invoke "sub" (f32.const 0x1p-1) (f32.const -0x0p+0)) (f32.const 0x1p-1)) +(assert_return (invoke "sub" (f32.const 0x1p-1) (f32.const 0x0p+0)) (f32.const 0x1p-1)) +(assert_return (invoke "sub" (f32.const -0x1p-1) (f32.const -0x1p-149)) (f32.const -0x1p-1)) +(assert_return (invoke "sub" (f32.const -0x1p-1) (f32.const 0x1p-149)) (f32.const -0x1p-1)) +(assert_return (invoke "sub" (f32.const 0x1p-1) (f32.const -0x1p-149)) (f32.const 0x1p-1)) +(assert_return (invoke "sub" (f32.const 0x1p-1) (f32.const 0x1p-149)) (f32.const 0x1p-1)) +(assert_return (invoke "sub" (f32.const -0x1p-1) (f32.const -0x1p-126)) (f32.const -0x1p-1)) +(assert_return (invoke "sub" (f32.const -0x1p-1) (f32.const 0x1p-126)) (f32.const -0x1p-1)) +(assert_return (invoke "sub" (f32.const 0x1p-1) (f32.const -0x1p-126)) (f32.const 0x1p-1)) +(assert_return (invoke "sub" (f32.const 0x1p-1) (f32.const 0x1p-126)) (f32.const 0x1p-1)) +(assert_return (invoke "sub" (f32.const -0x1p-1) (f32.const -0x1p-1)) (f32.const 0x0p+0)) +(assert_return (invoke "sub" (f32.const -0x1p-1) (f32.const 0x1p-1)) (f32.const -0x1p+0)) +(assert_return (invoke "sub" (f32.const 0x1p-1) (f32.const -0x1p-1)) (f32.const 0x1p+0)) +(assert_return (invoke "sub" (f32.const 0x1p-1) (f32.const 0x1p-1)) (f32.const 0x0p+0)) +(assert_return (invoke "sub" (f32.const -0x1p-1) (f32.const -0x1p+0)) (f32.const 0x1p-1)) +(assert_return (invoke "sub" (f32.const -0x1p-1) (f32.const 0x1p+0)) (f32.const -0x1.8p+0)) +(assert_return (invoke "sub" (f32.const 0x1p-1) (f32.const -0x1p+0)) (f32.const 0x1.8p+0)) +(assert_return (invoke "sub" (f32.const 0x1p-1) (f32.const 0x1p+0)) (f32.const -0x1p-1)) +(assert_return (invoke "sub" (f32.const -0x1p-1) (f32.const -0x1.921fb6p+2)) (f32.const 0x1.721fb6p+2)) +(assert_return (invoke "sub" (f32.const -0x1p-1) (f32.const 0x1.921fb6p+2)) (f32.const -0x1.b21fb6p+2)) +(assert_return (invoke "sub" (f32.const 0x1p-1) (f32.const -0x1.921fb6p+2)) (f32.const 0x1.b21fb6p+2)) +(assert_return (invoke "sub" (f32.const 0x1p-1) (f32.const 0x1.921fb6p+2)) (f32.const -0x1.721fb6p+2)) +(assert_return (invoke "sub" (f32.const -0x1p-1) (f32.const -0x1.fffffep+127)) (f32.const 0x1.fffffep+127)) +(assert_return (invoke "sub" (f32.const -0x1p-1) (f32.const 0x1.fffffep+127)) (f32.const -0x1.fffffep+127)) +(assert_return (invoke "sub" (f32.const 0x1p-1) (f32.const -0x1.fffffep+127)) (f32.const 0x1.fffffep+127)) +(assert_return (invoke "sub" (f32.const 0x1p-1) (f32.const 0x1.fffffep+127)) (f32.const -0x1.fffffep+127)) +(assert_return (invoke "sub" (f32.const -0x1p-1) (f32.const -inf)) (f32.const inf)) +(assert_return (invoke "sub" (f32.const -0x1p-1) (f32.const inf)) (f32.const -inf)) +(assert_return (invoke "sub" (f32.const 0x1p-1) (f32.const -inf)) (f32.const inf)) +(assert_return (invoke "sub" (f32.const 0x1p-1) (f32.const inf)) (f32.const -inf)) +(assert_return (invoke "sub" (f32.const -0x1p-1) (f32.const -nan)) (f32.const nan:canonical)) +(assert_return (invoke "sub" (f32.const -0x1p-1) (f32.const -nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "sub" (f32.const -0x1p-1) (f32.const nan)) (f32.const nan:canonical)) +(assert_return (invoke "sub" (f32.const -0x1p-1) (f32.const nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "sub" (f32.const 0x1p-1) (f32.const -nan)) (f32.const nan:canonical)) +(assert_return (invoke "sub" (f32.const 0x1p-1) (f32.const -nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "sub" (f32.const 0x1p-1) (f32.const nan)) (f32.const nan:canonical)) +(assert_return (invoke "sub" (f32.const 0x1p-1) (f32.const nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "sub" (f32.const -0x1p+0) (f32.const -0x0p+0)) (f32.const -0x1p+0)) +(assert_return (invoke "sub" (f32.const -0x1p+0) (f32.const 0x0p+0)) (f32.const -0x1p+0)) +(assert_return (invoke "sub" (f32.const 0x1p+0) (f32.const -0x0p+0)) (f32.const 0x1p+0)) +(assert_return (invoke "sub" (f32.const 0x1p+0) (f32.const 0x0p+0)) (f32.const 0x1p+0)) +(assert_return (invoke "sub" (f32.const -0x1p+0) (f32.const -0x1p-149)) (f32.const -0x1p+0)) +(assert_return (invoke "sub" (f32.const -0x1p+0) (f32.const 0x1p-149)) (f32.const -0x1p+0)) +(assert_return (invoke "sub" (f32.const 0x1p+0) (f32.const -0x1p-149)) (f32.const 0x1p+0)) +(assert_return (invoke "sub" (f32.const 0x1p+0) (f32.const 0x1p-149)) (f32.const 0x1p+0)) +(assert_return (invoke "sub" (f32.const -0x1p+0) (f32.const -0x1p-126)) (f32.const -0x1p+0)) +(assert_return (invoke "sub" (f32.const -0x1p+0) (f32.const 0x1p-126)) (f32.const -0x1p+0)) +(assert_return (invoke "sub" (f32.const 0x1p+0) (f32.const -0x1p-126)) (f32.const 0x1p+0)) +(assert_return (invoke "sub" (f32.const 0x1p+0) (f32.const 0x1p-126)) (f32.const 0x1p+0)) +(assert_return (invoke "sub" (f32.const -0x1p+0) (f32.const -0x1p-1)) (f32.const -0x1p-1)) +(assert_return (invoke "sub" (f32.const -0x1p+0) (f32.const 0x1p-1)) (f32.const -0x1.8p+0)) +(assert_return (invoke "sub" (f32.const 0x1p+0) (f32.const -0x1p-1)) (f32.const 0x1.8p+0)) +(assert_return (invoke "sub" (f32.const 0x1p+0) (f32.const 0x1p-1)) (f32.const 0x1p-1)) +(assert_return (invoke "sub" (f32.const -0x1p+0) (f32.const -0x1p+0)) (f32.const 0x0p+0)) +(assert_return (invoke "sub" (f32.const -0x1p+0) (f32.const 0x1p+0)) (f32.const -0x1p+1)) +(assert_return (invoke "sub" (f32.const 0x1p+0) (f32.const -0x1p+0)) (f32.const 0x1p+1)) +(assert_return (invoke "sub" (f32.const 0x1p+0) (f32.const 0x1p+0)) (f32.const 0x0p+0)) +(assert_return (invoke "sub" (f32.const -0x1p+0) (f32.const -0x1.921fb6p+2)) (f32.const 0x1.521fb6p+2)) +(assert_return (invoke "sub" (f32.const -0x1p+0) (f32.const 0x1.921fb6p+2)) (f32.const -0x1.d21fb6p+2)) +(assert_return (invoke "sub" (f32.const 0x1p+0) (f32.const -0x1.921fb6p+2)) (f32.const 0x1.d21fb6p+2)) +(assert_return (invoke "sub" (f32.const 0x1p+0) (f32.const 0x1.921fb6p+2)) (f32.const -0x1.521fb6p+2)) +(assert_return (invoke "sub" (f32.const -0x1p+0) (f32.const -0x1.fffffep+127)) (f32.const 0x1.fffffep+127)) +(assert_return (invoke "sub" (f32.const -0x1p+0) (f32.const 0x1.fffffep+127)) (f32.const -0x1.fffffep+127)) +(assert_return (invoke "sub" (f32.const 0x1p+0) (f32.const -0x1.fffffep+127)) (f32.const 0x1.fffffep+127)) +(assert_return (invoke "sub" (f32.const 0x1p+0) (f32.const 0x1.fffffep+127)) (f32.const -0x1.fffffep+127)) +(assert_return (invoke "sub" (f32.const -0x1p+0) (f32.const -inf)) (f32.const inf)) +(assert_return (invoke "sub" (f32.const -0x1p+0) (f32.const inf)) (f32.const -inf)) +(assert_return (invoke "sub" (f32.const 0x1p+0) (f32.const -inf)) (f32.const inf)) +(assert_return (invoke "sub" (f32.const 0x1p+0) (f32.const inf)) (f32.const -inf)) +(assert_return (invoke "sub" (f32.const -0x1p+0) (f32.const -nan)) (f32.const nan:canonical)) +(assert_return (invoke "sub" (f32.const -0x1p+0) (f32.const -nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "sub" (f32.const -0x1p+0) (f32.const nan)) (f32.const nan:canonical)) +(assert_return (invoke "sub" (f32.const -0x1p+0) (f32.const nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "sub" (f32.const 0x1p+0) (f32.const -nan)) (f32.const nan:canonical)) +(assert_return (invoke "sub" (f32.const 0x1p+0) (f32.const -nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "sub" (f32.const 0x1p+0) (f32.const nan)) (f32.const nan:canonical)) +(assert_return (invoke "sub" (f32.const 0x1p+0) (f32.const nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "sub" (f32.const -0x1.921fb6p+2) (f32.const -0x0p+0)) (f32.const -0x1.921fb6p+2)) +(assert_return (invoke "sub" (f32.const -0x1.921fb6p+2) (f32.const 0x0p+0)) (f32.const -0x1.921fb6p+2)) +(assert_return (invoke "sub" (f32.const 0x1.921fb6p+2) (f32.const -0x0p+0)) (f32.const 0x1.921fb6p+2)) +(assert_return (invoke "sub" (f32.const 0x1.921fb6p+2) (f32.const 0x0p+0)) (f32.const 0x1.921fb6p+2)) +(assert_return (invoke "sub" (f32.const -0x1.921fb6p+2) (f32.const -0x1p-149)) (f32.const -0x1.921fb6p+2)) +(assert_return (invoke "sub" (f32.const -0x1.921fb6p+2) (f32.const 0x1p-149)) (f32.const -0x1.921fb6p+2)) +(assert_return (invoke "sub" (f32.const 0x1.921fb6p+2) (f32.const -0x1p-149)) (f32.const 0x1.921fb6p+2)) +(assert_return (invoke "sub" (f32.const 0x1.921fb6p+2) (f32.const 0x1p-149)) (f32.const 0x1.921fb6p+2)) +(assert_return (invoke "sub" (f32.const -0x1.921fb6p+2) (f32.const -0x1p-126)) (f32.const -0x1.921fb6p+2)) +(assert_return (invoke "sub" (f32.const -0x1.921fb6p+2) (f32.const 0x1p-126)) (f32.const -0x1.921fb6p+2)) +(assert_return (invoke "sub" (f32.const 0x1.921fb6p+2) (f32.const -0x1p-126)) (f32.const 0x1.921fb6p+2)) +(assert_return (invoke "sub" (f32.const 0x1.921fb6p+2) (f32.const 0x1p-126)) (f32.const 0x1.921fb6p+2)) +(assert_return (invoke "sub" (f32.const -0x1.921fb6p+2) (f32.const -0x1p-1)) (f32.const -0x1.721fb6p+2)) +(assert_return (invoke "sub" (f32.const -0x1.921fb6p+2) (f32.const 0x1p-1)) (f32.const -0x1.b21fb6p+2)) +(assert_return (invoke "sub" (f32.const 0x1.921fb6p+2) (f32.const -0x1p-1)) (f32.const 0x1.b21fb6p+2)) +(assert_return (invoke "sub" (f32.const 0x1.921fb6p+2) (f32.const 0x1p-1)) (f32.const 0x1.721fb6p+2)) +(assert_return (invoke "sub" (f32.const -0x1.921fb6p+2) (f32.const -0x1p+0)) (f32.const -0x1.521fb6p+2)) +(assert_return (invoke "sub" (f32.const -0x1.921fb6p+2) (f32.const 0x1p+0)) (f32.const -0x1.d21fb6p+2)) +(assert_return (invoke "sub" (f32.const 0x1.921fb6p+2) (f32.const -0x1p+0)) (f32.const 0x1.d21fb6p+2)) +(assert_return (invoke "sub" (f32.const 0x1.921fb6p+2) (f32.const 0x1p+0)) (f32.const 0x1.521fb6p+2)) +(assert_return (invoke "sub" (f32.const -0x1.921fb6p+2) (f32.const -0x1.921fb6p+2)) (f32.const 0x0p+0)) +(assert_return (invoke "sub" (f32.const -0x1.921fb6p+2) (f32.const 0x1.921fb6p+2)) (f32.const -0x1.921fb6p+3)) +(assert_return (invoke "sub" (f32.const 0x1.921fb6p+2) (f32.const -0x1.921fb6p+2)) (f32.const 0x1.921fb6p+3)) +(assert_return (invoke "sub" (f32.const 0x1.921fb6p+2) (f32.const 0x1.921fb6p+2)) (f32.const 0x0p+0)) +(assert_return (invoke "sub" (f32.const -0x1.921fb6p+2) (f32.const -0x1.fffffep+127)) (f32.const 0x1.fffffep+127)) +(assert_return (invoke "sub" (f32.const -0x1.921fb6p+2) (f32.const 0x1.fffffep+127)) (f32.const -0x1.fffffep+127)) +(assert_return (invoke "sub" (f32.const 0x1.921fb6p+2) (f32.const -0x1.fffffep+127)) (f32.const 0x1.fffffep+127)) +(assert_return (invoke "sub" (f32.const 0x1.921fb6p+2) (f32.const 0x1.fffffep+127)) (f32.const -0x1.fffffep+127)) +(assert_return (invoke "sub" (f32.const -0x1.921fb6p+2) (f32.const -inf)) (f32.const inf)) +(assert_return (invoke "sub" (f32.const -0x1.921fb6p+2) (f32.const inf)) (f32.const -inf)) +(assert_return (invoke "sub" (f32.const 0x1.921fb6p+2) (f32.const -inf)) (f32.const inf)) +(assert_return (invoke "sub" (f32.const 0x1.921fb6p+2) (f32.const inf)) (f32.const -inf)) +(assert_return (invoke "sub" (f32.const -0x1.921fb6p+2) (f32.const -nan)) (f32.const nan:canonical)) +(assert_return (invoke "sub" (f32.const -0x1.921fb6p+2) (f32.const -nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "sub" (f32.const -0x1.921fb6p+2) (f32.const nan)) (f32.const nan:canonical)) +(assert_return (invoke "sub" (f32.const -0x1.921fb6p+2) (f32.const nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "sub" (f32.const 0x1.921fb6p+2) (f32.const -nan)) (f32.const nan:canonical)) +(assert_return (invoke "sub" (f32.const 0x1.921fb6p+2) (f32.const -nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "sub" (f32.const 0x1.921fb6p+2) (f32.const nan)) (f32.const nan:canonical)) +(assert_return (invoke "sub" (f32.const 0x1.921fb6p+2) (f32.const nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "sub" (f32.const -0x1.fffffep+127) (f32.const -0x0p+0)) (f32.const -0x1.fffffep+127)) +(assert_return (invoke "sub" (f32.const -0x1.fffffep+127) (f32.const 0x0p+0)) (f32.const -0x1.fffffep+127)) +(assert_return (invoke "sub" (f32.const 0x1.fffffep+127) (f32.const -0x0p+0)) (f32.const 0x1.fffffep+127)) +(assert_return (invoke "sub" (f32.const 0x1.fffffep+127) (f32.const 0x0p+0)) (f32.const 0x1.fffffep+127)) +(assert_return (invoke "sub" (f32.const -0x1.fffffep+127) (f32.const -0x1p-149)) (f32.const -0x1.fffffep+127)) +(assert_return (invoke "sub" (f32.const -0x1.fffffep+127) (f32.const 0x1p-149)) (f32.const -0x1.fffffep+127)) +(assert_return (invoke "sub" (f32.const 0x1.fffffep+127) (f32.const -0x1p-149)) (f32.const 0x1.fffffep+127)) +(assert_return (invoke "sub" (f32.const 0x1.fffffep+127) (f32.const 0x1p-149)) (f32.const 0x1.fffffep+127)) +(assert_return (invoke "sub" (f32.const -0x1.fffffep+127) (f32.const -0x1p-126)) (f32.const -0x1.fffffep+127)) +(assert_return (invoke "sub" (f32.const -0x1.fffffep+127) (f32.const 0x1p-126)) (f32.const -0x1.fffffep+127)) +(assert_return (invoke "sub" (f32.const 0x1.fffffep+127) (f32.const -0x1p-126)) (f32.const 0x1.fffffep+127)) +(assert_return (invoke "sub" (f32.const 0x1.fffffep+127) (f32.const 0x1p-126)) (f32.const 0x1.fffffep+127)) +(assert_return (invoke "sub" (f32.const -0x1.fffffep+127) (f32.const -0x1p-1)) (f32.const -0x1.fffffep+127)) +(assert_return (invoke "sub" (f32.const -0x1.fffffep+127) (f32.const 0x1p-1)) (f32.const -0x1.fffffep+127)) +(assert_return (invoke "sub" (f32.const 0x1.fffffep+127) (f32.const -0x1p-1)) (f32.const 0x1.fffffep+127)) +(assert_return (invoke "sub" (f32.const 0x1.fffffep+127) (f32.const 0x1p-1)) (f32.const 0x1.fffffep+127)) +(assert_return (invoke "sub" (f32.const -0x1.fffffep+127) (f32.const -0x1p+0)) (f32.const -0x1.fffffep+127)) +(assert_return (invoke "sub" (f32.const -0x1.fffffep+127) (f32.const 0x1p+0)) (f32.const -0x1.fffffep+127)) +(assert_return (invoke "sub" (f32.const 0x1.fffffep+127) (f32.const -0x1p+0)) (f32.const 0x1.fffffep+127)) +(assert_return (invoke "sub" (f32.const 0x1.fffffep+127) (f32.const 0x1p+0)) (f32.const 0x1.fffffep+127)) +(assert_return (invoke "sub" (f32.const -0x1.fffffep+127) (f32.const -0x1.921fb6p+2)) (f32.const -0x1.fffffep+127)) +(assert_return (invoke "sub" (f32.const -0x1.fffffep+127) (f32.const 0x1.921fb6p+2)) (f32.const -0x1.fffffep+127)) +(assert_return (invoke "sub" (f32.const 0x1.fffffep+127) (f32.const -0x1.921fb6p+2)) (f32.const 0x1.fffffep+127)) +(assert_return (invoke "sub" (f32.const 0x1.fffffep+127) (f32.const 0x1.921fb6p+2)) (f32.const 0x1.fffffep+127)) +(assert_return (invoke "sub" (f32.const -0x1.fffffep+127) (f32.const -0x1.fffffep+127)) (f32.const 0x0p+0)) +(assert_return (invoke "sub" (f32.const -0x1.fffffep+127) (f32.const 0x1.fffffep+127)) (f32.const -inf)) +(assert_return (invoke "sub" (f32.const 0x1.fffffep+127) (f32.const -0x1.fffffep+127)) (f32.const inf)) +(assert_return (invoke "sub" (f32.const 0x1.fffffep+127) (f32.const 0x1.fffffep+127)) (f32.const 0x0p+0)) +(assert_return (invoke "sub" (f32.const -0x1.fffffep+127) (f32.const -inf)) (f32.const inf)) +(assert_return (invoke "sub" (f32.const -0x1.fffffep+127) (f32.const inf)) (f32.const -inf)) +(assert_return (invoke "sub" (f32.const 0x1.fffffep+127) (f32.const -inf)) (f32.const inf)) +(assert_return (invoke "sub" (f32.const 0x1.fffffep+127) (f32.const inf)) (f32.const -inf)) +(assert_return (invoke "sub" (f32.const -0x1.fffffep+127) (f32.const -nan)) (f32.const nan:canonical)) +(assert_return (invoke "sub" (f32.const -0x1.fffffep+127) (f32.const -nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "sub" (f32.const -0x1.fffffep+127) (f32.const nan)) (f32.const nan:canonical)) +(assert_return (invoke "sub" (f32.const -0x1.fffffep+127) (f32.const nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "sub" (f32.const 0x1.fffffep+127) (f32.const -nan)) (f32.const nan:canonical)) +(assert_return (invoke "sub" (f32.const 0x1.fffffep+127) (f32.const -nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "sub" (f32.const 0x1.fffffep+127) (f32.const nan)) (f32.const nan:canonical)) +(assert_return (invoke "sub" (f32.const 0x1.fffffep+127) (f32.const nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "sub" (f32.const -inf) (f32.const -0x0p+0)) (f32.const -inf)) +(assert_return (invoke "sub" (f32.const -inf) (f32.const 0x0p+0)) (f32.const -inf)) +(assert_return (invoke "sub" (f32.const inf) (f32.const -0x0p+0)) (f32.const inf)) +(assert_return (invoke "sub" (f32.const inf) (f32.const 0x0p+0)) (f32.const inf)) +(assert_return (invoke "sub" (f32.const -inf) (f32.const -0x1p-149)) (f32.const -inf)) +(assert_return (invoke "sub" (f32.const -inf) (f32.const 0x1p-149)) (f32.const -inf)) +(assert_return (invoke "sub" (f32.const inf) (f32.const -0x1p-149)) (f32.const inf)) +(assert_return (invoke "sub" (f32.const inf) (f32.const 0x1p-149)) (f32.const inf)) +(assert_return (invoke "sub" (f32.const -inf) (f32.const -0x1p-126)) (f32.const -inf)) +(assert_return (invoke "sub" (f32.const -inf) (f32.const 0x1p-126)) (f32.const -inf)) +(assert_return (invoke "sub" (f32.const inf) (f32.const -0x1p-126)) (f32.const inf)) +(assert_return (invoke "sub" (f32.const inf) (f32.const 0x1p-126)) (f32.const inf)) +(assert_return (invoke "sub" (f32.const -inf) (f32.const -0x1p-1)) (f32.const -inf)) +(assert_return (invoke "sub" (f32.const -inf) (f32.const 0x1p-1)) (f32.const -inf)) +(assert_return (invoke "sub" (f32.const inf) (f32.const -0x1p-1)) (f32.const inf)) +(assert_return (invoke "sub" (f32.const inf) (f32.const 0x1p-1)) (f32.const inf)) +(assert_return (invoke "sub" (f32.const -inf) (f32.const -0x1p+0)) (f32.const -inf)) +(assert_return (invoke "sub" (f32.const -inf) (f32.const 0x1p+0)) (f32.const -inf)) +(assert_return (invoke "sub" (f32.const inf) (f32.const -0x1p+0)) (f32.const inf)) +(assert_return (invoke "sub" (f32.const inf) (f32.const 0x1p+0)) (f32.const inf)) +(assert_return (invoke "sub" (f32.const -inf) (f32.const -0x1.921fb6p+2)) (f32.const -inf)) +(assert_return (invoke "sub" (f32.const -inf) (f32.const 0x1.921fb6p+2)) (f32.const -inf)) +(assert_return (invoke "sub" (f32.const inf) (f32.const -0x1.921fb6p+2)) (f32.const inf)) +(assert_return (invoke "sub" (f32.const inf) (f32.const 0x1.921fb6p+2)) (f32.const inf)) +(assert_return (invoke "sub" (f32.const -inf) (f32.const -0x1.fffffep+127)) (f32.const -inf)) +(assert_return (invoke "sub" (f32.const -inf) (f32.const 0x1.fffffep+127)) (f32.const -inf)) +(assert_return (invoke "sub" (f32.const inf) (f32.const -0x1.fffffep+127)) (f32.const inf)) +(assert_return (invoke "sub" (f32.const inf) (f32.const 0x1.fffffep+127)) (f32.const inf)) +(assert_return (invoke "sub" (f32.const -inf) (f32.const -inf)) (f32.const nan:canonical)) +(assert_return (invoke "sub" (f32.const -inf) (f32.const inf)) (f32.const -inf)) +(assert_return (invoke "sub" (f32.const inf) (f32.const -inf)) (f32.const inf)) +(assert_return (invoke "sub" (f32.const inf) (f32.const inf)) (f32.const nan:canonical)) +(assert_return (invoke "sub" (f32.const -inf) (f32.const -nan)) (f32.const nan:canonical)) +(assert_return (invoke "sub" (f32.const -inf) (f32.const -nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "sub" (f32.const -inf) (f32.const nan)) (f32.const nan:canonical)) +(assert_return (invoke "sub" (f32.const -inf) (f32.const nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "sub" (f32.const inf) (f32.const -nan)) (f32.const nan:canonical)) +(assert_return (invoke "sub" (f32.const inf) (f32.const -nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "sub" (f32.const inf) (f32.const nan)) (f32.const nan:canonical)) +(assert_return (invoke "sub" (f32.const inf) (f32.const nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "sub" (f32.const -nan) (f32.const -0x0p+0)) (f32.const nan:canonical)) +(assert_return (invoke "sub" (f32.const -nan:0x200000) (f32.const -0x0p+0)) (f32.const nan:arithmetic)) +(assert_return (invoke "sub" (f32.const -nan) (f32.const 0x0p+0)) (f32.const nan:canonical)) +(assert_return (invoke "sub" (f32.const -nan:0x200000) (f32.const 0x0p+0)) (f32.const nan:arithmetic)) +(assert_return (invoke "sub" (f32.const nan) (f32.const -0x0p+0)) (f32.const nan:canonical)) +(assert_return (invoke "sub" (f32.const nan:0x200000) (f32.const -0x0p+0)) (f32.const nan:arithmetic)) +(assert_return (invoke "sub" (f32.const nan) (f32.const 0x0p+0)) (f32.const nan:canonical)) +(assert_return (invoke "sub" (f32.const nan:0x200000) (f32.const 0x0p+0)) (f32.const nan:arithmetic)) +(assert_return (invoke "sub" (f32.const -nan) (f32.const -0x1p-149)) (f32.const nan:canonical)) +(assert_return (invoke "sub" (f32.const -nan:0x200000) (f32.const -0x1p-149)) (f32.const nan:arithmetic)) +(assert_return (invoke "sub" (f32.const -nan) (f32.const 0x1p-149)) (f32.const nan:canonical)) +(assert_return (invoke "sub" (f32.const -nan:0x200000) (f32.const 0x1p-149)) (f32.const nan:arithmetic)) +(assert_return (invoke "sub" (f32.const nan) (f32.const -0x1p-149)) (f32.const nan:canonical)) +(assert_return (invoke "sub" (f32.const nan:0x200000) (f32.const -0x1p-149)) (f32.const nan:arithmetic)) +(assert_return (invoke "sub" (f32.const nan) (f32.const 0x1p-149)) (f32.const nan:canonical)) +(assert_return (invoke "sub" (f32.const nan:0x200000) (f32.const 0x1p-149)) (f32.const nan:arithmetic)) +(assert_return (invoke "sub" (f32.const -nan) (f32.const -0x1p-126)) (f32.const nan:canonical)) +(assert_return (invoke "sub" (f32.const -nan:0x200000) (f32.const -0x1p-126)) (f32.const nan:arithmetic)) +(assert_return (invoke "sub" (f32.const -nan) (f32.const 0x1p-126)) (f32.const nan:canonical)) +(assert_return (invoke "sub" (f32.const -nan:0x200000) (f32.const 0x1p-126)) (f32.const nan:arithmetic)) +(assert_return (invoke "sub" (f32.const nan) (f32.const -0x1p-126)) (f32.const nan:canonical)) +(assert_return (invoke "sub" (f32.const nan:0x200000) (f32.const -0x1p-126)) (f32.const nan:arithmetic)) +(assert_return (invoke "sub" (f32.const nan) (f32.const 0x1p-126)) (f32.const nan:canonical)) +(assert_return (invoke "sub" (f32.const nan:0x200000) (f32.const 0x1p-126)) (f32.const nan:arithmetic)) +(assert_return (invoke "sub" (f32.const -nan) (f32.const -0x1p-1)) (f32.const nan:canonical)) +(assert_return (invoke "sub" (f32.const -nan:0x200000) (f32.const -0x1p-1)) (f32.const nan:arithmetic)) +(assert_return (invoke "sub" (f32.const -nan) (f32.const 0x1p-1)) (f32.const nan:canonical)) +(assert_return (invoke "sub" (f32.const -nan:0x200000) (f32.const 0x1p-1)) (f32.const nan:arithmetic)) +(assert_return (invoke "sub" (f32.const nan) (f32.const -0x1p-1)) (f32.const nan:canonical)) +(assert_return (invoke "sub" (f32.const nan:0x200000) (f32.const -0x1p-1)) (f32.const nan:arithmetic)) +(assert_return (invoke "sub" (f32.const nan) (f32.const 0x1p-1)) (f32.const nan:canonical)) +(assert_return (invoke "sub" (f32.const nan:0x200000) (f32.const 0x1p-1)) (f32.const nan:arithmetic)) +(assert_return (invoke "sub" (f32.const -nan) (f32.const -0x1p+0)) (f32.const nan:canonical)) +(assert_return (invoke "sub" (f32.const -nan:0x200000) (f32.const -0x1p+0)) (f32.const nan:arithmetic)) +(assert_return (invoke "sub" (f32.const -nan) (f32.const 0x1p+0)) (f32.const nan:canonical)) +(assert_return (invoke "sub" (f32.const -nan:0x200000) (f32.const 0x1p+0)) (f32.const nan:arithmetic)) +(assert_return (invoke "sub" (f32.const nan) (f32.const -0x1p+0)) (f32.const nan:canonical)) +(assert_return (invoke "sub" (f32.const nan:0x200000) (f32.const -0x1p+0)) (f32.const nan:arithmetic)) +(assert_return (invoke "sub" (f32.const nan) (f32.const 0x1p+0)) (f32.const nan:canonical)) +(assert_return (invoke "sub" (f32.const nan:0x200000) (f32.const 0x1p+0)) (f32.const nan:arithmetic)) +(assert_return (invoke "sub" (f32.const -nan) (f32.const -0x1.921fb6p+2)) (f32.const nan:canonical)) +(assert_return (invoke "sub" (f32.const -nan:0x200000) (f32.const -0x1.921fb6p+2)) (f32.const nan:arithmetic)) +(assert_return (invoke "sub" (f32.const -nan) (f32.const 0x1.921fb6p+2)) (f32.const nan:canonical)) +(assert_return (invoke "sub" (f32.const -nan:0x200000) (f32.const 0x1.921fb6p+2)) (f32.const nan:arithmetic)) +(assert_return (invoke "sub" (f32.const nan) (f32.const -0x1.921fb6p+2)) (f32.const nan:canonical)) +(assert_return (invoke "sub" (f32.const nan:0x200000) (f32.const -0x1.921fb6p+2)) (f32.const nan:arithmetic)) +(assert_return (invoke "sub" (f32.const nan) (f32.const 0x1.921fb6p+2)) (f32.const nan:canonical)) +(assert_return (invoke "sub" (f32.const nan:0x200000) (f32.const 0x1.921fb6p+2)) (f32.const nan:arithmetic)) +(assert_return (invoke "sub" (f32.const -nan) (f32.const -0x1.fffffep+127)) (f32.const nan:canonical)) +(assert_return (invoke "sub" (f32.const -nan:0x200000) (f32.const -0x1.fffffep+127)) (f32.const nan:arithmetic)) +(assert_return (invoke "sub" (f32.const -nan) (f32.const 0x1.fffffep+127)) (f32.const nan:canonical)) +(assert_return (invoke "sub" (f32.const -nan:0x200000) (f32.const 0x1.fffffep+127)) (f32.const nan:arithmetic)) +(assert_return (invoke "sub" (f32.const nan) (f32.const -0x1.fffffep+127)) (f32.const nan:canonical)) +(assert_return (invoke "sub" (f32.const nan:0x200000) (f32.const -0x1.fffffep+127)) (f32.const nan:arithmetic)) +(assert_return (invoke "sub" (f32.const nan) (f32.const 0x1.fffffep+127)) (f32.const nan:canonical)) +(assert_return (invoke "sub" (f32.const nan:0x200000) (f32.const 0x1.fffffep+127)) (f32.const nan:arithmetic)) +(assert_return (invoke "sub" (f32.const -nan) (f32.const -inf)) (f32.const nan:canonical)) +(assert_return (invoke "sub" (f32.const -nan:0x200000) (f32.const -inf)) (f32.const nan:arithmetic)) +(assert_return (invoke "sub" (f32.const -nan) (f32.const inf)) (f32.const nan:canonical)) +(assert_return (invoke "sub" (f32.const -nan:0x200000) (f32.const inf)) (f32.const nan:arithmetic)) +(assert_return (invoke "sub" (f32.const nan) (f32.const -inf)) (f32.const nan:canonical)) +(assert_return (invoke "sub" (f32.const nan:0x200000) (f32.const -inf)) (f32.const nan:arithmetic)) +(assert_return (invoke "sub" (f32.const nan) (f32.const inf)) (f32.const nan:canonical)) +(assert_return (invoke "sub" (f32.const nan:0x200000) (f32.const inf)) (f32.const nan:arithmetic)) +(assert_return (invoke "sub" (f32.const -nan) (f32.const -nan)) (f32.const nan:canonical)) +(assert_return (invoke "sub" (f32.const -nan:0x200000) (f32.const -nan)) (f32.const nan:arithmetic)) +(assert_return (invoke "sub" (f32.const -nan) (f32.const -nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "sub" (f32.const -nan:0x200000) (f32.const -nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "sub" (f32.const -nan) (f32.const nan)) (f32.const nan:canonical)) +(assert_return (invoke "sub" (f32.const -nan:0x200000) (f32.const nan)) (f32.const nan:arithmetic)) +(assert_return (invoke "sub" (f32.const -nan) (f32.const nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "sub" (f32.const -nan:0x200000) (f32.const nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "sub" (f32.const nan) (f32.const -nan)) (f32.const nan:canonical)) +(assert_return (invoke "sub" (f32.const nan:0x200000) (f32.const -nan)) (f32.const nan:arithmetic)) +(assert_return (invoke "sub" (f32.const nan) (f32.const -nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "sub" (f32.const nan:0x200000) (f32.const -nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "sub" (f32.const nan) (f32.const nan)) (f32.const nan:canonical)) +(assert_return (invoke "sub" (f32.const nan:0x200000) (f32.const nan)) (f32.const nan:arithmetic)) +(assert_return (invoke "sub" (f32.const nan) (f32.const nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "sub" (f32.const nan:0x200000) (f32.const nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "mul" (f32.const -0x0p+0) (f32.const -0x0p+0)) (f32.const 0x0p+0)) +(assert_return (invoke "mul" (f32.const -0x0p+0) (f32.const 0x0p+0)) (f32.const -0x0p+0)) +(assert_return (invoke "mul" (f32.const 0x0p+0) (f32.const -0x0p+0)) (f32.const -0x0p+0)) +(assert_return (invoke "mul" (f32.const 0x0p+0) (f32.const 0x0p+0)) (f32.const 0x0p+0)) +(assert_return (invoke "mul" (f32.const -0x0p+0) (f32.const -0x1p-149)) (f32.const 0x0p+0)) +(assert_return (invoke "mul" (f32.const -0x0p+0) (f32.const 0x1p-149)) (f32.const -0x0p+0)) +(assert_return (invoke "mul" (f32.const 0x0p+0) (f32.const -0x1p-149)) (f32.const -0x0p+0)) +(assert_return (invoke "mul" (f32.const 0x0p+0) (f32.const 0x1p-149)) (f32.const 0x0p+0)) +(assert_return (invoke "mul" (f32.const -0x0p+0) (f32.const -0x1p-126)) (f32.const 0x0p+0)) +(assert_return (invoke "mul" (f32.const -0x0p+0) (f32.const 0x1p-126)) (f32.const -0x0p+0)) +(assert_return (invoke "mul" (f32.const 0x0p+0) (f32.const -0x1p-126)) (f32.const -0x0p+0)) +(assert_return (invoke "mul" (f32.const 0x0p+0) (f32.const 0x1p-126)) (f32.const 0x0p+0)) +(assert_return (invoke "mul" (f32.const -0x0p+0) (f32.const -0x1p-1)) (f32.const 0x0p+0)) +(assert_return (invoke "mul" (f32.const -0x0p+0) (f32.const 0x1p-1)) (f32.const -0x0p+0)) +(assert_return (invoke "mul" (f32.const 0x0p+0) (f32.const -0x1p-1)) (f32.const -0x0p+0)) +(assert_return (invoke "mul" (f32.const 0x0p+0) (f32.const 0x1p-1)) (f32.const 0x0p+0)) +(assert_return (invoke "mul" (f32.const -0x0p+0) (f32.const -0x1p+0)) (f32.const 0x0p+0)) +(assert_return (invoke "mul" (f32.const -0x0p+0) (f32.const 0x1p+0)) (f32.const -0x0p+0)) +(assert_return (invoke "mul" (f32.const 0x0p+0) (f32.const -0x1p+0)) (f32.const -0x0p+0)) +(assert_return (invoke "mul" (f32.const 0x0p+0) (f32.const 0x1p+0)) (f32.const 0x0p+0)) +(assert_return (invoke "mul" (f32.const -0x0p+0) (f32.const -0x1.921fb6p+2)) (f32.const 0x0p+0)) +(assert_return (invoke "mul" (f32.const -0x0p+0) (f32.const 0x1.921fb6p+2)) (f32.const -0x0p+0)) +(assert_return (invoke "mul" (f32.const 0x0p+0) (f32.const -0x1.921fb6p+2)) (f32.const -0x0p+0)) +(assert_return (invoke "mul" (f32.const 0x0p+0) (f32.const 0x1.921fb6p+2)) (f32.const 0x0p+0)) +(assert_return (invoke "mul" (f32.const -0x0p+0) (f32.const -0x1.fffffep+127)) (f32.const 0x0p+0)) +(assert_return (invoke "mul" (f32.const -0x0p+0) (f32.const 0x1.fffffep+127)) (f32.const -0x0p+0)) +(assert_return (invoke "mul" (f32.const 0x0p+0) (f32.const -0x1.fffffep+127)) (f32.const -0x0p+0)) +(assert_return (invoke "mul" (f32.const 0x0p+0) (f32.const 0x1.fffffep+127)) (f32.const 0x0p+0)) +(assert_return (invoke "mul" (f32.const -0x0p+0) (f32.const -inf)) (f32.const nan:canonical)) +(assert_return (invoke "mul" (f32.const -0x0p+0) (f32.const inf)) (f32.const nan:canonical)) +(assert_return (invoke "mul" (f32.const 0x0p+0) (f32.const -inf)) (f32.const nan:canonical)) +(assert_return (invoke "mul" (f32.const 0x0p+0) (f32.const inf)) (f32.const nan:canonical)) +(assert_return (invoke "mul" (f32.const -0x0p+0) (f32.const -nan)) (f32.const nan:canonical)) +(assert_return (invoke "mul" (f32.const -0x0p+0) (f32.const -nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "mul" (f32.const -0x0p+0) (f32.const nan)) (f32.const nan:canonical)) +(assert_return (invoke "mul" (f32.const -0x0p+0) (f32.const nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "mul" (f32.const 0x0p+0) (f32.const -nan)) (f32.const nan:canonical)) +(assert_return (invoke "mul" (f32.const 0x0p+0) (f32.const -nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "mul" (f32.const 0x0p+0) (f32.const nan)) (f32.const nan:canonical)) +(assert_return (invoke "mul" (f32.const 0x0p+0) (f32.const nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "mul" (f32.const -0x1p-149) (f32.const -0x0p+0)) (f32.const 0x0p+0)) +(assert_return (invoke "mul" (f32.const -0x1p-149) (f32.const 0x0p+0)) (f32.const -0x0p+0)) +(assert_return (invoke "mul" (f32.const 0x1p-149) (f32.const -0x0p+0)) (f32.const -0x0p+0)) +(assert_return (invoke "mul" (f32.const 0x1p-149) (f32.const 0x0p+0)) (f32.const 0x0p+0)) +(assert_return (invoke "mul" (f32.const -0x1p-149) (f32.const -0x1p-149)) (f32.const 0x0p+0)) +(assert_return (invoke "mul" (f32.const -0x1p-149) (f32.const 0x1p-149)) (f32.const -0x0p+0)) +(assert_return (invoke "mul" (f32.const 0x1p-149) (f32.const -0x1p-149)) (f32.const -0x0p+0)) +(assert_return (invoke "mul" (f32.const 0x1p-149) (f32.const 0x1p-149)) (f32.const 0x0p+0)) +(assert_return (invoke "mul" (f32.const -0x1p-149) (f32.const -0x1p-126)) (f32.const 0x0p+0)) +(assert_return (invoke "mul" (f32.const -0x1p-149) (f32.const 0x1p-126)) (f32.const -0x0p+0)) +(assert_return (invoke "mul" (f32.const 0x1p-149) (f32.const -0x1p-126)) (f32.const -0x0p+0)) +(assert_return (invoke "mul" (f32.const 0x1p-149) (f32.const 0x1p-126)) (f32.const 0x0p+0)) +(assert_return (invoke "mul" (f32.const -0x1p-149) (f32.const -0x1p-1)) (f32.const 0x0p+0)) +(assert_return (invoke "mul" (f32.const -0x1p-149) (f32.const 0x1p-1)) (f32.const -0x0p+0)) +(assert_return (invoke "mul" (f32.const 0x1p-149) (f32.const -0x1p-1)) (f32.const -0x0p+0)) +(assert_return (invoke "mul" (f32.const 0x1p-149) (f32.const 0x1p-1)) (f32.const 0x0p+0)) +(assert_return (invoke "mul" (f32.const -0x1p-149) (f32.const -0x1p+0)) (f32.const 0x1p-149)) +(assert_return (invoke "mul" (f32.const -0x1p-149) (f32.const 0x1p+0)) (f32.const -0x1p-149)) +(assert_return (invoke "mul" (f32.const 0x1p-149) (f32.const -0x1p+0)) (f32.const -0x1p-149)) +(assert_return (invoke "mul" (f32.const 0x1p-149) (f32.const 0x1p+0)) (f32.const 0x1p-149)) +(assert_return (invoke "mul" (f32.const -0x1p-149) (f32.const -0x1.921fb6p+2)) (f32.const 0x1.8p-147)) +(assert_return (invoke "mul" (f32.const -0x1p-149) (f32.const 0x1.921fb6p+2)) (f32.const -0x1.8p-147)) +(assert_return (invoke "mul" (f32.const 0x1p-149) (f32.const -0x1.921fb6p+2)) (f32.const -0x1.8p-147)) +(assert_return (invoke "mul" (f32.const 0x1p-149) (f32.const 0x1.921fb6p+2)) (f32.const 0x1.8p-147)) +(assert_return (invoke "mul" (f32.const -0x1p-149) (f32.const -0x1.fffffep+127)) (f32.const 0x1.fffffep-22)) +(assert_return (invoke "mul" (f32.const -0x1p-149) (f32.const 0x1.fffffep+127)) (f32.const -0x1.fffffep-22)) +(assert_return (invoke "mul" (f32.const 0x1p-149) (f32.const -0x1.fffffep+127)) (f32.const -0x1.fffffep-22)) +(assert_return (invoke "mul" (f32.const 0x1p-149) (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep-22)) +(assert_return (invoke "mul" (f32.const -0x1p-149) (f32.const -inf)) (f32.const inf)) +(assert_return (invoke "mul" (f32.const -0x1p-149) (f32.const inf)) (f32.const -inf)) +(assert_return (invoke "mul" (f32.const 0x1p-149) (f32.const -inf)) (f32.const -inf)) +(assert_return (invoke "mul" (f32.const 0x1p-149) (f32.const inf)) (f32.const inf)) +(assert_return (invoke "mul" (f32.const -0x1p-149) (f32.const -nan)) (f32.const nan:canonical)) +(assert_return (invoke "mul" (f32.const -0x1p-149) (f32.const -nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "mul" (f32.const -0x1p-149) (f32.const nan)) (f32.const nan:canonical)) +(assert_return (invoke "mul" (f32.const -0x1p-149) (f32.const nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "mul" (f32.const 0x1p-149) (f32.const -nan)) (f32.const nan:canonical)) +(assert_return (invoke "mul" (f32.const 0x1p-149) (f32.const -nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "mul" (f32.const 0x1p-149) (f32.const nan)) (f32.const nan:canonical)) +(assert_return (invoke "mul" (f32.const 0x1p-149) (f32.const nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "mul" (f32.const -0x1p-126) (f32.const -0x0p+0)) (f32.const 0x0p+0)) +(assert_return (invoke "mul" (f32.const -0x1p-126) (f32.const 0x0p+0)) (f32.const -0x0p+0)) +(assert_return (invoke "mul" (f32.const 0x1p-126) (f32.const -0x0p+0)) (f32.const -0x0p+0)) +(assert_return (invoke "mul" (f32.const 0x1p-126) (f32.const 0x0p+0)) (f32.const 0x0p+0)) +(assert_return (invoke "mul" (f32.const -0x1p-126) (f32.const -0x1p-149)) (f32.const 0x0p+0)) +(assert_return (invoke "mul" (f32.const -0x1p-126) (f32.const 0x1p-149)) (f32.const -0x0p+0)) +(assert_return (invoke "mul" (f32.const 0x1p-126) (f32.const -0x1p-149)) (f32.const -0x0p+0)) +(assert_return (invoke "mul" (f32.const 0x1p-126) (f32.const 0x1p-149)) (f32.const 0x0p+0)) +(assert_return (invoke "mul" (f32.const -0x1p-126) (f32.const -0x1p-126)) (f32.const 0x0p+0)) +(assert_return (invoke "mul" (f32.const -0x1p-126) (f32.const 0x1p-126)) (f32.const -0x0p+0)) +(assert_return (invoke "mul" (f32.const 0x1p-126) (f32.const -0x1p-126)) (f32.const -0x0p+0)) +(assert_return (invoke "mul" (f32.const 0x1p-126) (f32.const 0x1p-126)) (f32.const 0x0p+0)) +(assert_return (invoke "mul" (f32.const -0x1p-126) (f32.const -0x1p-1)) (f32.const 0x1p-127)) +(assert_return (invoke "mul" (f32.const -0x1p-126) (f32.const 0x1p-1)) (f32.const -0x1p-127)) +(assert_return (invoke "mul" (f32.const 0x1p-126) (f32.const -0x1p-1)) (f32.const -0x1p-127)) +(assert_return (invoke "mul" (f32.const 0x1p-126) (f32.const 0x1p-1)) (f32.const 0x1p-127)) +(assert_return (invoke "mul" (f32.const -0x1p-126) (f32.const -0x1p+0)) (f32.const 0x1p-126)) +(assert_return (invoke "mul" (f32.const -0x1p-126) (f32.const 0x1p+0)) (f32.const -0x1p-126)) +(assert_return (invoke "mul" (f32.const 0x1p-126) (f32.const -0x1p+0)) (f32.const -0x1p-126)) +(assert_return (invoke "mul" (f32.const 0x1p-126) (f32.const 0x1p+0)) (f32.const 0x1p-126)) +(assert_return (invoke "mul" (f32.const -0x1p-126) (f32.const -0x1.921fb6p+2)) (f32.const 0x1.921fb6p-124)) +(assert_return (invoke "mul" (f32.const -0x1p-126) (f32.const 0x1.921fb6p+2)) (f32.const -0x1.921fb6p-124)) +(assert_return (invoke "mul" (f32.const 0x1p-126) (f32.const -0x1.921fb6p+2)) (f32.const -0x1.921fb6p-124)) +(assert_return (invoke "mul" (f32.const 0x1p-126) (f32.const 0x1.921fb6p+2)) (f32.const 0x1.921fb6p-124)) +(assert_return (invoke "mul" (f32.const -0x1p-126) (f32.const -0x1.fffffep+127)) (f32.const 0x1.fffffep+1)) +(assert_return (invoke "mul" (f32.const -0x1p-126) (f32.const 0x1.fffffep+127)) (f32.const -0x1.fffffep+1)) +(assert_return (invoke "mul" (f32.const 0x1p-126) (f32.const -0x1.fffffep+127)) (f32.const -0x1.fffffep+1)) +(assert_return (invoke "mul" (f32.const 0x1p-126) (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+1)) +(assert_return (invoke "mul" (f32.const -0x1p-126) (f32.const -inf)) (f32.const inf)) +(assert_return (invoke "mul" (f32.const -0x1p-126) (f32.const inf)) (f32.const -inf)) +(assert_return (invoke "mul" (f32.const 0x1p-126) (f32.const -inf)) (f32.const -inf)) +(assert_return (invoke "mul" (f32.const 0x1p-126) (f32.const inf)) (f32.const inf)) +(assert_return (invoke "mul" (f32.const -0x1p-126) (f32.const -nan)) (f32.const nan:canonical)) +(assert_return (invoke "mul" (f32.const -0x1p-126) (f32.const -nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "mul" (f32.const -0x1p-126) (f32.const nan)) (f32.const nan:canonical)) +(assert_return (invoke "mul" (f32.const -0x1p-126) (f32.const nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "mul" (f32.const 0x1p-126) (f32.const -nan)) (f32.const nan:canonical)) +(assert_return (invoke "mul" (f32.const 0x1p-126) (f32.const -nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "mul" (f32.const 0x1p-126) (f32.const nan)) (f32.const nan:canonical)) +(assert_return (invoke "mul" (f32.const 0x1p-126) (f32.const nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "mul" (f32.const -0x1p-1) (f32.const -0x0p+0)) (f32.const 0x0p+0)) +(assert_return (invoke "mul" (f32.const -0x1p-1) (f32.const 0x0p+0)) (f32.const -0x0p+0)) +(assert_return (invoke "mul" (f32.const 0x1p-1) (f32.const -0x0p+0)) (f32.const -0x0p+0)) +(assert_return (invoke "mul" (f32.const 0x1p-1) (f32.const 0x0p+0)) (f32.const 0x0p+0)) +(assert_return (invoke "mul" (f32.const -0x1p-1) (f32.const -0x1p-149)) (f32.const 0x0p+0)) +(assert_return (invoke "mul" (f32.const -0x1p-1) (f32.const 0x1p-149)) (f32.const -0x0p+0)) +(assert_return (invoke "mul" (f32.const 0x1p-1) (f32.const -0x1p-149)) (f32.const -0x0p+0)) +(assert_return (invoke "mul" (f32.const 0x1p-1) (f32.const 0x1p-149)) (f32.const 0x0p+0)) +(assert_return (invoke "mul" (f32.const -0x1p-1) (f32.const -0x1p-126)) (f32.const 0x1p-127)) +(assert_return (invoke "mul" (f32.const -0x1p-1) (f32.const 0x1p-126)) (f32.const -0x1p-127)) +(assert_return (invoke "mul" (f32.const 0x1p-1) (f32.const -0x1p-126)) (f32.const -0x1p-127)) +(assert_return (invoke "mul" (f32.const 0x1p-1) (f32.const 0x1p-126)) (f32.const 0x1p-127)) +(assert_return (invoke "mul" (f32.const -0x1p-1) (f32.const -0x1p-1)) (f32.const 0x1p-2)) +(assert_return (invoke "mul" (f32.const -0x1p-1) (f32.const 0x1p-1)) (f32.const -0x1p-2)) +(assert_return (invoke "mul" (f32.const 0x1p-1) (f32.const -0x1p-1)) (f32.const -0x1p-2)) +(assert_return (invoke "mul" (f32.const 0x1p-1) (f32.const 0x1p-1)) (f32.const 0x1p-2)) +(assert_return (invoke "mul" (f32.const -0x1p-1) (f32.const -0x1p+0)) (f32.const 0x1p-1)) +(assert_return (invoke "mul" (f32.const -0x1p-1) (f32.const 0x1p+0)) (f32.const -0x1p-1)) +(assert_return (invoke "mul" (f32.const 0x1p-1) (f32.const -0x1p+0)) (f32.const -0x1p-1)) +(assert_return (invoke "mul" (f32.const 0x1p-1) (f32.const 0x1p+0)) (f32.const 0x1p-1)) +(assert_return (invoke "mul" (f32.const -0x1p-1) (f32.const -0x1.921fb6p+2)) (f32.const 0x1.921fb6p+1)) +(assert_return (invoke "mul" (f32.const -0x1p-1) (f32.const 0x1.921fb6p+2)) (f32.const -0x1.921fb6p+1)) +(assert_return (invoke "mul" (f32.const 0x1p-1) (f32.const -0x1.921fb6p+2)) (f32.const -0x1.921fb6p+1)) +(assert_return (invoke "mul" (f32.const 0x1p-1) (f32.const 0x1.921fb6p+2)) (f32.const 0x1.921fb6p+1)) +(assert_return (invoke "mul" (f32.const -0x1p-1) (f32.const -0x1.fffffep+127)) (f32.const 0x1.fffffep+126)) +(assert_return (invoke "mul" (f32.const -0x1p-1) (f32.const 0x1.fffffep+127)) (f32.const -0x1.fffffep+126)) +(assert_return (invoke "mul" (f32.const 0x1p-1) (f32.const -0x1.fffffep+127)) (f32.const -0x1.fffffep+126)) +(assert_return (invoke "mul" (f32.const 0x1p-1) (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+126)) +(assert_return (invoke "mul" (f32.const -0x1p-1) (f32.const -inf)) (f32.const inf)) +(assert_return (invoke "mul" (f32.const -0x1p-1) (f32.const inf)) (f32.const -inf)) +(assert_return (invoke "mul" (f32.const 0x1p-1) (f32.const -inf)) (f32.const -inf)) +(assert_return (invoke "mul" (f32.const 0x1p-1) (f32.const inf)) (f32.const inf)) +(assert_return (invoke "mul" (f32.const -0x1p-1) (f32.const -nan)) (f32.const nan:canonical)) +(assert_return (invoke "mul" (f32.const -0x1p-1) (f32.const -nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "mul" (f32.const -0x1p-1) (f32.const nan)) (f32.const nan:canonical)) +(assert_return (invoke "mul" (f32.const -0x1p-1) (f32.const nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "mul" (f32.const 0x1p-1) (f32.const -nan)) (f32.const nan:canonical)) +(assert_return (invoke "mul" (f32.const 0x1p-1) (f32.const -nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "mul" (f32.const 0x1p-1) (f32.const nan)) (f32.const nan:canonical)) +(assert_return (invoke "mul" (f32.const 0x1p-1) (f32.const nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "mul" (f32.const -0x1p+0) (f32.const -0x0p+0)) (f32.const 0x0p+0)) +(assert_return (invoke "mul" (f32.const -0x1p+0) (f32.const 0x0p+0)) (f32.const -0x0p+0)) +(assert_return (invoke "mul" (f32.const 0x1p+0) (f32.const -0x0p+0)) (f32.const -0x0p+0)) +(assert_return (invoke "mul" (f32.const 0x1p+0) (f32.const 0x0p+0)) (f32.const 0x0p+0)) +(assert_return (invoke "mul" (f32.const -0x1p+0) (f32.const -0x1p-149)) (f32.const 0x1p-149)) +(assert_return (invoke "mul" (f32.const -0x1p+0) (f32.const 0x1p-149)) (f32.const -0x1p-149)) +(assert_return (invoke "mul" (f32.const 0x1p+0) (f32.const -0x1p-149)) (f32.const -0x1p-149)) +(assert_return (invoke "mul" (f32.const 0x1p+0) (f32.const 0x1p-149)) (f32.const 0x1p-149)) +(assert_return (invoke "mul" (f32.const -0x1p+0) (f32.const -0x1p-126)) (f32.const 0x1p-126)) +(assert_return (invoke "mul" (f32.const -0x1p+0) (f32.const 0x1p-126)) (f32.const -0x1p-126)) +(assert_return (invoke "mul" (f32.const 0x1p+0) (f32.const -0x1p-126)) (f32.const -0x1p-126)) +(assert_return (invoke "mul" (f32.const 0x1p+0) (f32.const 0x1p-126)) (f32.const 0x1p-126)) +(assert_return (invoke "mul" (f32.const -0x1p+0) (f32.const -0x1p-1)) (f32.const 0x1p-1)) +(assert_return (invoke "mul" (f32.const -0x1p+0) (f32.const 0x1p-1)) (f32.const -0x1p-1)) +(assert_return (invoke "mul" (f32.const 0x1p+0) (f32.const -0x1p-1)) (f32.const -0x1p-1)) +(assert_return (invoke "mul" (f32.const 0x1p+0) (f32.const 0x1p-1)) (f32.const 0x1p-1)) +(assert_return (invoke "mul" (f32.const -0x1p+0) (f32.const -0x1p+0)) (f32.const 0x1p+0)) +(assert_return (invoke "mul" (f32.const -0x1p+0) (f32.const 0x1p+0)) (f32.const -0x1p+0)) +(assert_return (invoke "mul" (f32.const 0x1p+0) (f32.const -0x1p+0)) (f32.const -0x1p+0)) +(assert_return (invoke "mul" (f32.const 0x1p+0) (f32.const 0x1p+0)) (f32.const 0x1p+0)) +(assert_return (invoke "mul" (f32.const -0x1p+0) (f32.const -0x1.921fb6p+2)) (f32.const 0x1.921fb6p+2)) +(assert_return (invoke "mul" (f32.const -0x1p+0) (f32.const 0x1.921fb6p+2)) (f32.const -0x1.921fb6p+2)) +(assert_return (invoke "mul" (f32.const 0x1p+0) (f32.const -0x1.921fb6p+2)) (f32.const -0x1.921fb6p+2)) +(assert_return (invoke "mul" (f32.const 0x1p+0) (f32.const 0x1.921fb6p+2)) (f32.const 0x1.921fb6p+2)) +(assert_return (invoke "mul" (f32.const -0x1p+0) (f32.const -0x1.fffffep+127)) (f32.const 0x1.fffffep+127)) +(assert_return (invoke "mul" (f32.const -0x1p+0) (f32.const 0x1.fffffep+127)) (f32.const -0x1.fffffep+127)) +(assert_return (invoke "mul" (f32.const 0x1p+0) (f32.const -0x1.fffffep+127)) (f32.const -0x1.fffffep+127)) +(assert_return (invoke "mul" (f32.const 0x1p+0) (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127)) +(assert_return (invoke "mul" (f32.const -0x1p+0) (f32.const -inf)) (f32.const inf)) +(assert_return (invoke "mul" (f32.const -0x1p+0) (f32.const inf)) (f32.const -inf)) +(assert_return (invoke "mul" (f32.const 0x1p+0) (f32.const -inf)) (f32.const -inf)) +(assert_return (invoke "mul" (f32.const 0x1p+0) (f32.const inf)) (f32.const inf)) +(assert_return (invoke "mul" (f32.const -0x1p+0) (f32.const -nan)) (f32.const nan:canonical)) +(assert_return (invoke "mul" (f32.const -0x1p+0) (f32.const -nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "mul" (f32.const -0x1p+0) (f32.const nan)) (f32.const nan:canonical)) +(assert_return (invoke "mul" (f32.const -0x1p+0) (f32.const nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "mul" (f32.const 0x1p+0) (f32.const -nan)) (f32.const nan:canonical)) +(assert_return (invoke "mul" (f32.const 0x1p+0) (f32.const -nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "mul" (f32.const 0x1p+0) (f32.const nan)) (f32.const nan:canonical)) +(assert_return (invoke "mul" (f32.const 0x1p+0) (f32.const nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "mul" (f32.const -0x1.921fb6p+2) (f32.const -0x0p+0)) (f32.const 0x0p+0)) +(assert_return (invoke "mul" (f32.const -0x1.921fb6p+2) (f32.const 0x0p+0)) (f32.const -0x0p+0)) +(assert_return (invoke "mul" (f32.const 0x1.921fb6p+2) (f32.const -0x0p+0)) (f32.const -0x0p+0)) +(assert_return (invoke "mul" (f32.const 0x1.921fb6p+2) (f32.const 0x0p+0)) (f32.const 0x0p+0)) +(assert_return (invoke "mul" (f32.const -0x1.921fb6p+2) (f32.const -0x1p-149)) (f32.const 0x1.8p-147)) +(assert_return (invoke "mul" (f32.const -0x1.921fb6p+2) (f32.const 0x1p-149)) (f32.const -0x1.8p-147)) +(assert_return (invoke "mul" (f32.const 0x1.921fb6p+2) (f32.const -0x1p-149)) (f32.const -0x1.8p-147)) +(assert_return (invoke "mul" (f32.const 0x1.921fb6p+2) (f32.const 0x1p-149)) (f32.const 0x1.8p-147)) +(assert_return (invoke "mul" (f32.const -0x1.921fb6p+2) (f32.const -0x1p-126)) (f32.const 0x1.921fb6p-124)) +(assert_return (invoke "mul" (f32.const -0x1.921fb6p+2) (f32.const 0x1p-126)) (f32.const -0x1.921fb6p-124)) +(assert_return (invoke "mul" (f32.const 0x1.921fb6p+2) (f32.const -0x1p-126)) (f32.const -0x1.921fb6p-124)) +(assert_return (invoke "mul" (f32.const 0x1.921fb6p+2) (f32.const 0x1p-126)) (f32.const 0x1.921fb6p-124)) +(assert_return (invoke "mul" (f32.const -0x1.921fb6p+2) (f32.const -0x1p-1)) (f32.const 0x1.921fb6p+1)) +(assert_return (invoke "mul" (f32.const -0x1.921fb6p+2) (f32.const 0x1p-1)) (f32.const -0x1.921fb6p+1)) +(assert_return (invoke "mul" (f32.const 0x1.921fb6p+2) (f32.const -0x1p-1)) (f32.const -0x1.921fb6p+1)) +(assert_return (invoke "mul" (f32.const 0x1.921fb6p+2) (f32.const 0x1p-1)) (f32.const 0x1.921fb6p+1)) +(assert_return (invoke "mul" (f32.const -0x1.921fb6p+2) (f32.const -0x1p+0)) (f32.const 0x1.921fb6p+2)) +(assert_return (invoke "mul" (f32.const -0x1.921fb6p+2) (f32.const 0x1p+0)) (f32.const -0x1.921fb6p+2)) +(assert_return (invoke "mul" (f32.const 0x1.921fb6p+2) (f32.const -0x1p+0)) (f32.const -0x1.921fb6p+2)) +(assert_return (invoke "mul" (f32.const 0x1.921fb6p+2) (f32.const 0x1p+0)) (f32.const 0x1.921fb6p+2)) +(assert_return (invoke "mul" (f32.const -0x1.921fb6p+2) (f32.const -0x1.921fb6p+2)) (f32.const 0x1.3bd3cep+5)) +(assert_return (invoke "mul" (f32.const -0x1.921fb6p+2) (f32.const 0x1.921fb6p+2)) (f32.const -0x1.3bd3cep+5)) +(assert_return (invoke "mul" (f32.const 0x1.921fb6p+2) (f32.const -0x1.921fb6p+2)) (f32.const -0x1.3bd3cep+5)) +(assert_return (invoke "mul" (f32.const 0x1.921fb6p+2) (f32.const 0x1.921fb6p+2)) (f32.const 0x1.3bd3cep+5)) +(assert_return (invoke "mul" (f32.const -0x1.921fb6p+2) (f32.const -0x1.fffffep+127)) (f32.const inf)) +(assert_return (invoke "mul" (f32.const -0x1.921fb6p+2) (f32.const 0x1.fffffep+127)) (f32.const -inf)) +(assert_return (invoke "mul" (f32.const 0x1.921fb6p+2) (f32.const -0x1.fffffep+127)) (f32.const -inf)) +(assert_return (invoke "mul" (f32.const 0x1.921fb6p+2) (f32.const 0x1.fffffep+127)) (f32.const inf)) +(assert_return (invoke "mul" (f32.const -0x1.921fb6p+2) (f32.const -inf)) (f32.const inf)) +(assert_return (invoke "mul" (f32.const -0x1.921fb6p+2) (f32.const inf)) (f32.const -inf)) +(assert_return (invoke "mul" (f32.const 0x1.921fb6p+2) (f32.const -inf)) (f32.const -inf)) +(assert_return (invoke "mul" (f32.const 0x1.921fb6p+2) (f32.const inf)) (f32.const inf)) +(assert_return (invoke "mul" (f32.const -0x1.921fb6p+2) (f32.const -nan)) (f32.const nan:canonical)) +(assert_return (invoke "mul" (f32.const -0x1.921fb6p+2) (f32.const -nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "mul" (f32.const -0x1.921fb6p+2) (f32.const nan)) (f32.const nan:canonical)) +(assert_return (invoke "mul" (f32.const -0x1.921fb6p+2) (f32.const nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "mul" (f32.const 0x1.921fb6p+2) (f32.const -nan)) (f32.const nan:canonical)) +(assert_return (invoke "mul" (f32.const 0x1.921fb6p+2) (f32.const -nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "mul" (f32.const 0x1.921fb6p+2) (f32.const nan)) (f32.const nan:canonical)) +(assert_return (invoke "mul" (f32.const 0x1.921fb6p+2) (f32.const nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "mul" (f32.const -0x1.fffffep+127) (f32.const -0x0p+0)) (f32.const 0x0p+0)) +(assert_return (invoke "mul" (f32.const -0x1.fffffep+127) (f32.const 0x0p+0)) (f32.const -0x0p+0)) +(assert_return (invoke "mul" (f32.const 0x1.fffffep+127) (f32.const -0x0p+0)) (f32.const -0x0p+0)) +(assert_return (invoke "mul" (f32.const 0x1.fffffep+127) (f32.const 0x0p+0)) (f32.const 0x0p+0)) +(assert_return (invoke "mul" (f32.const -0x1.fffffep+127) (f32.const -0x1p-149)) (f32.const 0x1.fffffep-22)) +(assert_return (invoke "mul" (f32.const -0x1.fffffep+127) (f32.const 0x1p-149)) (f32.const -0x1.fffffep-22)) +(assert_return (invoke "mul" (f32.const 0x1.fffffep+127) (f32.const -0x1p-149)) (f32.const -0x1.fffffep-22)) +(assert_return (invoke "mul" (f32.const 0x1.fffffep+127) (f32.const 0x1p-149)) (f32.const 0x1.fffffep-22)) +(assert_return (invoke "mul" (f32.const -0x1.fffffep+127) (f32.const -0x1p-126)) (f32.const 0x1.fffffep+1)) +(assert_return (invoke "mul" (f32.const -0x1.fffffep+127) (f32.const 0x1p-126)) (f32.const -0x1.fffffep+1)) +(assert_return (invoke "mul" (f32.const 0x1.fffffep+127) (f32.const -0x1p-126)) (f32.const -0x1.fffffep+1)) +(assert_return (invoke "mul" (f32.const 0x1.fffffep+127) (f32.const 0x1p-126)) (f32.const 0x1.fffffep+1)) +(assert_return (invoke "mul" (f32.const -0x1.fffffep+127) (f32.const -0x1p-1)) (f32.const 0x1.fffffep+126)) +(assert_return (invoke "mul" (f32.const -0x1.fffffep+127) (f32.const 0x1p-1)) (f32.const -0x1.fffffep+126)) +(assert_return (invoke "mul" (f32.const 0x1.fffffep+127) (f32.const -0x1p-1)) (f32.const -0x1.fffffep+126)) +(assert_return (invoke "mul" (f32.const 0x1.fffffep+127) (f32.const 0x1p-1)) (f32.const 0x1.fffffep+126)) +(assert_return (invoke "mul" (f32.const -0x1.fffffep+127) (f32.const -0x1p+0)) (f32.const 0x1.fffffep+127)) +(assert_return (invoke "mul" (f32.const -0x1.fffffep+127) (f32.const 0x1p+0)) (f32.const -0x1.fffffep+127)) +(assert_return (invoke "mul" (f32.const 0x1.fffffep+127) (f32.const -0x1p+0)) (f32.const -0x1.fffffep+127)) +(assert_return (invoke "mul" (f32.const 0x1.fffffep+127) (f32.const 0x1p+0)) (f32.const 0x1.fffffep+127)) +(assert_return (invoke "mul" (f32.const -0x1.fffffep+127) (f32.const -0x1.921fb6p+2)) (f32.const inf)) +(assert_return (invoke "mul" (f32.const -0x1.fffffep+127) (f32.const 0x1.921fb6p+2)) (f32.const -inf)) +(assert_return (invoke "mul" (f32.const 0x1.fffffep+127) (f32.const -0x1.921fb6p+2)) (f32.const -inf)) +(assert_return (invoke "mul" (f32.const 0x1.fffffep+127) (f32.const 0x1.921fb6p+2)) (f32.const inf)) +(assert_return (invoke "mul" (f32.const -0x1.fffffep+127) (f32.const -0x1.fffffep+127)) (f32.const inf)) +(assert_return (invoke "mul" (f32.const -0x1.fffffep+127) (f32.const 0x1.fffffep+127)) (f32.const -inf)) +(assert_return (invoke "mul" (f32.const 0x1.fffffep+127) (f32.const -0x1.fffffep+127)) (f32.const -inf)) +(assert_return (invoke "mul" (f32.const 0x1.fffffep+127) (f32.const 0x1.fffffep+127)) (f32.const inf)) +(assert_return (invoke "mul" (f32.const -0x1.fffffep+127) (f32.const -inf)) (f32.const inf)) +(assert_return (invoke "mul" (f32.const -0x1.fffffep+127) (f32.const inf)) (f32.const -inf)) +(assert_return (invoke "mul" (f32.const 0x1.fffffep+127) (f32.const -inf)) (f32.const -inf)) +(assert_return (invoke "mul" (f32.const 0x1.fffffep+127) (f32.const inf)) (f32.const inf)) +(assert_return (invoke "mul" (f32.const -0x1.fffffep+127) (f32.const -nan)) (f32.const nan:canonical)) +(assert_return (invoke "mul" (f32.const -0x1.fffffep+127) (f32.const -nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "mul" (f32.const -0x1.fffffep+127) (f32.const nan)) (f32.const nan:canonical)) +(assert_return (invoke "mul" (f32.const -0x1.fffffep+127) (f32.const nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "mul" (f32.const 0x1.fffffep+127) (f32.const -nan)) (f32.const nan:canonical)) +(assert_return (invoke "mul" (f32.const 0x1.fffffep+127) (f32.const -nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "mul" (f32.const 0x1.fffffep+127) (f32.const nan)) (f32.const nan:canonical)) +(assert_return (invoke "mul" (f32.const 0x1.fffffep+127) (f32.const nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "mul" (f32.const -inf) (f32.const -0x0p+0)) (f32.const nan:canonical)) +(assert_return (invoke "mul" (f32.const -inf) (f32.const 0x0p+0)) (f32.const nan:canonical)) +(assert_return (invoke "mul" (f32.const inf) (f32.const -0x0p+0)) (f32.const nan:canonical)) +(assert_return (invoke "mul" (f32.const inf) (f32.const 0x0p+0)) (f32.const nan:canonical)) +(assert_return (invoke "mul" (f32.const -inf) (f32.const -0x1p-149)) (f32.const inf)) +(assert_return (invoke "mul" (f32.const -inf) (f32.const 0x1p-149)) (f32.const -inf)) +(assert_return (invoke "mul" (f32.const inf) (f32.const -0x1p-149)) (f32.const -inf)) +(assert_return (invoke "mul" (f32.const inf) (f32.const 0x1p-149)) (f32.const inf)) +(assert_return (invoke "mul" (f32.const -inf) (f32.const -0x1p-126)) (f32.const inf)) +(assert_return (invoke "mul" (f32.const -inf) (f32.const 0x1p-126)) (f32.const -inf)) +(assert_return (invoke "mul" (f32.const inf) (f32.const -0x1p-126)) (f32.const -inf)) +(assert_return (invoke "mul" (f32.const inf) (f32.const 0x1p-126)) (f32.const inf)) +(assert_return (invoke "mul" (f32.const -inf) (f32.const -0x1p-1)) (f32.const inf)) +(assert_return (invoke "mul" (f32.const -inf) (f32.const 0x1p-1)) (f32.const -inf)) +(assert_return (invoke "mul" (f32.const inf) (f32.const -0x1p-1)) (f32.const -inf)) +(assert_return (invoke "mul" (f32.const inf) (f32.const 0x1p-1)) (f32.const inf)) +(assert_return (invoke "mul" (f32.const -inf) (f32.const -0x1p+0)) (f32.const inf)) +(assert_return (invoke "mul" (f32.const -inf) (f32.const 0x1p+0)) (f32.const -inf)) +(assert_return (invoke "mul" (f32.const inf) (f32.const -0x1p+0)) (f32.const -inf)) +(assert_return (invoke "mul" (f32.const inf) (f32.const 0x1p+0)) (f32.const inf)) +(assert_return (invoke "mul" (f32.const -inf) (f32.const -0x1.921fb6p+2)) (f32.const inf)) +(assert_return (invoke "mul" (f32.const -inf) (f32.const 0x1.921fb6p+2)) (f32.const -inf)) +(assert_return (invoke "mul" (f32.const inf) (f32.const -0x1.921fb6p+2)) (f32.const -inf)) +(assert_return (invoke "mul" (f32.const inf) (f32.const 0x1.921fb6p+2)) (f32.const inf)) +(assert_return (invoke "mul" (f32.const -inf) (f32.const -0x1.fffffep+127)) (f32.const inf)) +(assert_return (invoke "mul" (f32.const -inf) (f32.const 0x1.fffffep+127)) (f32.const -inf)) +(assert_return (invoke "mul" (f32.const inf) (f32.const -0x1.fffffep+127)) (f32.const -inf)) +(assert_return (invoke "mul" (f32.const inf) (f32.const 0x1.fffffep+127)) (f32.const inf)) +(assert_return (invoke "mul" (f32.const -inf) (f32.const -inf)) (f32.const inf)) +(assert_return (invoke "mul" (f32.const -inf) (f32.const inf)) (f32.const -inf)) +(assert_return (invoke "mul" (f32.const inf) (f32.const -inf)) (f32.const -inf)) +(assert_return (invoke "mul" (f32.const inf) (f32.const inf)) (f32.const inf)) +(assert_return (invoke "mul" (f32.const -inf) (f32.const -nan)) (f32.const nan:canonical)) +(assert_return (invoke "mul" (f32.const -inf) (f32.const -nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "mul" (f32.const -inf) (f32.const nan)) (f32.const nan:canonical)) +(assert_return (invoke "mul" (f32.const -inf) (f32.const nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "mul" (f32.const inf) (f32.const -nan)) (f32.const nan:canonical)) +(assert_return (invoke "mul" (f32.const inf) (f32.const -nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "mul" (f32.const inf) (f32.const nan)) (f32.const nan:canonical)) +(assert_return (invoke "mul" (f32.const inf) (f32.const nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "mul" (f32.const -nan) (f32.const -0x0p+0)) (f32.const nan:canonical)) +(assert_return (invoke "mul" (f32.const -nan:0x200000) (f32.const -0x0p+0)) (f32.const nan:arithmetic)) +(assert_return (invoke "mul" (f32.const -nan) (f32.const 0x0p+0)) (f32.const nan:canonical)) +(assert_return (invoke "mul" (f32.const -nan:0x200000) (f32.const 0x0p+0)) (f32.const nan:arithmetic)) +(assert_return (invoke "mul" (f32.const nan) (f32.const -0x0p+0)) (f32.const nan:canonical)) +(assert_return (invoke "mul" (f32.const nan:0x200000) (f32.const -0x0p+0)) (f32.const nan:arithmetic)) +(assert_return (invoke "mul" (f32.const nan) (f32.const 0x0p+0)) (f32.const nan:canonical)) +(assert_return (invoke "mul" (f32.const nan:0x200000) (f32.const 0x0p+0)) (f32.const nan:arithmetic)) +(assert_return (invoke "mul" (f32.const -nan) (f32.const -0x1p-149)) (f32.const nan:canonical)) +(assert_return (invoke "mul" (f32.const -nan:0x200000) (f32.const -0x1p-149)) (f32.const nan:arithmetic)) +(assert_return (invoke "mul" (f32.const -nan) (f32.const 0x1p-149)) (f32.const nan:canonical)) +(assert_return (invoke "mul" (f32.const -nan:0x200000) (f32.const 0x1p-149)) (f32.const nan:arithmetic)) +(assert_return (invoke "mul" (f32.const nan) (f32.const -0x1p-149)) (f32.const nan:canonical)) +(assert_return (invoke "mul" (f32.const nan:0x200000) (f32.const -0x1p-149)) (f32.const nan:arithmetic)) +(assert_return (invoke "mul" (f32.const nan) (f32.const 0x1p-149)) (f32.const nan:canonical)) +(assert_return (invoke "mul" (f32.const nan:0x200000) (f32.const 0x1p-149)) (f32.const nan:arithmetic)) +(assert_return (invoke "mul" (f32.const -nan) (f32.const -0x1p-126)) (f32.const nan:canonical)) +(assert_return (invoke "mul" (f32.const -nan:0x200000) (f32.const -0x1p-126)) (f32.const nan:arithmetic)) +(assert_return (invoke "mul" (f32.const -nan) (f32.const 0x1p-126)) (f32.const nan:canonical)) +(assert_return (invoke "mul" (f32.const -nan:0x200000) (f32.const 0x1p-126)) (f32.const nan:arithmetic)) +(assert_return (invoke "mul" (f32.const nan) (f32.const -0x1p-126)) (f32.const nan:canonical)) +(assert_return (invoke "mul" (f32.const nan:0x200000) (f32.const -0x1p-126)) (f32.const nan:arithmetic)) +(assert_return (invoke "mul" (f32.const nan) (f32.const 0x1p-126)) (f32.const nan:canonical)) +(assert_return (invoke "mul" (f32.const nan:0x200000) (f32.const 0x1p-126)) (f32.const nan:arithmetic)) +(assert_return (invoke "mul" (f32.const -nan) (f32.const -0x1p-1)) (f32.const nan:canonical)) +(assert_return (invoke "mul" (f32.const -nan:0x200000) (f32.const -0x1p-1)) (f32.const nan:arithmetic)) +(assert_return (invoke "mul" (f32.const -nan) (f32.const 0x1p-1)) (f32.const nan:canonical)) +(assert_return (invoke "mul" (f32.const -nan:0x200000) (f32.const 0x1p-1)) (f32.const nan:arithmetic)) +(assert_return (invoke "mul" (f32.const nan) (f32.const -0x1p-1)) (f32.const nan:canonical)) +(assert_return (invoke "mul" (f32.const nan:0x200000) (f32.const -0x1p-1)) (f32.const nan:arithmetic)) +(assert_return (invoke "mul" (f32.const nan) (f32.const 0x1p-1)) (f32.const nan:canonical)) +(assert_return (invoke "mul" (f32.const nan:0x200000) (f32.const 0x1p-1)) (f32.const nan:arithmetic)) +(assert_return (invoke "mul" (f32.const -nan) (f32.const -0x1p+0)) (f32.const nan:canonical)) +(assert_return (invoke "mul" (f32.const -nan:0x200000) (f32.const -0x1p+0)) (f32.const nan:arithmetic)) +(assert_return (invoke "mul" (f32.const -nan) (f32.const 0x1p+0)) (f32.const nan:canonical)) +(assert_return (invoke "mul" (f32.const -nan:0x200000) (f32.const 0x1p+0)) (f32.const nan:arithmetic)) +(assert_return (invoke "mul" (f32.const nan) (f32.const -0x1p+0)) (f32.const nan:canonical)) +(assert_return (invoke "mul" (f32.const nan:0x200000) (f32.const -0x1p+0)) (f32.const nan:arithmetic)) +(assert_return (invoke "mul" (f32.const nan) (f32.const 0x1p+0)) (f32.const nan:canonical)) +(assert_return (invoke "mul" (f32.const nan:0x200000) (f32.const 0x1p+0)) (f32.const nan:arithmetic)) +(assert_return (invoke "mul" (f32.const -nan) (f32.const -0x1.921fb6p+2)) (f32.const nan:canonical)) +(assert_return (invoke "mul" (f32.const -nan:0x200000) (f32.const -0x1.921fb6p+2)) (f32.const nan:arithmetic)) +(assert_return (invoke "mul" (f32.const -nan) (f32.const 0x1.921fb6p+2)) (f32.const nan:canonical)) +(assert_return (invoke "mul" (f32.const -nan:0x200000) (f32.const 0x1.921fb6p+2)) (f32.const nan:arithmetic)) +(assert_return (invoke "mul" (f32.const nan) (f32.const -0x1.921fb6p+2)) (f32.const nan:canonical)) +(assert_return (invoke "mul" (f32.const nan:0x200000) (f32.const -0x1.921fb6p+2)) (f32.const nan:arithmetic)) +(assert_return (invoke "mul" (f32.const nan) (f32.const 0x1.921fb6p+2)) (f32.const nan:canonical)) +(assert_return (invoke "mul" (f32.const nan:0x200000) (f32.const 0x1.921fb6p+2)) (f32.const nan:arithmetic)) +(assert_return (invoke "mul" (f32.const -nan) (f32.const -0x1.fffffep+127)) (f32.const nan:canonical)) +(assert_return (invoke "mul" (f32.const -nan:0x200000) (f32.const -0x1.fffffep+127)) (f32.const nan:arithmetic)) +(assert_return (invoke "mul" (f32.const -nan) (f32.const 0x1.fffffep+127)) (f32.const nan:canonical)) +(assert_return (invoke "mul" (f32.const -nan:0x200000) (f32.const 0x1.fffffep+127)) (f32.const nan:arithmetic)) +(assert_return (invoke "mul" (f32.const nan) (f32.const -0x1.fffffep+127)) (f32.const nan:canonical)) +(assert_return (invoke "mul" (f32.const nan:0x200000) (f32.const -0x1.fffffep+127)) (f32.const nan:arithmetic)) +(assert_return (invoke "mul" (f32.const nan) (f32.const 0x1.fffffep+127)) (f32.const nan:canonical)) +(assert_return (invoke "mul" (f32.const nan:0x200000) (f32.const 0x1.fffffep+127)) (f32.const nan:arithmetic)) +(assert_return (invoke "mul" (f32.const -nan) (f32.const -inf)) (f32.const nan:canonical)) +(assert_return (invoke "mul" (f32.const -nan:0x200000) (f32.const -inf)) (f32.const nan:arithmetic)) +(assert_return (invoke "mul" (f32.const -nan) (f32.const inf)) (f32.const nan:canonical)) +(assert_return (invoke "mul" (f32.const -nan:0x200000) (f32.const inf)) (f32.const nan:arithmetic)) +(assert_return (invoke "mul" (f32.const nan) (f32.const -inf)) (f32.const nan:canonical)) +(assert_return (invoke "mul" (f32.const nan:0x200000) (f32.const -inf)) (f32.const nan:arithmetic)) +(assert_return (invoke "mul" (f32.const nan) (f32.const inf)) (f32.const nan:canonical)) +(assert_return (invoke "mul" (f32.const nan:0x200000) (f32.const inf)) (f32.const nan:arithmetic)) +(assert_return (invoke "mul" (f32.const -nan) (f32.const -nan)) (f32.const nan:canonical)) +(assert_return (invoke "mul" (f32.const -nan:0x200000) (f32.const -nan)) (f32.const nan:arithmetic)) +(assert_return (invoke "mul" (f32.const -nan) (f32.const -nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "mul" (f32.const -nan:0x200000) (f32.const -nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "mul" (f32.const -nan) (f32.const nan)) (f32.const nan:canonical)) +(assert_return (invoke "mul" (f32.const -nan:0x200000) (f32.const nan)) (f32.const nan:arithmetic)) +(assert_return (invoke "mul" (f32.const -nan) (f32.const nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "mul" (f32.const -nan:0x200000) (f32.const nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "mul" (f32.const nan) (f32.const -nan)) (f32.const nan:canonical)) +(assert_return (invoke "mul" (f32.const nan:0x200000) (f32.const -nan)) (f32.const nan:arithmetic)) +(assert_return (invoke "mul" (f32.const nan) (f32.const -nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "mul" (f32.const nan:0x200000) (f32.const -nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "mul" (f32.const nan) (f32.const nan)) (f32.const nan:canonical)) +(assert_return (invoke "mul" (f32.const nan:0x200000) (f32.const nan)) (f32.const nan:arithmetic)) +(assert_return (invoke "mul" (f32.const nan) (f32.const nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "mul" (f32.const nan:0x200000) (f32.const nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "div" (f32.const -0x0p+0) (f32.const -0x0p+0)) (f32.const nan:canonical)) +(assert_return (invoke "div" (f32.const -0x0p+0) (f32.const 0x0p+0)) (f32.const nan:canonical)) +(assert_return (invoke "div" (f32.const 0x0p+0) (f32.const -0x0p+0)) (f32.const nan:canonical)) +(assert_return (invoke "div" (f32.const 0x0p+0) (f32.const 0x0p+0)) (f32.const nan:canonical)) +(assert_return (invoke "div" (f32.const -0x0p+0) (f32.const -0x1p-149)) (f32.const 0x0p+0)) +(assert_return (invoke "div" (f32.const -0x0p+0) (f32.const 0x1p-149)) (f32.const -0x0p+0)) +(assert_return (invoke "div" (f32.const 0x0p+0) (f32.const -0x1p-149)) (f32.const -0x0p+0)) +(assert_return (invoke "div" (f32.const 0x0p+0) (f32.const 0x1p-149)) (f32.const 0x0p+0)) +(assert_return (invoke "div" (f32.const -0x0p+0) (f32.const -0x1p-126)) (f32.const 0x0p+0)) +(assert_return (invoke "div" (f32.const -0x0p+0) (f32.const 0x1p-126)) (f32.const -0x0p+0)) +(assert_return (invoke "div" (f32.const 0x0p+0) (f32.const -0x1p-126)) (f32.const -0x0p+0)) +(assert_return (invoke "div" (f32.const 0x0p+0) (f32.const 0x1p-126)) (f32.const 0x0p+0)) +(assert_return (invoke "div" (f32.const -0x0p+0) (f32.const -0x1p-1)) (f32.const 0x0p+0)) +(assert_return (invoke "div" (f32.const -0x0p+0) (f32.const 0x1p-1)) (f32.const -0x0p+0)) +(assert_return (invoke "div" (f32.const 0x0p+0) (f32.const -0x1p-1)) (f32.const -0x0p+0)) +(assert_return (invoke "div" (f32.const 0x0p+0) (f32.const 0x1p-1)) (f32.const 0x0p+0)) +(assert_return (invoke "div" (f32.const -0x0p+0) (f32.const -0x1p+0)) (f32.const 0x0p+0)) +(assert_return (invoke "div" (f32.const -0x0p+0) (f32.const 0x1p+0)) (f32.const -0x0p+0)) +(assert_return (invoke "div" (f32.const 0x0p+0) (f32.const -0x1p+0)) (f32.const -0x0p+0)) +(assert_return (invoke "div" (f32.const 0x0p+0) (f32.const 0x1p+0)) (f32.const 0x0p+0)) +(assert_return (invoke "div" (f32.const -0x0p+0) (f32.const -0x1.921fb6p+2)) (f32.const 0x0p+0)) +(assert_return (invoke "div" (f32.const -0x0p+0) (f32.const 0x1.921fb6p+2)) (f32.const -0x0p+0)) +(assert_return (invoke "div" (f32.const 0x0p+0) (f32.const -0x1.921fb6p+2)) (f32.const -0x0p+0)) +(assert_return (invoke "div" (f32.const 0x0p+0) (f32.const 0x1.921fb6p+2)) (f32.const 0x0p+0)) +(assert_return (invoke "div" (f32.const -0x0p+0) (f32.const -0x1.fffffep+127)) (f32.const 0x0p+0)) +(assert_return (invoke "div" (f32.const -0x0p+0) (f32.const 0x1.fffffep+127)) (f32.const -0x0p+0)) +(assert_return (invoke "div" (f32.const 0x0p+0) (f32.const -0x1.fffffep+127)) (f32.const -0x0p+0)) +(assert_return (invoke "div" (f32.const 0x0p+0) (f32.const 0x1.fffffep+127)) (f32.const 0x0p+0)) +(assert_return (invoke "div" (f32.const -0x0p+0) (f32.const -inf)) (f32.const 0x0p+0)) +(assert_return (invoke "div" (f32.const -0x0p+0) (f32.const inf)) (f32.const -0x0p+0)) +(assert_return (invoke "div" (f32.const 0x0p+0) (f32.const -inf)) (f32.const -0x0p+0)) +(assert_return (invoke "div" (f32.const 0x0p+0) (f32.const inf)) (f32.const 0x0p+0)) +(assert_return (invoke "div" (f32.const -0x0p+0) (f32.const -nan)) (f32.const nan:canonical)) +(assert_return (invoke "div" (f32.const -0x0p+0) (f32.const -nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "div" (f32.const -0x0p+0) (f32.const nan)) (f32.const nan:canonical)) +(assert_return (invoke "div" (f32.const -0x0p+0) (f32.const nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "div" (f32.const 0x0p+0) (f32.const -nan)) (f32.const nan:canonical)) +(assert_return (invoke "div" (f32.const 0x0p+0) (f32.const -nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "div" (f32.const 0x0p+0) (f32.const nan)) (f32.const nan:canonical)) +(assert_return (invoke "div" (f32.const 0x0p+0) (f32.const nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "div" (f32.const -0x1p-149) (f32.const -0x0p+0)) (f32.const inf)) +(assert_return (invoke "div" (f32.const -0x1p-149) (f32.const 0x0p+0)) (f32.const -inf)) +(assert_return (invoke "div" (f32.const 0x1p-149) (f32.const -0x0p+0)) (f32.const -inf)) +(assert_return (invoke "div" (f32.const 0x1p-149) (f32.const 0x0p+0)) (f32.const inf)) +(assert_return (invoke "div" (f32.const -0x1p-149) (f32.const -0x1p-149)) (f32.const 0x1p+0)) +(assert_return (invoke "div" (f32.const -0x1p-149) (f32.const 0x1p-149)) (f32.const -0x1p+0)) +(assert_return (invoke "div" (f32.const 0x1p-149) (f32.const -0x1p-149)) (f32.const -0x1p+0)) +(assert_return (invoke "div" (f32.const 0x1p-149) (f32.const 0x1p-149)) (f32.const 0x1p+0)) +(assert_return (invoke "div" (f32.const -0x1p-149) (f32.const -0x1p-126)) (f32.const 0x1p-23)) +(assert_return (invoke "div" (f32.const -0x1p-149) (f32.const 0x1p-126)) (f32.const -0x1p-23)) +(assert_return (invoke "div" (f32.const 0x1p-149) (f32.const -0x1p-126)) (f32.const -0x1p-23)) +(assert_return (invoke "div" (f32.const 0x1p-149) (f32.const 0x1p-126)) (f32.const 0x1p-23)) +(assert_return (invoke "div" (f32.const -0x1p-149) (f32.const -0x1p-1)) (f32.const 0x1p-148)) +(assert_return (invoke "div" (f32.const -0x1p-149) (f32.const 0x1p-1)) (f32.const -0x1p-148)) +(assert_return (invoke "div" (f32.const 0x1p-149) (f32.const -0x1p-1)) (f32.const -0x1p-148)) +(assert_return (invoke "div" (f32.const 0x1p-149) (f32.const 0x1p-1)) (f32.const 0x1p-148)) +(assert_return (invoke "div" (f32.const -0x1p-149) (f32.const -0x1p+0)) (f32.const 0x1p-149)) +(assert_return (invoke "div" (f32.const -0x1p-149) (f32.const 0x1p+0)) (f32.const -0x1p-149)) +(assert_return (invoke "div" (f32.const 0x1p-149) (f32.const -0x1p+0)) (f32.const -0x1p-149)) +(assert_return (invoke "div" (f32.const 0x1p-149) (f32.const 0x1p+0)) (f32.const 0x1p-149)) +(assert_return (invoke "div" (f32.const -0x1p-149) (f32.const -0x1.921fb6p+2)) (f32.const 0x0p+0)) +(assert_return (invoke "div" (f32.const -0x1p-149) (f32.const 0x1.921fb6p+2)) (f32.const -0x0p+0)) +(assert_return (invoke "div" (f32.const 0x1p-149) (f32.const -0x1.921fb6p+2)) (f32.const -0x0p+0)) +(assert_return (invoke "div" (f32.const 0x1p-149) (f32.const 0x1.921fb6p+2)) (f32.const 0x0p+0)) +(assert_return (invoke "div" (f32.const -0x1p-149) (f32.const -0x1.fffffep+127)) (f32.const 0x0p+0)) +(assert_return (invoke "div" (f32.const -0x1p-149) (f32.const 0x1.fffffep+127)) (f32.const -0x0p+0)) +(assert_return (invoke "div" (f32.const 0x1p-149) (f32.const -0x1.fffffep+127)) (f32.const -0x0p+0)) +(assert_return (invoke "div" (f32.const 0x1p-149) (f32.const 0x1.fffffep+127)) (f32.const 0x0p+0)) +(assert_return (invoke "div" (f32.const -0x1p-149) (f32.const -inf)) (f32.const 0x0p+0)) +(assert_return (invoke "div" (f32.const -0x1p-149) (f32.const inf)) (f32.const -0x0p+0)) +(assert_return (invoke "div" (f32.const 0x1p-149) (f32.const -inf)) (f32.const -0x0p+0)) +(assert_return (invoke "div" (f32.const 0x1p-149) (f32.const inf)) (f32.const 0x0p+0)) +(assert_return (invoke "div" (f32.const -0x1p-149) (f32.const -nan)) (f32.const nan:canonical)) +(assert_return (invoke "div" (f32.const -0x1p-149) (f32.const -nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "div" (f32.const -0x1p-149) (f32.const nan)) (f32.const nan:canonical)) +(assert_return (invoke "div" (f32.const -0x1p-149) (f32.const nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "div" (f32.const 0x1p-149) (f32.const -nan)) (f32.const nan:canonical)) +(assert_return (invoke "div" (f32.const 0x1p-149) (f32.const -nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "div" (f32.const 0x1p-149) (f32.const nan)) (f32.const nan:canonical)) +(assert_return (invoke "div" (f32.const 0x1p-149) (f32.const nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "div" (f32.const -0x1p-126) (f32.const -0x0p+0)) (f32.const inf)) +(assert_return (invoke "div" (f32.const -0x1p-126) (f32.const 0x0p+0)) (f32.const -inf)) +(assert_return (invoke "div" (f32.const 0x1p-126) (f32.const -0x0p+0)) (f32.const -inf)) +(assert_return (invoke "div" (f32.const 0x1p-126) (f32.const 0x0p+0)) (f32.const inf)) +(assert_return (invoke "div" (f32.const -0x1p-126) (f32.const -0x1p-149)) (f32.const 0x1p+23)) +(assert_return (invoke "div" (f32.const -0x1p-126) (f32.const 0x1p-149)) (f32.const -0x1p+23)) +(assert_return (invoke "div" (f32.const 0x1p-126) (f32.const -0x1p-149)) (f32.const -0x1p+23)) +(assert_return (invoke "div" (f32.const 0x1p-126) (f32.const 0x1p-149)) (f32.const 0x1p+23)) +(assert_return (invoke "div" (f32.const -0x1p-126) (f32.const -0x1p-126)) (f32.const 0x1p+0)) +(assert_return (invoke "div" (f32.const -0x1p-126) (f32.const 0x1p-126)) (f32.const -0x1p+0)) +(assert_return (invoke "div" (f32.const 0x1p-126) (f32.const -0x1p-126)) (f32.const -0x1p+0)) +(assert_return (invoke "div" (f32.const 0x1p-126) (f32.const 0x1p-126)) (f32.const 0x1p+0)) +(assert_return (invoke "div" (f32.const -0x1p-126) (f32.const -0x1p-1)) (f32.const 0x1p-125)) +(assert_return (invoke "div" (f32.const -0x1p-126) (f32.const 0x1p-1)) (f32.const -0x1p-125)) +(assert_return (invoke "div" (f32.const 0x1p-126) (f32.const -0x1p-1)) (f32.const -0x1p-125)) +(assert_return (invoke "div" (f32.const 0x1p-126) (f32.const 0x1p-1)) (f32.const 0x1p-125)) +(assert_return (invoke "div" (f32.const -0x1p-126) (f32.const -0x1p+0)) (f32.const 0x1p-126)) +(assert_return (invoke "div" (f32.const -0x1p-126) (f32.const 0x1p+0)) (f32.const -0x1p-126)) +(assert_return (invoke "div" (f32.const 0x1p-126) (f32.const -0x1p+0)) (f32.const -0x1p-126)) +(assert_return (invoke "div" (f32.const 0x1p-126) (f32.const 0x1p+0)) (f32.const 0x1p-126)) +(assert_return (invoke "div" (f32.const -0x1p-126) (f32.const -0x1.921fb6p+2)) (f32.const 0x1.45f3p-129)) +(assert_return (invoke "div" (f32.const -0x1p-126) (f32.const 0x1.921fb6p+2)) (f32.const -0x1.45f3p-129)) +(assert_return (invoke "div" (f32.const 0x1p-126) (f32.const -0x1.921fb6p+2)) (f32.const -0x1.45f3p-129)) +(assert_return (invoke "div" (f32.const 0x1p-126) (f32.const 0x1.921fb6p+2)) (f32.const 0x1.45f3p-129)) +(assert_return (invoke "div" (f32.const -0x1p-126) (f32.const -0x1.fffffep+127)) (f32.const 0x0p+0)) +(assert_return (invoke "div" (f32.const -0x1p-126) (f32.const 0x1.fffffep+127)) (f32.const -0x0p+0)) +(assert_return (invoke "div" (f32.const 0x1p-126) (f32.const -0x1.fffffep+127)) (f32.const -0x0p+0)) +(assert_return (invoke "div" (f32.const 0x1p-126) (f32.const 0x1.fffffep+127)) (f32.const 0x0p+0)) +(assert_return (invoke "div" (f32.const -0x1p-126) (f32.const -inf)) (f32.const 0x0p+0)) +(assert_return (invoke "div" (f32.const -0x1p-126) (f32.const inf)) (f32.const -0x0p+0)) +(assert_return (invoke "div" (f32.const 0x1p-126) (f32.const -inf)) (f32.const -0x0p+0)) +(assert_return (invoke "div" (f32.const 0x1p-126) (f32.const inf)) (f32.const 0x0p+0)) +(assert_return (invoke "div" (f32.const -0x1p-126) (f32.const -nan)) (f32.const nan:canonical)) +(assert_return (invoke "div" (f32.const -0x1p-126) (f32.const -nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "div" (f32.const -0x1p-126) (f32.const nan)) (f32.const nan:canonical)) +(assert_return (invoke "div" (f32.const -0x1p-126) (f32.const nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "div" (f32.const 0x1p-126) (f32.const -nan)) (f32.const nan:canonical)) +(assert_return (invoke "div" (f32.const 0x1p-126) (f32.const -nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "div" (f32.const 0x1p-126) (f32.const nan)) (f32.const nan:canonical)) +(assert_return (invoke "div" (f32.const 0x1p-126) (f32.const nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "div" (f32.const -0x1p-1) (f32.const -0x0p+0)) (f32.const inf)) +(assert_return (invoke "div" (f32.const -0x1p-1) (f32.const 0x0p+0)) (f32.const -inf)) +(assert_return (invoke "div" (f32.const 0x1p-1) (f32.const -0x0p+0)) (f32.const -inf)) +(assert_return (invoke "div" (f32.const 0x1p-1) (f32.const 0x0p+0)) (f32.const inf)) +(assert_return (invoke "div" (f32.const -0x1p-1) (f32.const -0x1p-149)) (f32.const inf)) +(assert_return (invoke "div" (f32.const -0x1p-1) (f32.const 0x1p-149)) (f32.const -inf)) +(assert_return (invoke "div" (f32.const 0x1p-1) (f32.const -0x1p-149)) (f32.const -inf)) +(assert_return (invoke "div" (f32.const 0x1p-1) (f32.const 0x1p-149)) (f32.const inf)) +(assert_return (invoke "div" (f32.const -0x1p-1) (f32.const -0x1p-126)) (f32.const 0x1p+125)) +(assert_return (invoke "div" (f32.const -0x1p-1) (f32.const 0x1p-126)) (f32.const -0x1p+125)) +(assert_return (invoke "div" (f32.const 0x1p-1) (f32.const -0x1p-126)) (f32.const -0x1p+125)) +(assert_return (invoke "div" (f32.const 0x1p-1) (f32.const 0x1p-126)) (f32.const 0x1p+125)) +(assert_return (invoke "div" (f32.const -0x1p-1) (f32.const -0x1p-1)) (f32.const 0x1p+0)) +(assert_return (invoke "div" (f32.const -0x1p-1) (f32.const 0x1p-1)) (f32.const -0x1p+0)) +(assert_return (invoke "div" (f32.const 0x1p-1) (f32.const -0x1p-1)) (f32.const -0x1p+0)) +(assert_return (invoke "div" (f32.const 0x1p-1) (f32.const 0x1p-1)) (f32.const 0x1p+0)) +(assert_return (invoke "div" (f32.const -0x1p-1) (f32.const -0x1p+0)) (f32.const 0x1p-1)) +(assert_return (invoke "div" (f32.const -0x1p-1) (f32.const 0x1p+0)) (f32.const -0x1p-1)) +(assert_return (invoke "div" (f32.const 0x1p-1) (f32.const -0x1p+0)) (f32.const -0x1p-1)) +(assert_return (invoke "div" (f32.const 0x1p-1) (f32.const 0x1p+0)) (f32.const 0x1p-1)) +(assert_return (invoke "div" (f32.const -0x1p-1) (f32.const -0x1.921fb6p+2)) (f32.const 0x1.45f306p-4)) +(assert_return (invoke "div" (f32.const -0x1p-1) (f32.const 0x1.921fb6p+2)) (f32.const -0x1.45f306p-4)) +(assert_return (invoke "div" (f32.const 0x1p-1) (f32.const -0x1.921fb6p+2)) (f32.const -0x1.45f306p-4)) +(assert_return (invoke "div" (f32.const 0x1p-1) (f32.const 0x1.921fb6p+2)) (f32.const 0x1.45f306p-4)) +(assert_return (invoke "div" (f32.const -0x1p-1) (f32.const -0x1.fffffep+127)) (f32.const 0x1p-129)) +(assert_return (invoke "div" (f32.const -0x1p-1) (f32.const 0x1.fffffep+127)) (f32.const -0x1p-129)) +(assert_return (invoke "div" (f32.const 0x1p-1) (f32.const -0x1.fffffep+127)) (f32.const -0x1p-129)) +(assert_return (invoke "div" (f32.const 0x1p-1) (f32.const 0x1.fffffep+127)) (f32.const 0x1p-129)) +(assert_return (invoke "div" (f32.const -0x1p-1) (f32.const -inf)) (f32.const 0x0p+0)) +(assert_return (invoke "div" (f32.const -0x1p-1) (f32.const inf)) (f32.const -0x0p+0)) +(assert_return (invoke "div" (f32.const 0x1p-1) (f32.const -inf)) (f32.const -0x0p+0)) +(assert_return (invoke "div" (f32.const 0x1p-1) (f32.const inf)) (f32.const 0x0p+0)) +(assert_return (invoke "div" (f32.const -0x1p-1) (f32.const -nan)) (f32.const nan:canonical)) +(assert_return (invoke "div" (f32.const -0x1p-1) (f32.const -nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "div" (f32.const -0x1p-1) (f32.const nan)) (f32.const nan:canonical)) +(assert_return (invoke "div" (f32.const -0x1p-1) (f32.const nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "div" (f32.const 0x1p-1) (f32.const -nan)) (f32.const nan:canonical)) +(assert_return (invoke "div" (f32.const 0x1p-1) (f32.const -nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "div" (f32.const 0x1p-1) (f32.const nan)) (f32.const nan:canonical)) +(assert_return (invoke "div" (f32.const 0x1p-1) (f32.const nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "div" (f32.const -0x1p+0) (f32.const -0x0p+0)) (f32.const inf)) +(assert_return (invoke "div" (f32.const -0x1p+0) (f32.const 0x0p+0)) (f32.const -inf)) +(assert_return (invoke "div" (f32.const 0x1p+0) (f32.const -0x0p+0)) (f32.const -inf)) +(assert_return (invoke "div" (f32.const 0x1p+0) (f32.const 0x0p+0)) (f32.const inf)) +(assert_return (invoke "div" (f32.const -0x1p+0) (f32.const -0x1p-149)) (f32.const inf)) +(assert_return (invoke "div" (f32.const -0x1p+0) (f32.const 0x1p-149)) (f32.const -inf)) +(assert_return (invoke "div" (f32.const 0x1p+0) (f32.const -0x1p-149)) (f32.const -inf)) +(assert_return (invoke "div" (f32.const 0x1p+0) (f32.const 0x1p-149)) (f32.const inf)) +(assert_return (invoke "div" (f32.const -0x1p+0) (f32.const -0x1p-126)) (f32.const 0x1p+126)) +(assert_return (invoke "div" (f32.const -0x1p+0) (f32.const 0x1p-126)) (f32.const -0x1p+126)) +(assert_return (invoke "div" (f32.const 0x1p+0) (f32.const -0x1p-126)) (f32.const -0x1p+126)) +(assert_return (invoke "div" (f32.const 0x1p+0) (f32.const 0x1p-126)) (f32.const 0x1p+126)) +(assert_return (invoke "div" (f32.const -0x1p+0) (f32.const -0x1p-1)) (f32.const 0x1p+1)) +(assert_return (invoke "div" (f32.const -0x1p+0) (f32.const 0x1p-1)) (f32.const -0x1p+1)) +(assert_return (invoke "div" (f32.const 0x1p+0) (f32.const -0x1p-1)) (f32.const -0x1p+1)) +(assert_return (invoke "div" (f32.const 0x1p+0) (f32.const 0x1p-1)) (f32.const 0x1p+1)) +(assert_return (invoke "div" (f32.const -0x1p+0) (f32.const -0x1p+0)) (f32.const 0x1p+0)) +(assert_return (invoke "div" (f32.const -0x1p+0) (f32.const 0x1p+0)) (f32.const -0x1p+0)) +(assert_return (invoke "div" (f32.const 0x1p+0) (f32.const -0x1p+0)) (f32.const -0x1p+0)) +(assert_return (invoke "div" (f32.const 0x1p+0) (f32.const 0x1p+0)) (f32.const 0x1p+0)) +(assert_return (invoke "div" (f32.const -0x1p+0) (f32.const -0x1.921fb6p+2)) (f32.const 0x1.45f306p-3)) +(assert_return (invoke "div" (f32.const -0x1p+0) (f32.const 0x1.921fb6p+2)) (f32.const -0x1.45f306p-3)) +(assert_return (invoke "div" (f32.const 0x1p+0) (f32.const -0x1.921fb6p+2)) (f32.const -0x1.45f306p-3)) +(assert_return (invoke "div" (f32.const 0x1p+0) (f32.const 0x1.921fb6p+2)) (f32.const 0x1.45f306p-3)) +(assert_return (invoke "div" (f32.const -0x1p+0) (f32.const -0x1.fffffep+127)) (f32.const 0x1p-128)) +(assert_return (invoke "div" (f32.const -0x1p+0) (f32.const 0x1.fffffep+127)) (f32.const -0x1p-128)) +(assert_return (invoke "div" (f32.const 0x1p+0) (f32.const -0x1.fffffep+127)) (f32.const -0x1p-128)) +(assert_return (invoke "div" (f32.const 0x1p+0) (f32.const 0x1.fffffep+127)) (f32.const 0x1p-128)) +(assert_return (invoke "div" (f32.const -0x1p+0) (f32.const -inf)) (f32.const 0x0p+0)) +(assert_return (invoke "div" (f32.const -0x1p+0) (f32.const inf)) (f32.const -0x0p+0)) +(assert_return (invoke "div" (f32.const 0x1p+0) (f32.const -inf)) (f32.const -0x0p+0)) +(assert_return (invoke "div" (f32.const 0x1p+0) (f32.const inf)) (f32.const 0x0p+0)) +(assert_return (invoke "div" (f32.const -0x1p+0) (f32.const -nan)) (f32.const nan:canonical)) +(assert_return (invoke "div" (f32.const -0x1p+0) (f32.const -nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "div" (f32.const -0x1p+0) (f32.const nan)) (f32.const nan:canonical)) +(assert_return (invoke "div" (f32.const -0x1p+0) (f32.const nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "div" (f32.const 0x1p+0) (f32.const -nan)) (f32.const nan:canonical)) +(assert_return (invoke "div" (f32.const 0x1p+0) (f32.const -nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "div" (f32.const 0x1p+0) (f32.const nan)) (f32.const nan:canonical)) +(assert_return (invoke "div" (f32.const 0x1p+0) (f32.const nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "div" (f32.const -0x1.921fb6p+2) (f32.const -0x0p+0)) (f32.const inf)) +(assert_return (invoke "div" (f32.const -0x1.921fb6p+2) (f32.const 0x0p+0)) (f32.const -inf)) +(assert_return (invoke "div" (f32.const 0x1.921fb6p+2) (f32.const -0x0p+0)) (f32.const -inf)) +(assert_return (invoke "div" (f32.const 0x1.921fb6p+2) (f32.const 0x0p+0)) (f32.const inf)) +(assert_return (invoke "div" (f32.const -0x1.921fb6p+2) (f32.const -0x1p-149)) (f32.const inf)) +(assert_return (invoke "div" (f32.const -0x1.921fb6p+2) (f32.const 0x1p-149)) (f32.const -inf)) +(assert_return (invoke "div" (f32.const 0x1.921fb6p+2) (f32.const -0x1p-149)) (f32.const -inf)) +(assert_return (invoke "div" (f32.const 0x1.921fb6p+2) (f32.const 0x1p-149)) (f32.const inf)) +(assert_return (invoke "div" (f32.const -0x1.921fb6p+2) (f32.const -0x1p-126)) (f32.const inf)) +(assert_return (invoke "div" (f32.const -0x1.921fb6p+2) (f32.const 0x1p-126)) (f32.const -inf)) +(assert_return (invoke "div" (f32.const 0x1.921fb6p+2) (f32.const -0x1p-126)) (f32.const -inf)) +(assert_return (invoke "div" (f32.const 0x1.921fb6p+2) (f32.const 0x1p-126)) (f32.const inf)) +(assert_return (invoke "div" (f32.const -0x1.921fb6p+2) (f32.const -0x1p-1)) (f32.const 0x1.921fb6p+3)) +(assert_return (invoke "div" (f32.const -0x1.921fb6p+2) (f32.const 0x1p-1)) (f32.const -0x1.921fb6p+3)) +(assert_return (invoke "div" (f32.const 0x1.921fb6p+2) (f32.const -0x1p-1)) (f32.const -0x1.921fb6p+3)) +(assert_return (invoke "div" (f32.const 0x1.921fb6p+2) (f32.const 0x1p-1)) (f32.const 0x1.921fb6p+3)) +(assert_return (invoke "div" (f32.const -0x1.921fb6p+2) (f32.const -0x1p+0)) (f32.const 0x1.921fb6p+2)) +(assert_return (invoke "div" (f32.const -0x1.921fb6p+2) (f32.const 0x1p+0)) (f32.const -0x1.921fb6p+2)) +(assert_return (invoke "div" (f32.const 0x1.921fb6p+2) (f32.const -0x1p+0)) (f32.const -0x1.921fb6p+2)) +(assert_return (invoke "div" (f32.const 0x1.921fb6p+2) (f32.const 0x1p+0)) (f32.const 0x1.921fb6p+2)) +(assert_return (invoke "div" (f32.const -0x1.921fb6p+2) (f32.const -0x1.921fb6p+2)) (f32.const 0x1p+0)) +(assert_return (invoke "div" (f32.const -0x1.921fb6p+2) (f32.const 0x1.921fb6p+2)) (f32.const -0x1p+0)) +(assert_return (invoke "div" (f32.const 0x1.921fb6p+2) (f32.const -0x1.921fb6p+2)) (f32.const -0x1p+0)) +(assert_return (invoke "div" (f32.const 0x1.921fb6p+2) (f32.const 0x1.921fb6p+2)) (f32.const 0x1p+0)) +(assert_return (invoke "div" (f32.const -0x1.921fb6p+2) (f32.const -0x1.fffffep+127)) (f32.const 0x1.921fb8p-126)) +(assert_return (invoke "div" (f32.const -0x1.921fb6p+2) (f32.const 0x1.fffffep+127)) (f32.const -0x1.921fb8p-126)) +(assert_return (invoke "div" (f32.const 0x1.921fb6p+2) (f32.const -0x1.fffffep+127)) (f32.const -0x1.921fb8p-126)) +(assert_return (invoke "div" (f32.const 0x1.921fb6p+2) (f32.const 0x1.fffffep+127)) (f32.const 0x1.921fb8p-126)) +(assert_return (invoke "div" (f32.const -0x1.921fb6p+2) (f32.const -inf)) (f32.const 0x0p+0)) +(assert_return (invoke "div" (f32.const -0x1.921fb6p+2) (f32.const inf)) (f32.const -0x0p+0)) +(assert_return (invoke "div" (f32.const 0x1.921fb6p+2) (f32.const -inf)) (f32.const -0x0p+0)) +(assert_return (invoke "div" (f32.const 0x1.921fb6p+2) (f32.const inf)) (f32.const 0x0p+0)) +(assert_return (invoke "div" (f32.const -0x1.921fb6p+2) (f32.const -nan)) (f32.const nan:canonical)) +(assert_return (invoke "div" (f32.const -0x1.921fb6p+2) (f32.const -nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "div" (f32.const -0x1.921fb6p+2) (f32.const nan)) (f32.const nan:canonical)) +(assert_return (invoke "div" (f32.const -0x1.921fb6p+2) (f32.const nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "div" (f32.const 0x1.921fb6p+2) (f32.const -nan)) (f32.const nan:canonical)) +(assert_return (invoke "div" (f32.const 0x1.921fb6p+2) (f32.const -nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "div" (f32.const 0x1.921fb6p+2) (f32.const nan)) (f32.const nan:canonical)) +(assert_return (invoke "div" (f32.const 0x1.921fb6p+2) (f32.const nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "div" (f32.const -0x1.fffffep+127) (f32.const -0x0p+0)) (f32.const inf)) +(assert_return (invoke "div" (f32.const -0x1.fffffep+127) (f32.const 0x0p+0)) (f32.const -inf)) +(assert_return (invoke "div" (f32.const 0x1.fffffep+127) (f32.const -0x0p+0)) (f32.const -inf)) +(assert_return (invoke "div" (f32.const 0x1.fffffep+127) (f32.const 0x0p+0)) (f32.const inf)) +(assert_return (invoke "div" (f32.const -0x1.fffffep+127) (f32.const -0x1p-149)) (f32.const inf)) +(assert_return (invoke "div" (f32.const -0x1.fffffep+127) (f32.const 0x1p-149)) (f32.const -inf)) +(assert_return (invoke "div" (f32.const 0x1.fffffep+127) (f32.const -0x1p-149)) (f32.const -inf)) +(assert_return (invoke "div" (f32.const 0x1.fffffep+127) (f32.const 0x1p-149)) (f32.const inf)) +(assert_return (invoke "div" (f32.const -0x1.fffffep+127) (f32.const -0x1p-126)) (f32.const inf)) +(assert_return (invoke "div" (f32.const -0x1.fffffep+127) (f32.const 0x1p-126)) (f32.const -inf)) +(assert_return (invoke "div" (f32.const 0x1.fffffep+127) (f32.const -0x1p-126)) (f32.const -inf)) +(assert_return (invoke "div" (f32.const 0x1.fffffep+127) (f32.const 0x1p-126)) (f32.const inf)) +(assert_return (invoke "div" (f32.const -0x1.fffffep+127) (f32.const -0x1p-1)) (f32.const inf)) +(assert_return (invoke "div" (f32.const -0x1.fffffep+127) (f32.const 0x1p-1)) (f32.const -inf)) +(assert_return (invoke "div" (f32.const 0x1.fffffep+127) (f32.const -0x1p-1)) (f32.const -inf)) +(assert_return (invoke "div" (f32.const 0x1.fffffep+127) (f32.const 0x1p-1)) (f32.const inf)) +(assert_return (invoke "div" (f32.const -0x1.fffffep+127) (f32.const -0x1p+0)) (f32.const 0x1.fffffep+127)) +(assert_return (invoke "div" (f32.const -0x1.fffffep+127) (f32.const 0x1p+0)) (f32.const -0x1.fffffep+127)) +(assert_return (invoke "div" (f32.const 0x1.fffffep+127) (f32.const -0x1p+0)) (f32.const -0x1.fffffep+127)) +(assert_return (invoke "div" (f32.const 0x1.fffffep+127) (f32.const 0x1p+0)) (f32.const 0x1.fffffep+127)) +(assert_return (invoke "div" (f32.const -0x1.fffffep+127) (f32.const -0x1.921fb6p+2)) (f32.const 0x1.45f304p+125)) +(assert_return (invoke "div" (f32.const -0x1.fffffep+127) (f32.const 0x1.921fb6p+2)) (f32.const -0x1.45f304p+125)) +(assert_return (invoke "div" (f32.const 0x1.fffffep+127) (f32.const -0x1.921fb6p+2)) (f32.const -0x1.45f304p+125)) +(assert_return (invoke "div" (f32.const 0x1.fffffep+127) (f32.const 0x1.921fb6p+2)) (f32.const 0x1.45f304p+125)) +(assert_return (invoke "div" (f32.const -0x1.fffffep+127) (f32.const -0x1.fffffep+127)) (f32.const 0x1p+0)) +(assert_return (invoke "div" (f32.const -0x1.fffffep+127) (f32.const 0x1.fffffep+127)) (f32.const -0x1p+0)) +(assert_return (invoke "div" (f32.const 0x1.fffffep+127) (f32.const -0x1.fffffep+127)) (f32.const -0x1p+0)) +(assert_return (invoke "div" (f32.const 0x1.fffffep+127) (f32.const 0x1.fffffep+127)) (f32.const 0x1p+0)) +(assert_return (invoke "div" (f32.const -0x1.fffffep+127) (f32.const -inf)) (f32.const 0x0p+0)) +(assert_return (invoke "div" (f32.const -0x1.fffffep+127) (f32.const inf)) (f32.const -0x0p+0)) +(assert_return (invoke "div" (f32.const 0x1.fffffep+127) (f32.const -inf)) (f32.const -0x0p+0)) +(assert_return (invoke "div" (f32.const 0x1.fffffep+127) (f32.const inf)) (f32.const 0x0p+0)) +(assert_return (invoke "div" (f32.const -0x1.fffffep+127) (f32.const -nan)) (f32.const nan:canonical)) +(assert_return (invoke "div" (f32.const -0x1.fffffep+127) (f32.const -nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "div" (f32.const -0x1.fffffep+127) (f32.const nan)) (f32.const nan:canonical)) +(assert_return (invoke "div" (f32.const -0x1.fffffep+127) (f32.const nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "div" (f32.const 0x1.fffffep+127) (f32.const -nan)) (f32.const nan:canonical)) +(assert_return (invoke "div" (f32.const 0x1.fffffep+127) (f32.const -nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "div" (f32.const 0x1.fffffep+127) (f32.const nan)) (f32.const nan:canonical)) +(assert_return (invoke "div" (f32.const 0x1.fffffep+127) (f32.const nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "div" (f32.const -inf) (f32.const -0x0p+0)) (f32.const inf)) +(assert_return (invoke "div" (f32.const -inf) (f32.const 0x0p+0)) (f32.const -inf)) +(assert_return (invoke "div" (f32.const inf) (f32.const -0x0p+0)) (f32.const -inf)) +(assert_return (invoke "div" (f32.const inf) (f32.const 0x0p+0)) (f32.const inf)) +(assert_return (invoke "div" (f32.const -inf) (f32.const -0x1p-149)) (f32.const inf)) +(assert_return (invoke "div" (f32.const -inf) (f32.const 0x1p-149)) (f32.const -inf)) +(assert_return (invoke "div" (f32.const inf) (f32.const -0x1p-149)) (f32.const -inf)) +(assert_return (invoke "div" (f32.const inf) (f32.const 0x1p-149)) (f32.const inf)) +(assert_return (invoke "div" (f32.const -inf) (f32.const -0x1p-126)) (f32.const inf)) +(assert_return (invoke "div" (f32.const -inf) (f32.const 0x1p-126)) (f32.const -inf)) +(assert_return (invoke "div" (f32.const inf) (f32.const -0x1p-126)) (f32.const -inf)) +(assert_return (invoke "div" (f32.const inf) (f32.const 0x1p-126)) (f32.const inf)) +(assert_return (invoke "div" (f32.const -inf) (f32.const -0x1p-1)) (f32.const inf)) +(assert_return (invoke "div" (f32.const -inf) (f32.const 0x1p-1)) (f32.const -inf)) +(assert_return (invoke "div" (f32.const inf) (f32.const -0x1p-1)) (f32.const -inf)) +(assert_return (invoke "div" (f32.const inf) (f32.const 0x1p-1)) (f32.const inf)) +(assert_return (invoke "div" (f32.const -inf) (f32.const -0x1p+0)) (f32.const inf)) +(assert_return (invoke "div" (f32.const -inf) (f32.const 0x1p+0)) (f32.const -inf)) +(assert_return (invoke "div" (f32.const inf) (f32.const -0x1p+0)) (f32.const -inf)) +(assert_return (invoke "div" (f32.const inf) (f32.const 0x1p+0)) (f32.const inf)) +(assert_return (invoke "div" (f32.const -inf) (f32.const -0x1.921fb6p+2)) (f32.const inf)) +(assert_return (invoke "div" (f32.const -inf) (f32.const 0x1.921fb6p+2)) (f32.const -inf)) +(assert_return (invoke "div" (f32.const inf) (f32.const -0x1.921fb6p+2)) (f32.const -inf)) +(assert_return (invoke "div" (f32.const inf) (f32.const 0x1.921fb6p+2)) (f32.const inf)) +(assert_return (invoke "div" (f32.const -inf) (f32.const -0x1.fffffep+127)) (f32.const inf)) +(assert_return (invoke "div" (f32.const -inf) (f32.const 0x1.fffffep+127)) (f32.const -inf)) +(assert_return (invoke "div" (f32.const inf) (f32.const -0x1.fffffep+127)) (f32.const -inf)) +(assert_return (invoke "div" (f32.const inf) (f32.const 0x1.fffffep+127)) (f32.const inf)) +(assert_return (invoke "div" (f32.const -inf) (f32.const -inf)) (f32.const nan:canonical)) +(assert_return (invoke "div" (f32.const -inf) (f32.const inf)) (f32.const nan:canonical)) +(assert_return (invoke "div" (f32.const inf) (f32.const -inf)) (f32.const nan:canonical)) +(assert_return (invoke "div" (f32.const inf) (f32.const inf)) (f32.const nan:canonical)) +(assert_return (invoke "div" (f32.const -inf) (f32.const -nan)) (f32.const nan:canonical)) +(assert_return (invoke "div" (f32.const -inf) (f32.const -nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "div" (f32.const -inf) (f32.const nan)) (f32.const nan:canonical)) +(assert_return (invoke "div" (f32.const -inf) (f32.const nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "div" (f32.const inf) (f32.const -nan)) (f32.const nan:canonical)) +(assert_return (invoke "div" (f32.const inf) (f32.const -nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "div" (f32.const inf) (f32.const nan)) (f32.const nan:canonical)) +(assert_return (invoke "div" (f32.const inf) (f32.const nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "div" (f32.const -nan) (f32.const -0x0p+0)) (f32.const nan:canonical)) +(assert_return (invoke "div" (f32.const -nan:0x200000) (f32.const -0x0p+0)) (f32.const nan:arithmetic)) +(assert_return (invoke "div" (f32.const -nan) (f32.const 0x0p+0)) (f32.const nan:canonical)) +(assert_return (invoke "div" (f32.const -nan:0x200000) (f32.const 0x0p+0)) (f32.const nan:arithmetic)) +(assert_return (invoke "div" (f32.const nan) (f32.const -0x0p+0)) (f32.const nan:canonical)) +(assert_return (invoke "div" (f32.const nan:0x200000) (f32.const -0x0p+0)) (f32.const nan:arithmetic)) +(assert_return (invoke "div" (f32.const nan) (f32.const 0x0p+0)) (f32.const nan:canonical)) +(assert_return (invoke "div" (f32.const nan:0x200000) (f32.const 0x0p+0)) (f32.const nan:arithmetic)) +(assert_return (invoke "div" (f32.const -nan) (f32.const -0x1p-149)) (f32.const nan:canonical)) +(assert_return (invoke "div" (f32.const -nan:0x200000) (f32.const -0x1p-149)) (f32.const nan:arithmetic)) +(assert_return (invoke "div" (f32.const -nan) (f32.const 0x1p-149)) (f32.const nan:canonical)) +(assert_return (invoke "div" (f32.const -nan:0x200000) (f32.const 0x1p-149)) (f32.const nan:arithmetic)) +(assert_return (invoke "div" (f32.const nan) (f32.const -0x1p-149)) (f32.const nan:canonical)) +(assert_return (invoke "div" (f32.const nan:0x200000) (f32.const -0x1p-149)) (f32.const nan:arithmetic)) +(assert_return (invoke "div" (f32.const nan) (f32.const 0x1p-149)) (f32.const nan:canonical)) +(assert_return (invoke "div" (f32.const nan:0x200000) (f32.const 0x1p-149)) (f32.const nan:arithmetic)) +(assert_return (invoke "div" (f32.const -nan) (f32.const -0x1p-126)) (f32.const nan:canonical)) +(assert_return (invoke "div" (f32.const -nan:0x200000) (f32.const -0x1p-126)) (f32.const nan:arithmetic)) +(assert_return (invoke "div" (f32.const -nan) (f32.const 0x1p-126)) (f32.const nan:canonical)) +(assert_return (invoke "div" (f32.const -nan:0x200000) (f32.const 0x1p-126)) (f32.const nan:arithmetic)) +(assert_return (invoke "div" (f32.const nan) (f32.const -0x1p-126)) (f32.const nan:canonical)) +(assert_return (invoke "div" (f32.const nan:0x200000) (f32.const -0x1p-126)) (f32.const nan:arithmetic)) +(assert_return (invoke "div" (f32.const nan) (f32.const 0x1p-126)) (f32.const nan:canonical)) +(assert_return (invoke "div" (f32.const nan:0x200000) (f32.const 0x1p-126)) (f32.const nan:arithmetic)) +(assert_return (invoke "div" (f32.const -nan) (f32.const -0x1p-1)) (f32.const nan:canonical)) +(assert_return (invoke "div" (f32.const -nan:0x200000) (f32.const -0x1p-1)) (f32.const nan:arithmetic)) +(assert_return (invoke "div" (f32.const -nan) (f32.const 0x1p-1)) (f32.const nan:canonical)) +(assert_return (invoke "div" (f32.const -nan:0x200000) (f32.const 0x1p-1)) (f32.const nan:arithmetic)) +(assert_return (invoke "div" (f32.const nan) (f32.const -0x1p-1)) (f32.const nan:canonical)) +(assert_return (invoke "div" (f32.const nan:0x200000) (f32.const -0x1p-1)) (f32.const nan:arithmetic)) +(assert_return (invoke "div" (f32.const nan) (f32.const 0x1p-1)) (f32.const nan:canonical)) +(assert_return (invoke "div" (f32.const nan:0x200000) (f32.const 0x1p-1)) (f32.const nan:arithmetic)) +(assert_return (invoke "div" (f32.const -nan) (f32.const -0x1p+0)) (f32.const nan:canonical)) +(assert_return (invoke "div" (f32.const -nan:0x200000) (f32.const -0x1p+0)) (f32.const nan:arithmetic)) +(assert_return (invoke "div" (f32.const -nan) (f32.const 0x1p+0)) (f32.const nan:canonical)) +(assert_return (invoke "div" (f32.const -nan:0x200000) (f32.const 0x1p+0)) (f32.const nan:arithmetic)) +(assert_return (invoke "div" (f32.const nan) (f32.const -0x1p+0)) (f32.const nan:canonical)) +(assert_return (invoke "div" (f32.const nan:0x200000) (f32.const -0x1p+0)) (f32.const nan:arithmetic)) +(assert_return (invoke "div" (f32.const nan) (f32.const 0x1p+0)) (f32.const nan:canonical)) +(assert_return (invoke "div" (f32.const nan:0x200000) (f32.const 0x1p+0)) (f32.const nan:arithmetic)) +(assert_return (invoke "div" (f32.const -nan) (f32.const -0x1.921fb6p+2)) (f32.const nan:canonical)) +(assert_return (invoke "div" (f32.const -nan:0x200000) (f32.const -0x1.921fb6p+2)) (f32.const nan:arithmetic)) +(assert_return (invoke "div" (f32.const -nan) (f32.const 0x1.921fb6p+2)) (f32.const nan:canonical)) +(assert_return (invoke "div" (f32.const -nan:0x200000) (f32.const 0x1.921fb6p+2)) (f32.const nan:arithmetic)) +(assert_return (invoke "div" (f32.const nan) (f32.const -0x1.921fb6p+2)) (f32.const nan:canonical)) +(assert_return (invoke "div" (f32.const nan:0x200000) (f32.const -0x1.921fb6p+2)) (f32.const nan:arithmetic)) +(assert_return (invoke "div" (f32.const nan) (f32.const 0x1.921fb6p+2)) (f32.const nan:canonical)) +(assert_return (invoke "div" (f32.const nan:0x200000) (f32.const 0x1.921fb6p+2)) (f32.const nan:arithmetic)) +(assert_return (invoke "div" (f32.const -nan) (f32.const -0x1.fffffep+127)) (f32.const nan:canonical)) +(assert_return (invoke "div" (f32.const -nan:0x200000) (f32.const -0x1.fffffep+127)) (f32.const nan:arithmetic)) +(assert_return (invoke "div" (f32.const -nan) (f32.const 0x1.fffffep+127)) (f32.const nan:canonical)) +(assert_return (invoke "div" (f32.const -nan:0x200000) (f32.const 0x1.fffffep+127)) (f32.const nan:arithmetic)) +(assert_return (invoke "div" (f32.const nan) (f32.const -0x1.fffffep+127)) (f32.const nan:canonical)) +(assert_return (invoke "div" (f32.const nan:0x200000) (f32.const -0x1.fffffep+127)) (f32.const nan:arithmetic)) +(assert_return (invoke "div" (f32.const nan) (f32.const 0x1.fffffep+127)) (f32.const nan:canonical)) +(assert_return (invoke "div" (f32.const nan:0x200000) (f32.const 0x1.fffffep+127)) (f32.const nan:arithmetic)) +(assert_return (invoke "div" (f32.const -nan) (f32.const -inf)) (f32.const nan:canonical)) +(assert_return (invoke "div" (f32.const -nan:0x200000) (f32.const -inf)) (f32.const nan:arithmetic)) +(assert_return (invoke "div" (f32.const -nan) (f32.const inf)) (f32.const nan:canonical)) +(assert_return (invoke "div" (f32.const -nan:0x200000) (f32.const inf)) (f32.const nan:arithmetic)) +(assert_return (invoke "div" (f32.const nan) (f32.const -inf)) (f32.const nan:canonical)) +(assert_return (invoke "div" (f32.const nan:0x200000) (f32.const -inf)) (f32.const nan:arithmetic)) +(assert_return (invoke "div" (f32.const nan) (f32.const inf)) (f32.const nan:canonical)) +(assert_return (invoke "div" (f32.const nan:0x200000) (f32.const inf)) (f32.const nan:arithmetic)) +(assert_return (invoke "div" (f32.const -nan) (f32.const -nan)) (f32.const nan:canonical)) +(assert_return (invoke "div" (f32.const -nan:0x200000) (f32.const -nan)) (f32.const nan:arithmetic)) +(assert_return (invoke "div" (f32.const -nan) (f32.const -nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "div" (f32.const -nan:0x200000) (f32.const -nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "div" (f32.const -nan) (f32.const nan)) (f32.const nan:canonical)) +(assert_return (invoke "div" (f32.const -nan:0x200000) (f32.const nan)) (f32.const nan:arithmetic)) +(assert_return (invoke "div" (f32.const -nan) (f32.const nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "div" (f32.const -nan:0x200000) (f32.const nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "div" (f32.const nan) (f32.const -nan)) (f32.const nan:canonical)) +(assert_return (invoke "div" (f32.const nan:0x200000) (f32.const -nan)) (f32.const nan:arithmetic)) +(assert_return (invoke "div" (f32.const nan) (f32.const -nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "div" (f32.const nan:0x200000) (f32.const -nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "div" (f32.const nan) (f32.const nan)) (f32.const nan:canonical)) +(assert_return (invoke "div" (f32.const nan:0x200000) (f32.const nan)) (f32.const nan:arithmetic)) +(assert_return (invoke "div" (f32.const nan) (f32.const nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "div" (f32.const nan:0x200000) (f32.const nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "min" (f32.const -0x0p+0) (f32.const -0x0p+0)) (f32.const -0x0p+0)) +(assert_return (invoke "min" (f32.const -0x0p+0) (f32.const 0x0p+0)) (f32.const -0x0p+0)) +(assert_return (invoke "min" (f32.const 0x0p+0) (f32.const -0x0p+0)) (f32.const -0x0p+0)) +(assert_return (invoke "min" (f32.const 0x0p+0) (f32.const 0x0p+0)) (f32.const 0x0p+0)) +(assert_return (invoke "min" (f32.const -0x0p+0) (f32.const -0x1p-149)) (f32.const -0x1p-149)) +(assert_return (invoke "min" (f32.const -0x0p+0) (f32.const 0x1p-149)) (f32.const -0x0p+0)) +(assert_return (invoke "min" (f32.const 0x0p+0) (f32.const -0x1p-149)) (f32.const -0x1p-149)) +(assert_return (invoke "min" (f32.const 0x0p+0) (f32.const 0x1p-149)) (f32.const 0x0p+0)) +(assert_return (invoke "min" (f32.const -0x0p+0) (f32.const -0x1p-126)) (f32.const -0x1p-126)) +(assert_return (invoke "min" (f32.const -0x0p+0) (f32.const 0x1p-126)) (f32.const -0x0p+0)) +(assert_return (invoke "min" (f32.const 0x0p+0) (f32.const -0x1p-126)) (f32.const -0x1p-126)) +(assert_return (invoke "min" (f32.const 0x0p+0) (f32.const 0x1p-126)) (f32.const 0x0p+0)) +(assert_return (invoke "min" (f32.const -0x0p+0) (f32.const -0x1p-1)) (f32.const -0x1p-1)) +(assert_return (invoke "min" (f32.const -0x0p+0) (f32.const 0x1p-1)) (f32.const -0x0p+0)) +(assert_return (invoke "min" (f32.const 0x0p+0) (f32.const -0x1p-1)) (f32.const -0x1p-1)) +(assert_return (invoke "min" (f32.const 0x0p+0) (f32.const 0x1p-1)) (f32.const 0x0p+0)) +(assert_return (invoke "min" (f32.const -0x0p+0) (f32.const -0x1p+0)) (f32.const -0x1p+0)) +(assert_return (invoke "min" (f32.const -0x0p+0) (f32.const 0x1p+0)) (f32.const -0x0p+0)) +(assert_return (invoke "min" (f32.const 0x0p+0) (f32.const -0x1p+0)) (f32.const -0x1p+0)) +(assert_return (invoke "min" (f32.const 0x0p+0) (f32.const 0x1p+0)) (f32.const 0x0p+0)) +(assert_return (invoke "min" (f32.const -0x0p+0) (f32.const -0x1.921fb6p+2)) (f32.const -0x1.921fb6p+2)) +(assert_return (invoke "min" (f32.const -0x0p+0) (f32.const 0x1.921fb6p+2)) (f32.const -0x0p+0)) +(assert_return (invoke "min" (f32.const 0x0p+0) (f32.const -0x1.921fb6p+2)) (f32.const -0x1.921fb6p+2)) +(assert_return (invoke "min" (f32.const 0x0p+0) (f32.const 0x1.921fb6p+2)) (f32.const 0x0p+0)) +(assert_return (invoke "min" (f32.const -0x0p+0) (f32.const -0x1.fffffep+127)) (f32.const -0x1.fffffep+127)) +(assert_return (invoke "min" (f32.const -0x0p+0) (f32.const 0x1.fffffep+127)) (f32.const -0x0p+0)) +(assert_return (invoke "min" (f32.const 0x0p+0) (f32.const -0x1.fffffep+127)) (f32.const -0x1.fffffep+127)) +(assert_return (invoke "min" (f32.const 0x0p+0) (f32.const 0x1.fffffep+127)) (f32.const 0x0p+0)) +(assert_return (invoke "min" (f32.const -0x0p+0) (f32.const -inf)) (f32.const -inf)) +(assert_return (invoke "min" (f32.const -0x0p+0) (f32.const inf)) (f32.const -0x0p+0)) +(assert_return (invoke "min" (f32.const 0x0p+0) (f32.const -inf)) (f32.const -inf)) +(assert_return (invoke "min" (f32.const 0x0p+0) (f32.const inf)) (f32.const 0x0p+0)) +(assert_return (invoke "min" (f32.const -0x0p+0) (f32.const -nan)) (f32.const nan:canonical)) +(assert_return (invoke "min" (f32.const -0x0p+0) (f32.const -nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "min" (f32.const -0x0p+0) (f32.const nan)) (f32.const nan:canonical)) +(assert_return (invoke "min" (f32.const -0x0p+0) (f32.const nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "min" (f32.const 0x0p+0) (f32.const -nan)) (f32.const nan:canonical)) +(assert_return (invoke "min" (f32.const 0x0p+0) (f32.const -nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "min" (f32.const 0x0p+0) (f32.const nan)) (f32.const nan:canonical)) +(assert_return (invoke "min" (f32.const 0x0p+0) (f32.const nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "min" (f32.const -0x1p-149) (f32.const -0x0p+0)) (f32.const -0x1p-149)) +(assert_return (invoke "min" (f32.const -0x1p-149) (f32.const 0x0p+0)) (f32.const -0x1p-149)) +(assert_return (invoke "min" (f32.const 0x1p-149) (f32.const -0x0p+0)) (f32.const -0x0p+0)) +(assert_return (invoke "min" (f32.const 0x1p-149) (f32.const 0x0p+0)) (f32.const 0x0p+0)) +(assert_return (invoke "min" (f32.const -0x1p-149) (f32.const -0x1p-149)) (f32.const -0x1p-149)) +(assert_return (invoke "min" (f32.const -0x1p-149) (f32.const 0x1p-149)) (f32.const -0x1p-149)) +(assert_return (invoke "min" (f32.const 0x1p-149) (f32.const -0x1p-149)) (f32.const -0x1p-149)) +(assert_return (invoke "min" (f32.const 0x1p-149) (f32.const 0x1p-149)) (f32.const 0x1p-149)) +(assert_return (invoke "min" (f32.const -0x1p-149) (f32.const -0x1p-126)) (f32.const -0x1p-126)) +(assert_return (invoke "min" (f32.const -0x1p-149) (f32.const 0x1p-126)) (f32.const -0x1p-149)) +(assert_return (invoke "min" (f32.const 0x1p-149) (f32.const -0x1p-126)) (f32.const -0x1p-126)) +(assert_return (invoke "min" (f32.const 0x1p-149) (f32.const 0x1p-126)) (f32.const 0x1p-149)) +(assert_return (invoke "min" (f32.const -0x1p-149) (f32.const -0x1p-1)) (f32.const -0x1p-1)) +(assert_return (invoke "min" (f32.const -0x1p-149) (f32.const 0x1p-1)) (f32.const -0x1p-149)) +(assert_return (invoke "min" (f32.const 0x1p-149) (f32.const -0x1p-1)) (f32.const -0x1p-1)) +(assert_return (invoke "min" (f32.const 0x1p-149) (f32.const 0x1p-1)) (f32.const 0x1p-149)) +(assert_return (invoke "min" (f32.const -0x1p-149) (f32.const -0x1p+0)) (f32.const -0x1p+0)) +(assert_return (invoke "min" (f32.const -0x1p-149) (f32.const 0x1p+0)) (f32.const -0x1p-149)) +(assert_return (invoke "min" (f32.const 0x1p-149) (f32.const -0x1p+0)) (f32.const -0x1p+0)) +(assert_return (invoke "min" (f32.const 0x1p-149) (f32.const 0x1p+0)) (f32.const 0x1p-149)) +(assert_return (invoke "min" (f32.const -0x1p-149) (f32.const -0x1.921fb6p+2)) (f32.const -0x1.921fb6p+2)) +(assert_return (invoke "min" (f32.const -0x1p-149) (f32.const 0x1.921fb6p+2)) (f32.const -0x1p-149)) +(assert_return (invoke "min" (f32.const 0x1p-149) (f32.const -0x1.921fb6p+2)) (f32.const -0x1.921fb6p+2)) +(assert_return (invoke "min" (f32.const 0x1p-149) (f32.const 0x1.921fb6p+2)) (f32.const 0x1p-149)) +(assert_return (invoke "min" (f32.const -0x1p-149) (f32.const -0x1.fffffep+127)) (f32.const -0x1.fffffep+127)) +(assert_return (invoke "min" (f32.const -0x1p-149) (f32.const 0x1.fffffep+127)) (f32.const -0x1p-149)) +(assert_return (invoke "min" (f32.const 0x1p-149) (f32.const -0x1.fffffep+127)) (f32.const -0x1.fffffep+127)) +(assert_return (invoke "min" (f32.const 0x1p-149) (f32.const 0x1.fffffep+127)) (f32.const 0x1p-149)) +(assert_return (invoke "min" (f32.const -0x1p-149) (f32.const -inf)) (f32.const -inf)) +(assert_return (invoke "min" (f32.const -0x1p-149) (f32.const inf)) (f32.const -0x1p-149)) +(assert_return (invoke "min" (f32.const 0x1p-149) (f32.const -inf)) (f32.const -inf)) +(assert_return (invoke "min" (f32.const 0x1p-149) (f32.const inf)) (f32.const 0x1p-149)) +(assert_return (invoke "min" (f32.const -0x1p-149) (f32.const -nan)) (f32.const nan:canonical)) +(assert_return (invoke "min" (f32.const -0x1p-149) (f32.const -nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "min" (f32.const -0x1p-149) (f32.const nan)) (f32.const nan:canonical)) +(assert_return (invoke "min" (f32.const -0x1p-149) (f32.const nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "min" (f32.const 0x1p-149) (f32.const -nan)) (f32.const nan:canonical)) +(assert_return (invoke "min" (f32.const 0x1p-149) (f32.const -nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "min" (f32.const 0x1p-149) (f32.const nan)) (f32.const nan:canonical)) +(assert_return (invoke "min" (f32.const 0x1p-149) (f32.const nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "min" (f32.const -0x1p-126) (f32.const -0x0p+0)) (f32.const -0x1p-126)) +(assert_return (invoke "min" (f32.const -0x1p-126) (f32.const 0x0p+0)) (f32.const -0x1p-126)) +(assert_return (invoke "min" (f32.const 0x1p-126) (f32.const -0x0p+0)) (f32.const -0x0p+0)) +(assert_return (invoke "min" (f32.const 0x1p-126) (f32.const 0x0p+0)) (f32.const 0x0p+0)) +(assert_return (invoke "min" (f32.const -0x1p-126) (f32.const -0x1p-149)) (f32.const -0x1p-126)) +(assert_return (invoke "min" (f32.const -0x1p-126) (f32.const 0x1p-149)) (f32.const -0x1p-126)) +(assert_return (invoke "min" (f32.const 0x1p-126) (f32.const -0x1p-149)) (f32.const -0x1p-149)) +(assert_return (invoke "min" (f32.const 0x1p-126) (f32.const 0x1p-149)) (f32.const 0x1p-149)) +(assert_return (invoke "min" (f32.const -0x1p-126) (f32.const -0x1p-126)) (f32.const -0x1p-126)) +(assert_return (invoke "min" (f32.const -0x1p-126) (f32.const 0x1p-126)) (f32.const -0x1p-126)) +(assert_return (invoke "min" (f32.const 0x1p-126) (f32.const -0x1p-126)) (f32.const -0x1p-126)) +(assert_return (invoke "min" (f32.const 0x1p-126) (f32.const 0x1p-126)) (f32.const 0x1p-126)) +(assert_return (invoke "min" (f32.const -0x1p-126) (f32.const -0x1p-1)) (f32.const -0x1p-1)) +(assert_return (invoke "min" (f32.const -0x1p-126) (f32.const 0x1p-1)) (f32.const -0x1p-126)) +(assert_return (invoke "min" (f32.const 0x1p-126) (f32.const -0x1p-1)) (f32.const -0x1p-1)) +(assert_return (invoke "min" (f32.const 0x1p-126) (f32.const 0x1p-1)) (f32.const 0x1p-126)) +(assert_return (invoke "min" (f32.const -0x1p-126) (f32.const -0x1p+0)) (f32.const -0x1p+0)) +(assert_return (invoke "min" (f32.const -0x1p-126) (f32.const 0x1p+0)) (f32.const -0x1p-126)) +(assert_return (invoke "min" (f32.const 0x1p-126) (f32.const -0x1p+0)) (f32.const -0x1p+0)) +(assert_return (invoke "min" (f32.const 0x1p-126) (f32.const 0x1p+0)) (f32.const 0x1p-126)) +(assert_return (invoke "min" (f32.const -0x1p-126) (f32.const -0x1.921fb6p+2)) (f32.const -0x1.921fb6p+2)) +(assert_return (invoke "min" (f32.const -0x1p-126) (f32.const 0x1.921fb6p+2)) (f32.const -0x1p-126)) +(assert_return (invoke "min" (f32.const 0x1p-126) (f32.const -0x1.921fb6p+2)) (f32.const -0x1.921fb6p+2)) +(assert_return (invoke "min" (f32.const 0x1p-126) (f32.const 0x1.921fb6p+2)) (f32.const 0x1p-126)) +(assert_return (invoke "min" (f32.const -0x1p-126) (f32.const -0x1.fffffep+127)) (f32.const -0x1.fffffep+127)) +(assert_return (invoke "min" (f32.const -0x1p-126) (f32.const 0x1.fffffep+127)) (f32.const -0x1p-126)) +(assert_return (invoke "min" (f32.const 0x1p-126) (f32.const -0x1.fffffep+127)) (f32.const -0x1.fffffep+127)) +(assert_return (invoke "min" (f32.const 0x1p-126) (f32.const 0x1.fffffep+127)) (f32.const 0x1p-126)) +(assert_return (invoke "min" (f32.const -0x1p-126) (f32.const -inf)) (f32.const -inf)) +(assert_return (invoke "min" (f32.const -0x1p-126) (f32.const inf)) (f32.const -0x1p-126)) +(assert_return (invoke "min" (f32.const 0x1p-126) (f32.const -inf)) (f32.const -inf)) +(assert_return (invoke "min" (f32.const 0x1p-126) (f32.const inf)) (f32.const 0x1p-126)) +(assert_return (invoke "min" (f32.const -0x1p-126) (f32.const -nan)) (f32.const nan:canonical)) +(assert_return (invoke "min" (f32.const -0x1p-126) (f32.const -nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "min" (f32.const -0x1p-126) (f32.const nan)) (f32.const nan:canonical)) +(assert_return (invoke "min" (f32.const -0x1p-126) (f32.const nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "min" (f32.const 0x1p-126) (f32.const -nan)) (f32.const nan:canonical)) +(assert_return (invoke "min" (f32.const 0x1p-126) (f32.const -nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "min" (f32.const 0x1p-126) (f32.const nan)) (f32.const nan:canonical)) +(assert_return (invoke "min" (f32.const 0x1p-126) (f32.const nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "min" (f32.const -0x1p-1) (f32.const -0x0p+0)) (f32.const -0x1p-1)) +(assert_return (invoke "min" (f32.const -0x1p-1) (f32.const 0x0p+0)) (f32.const -0x1p-1)) +(assert_return (invoke "min" (f32.const 0x1p-1) (f32.const -0x0p+0)) (f32.const -0x0p+0)) +(assert_return (invoke "min" (f32.const 0x1p-1) (f32.const 0x0p+0)) (f32.const 0x0p+0)) +(assert_return (invoke "min" (f32.const -0x1p-1) (f32.const -0x1p-149)) (f32.const -0x1p-1)) +(assert_return (invoke "min" (f32.const -0x1p-1) (f32.const 0x1p-149)) (f32.const -0x1p-1)) +(assert_return (invoke "min" (f32.const 0x1p-1) (f32.const -0x1p-149)) (f32.const -0x1p-149)) +(assert_return (invoke "min" (f32.const 0x1p-1) (f32.const 0x1p-149)) (f32.const 0x1p-149)) +(assert_return (invoke "min" (f32.const -0x1p-1) (f32.const -0x1p-126)) (f32.const -0x1p-1)) +(assert_return (invoke "min" (f32.const -0x1p-1) (f32.const 0x1p-126)) (f32.const -0x1p-1)) +(assert_return (invoke "min" (f32.const 0x1p-1) (f32.const -0x1p-126)) (f32.const -0x1p-126)) +(assert_return (invoke "min" (f32.const 0x1p-1) (f32.const 0x1p-126)) (f32.const 0x1p-126)) +(assert_return (invoke "min" (f32.const -0x1p-1) (f32.const -0x1p-1)) (f32.const -0x1p-1)) +(assert_return (invoke "min" (f32.const -0x1p-1) (f32.const 0x1p-1)) (f32.const -0x1p-1)) +(assert_return (invoke "min" (f32.const 0x1p-1) (f32.const -0x1p-1)) (f32.const -0x1p-1)) +(assert_return (invoke "min" (f32.const 0x1p-1) (f32.const 0x1p-1)) (f32.const 0x1p-1)) +(assert_return (invoke "min" (f32.const -0x1p-1) (f32.const -0x1p+0)) (f32.const -0x1p+0)) +(assert_return (invoke "min" (f32.const -0x1p-1) (f32.const 0x1p+0)) (f32.const -0x1p-1)) +(assert_return (invoke "min" (f32.const 0x1p-1) (f32.const -0x1p+0)) (f32.const -0x1p+0)) +(assert_return (invoke "min" (f32.const 0x1p-1) (f32.const 0x1p+0)) (f32.const 0x1p-1)) +(assert_return (invoke "min" (f32.const -0x1p-1) (f32.const -0x1.921fb6p+2)) (f32.const -0x1.921fb6p+2)) +(assert_return (invoke "min" (f32.const -0x1p-1) (f32.const 0x1.921fb6p+2)) (f32.const -0x1p-1)) +(assert_return (invoke "min" (f32.const 0x1p-1) (f32.const -0x1.921fb6p+2)) (f32.const -0x1.921fb6p+2)) +(assert_return (invoke "min" (f32.const 0x1p-1) (f32.const 0x1.921fb6p+2)) (f32.const 0x1p-1)) +(assert_return (invoke "min" (f32.const -0x1p-1) (f32.const -0x1.fffffep+127)) (f32.const -0x1.fffffep+127)) +(assert_return (invoke "min" (f32.const -0x1p-1) (f32.const 0x1.fffffep+127)) (f32.const -0x1p-1)) +(assert_return (invoke "min" (f32.const 0x1p-1) (f32.const -0x1.fffffep+127)) (f32.const -0x1.fffffep+127)) +(assert_return (invoke "min" (f32.const 0x1p-1) (f32.const 0x1.fffffep+127)) (f32.const 0x1p-1)) +(assert_return (invoke "min" (f32.const -0x1p-1) (f32.const -inf)) (f32.const -inf)) +(assert_return (invoke "min" (f32.const -0x1p-1) (f32.const inf)) (f32.const -0x1p-1)) +(assert_return (invoke "min" (f32.const 0x1p-1) (f32.const -inf)) (f32.const -inf)) +(assert_return (invoke "min" (f32.const 0x1p-1) (f32.const inf)) (f32.const 0x1p-1)) +(assert_return (invoke "min" (f32.const -0x1p-1) (f32.const -nan)) (f32.const nan:canonical)) +(assert_return (invoke "min" (f32.const -0x1p-1) (f32.const -nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "min" (f32.const -0x1p-1) (f32.const nan)) (f32.const nan:canonical)) +(assert_return (invoke "min" (f32.const -0x1p-1) (f32.const nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "min" (f32.const 0x1p-1) (f32.const -nan)) (f32.const nan:canonical)) +(assert_return (invoke "min" (f32.const 0x1p-1) (f32.const -nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "min" (f32.const 0x1p-1) (f32.const nan)) (f32.const nan:canonical)) +(assert_return (invoke "min" (f32.const 0x1p-1) (f32.const nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "min" (f32.const -0x1p+0) (f32.const -0x0p+0)) (f32.const -0x1p+0)) +(assert_return (invoke "min" (f32.const -0x1p+0) (f32.const 0x0p+0)) (f32.const -0x1p+0)) +(assert_return (invoke "min" (f32.const 0x1p+0) (f32.const -0x0p+0)) (f32.const -0x0p+0)) +(assert_return (invoke "min" (f32.const 0x1p+0) (f32.const 0x0p+0)) (f32.const 0x0p+0)) +(assert_return (invoke "min" (f32.const -0x1p+0) (f32.const -0x1p-149)) (f32.const -0x1p+0)) +(assert_return (invoke "min" (f32.const -0x1p+0) (f32.const 0x1p-149)) (f32.const -0x1p+0)) +(assert_return (invoke "min" (f32.const 0x1p+0) (f32.const -0x1p-149)) (f32.const -0x1p-149)) +(assert_return (invoke "min" (f32.const 0x1p+0) (f32.const 0x1p-149)) (f32.const 0x1p-149)) +(assert_return (invoke "min" (f32.const -0x1p+0) (f32.const -0x1p-126)) (f32.const -0x1p+0)) +(assert_return (invoke "min" (f32.const -0x1p+0) (f32.const 0x1p-126)) (f32.const -0x1p+0)) +(assert_return (invoke "min" (f32.const 0x1p+0) (f32.const -0x1p-126)) (f32.const -0x1p-126)) +(assert_return (invoke "min" (f32.const 0x1p+0) (f32.const 0x1p-126)) (f32.const 0x1p-126)) +(assert_return (invoke "min" (f32.const -0x1p+0) (f32.const -0x1p-1)) (f32.const -0x1p+0)) +(assert_return (invoke "min" (f32.const -0x1p+0) (f32.const 0x1p-1)) (f32.const -0x1p+0)) +(assert_return (invoke "min" (f32.const 0x1p+0) (f32.const -0x1p-1)) (f32.const -0x1p-1)) +(assert_return (invoke "min" (f32.const 0x1p+0) (f32.const 0x1p-1)) (f32.const 0x1p-1)) +(assert_return (invoke "min" (f32.const -0x1p+0) (f32.const -0x1p+0)) (f32.const -0x1p+0)) +(assert_return (invoke "min" (f32.const -0x1p+0) (f32.const 0x1p+0)) (f32.const -0x1p+0)) +(assert_return (invoke "min" (f32.const 0x1p+0) (f32.const -0x1p+0)) (f32.const -0x1p+0)) +(assert_return (invoke "min" (f32.const 0x1p+0) (f32.const 0x1p+0)) (f32.const 0x1p+0)) +(assert_return (invoke "min" (f32.const -0x1p+0) (f32.const -0x1.921fb6p+2)) (f32.const -0x1.921fb6p+2)) +(assert_return (invoke "min" (f32.const -0x1p+0) (f32.const 0x1.921fb6p+2)) (f32.const -0x1p+0)) +(assert_return (invoke "min" (f32.const 0x1p+0) (f32.const -0x1.921fb6p+2)) (f32.const -0x1.921fb6p+2)) +(assert_return (invoke "min" (f32.const 0x1p+0) (f32.const 0x1.921fb6p+2)) (f32.const 0x1p+0)) +(assert_return (invoke "min" (f32.const -0x1p+0) (f32.const -0x1.fffffep+127)) (f32.const -0x1.fffffep+127)) +(assert_return (invoke "min" (f32.const -0x1p+0) (f32.const 0x1.fffffep+127)) (f32.const -0x1p+0)) +(assert_return (invoke "min" (f32.const 0x1p+0) (f32.const -0x1.fffffep+127)) (f32.const -0x1.fffffep+127)) +(assert_return (invoke "min" (f32.const 0x1p+0) (f32.const 0x1.fffffep+127)) (f32.const 0x1p+0)) +(assert_return (invoke "min" (f32.const -0x1p+0) (f32.const -inf)) (f32.const -inf)) +(assert_return (invoke "min" (f32.const -0x1p+0) (f32.const inf)) (f32.const -0x1p+0)) +(assert_return (invoke "min" (f32.const 0x1p+0) (f32.const -inf)) (f32.const -inf)) +(assert_return (invoke "min" (f32.const 0x1p+0) (f32.const inf)) (f32.const 0x1p+0)) +(assert_return (invoke "min" (f32.const -0x1p+0) (f32.const -nan)) (f32.const nan:canonical)) +(assert_return (invoke "min" (f32.const -0x1p+0) (f32.const -nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "min" (f32.const -0x1p+0) (f32.const nan)) (f32.const nan:canonical)) +(assert_return (invoke "min" (f32.const -0x1p+0) (f32.const nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "min" (f32.const 0x1p+0) (f32.const -nan)) (f32.const nan:canonical)) +(assert_return (invoke "min" (f32.const 0x1p+0) (f32.const -nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "min" (f32.const 0x1p+0) (f32.const nan)) (f32.const nan:canonical)) +(assert_return (invoke "min" (f32.const 0x1p+0) (f32.const nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "min" (f32.const -0x1.921fb6p+2) (f32.const -0x0p+0)) (f32.const -0x1.921fb6p+2)) +(assert_return (invoke "min" (f32.const -0x1.921fb6p+2) (f32.const 0x0p+0)) (f32.const -0x1.921fb6p+2)) +(assert_return (invoke "min" (f32.const 0x1.921fb6p+2) (f32.const -0x0p+0)) (f32.const -0x0p+0)) +(assert_return (invoke "min" (f32.const 0x1.921fb6p+2) (f32.const 0x0p+0)) (f32.const 0x0p+0)) +(assert_return (invoke "min" (f32.const -0x1.921fb6p+2) (f32.const -0x1p-149)) (f32.const -0x1.921fb6p+2)) +(assert_return (invoke "min" (f32.const -0x1.921fb6p+2) (f32.const 0x1p-149)) (f32.const -0x1.921fb6p+2)) +(assert_return (invoke "min" (f32.const 0x1.921fb6p+2) (f32.const -0x1p-149)) (f32.const -0x1p-149)) +(assert_return (invoke "min" (f32.const 0x1.921fb6p+2) (f32.const 0x1p-149)) (f32.const 0x1p-149)) +(assert_return (invoke "min" (f32.const -0x1.921fb6p+2) (f32.const -0x1p-126)) (f32.const -0x1.921fb6p+2)) +(assert_return (invoke "min" (f32.const -0x1.921fb6p+2) (f32.const 0x1p-126)) (f32.const -0x1.921fb6p+2)) +(assert_return (invoke "min" (f32.const 0x1.921fb6p+2) (f32.const -0x1p-126)) (f32.const -0x1p-126)) +(assert_return (invoke "min" (f32.const 0x1.921fb6p+2) (f32.const 0x1p-126)) (f32.const 0x1p-126)) +(assert_return (invoke "min" (f32.const -0x1.921fb6p+2) (f32.const -0x1p-1)) (f32.const -0x1.921fb6p+2)) +(assert_return (invoke "min" (f32.const -0x1.921fb6p+2) (f32.const 0x1p-1)) (f32.const -0x1.921fb6p+2)) +(assert_return (invoke "min" (f32.const 0x1.921fb6p+2) (f32.const -0x1p-1)) (f32.const -0x1p-1)) +(assert_return (invoke "min" (f32.const 0x1.921fb6p+2) (f32.const 0x1p-1)) (f32.const 0x1p-1)) +(assert_return (invoke "min" (f32.const -0x1.921fb6p+2) (f32.const -0x1p+0)) (f32.const -0x1.921fb6p+2)) +(assert_return (invoke "min" (f32.const -0x1.921fb6p+2) (f32.const 0x1p+0)) (f32.const -0x1.921fb6p+2)) +(assert_return (invoke "min" (f32.const 0x1.921fb6p+2) (f32.const -0x1p+0)) (f32.const -0x1p+0)) +(assert_return (invoke "min" (f32.const 0x1.921fb6p+2) (f32.const 0x1p+0)) (f32.const 0x1p+0)) +(assert_return (invoke "min" (f32.const -0x1.921fb6p+2) (f32.const -0x1.921fb6p+2)) (f32.const -0x1.921fb6p+2)) +(assert_return (invoke "min" (f32.const -0x1.921fb6p+2) (f32.const 0x1.921fb6p+2)) (f32.const -0x1.921fb6p+2)) +(assert_return (invoke "min" (f32.const 0x1.921fb6p+2) (f32.const -0x1.921fb6p+2)) (f32.const -0x1.921fb6p+2)) +(assert_return (invoke "min" (f32.const 0x1.921fb6p+2) (f32.const 0x1.921fb6p+2)) (f32.const 0x1.921fb6p+2)) +(assert_return (invoke "min" (f32.const -0x1.921fb6p+2) (f32.const -0x1.fffffep+127)) (f32.const -0x1.fffffep+127)) +(assert_return (invoke "min" (f32.const -0x1.921fb6p+2) (f32.const 0x1.fffffep+127)) (f32.const -0x1.921fb6p+2)) +(assert_return (invoke "min" (f32.const 0x1.921fb6p+2) (f32.const -0x1.fffffep+127)) (f32.const -0x1.fffffep+127)) +(assert_return (invoke "min" (f32.const 0x1.921fb6p+2) (f32.const 0x1.fffffep+127)) (f32.const 0x1.921fb6p+2)) +(assert_return (invoke "min" (f32.const -0x1.921fb6p+2) (f32.const -inf)) (f32.const -inf)) +(assert_return (invoke "min" (f32.const -0x1.921fb6p+2) (f32.const inf)) (f32.const -0x1.921fb6p+2)) +(assert_return (invoke "min" (f32.const 0x1.921fb6p+2) (f32.const -inf)) (f32.const -inf)) +(assert_return (invoke "min" (f32.const 0x1.921fb6p+2) (f32.const inf)) (f32.const 0x1.921fb6p+2)) +(assert_return (invoke "min" (f32.const -0x1.921fb6p+2) (f32.const -nan)) (f32.const nan:canonical)) +(assert_return (invoke "min" (f32.const -0x1.921fb6p+2) (f32.const -nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "min" (f32.const -0x1.921fb6p+2) (f32.const nan)) (f32.const nan:canonical)) +(assert_return (invoke "min" (f32.const -0x1.921fb6p+2) (f32.const nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "min" (f32.const 0x1.921fb6p+2) (f32.const -nan)) (f32.const nan:canonical)) +(assert_return (invoke "min" (f32.const 0x1.921fb6p+2) (f32.const -nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "min" (f32.const 0x1.921fb6p+2) (f32.const nan)) (f32.const nan:canonical)) +(assert_return (invoke "min" (f32.const 0x1.921fb6p+2) (f32.const nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "min" (f32.const -0x1.fffffep+127) (f32.const -0x0p+0)) (f32.const -0x1.fffffep+127)) +(assert_return (invoke "min" (f32.const -0x1.fffffep+127) (f32.const 0x0p+0)) (f32.const -0x1.fffffep+127)) +(assert_return (invoke "min" (f32.const 0x1.fffffep+127) (f32.const -0x0p+0)) (f32.const -0x0p+0)) +(assert_return (invoke "min" (f32.const 0x1.fffffep+127) (f32.const 0x0p+0)) (f32.const 0x0p+0)) +(assert_return (invoke "min" (f32.const -0x1.fffffep+127) (f32.const -0x1p-149)) (f32.const -0x1.fffffep+127)) +(assert_return (invoke "min" (f32.const -0x1.fffffep+127) (f32.const 0x1p-149)) (f32.const -0x1.fffffep+127)) +(assert_return (invoke "min" (f32.const 0x1.fffffep+127) (f32.const -0x1p-149)) (f32.const -0x1p-149)) +(assert_return (invoke "min" (f32.const 0x1.fffffep+127) (f32.const 0x1p-149)) (f32.const 0x1p-149)) +(assert_return (invoke "min" (f32.const -0x1.fffffep+127) (f32.const -0x1p-126)) (f32.const -0x1.fffffep+127)) +(assert_return (invoke "min" (f32.const -0x1.fffffep+127) (f32.const 0x1p-126)) (f32.const -0x1.fffffep+127)) +(assert_return (invoke "min" (f32.const 0x1.fffffep+127) (f32.const -0x1p-126)) (f32.const -0x1p-126)) +(assert_return (invoke "min" (f32.const 0x1.fffffep+127) (f32.const 0x1p-126)) (f32.const 0x1p-126)) +(assert_return (invoke "min" (f32.const -0x1.fffffep+127) (f32.const -0x1p-1)) (f32.const -0x1.fffffep+127)) +(assert_return (invoke "min" (f32.const -0x1.fffffep+127) (f32.const 0x1p-1)) (f32.const -0x1.fffffep+127)) +(assert_return (invoke "min" (f32.const 0x1.fffffep+127) (f32.const -0x1p-1)) (f32.const -0x1p-1)) +(assert_return (invoke "min" (f32.const 0x1.fffffep+127) (f32.const 0x1p-1)) (f32.const 0x1p-1)) +(assert_return (invoke "min" (f32.const -0x1.fffffep+127) (f32.const -0x1p+0)) (f32.const -0x1.fffffep+127)) +(assert_return (invoke "min" (f32.const -0x1.fffffep+127) (f32.const 0x1p+0)) (f32.const -0x1.fffffep+127)) +(assert_return (invoke "min" (f32.const 0x1.fffffep+127) (f32.const -0x1p+0)) (f32.const -0x1p+0)) +(assert_return (invoke "min" (f32.const 0x1.fffffep+127) (f32.const 0x1p+0)) (f32.const 0x1p+0)) +(assert_return (invoke "min" (f32.const -0x1.fffffep+127) (f32.const -0x1.921fb6p+2)) (f32.const -0x1.fffffep+127)) +(assert_return (invoke "min" (f32.const -0x1.fffffep+127) (f32.const 0x1.921fb6p+2)) (f32.const -0x1.fffffep+127)) +(assert_return (invoke "min" (f32.const 0x1.fffffep+127) (f32.const -0x1.921fb6p+2)) (f32.const -0x1.921fb6p+2)) +(assert_return (invoke "min" (f32.const 0x1.fffffep+127) (f32.const 0x1.921fb6p+2)) (f32.const 0x1.921fb6p+2)) +(assert_return (invoke "min" (f32.const -0x1.fffffep+127) (f32.const -0x1.fffffep+127)) (f32.const -0x1.fffffep+127)) +(assert_return (invoke "min" (f32.const -0x1.fffffep+127) (f32.const 0x1.fffffep+127)) (f32.const -0x1.fffffep+127)) +(assert_return (invoke "min" (f32.const 0x1.fffffep+127) (f32.const -0x1.fffffep+127)) (f32.const -0x1.fffffep+127)) +(assert_return (invoke "min" (f32.const 0x1.fffffep+127) (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127)) +(assert_return (invoke "min" (f32.const -0x1.fffffep+127) (f32.const -inf)) (f32.const -inf)) +(assert_return (invoke "min" (f32.const -0x1.fffffep+127) (f32.const inf)) (f32.const -0x1.fffffep+127)) +(assert_return (invoke "min" (f32.const 0x1.fffffep+127) (f32.const -inf)) (f32.const -inf)) +(assert_return (invoke "min" (f32.const 0x1.fffffep+127) (f32.const inf)) (f32.const 0x1.fffffep+127)) +(assert_return (invoke "min" (f32.const -0x1.fffffep+127) (f32.const -nan)) (f32.const nan:canonical)) +(assert_return (invoke "min" (f32.const -0x1.fffffep+127) (f32.const -nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "min" (f32.const -0x1.fffffep+127) (f32.const nan)) (f32.const nan:canonical)) +(assert_return (invoke "min" (f32.const -0x1.fffffep+127) (f32.const nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "min" (f32.const 0x1.fffffep+127) (f32.const -nan)) (f32.const nan:canonical)) +(assert_return (invoke "min" (f32.const 0x1.fffffep+127) (f32.const -nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "min" (f32.const 0x1.fffffep+127) (f32.const nan)) (f32.const nan:canonical)) +(assert_return (invoke "min" (f32.const 0x1.fffffep+127) (f32.const nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "min" (f32.const -inf) (f32.const -0x0p+0)) (f32.const -inf)) +(assert_return (invoke "min" (f32.const -inf) (f32.const 0x0p+0)) (f32.const -inf)) +(assert_return (invoke "min" (f32.const inf) (f32.const -0x0p+0)) (f32.const -0x0p+0)) +(assert_return (invoke "min" (f32.const inf) (f32.const 0x0p+0)) (f32.const 0x0p+0)) +(assert_return (invoke "min" (f32.const -inf) (f32.const -0x1p-149)) (f32.const -inf)) +(assert_return (invoke "min" (f32.const -inf) (f32.const 0x1p-149)) (f32.const -inf)) +(assert_return (invoke "min" (f32.const inf) (f32.const -0x1p-149)) (f32.const -0x1p-149)) +(assert_return (invoke "min" (f32.const inf) (f32.const 0x1p-149)) (f32.const 0x1p-149)) +(assert_return (invoke "min" (f32.const -inf) (f32.const -0x1p-126)) (f32.const -inf)) +(assert_return (invoke "min" (f32.const -inf) (f32.const 0x1p-126)) (f32.const -inf)) +(assert_return (invoke "min" (f32.const inf) (f32.const -0x1p-126)) (f32.const -0x1p-126)) +(assert_return (invoke "min" (f32.const inf) (f32.const 0x1p-126)) (f32.const 0x1p-126)) +(assert_return (invoke "min" (f32.const -inf) (f32.const -0x1p-1)) (f32.const -inf)) +(assert_return (invoke "min" (f32.const -inf) (f32.const 0x1p-1)) (f32.const -inf)) +(assert_return (invoke "min" (f32.const inf) (f32.const -0x1p-1)) (f32.const -0x1p-1)) +(assert_return (invoke "min" (f32.const inf) (f32.const 0x1p-1)) (f32.const 0x1p-1)) +(assert_return (invoke "min" (f32.const -inf) (f32.const -0x1p+0)) (f32.const -inf)) +(assert_return (invoke "min" (f32.const -inf) (f32.const 0x1p+0)) (f32.const -inf)) +(assert_return (invoke "min" (f32.const inf) (f32.const -0x1p+0)) (f32.const -0x1p+0)) +(assert_return (invoke "min" (f32.const inf) (f32.const 0x1p+0)) (f32.const 0x1p+0)) +(assert_return (invoke "min" (f32.const -inf) (f32.const -0x1.921fb6p+2)) (f32.const -inf)) +(assert_return (invoke "min" (f32.const -inf) (f32.const 0x1.921fb6p+2)) (f32.const -inf)) +(assert_return (invoke "min" (f32.const inf) (f32.const -0x1.921fb6p+2)) (f32.const -0x1.921fb6p+2)) +(assert_return (invoke "min" (f32.const inf) (f32.const 0x1.921fb6p+2)) (f32.const 0x1.921fb6p+2)) +(assert_return (invoke "min" (f32.const -inf) (f32.const -0x1.fffffep+127)) (f32.const -inf)) +(assert_return (invoke "min" (f32.const -inf) (f32.const 0x1.fffffep+127)) (f32.const -inf)) +(assert_return (invoke "min" (f32.const inf) (f32.const -0x1.fffffep+127)) (f32.const -0x1.fffffep+127)) +(assert_return (invoke "min" (f32.const inf) (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127)) +(assert_return (invoke "min" (f32.const -inf) (f32.const -inf)) (f32.const -inf)) +(assert_return (invoke "min" (f32.const -inf) (f32.const inf)) (f32.const -inf)) +(assert_return (invoke "min" (f32.const inf) (f32.const -inf)) (f32.const -inf)) +(assert_return (invoke "min" (f32.const inf) (f32.const inf)) (f32.const inf)) +(assert_return (invoke "min" (f32.const -inf) (f32.const -nan)) (f32.const nan:canonical)) +(assert_return (invoke "min" (f32.const -inf) (f32.const -nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "min" (f32.const -inf) (f32.const nan)) (f32.const nan:canonical)) +(assert_return (invoke "min" (f32.const -inf) (f32.const nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "min" (f32.const inf) (f32.const -nan)) (f32.const nan:canonical)) +(assert_return (invoke "min" (f32.const inf) (f32.const -nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "min" (f32.const inf) (f32.const nan)) (f32.const nan:canonical)) +(assert_return (invoke "min" (f32.const inf) (f32.const nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "min" (f32.const -nan) (f32.const -0x0p+0)) (f32.const nan:canonical)) +(assert_return (invoke "min" (f32.const -nan:0x200000) (f32.const -0x0p+0)) (f32.const nan:arithmetic)) +(assert_return (invoke "min" (f32.const -nan) (f32.const 0x0p+0)) (f32.const nan:canonical)) +(assert_return (invoke "min" (f32.const -nan:0x200000) (f32.const 0x0p+0)) (f32.const nan:arithmetic)) +(assert_return (invoke "min" (f32.const nan) (f32.const -0x0p+0)) (f32.const nan:canonical)) +(assert_return (invoke "min" (f32.const nan:0x200000) (f32.const -0x0p+0)) (f32.const nan:arithmetic)) +(assert_return (invoke "min" (f32.const nan) (f32.const 0x0p+0)) (f32.const nan:canonical)) +(assert_return (invoke "min" (f32.const nan:0x200000) (f32.const 0x0p+0)) (f32.const nan:arithmetic)) +(assert_return (invoke "min" (f32.const -nan) (f32.const -0x1p-149)) (f32.const nan:canonical)) +(assert_return (invoke "min" (f32.const -nan:0x200000) (f32.const -0x1p-149)) (f32.const nan:arithmetic)) +(assert_return (invoke "min" (f32.const -nan) (f32.const 0x1p-149)) (f32.const nan:canonical)) +(assert_return (invoke "min" (f32.const -nan:0x200000) (f32.const 0x1p-149)) (f32.const nan:arithmetic)) +(assert_return (invoke "min" (f32.const nan) (f32.const -0x1p-149)) (f32.const nan:canonical)) +(assert_return (invoke "min" (f32.const nan:0x200000) (f32.const -0x1p-149)) (f32.const nan:arithmetic)) +(assert_return (invoke "min" (f32.const nan) (f32.const 0x1p-149)) (f32.const nan:canonical)) +(assert_return (invoke "min" (f32.const nan:0x200000) (f32.const 0x1p-149)) (f32.const nan:arithmetic)) +(assert_return (invoke "min" (f32.const -nan) (f32.const -0x1p-126)) (f32.const nan:canonical)) +(assert_return (invoke "min" (f32.const -nan:0x200000) (f32.const -0x1p-126)) (f32.const nan:arithmetic)) +(assert_return (invoke "min" (f32.const -nan) (f32.const 0x1p-126)) (f32.const nan:canonical)) +(assert_return (invoke "min" (f32.const -nan:0x200000) (f32.const 0x1p-126)) (f32.const nan:arithmetic)) +(assert_return (invoke "min" (f32.const nan) (f32.const -0x1p-126)) (f32.const nan:canonical)) +(assert_return (invoke "min" (f32.const nan:0x200000) (f32.const -0x1p-126)) (f32.const nan:arithmetic)) +(assert_return (invoke "min" (f32.const nan) (f32.const 0x1p-126)) (f32.const nan:canonical)) +(assert_return (invoke "min" (f32.const nan:0x200000) (f32.const 0x1p-126)) (f32.const nan:arithmetic)) +(assert_return (invoke "min" (f32.const -nan) (f32.const -0x1p-1)) (f32.const nan:canonical)) +(assert_return (invoke "min" (f32.const -nan:0x200000) (f32.const -0x1p-1)) (f32.const nan:arithmetic)) +(assert_return (invoke "min" (f32.const -nan) (f32.const 0x1p-1)) (f32.const nan:canonical)) +(assert_return (invoke "min" (f32.const -nan:0x200000) (f32.const 0x1p-1)) (f32.const nan:arithmetic)) +(assert_return (invoke "min" (f32.const nan) (f32.const -0x1p-1)) (f32.const nan:canonical)) +(assert_return (invoke "min" (f32.const nan:0x200000) (f32.const -0x1p-1)) (f32.const nan:arithmetic)) +(assert_return (invoke "min" (f32.const nan) (f32.const 0x1p-1)) (f32.const nan:canonical)) +(assert_return (invoke "min" (f32.const nan:0x200000) (f32.const 0x1p-1)) (f32.const nan:arithmetic)) +(assert_return (invoke "min" (f32.const -nan) (f32.const -0x1p+0)) (f32.const nan:canonical)) +(assert_return (invoke "min" (f32.const -nan:0x200000) (f32.const -0x1p+0)) (f32.const nan:arithmetic)) +(assert_return (invoke "min" (f32.const -nan) (f32.const 0x1p+0)) (f32.const nan:canonical)) +(assert_return (invoke "min" (f32.const -nan:0x200000) (f32.const 0x1p+0)) (f32.const nan:arithmetic)) +(assert_return (invoke "min" (f32.const nan) (f32.const -0x1p+0)) (f32.const nan:canonical)) +(assert_return (invoke "min" (f32.const nan:0x200000) (f32.const -0x1p+0)) (f32.const nan:arithmetic)) +(assert_return (invoke "min" (f32.const nan) (f32.const 0x1p+0)) (f32.const nan:canonical)) +(assert_return (invoke "min" (f32.const nan:0x200000) (f32.const 0x1p+0)) (f32.const nan:arithmetic)) +(assert_return (invoke "min" (f32.const -nan) (f32.const -0x1.921fb6p+2)) (f32.const nan:canonical)) +(assert_return (invoke "min" (f32.const -nan:0x200000) (f32.const -0x1.921fb6p+2)) (f32.const nan:arithmetic)) +(assert_return (invoke "min" (f32.const -nan) (f32.const 0x1.921fb6p+2)) (f32.const nan:canonical)) +(assert_return (invoke "min" (f32.const -nan:0x200000) (f32.const 0x1.921fb6p+2)) (f32.const nan:arithmetic)) +(assert_return (invoke "min" (f32.const nan) (f32.const -0x1.921fb6p+2)) (f32.const nan:canonical)) +(assert_return (invoke "min" (f32.const nan:0x200000) (f32.const -0x1.921fb6p+2)) (f32.const nan:arithmetic)) +(assert_return (invoke "min" (f32.const nan) (f32.const 0x1.921fb6p+2)) (f32.const nan:canonical)) +(assert_return (invoke "min" (f32.const nan:0x200000) (f32.const 0x1.921fb6p+2)) (f32.const nan:arithmetic)) +(assert_return (invoke "min" (f32.const -nan) (f32.const -0x1.fffffep+127)) (f32.const nan:canonical)) +(assert_return (invoke "min" (f32.const -nan:0x200000) (f32.const -0x1.fffffep+127)) (f32.const nan:arithmetic)) +(assert_return (invoke "min" (f32.const -nan) (f32.const 0x1.fffffep+127)) (f32.const nan:canonical)) +(assert_return (invoke "min" (f32.const -nan:0x200000) (f32.const 0x1.fffffep+127)) (f32.const nan:arithmetic)) +(assert_return (invoke "min" (f32.const nan) (f32.const -0x1.fffffep+127)) (f32.const nan:canonical)) +(assert_return (invoke "min" (f32.const nan:0x200000) (f32.const -0x1.fffffep+127)) (f32.const nan:arithmetic)) +(assert_return (invoke "min" (f32.const nan) (f32.const 0x1.fffffep+127)) (f32.const nan:canonical)) +(assert_return (invoke "min" (f32.const nan:0x200000) (f32.const 0x1.fffffep+127)) (f32.const nan:arithmetic)) +(assert_return (invoke "min" (f32.const -nan) (f32.const -inf)) (f32.const nan:canonical)) +(assert_return (invoke "min" (f32.const -nan:0x200000) (f32.const -inf)) (f32.const nan:arithmetic)) +(assert_return (invoke "min" (f32.const -nan) (f32.const inf)) (f32.const nan:canonical)) +(assert_return (invoke "min" (f32.const -nan:0x200000) (f32.const inf)) (f32.const nan:arithmetic)) +(assert_return (invoke "min" (f32.const nan) (f32.const -inf)) (f32.const nan:canonical)) +(assert_return (invoke "min" (f32.const nan:0x200000) (f32.const -inf)) (f32.const nan:arithmetic)) +(assert_return (invoke "min" (f32.const nan) (f32.const inf)) (f32.const nan:canonical)) +(assert_return (invoke "min" (f32.const nan:0x200000) (f32.const inf)) (f32.const nan:arithmetic)) +(assert_return (invoke "min" (f32.const -nan) (f32.const -nan)) (f32.const nan:canonical)) +(assert_return (invoke "min" (f32.const -nan:0x200000) (f32.const -nan)) (f32.const nan:arithmetic)) +(assert_return (invoke "min" (f32.const -nan) (f32.const -nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "min" (f32.const -nan:0x200000) (f32.const -nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "min" (f32.const -nan) (f32.const nan)) (f32.const nan:canonical)) +(assert_return (invoke "min" (f32.const -nan:0x200000) (f32.const nan)) (f32.const nan:arithmetic)) +(assert_return (invoke "min" (f32.const -nan) (f32.const nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "min" (f32.const -nan:0x200000) (f32.const nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "min" (f32.const nan) (f32.const -nan)) (f32.const nan:canonical)) +(assert_return (invoke "min" (f32.const nan:0x200000) (f32.const -nan)) (f32.const nan:arithmetic)) +(assert_return (invoke "min" (f32.const nan) (f32.const -nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "min" (f32.const nan:0x200000) (f32.const -nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "min" (f32.const nan) (f32.const nan)) (f32.const nan:canonical)) +(assert_return (invoke "min" (f32.const nan:0x200000) (f32.const nan)) (f32.const nan:arithmetic)) +(assert_return (invoke "min" (f32.const nan) (f32.const nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "min" (f32.const nan:0x200000) (f32.const nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "max" (f32.const -0x0p+0) (f32.const -0x0p+0)) (f32.const -0x0p+0)) +(assert_return (invoke "max" (f32.const -0x0p+0) (f32.const 0x0p+0)) (f32.const 0x0p+0)) +(assert_return (invoke "max" (f32.const 0x0p+0) (f32.const -0x0p+0)) (f32.const 0x0p+0)) +(assert_return (invoke "max" (f32.const 0x0p+0) (f32.const 0x0p+0)) (f32.const 0x0p+0)) +(assert_return (invoke "max" (f32.const -0x0p+0) (f32.const -0x1p-149)) (f32.const -0x0p+0)) +(assert_return (invoke "max" (f32.const -0x0p+0) (f32.const 0x1p-149)) (f32.const 0x1p-149)) +(assert_return (invoke "max" (f32.const 0x0p+0) (f32.const -0x1p-149)) (f32.const 0x0p+0)) +(assert_return (invoke "max" (f32.const 0x0p+0) (f32.const 0x1p-149)) (f32.const 0x1p-149)) +(assert_return (invoke "max" (f32.const -0x0p+0) (f32.const -0x1p-126)) (f32.const -0x0p+0)) +(assert_return (invoke "max" (f32.const -0x0p+0) (f32.const 0x1p-126)) (f32.const 0x1p-126)) +(assert_return (invoke "max" (f32.const 0x0p+0) (f32.const -0x1p-126)) (f32.const 0x0p+0)) +(assert_return (invoke "max" (f32.const 0x0p+0) (f32.const 0x1p-126)) (f32.const 0x1p-126)) +(assert_return (invoke "max" (f32.const -0x0p+0) (f32.const -0x1p-1)) (f32.const -0x0p+0)) +(assert_return (invoke "max" (f32.const -0x0p+0) (f32.const 0x1p-1)) (f32.const 0x1p-1)) +(assert_return (invoke "max" (f32.const 0x0p+0) (f32.const -0x1p-1)) (f32.const 0x0p+0)) +(assert_return (invoke "max" (f32.const 0x0p+0) (f32.const 0x1p-1)) (f32.const 0x1p-1)) +(assert_return (invoke "max" (f32.const -0x0p+0) (f32.const -0x1p+0)) (f32.const -0x0p+0)) +(assert_return (invoke "max" (f32.const -0x0p+0) (f32.const 0x1p+0)) (f32.const 0x1p+0)) +(assert_return (invoke "max" (f32.const 0x0p+0) (f32.const -0x1p+0)) (f32.const 0x0p+0)) +(assert_return (invoke "max" (f32.const 0x0p+0) (f32.const 0x1p+0)) (f32.const 0x1p+0)) +(assert_return (invoke "max" (f32.const -0x0p+0) (f32.const -0x1.921fb6p+2)) (f32.const -0x0p+0)) +(assert_return (invoke "max" (f32.const -0x0p+0) (f32.const 0x1.921fb6p+2)) (f32.const 0x1.921fb6p+2)) +(assert_return (invoke "max" (f32.const 0x0p+0) (f32.const -0x1.921fb6p+2)) (f32.const 0x0p+0)) +(assert_return (invoke "max" (f32.const 0x0p+0) (f32.const 0x1.921fb6p+2)) (f32.const 0x1.921fb6p+2)) +(assert_return (invoke "max" (f32.const -0x0p+0) (f32.const -0x1.fffffep+127)) (f32.const -0x0p+0)) +(assert_return (invoke "max" (f32.const -0x0p+0) (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127)) +(assert_return (invoke "max" (f32.const 0x0p+0) (f32.const -0x1.fffffep+127)) (f32.const 0x0p+0)) +(assert_return (invoke "max" (f32.const 0x0p+0) (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127)) +(assert_return (invoke "max" (f32.const -0x0p+0) (f32.const -inf)) (f32.const -0x0p+0)) +(assert_return (invoke "max" (f32.const -0x0p+0) (f32.const inf)) (f32.const inf)) +(assert_return (invoke "max" (f32.const 0x0p+0) (f32.const -inf)) (f32.const 0x0p+0)) +(assert_return (invoke "max" (f32.const 0x0p+0) (f32.const inf)) (f32.const inf)) +(assert_return (invoke "max" (f32.const -0x0p+0) (f32.const -nan)) (f32.const nan:canonical)) +(assert_return (invoke "max" (f32.const -0x0p+0) (f32.const -nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "max" (f32.const -0x0p+0) (f32.const nan)) (f32.const nan:canonical)) +(assert_return (invoke "max" (f32.const -0x0p+0) (f32.const nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "max" (f32.const 0x0p+0) (f32.const -nan)) (f32.const nan:canonical)) +(assert_return (invoke "max" (f32.const 0x0p+0) (f32.const -nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "max" (f32.const 0x0p+0) (f32.const nan)) (f32.const nan:canonical)) +(assert_return (invoke "max" (f32.const 0x0p+0) (f32.const nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "max" (f32.const -0x1p-149) (f32.const -0x0p+0)) (f32.const -0x0p+0)) +(assert_return (invoke "max" (f32.const -0x1p-149) (f32.const 0x0p+0)) (f32.const 0x0p+0)) +(assert_return (invoke "max" (f32.const 0x1p-149) (f32.const -0x0p+0)) (f32.const 0x1p-149)) +(assert_return (invoke "max" (f32.const 0x1p-149) (f32.const 0x0p+0)) (f32.const 0x1p-149)) +(assert_return (invoke "max" (f32.const -0x1p-149) (f32.const -0x1p-149)) (f32.const -0x1p-149)) +(assert_return (invoke "max" (f32.const -0x1p-149) (f32.const 0x1p-149)) (f32.const 0x1p-149)) +(assert_return (invoke "max" (f32.const 0x1p-149) (f32.const -0x1p-149)) (f32.const 0x1p-149)) +(assert_return (invoke "max" (f32.const 0x1p-149) (f32.const 0x1p-149)) (f32.const 0x1p-149)) +(assert_return (invoke "max" (f32.const -0x1p-149) (f32.const -0x1p-126)) (f32.const -0x1p-149)) +(assert_return (invoke "max" (f32.const -0x1p-149) (f32.const 0x1p-126)) (f32.const 0x1p-126)) +(assert_return (invoke "max" (f32.const 0x1p-149) (f32.const -0x1p-126)) (f32.const 0x1p-149)) +(assert_return (invoke "max" (f32.const 0x1p-149) (f32.const 0x1p-126)) (f32.const 0x1p-126)) +(assert_return (invoke "max" (f32.const -0x1p-149) (f32.const -0x1p-1)) (f32.const -0x1p-149)) +(assert_return (invoke "max" (f32.const -0x1p-149) (f32.const 0x1p-1)) (f32.const 0x1p-1)) +(assert_return (invoke "max" (f32.const 0x1p-149) (f32.const -0x1p-1)) (f32.const 0x1p-149)) +(assert_return (invoke "max" (f32.const 0x1p-149) (f32.const 0x1p-1)) (f32.const 0x1p-1)) +(assert_return (invoke "max" (f32.const -0x1p-149) (f32.const -0x1p+0)) (f32.const -0x1p-149)) +(assert_return (invoke "max" (f32.const -0x1p-149) (f32.const 0x1p+0)) (f32.const 0x1p+0)) +(assert_return (invoke "max" (f32.const 0x1p-149) (f32.const -0x1p+0)) (f32.const 0x1p-149)) +(assert_return (invoke "max" (f32.const 0x1p-149) (f32.const 0x1p+0)) (f32.const 0x1p+0)) +(assert_return (invoke "max" (f32.const -0x1p-149) (f32.const -0x1.921fb6p+2)) (f32.const -0x1p-149)) +(assert_return (invoke "max" (f32.const -0x1p-149) (f32.const 0x1.921fb6p+2)) (f32.const 0x1.921fb6p+2)) +(assert_return (invoke "max" (f32.const 0x1p-149) (f32.const -0x1.921fb6p+2)) (f32.const 0x1p-149)) +(assert_return (invoke "max" (f32.const 0x1p-149) (f32.const 0x1.921fb6p+2)) (f32.const 0x1.921fb6p+2)) +(assert_return (invoke "max" (f32.const -0x1p-149) (f32.const -0x1.fffffep+127)) (f32.const -0x1p-149)) +(assert_return (invoke "max" (f32.const -0x1p-149) (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127)) +(assert_return (invoke "max" (f32.const 0x1p-149) (f32.const -0x1.fffffep+127)) (f32.const 0x1p-149)) +(assert_return (invoke "max" (f32.const 0x1p-149) (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127)) +(assert_return (invoke "max" (f32.const -0x1p-149) (f32.const -inf)) (f32.const -0x1p-149)) +(assert_return (invoke "max" (f32.const -0x1p-149) (f32.const inf)) (f32.const inf)) +(assert_return (invoke "max" (f32.const 0x1p-149) (f32.const -inf)) (f32.const 0x1p-149)) +(assert_return (invoke "max" (f32.const 0x1p-149) (f32.const inf)) (f32.const inf)) +(assert_return (invoke "max" (f32.const -0x1p-149) (f32.const -nan)) (f32.const nan:canonical)) +(assert_return (invoke "max" (f32.const -0x1p-149) (f32.const -nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "max" (f32.const -0x1p-149) (f32.const nan)) (f32.const nan:canonical)) +(assert_return (invoke "max" (f32.const -0x1p-149) (f32.const nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "max" (f32.const 0x1p-149) (f32.const -nan)) (f32.const nan:canonical)) +(assert_return (invoke "max" (f32.const 0x1p-149) (f32.const -nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "max" (f32.const 0x1p-149) (f32.const nan)) (f32.const nan:canonical)) +(assert_return (invoke "max" (f32.const 0x1p-149) (f32.const nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "max" (f32.const -0x1p-126) (f32.const -0x0p+0)) (f32.const -0x0p+0)) +(assert_return (invoke "max" (f32.const -0x1p-126) (f32.const 0x0p+0)) (f32.const 0x0p+0)) +(assert_return (invoke "max" (f32.const 0x1p-126) (f32.const -0x0p+0)) (f32.const 0x1p-126)) +(assert_return (invoke "max" (f32.const 0x1p-126) (f32.const 0x0p+0)) (f32.const 0x1p-126)) +(assert_return (invoke "max" (f32.const -0x1p-126) (f32.const -0x1p-149)) (f32.const -0x1p-149)) +(assert_return (invoke "max" (f32.const -0x1p-126) (f32.const 0x1p-149)) (f32.const 0x1p-149)) +(assert_return (invoke "max" (f32.const 0x1p-126) (f32.const -0x1p-149)) (f32.const 0x1p-126)) +(assert_return (invoke "max" (f32.const 0x1p-126) (f32.const 0x1p-149)) (f32.const 0x1p-126)) +(assert_return (invoke "max" (f32.const -0x1p-126) (f32.const -0x1p-126)) (f32.const -0x1p-126)) +(assert_return (invoke "max" (f32.const -0x1p-126) (f32.const 0x1p-126)) (f32.const 0x1p-126)) +(assert_return (invoke "max" (f32.const 0x1p-126) (f32.const -0x1p-126)) (f32.const 0x1p-126)) +(assert_return (invoke "max" (f32.const 0x1p-126) (f32.const 0x1p-126)) (f32.const 0x1p-126)) +(assert_return (invoke "max" (f32.const -0x1p-126) (f32.const -0x1p-1)) (f32.const -0x1p-126)) +(assert_return (invoke "max" (f32.const -0x1p-126) (f32.const 0x1p-1)) (f32.const 0x1p-1)) +(assert_return (invoke "max" (f32.const 0x1p-126) (f32.const -0x1p-1)) (f32.const 0x1p-126)) +(assert_return (invoke "max" (f32.const 0x1p-126) (f32.const 0x1p-1)) (f32.const 0x1p-1)) +(assert_return (invoke "max" (f32.const -0x1p-126) (f32.const -0x1p+0)) (f32.const -0x1p-126)) +(assert_return (invoke "max" (f32.const -0x1p-126) (f32.const 0x1p+0)) (f32.const 0x1p+0)) +(assert_return (invoke "max" (f32.const 0x1p-126) (f32.const -0x1p+0)) (f32.const 0x1p-126)) +(assert_return (invoke "max" (f32.const 0x1p-126) (f32.const 0x1p+0)) (f32.const 0x1p+0)) +(assert_return (invoke "max" (f32.const -0x1p-126) (f32.const -0x1.921fb6p+2)) (f32.const -0x1p-126)) +(assert_return (invoke "max" (f32.const -0x1p-126) (f32.const 0x1.921fb6p+2)) (f32.const 0x1.921fb6p+2)) +(assert_return (invoke "max" (f32.const 0x1p-126) (f32.const -0x1.921fb6p+2)) (f32.const 0x1p-126)) +(assert_return (invoke "max" (f32.const 0x1p-126) (f32.const 0x1.921fb6p+2)) (f32.const 0x1.921fb6p+2)) +(assert_return (invoke "max" (f32.const -0x1p-126) (f32.const -0x1.fffffep+127)) (f32.const -0x1p-126)) +(assert_return (invoke "max" (f32.const -0x1p-126) (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127)) +(assert_return (invoke "max" (f32.const 0x1p-126) (f32.const -0x1.fffffep+127)) (f32.const 0x1p-126)) +(assert_return (invoke "max" (f32.const 0x1p-126) (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127)) +(assert_return (invoke "max" (f32.const -0x1p-126) (f32.const -inf)) (f32.const -0x1p-126)) +(assert_return (invoke "max" (f32.const -0x1p-126) (f32.const inf)) (f32.const inf)) +(assert_return (invoke "max" (f32.const 0x1p-126) (f32.const -inf)) (f32.const 0x1p-126)) +(assert_return (invoke "max" (f32.const 0x1p-126) (f32.const inf)) (f32.const inf)) +(assert_return (invoke "max" (f32.const -0x1p-126) (f32.const -nan)) (f32.const nan:canonical)) +(assert_return (invoke "max" (f32.const -0x1p-126) (f32.const -nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "max" (f32.const -0x1p-126) (f32.const nan)) (f32.const nan:canonical)) +(assert_return (invoke "max" (f32.const -0x1p-126) (f32.const nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "max" (f32.const 0x1p-126) (f32.const -nan)) (f32.const nan:canonical)) +(assert_return (invoke "max" (f32.const 0x1p-126) (f32.const -nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "max" (f32.const 0x1p-126) (f32.const nan)) (f32.const nan:canonical)) +(assert_return (invoke "max" (f32.const 0x1p-126) (f32.const nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "max" (f32.const -0x1p-1) (f32.const -0x0p+0)) (f32.const -0x0p+0)) +(assert_return (invoke "max" (f32.const -0x1p-1) (f32.const 0x0p+0)) (f32.const 0x0p+0)) +(assert_return (invoke "max" (f32.const 0x1p-1) (f32.const -0x0p+0)) (f32.const 0x1p-1)) +(assert_return (invoke "max" (f32.const 0x1p-1) (f32.const 0x0p+0)) (f32.const 0x1p-1)) +(assert_return (invoke "max" (f32.const -0x1p-1) (f32.const -0x1p-149)) (f32.const -0x1p-149)) +(assert_return (invoke "max" (f32.const -0x1p-1) (f32.const 0x1p-149)) (f32.const 0x1p-149)) +(assert_return (invoke "max" (f32.const 0x1p-1) (f32.const -0x1p-149)) (f32.const 0x1p-1)) +(assert_return (invoke "max" (f32.const 0x1p-1) (f32.const 0x1p-149)) (f32.const 0x1p-1)) +(assert_return (invoke "max" (f32.const -0x1p-1) (f32.const -0x1p-126)) (f32.const -0x1p-126)) +(assert_return (invoke "max" (f32.const -0x1p-1) (f32.const 0x1p-126)) (f32.const 0x1p-126)) +(assert_return (invoke "max" (f32.const 0x1p-1) (f32.const -0x1p-126)) (f32.const 0x1p-1)) +(assert_return (invoke "max" (f32.const 0x1p-1) (f32.const 0x1p-126)) (f32.const 0x1p-1)) +(assert_return (invoke "max" (f32.const -0x1p-1) (f32.const -0x1p-1)) (f32.const -0x1p-1)) +(assert_return (invoke "max" (f32.const -0x1p-1) (f32.const 0x1p-1)) (f32.const 0x1p-1)) +(assert_return (invoke "max" (f32.const 0x1p-1) (f32.const -0x1p-1)) (f32.const 0x1p-1)) +(assert_return (invoke "max" (f32.const 0x1p-1) (f32.const 0x1p-1)) (f32.const 0x1p-1)) +(assert_return (invoke "max" (f32.const -0x1p-1) (f32.const -0x1p+0)) (f32.const -0x1p-1)) +(assert_return (invoke "max" (f32.const -0x1p-1) (f32.const 0x1p+0)) (f32.const 0x1p+0)) +(assert_return (invoke "max" (f32.const 0x1p-1) (f32.const -0x1p+0)) (f32.const 0x1p-1)) +(assert_return (invoke "max" (f32.const 0x1p-1) (f32.const 0x1p+0)) (f32.const 0x1p+0)) +(assert_return (invoke "max" (f32.const -0x1p-1) (f32.const -0x1.921fb6p+2)) (f32.const -0x1p-1)) +(assert_return (invoke "max" (f32.const -0x1p-1) (f32.const 0x1.921fb6p+2)) (f32.const 0x1.921fb6p+2)) +(assert_return (invoke "max" (f32.const 0x1p-1) (f32.const -0x1.921fb6p+2)) (f32.const 0x1p-1)) +(assert_return (invoke "max" (f32.const 0x1p-1) (f32.const 0x1.921fb6p+2)) (f32.const 0x1.921fb6p+2)) +(assert_return (invoke "max" (f32.const -0x1p-1) (f32.const -0x1.fffffep+127)) (f32.const -0x1p-1)) +(assert_return (invoke "max" (f32.const -0x1p-1) (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127)) +(assert_return (invoke "max" (f32.const 0x1p-1) (f32.const -0x1.fffffep+127)) (f32.const 0x1p-1)) +(assert_return (invoke "max" (f32.const 0x1p-1) (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127)) +(assert_return (invoke "max" (f32.const -0x1p-1) (f32.const -inf)) (f32.const -0x1p-1)) +(assert_return (invoke "max" (f32.const -0x1p-1) (f32.const inf)) (f32.const inf)) +(assert_return (invoke "max" (f32.const 0x1p-1) (f32.const -inf)) (f32.const 0x1p-1)) +(assert_return (invoke "max" (f32.const 0x1p-1) (f32.const inf)) (f32.const inf)) +(assert_return (invoke "max" (f32.const -0x1p-1) (f32.const -nan)) (f32.const nan:canonical)) +(assert_return (invoke "max" (f32.const -0x1p-1) (f32.const -nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "max" (f32.const -0x1p-1) (f32.const nan)) (f32.const nan:canonical)) +(assert_return (invoke "max" (f32.const -0x1p-1) (f32.const nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "max" (f32.const 0x1p-1) (f32.const -nan)) (f32.const nan:canonical)) +(assert_return (invoke "max" (f32.const 0x1p-1) (f32.const -nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "max" (f32.const 0x1p-1) (f32.const nan)) (f32.const nan:canonical)) +(assert_return (invoke "max" (f32.const 0x1p-1) (f32.const nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "max" (f32.const -0x1p+0) (f32.const -0x0p+0)) (f32.const -0x0p+0)) +(assert_return (invoke "max" (f32.const -0x1p+0) (f32.const 0x0p+0)) (f32.const 0x0p+0)) +(assert_return (invoke "max" (f32.const 0x1p+0) (f32.const -0x0p+0)) (f32.const 0x1p+0)) +(assert_return (invoke "max" (f32.const 0x1p+0) (f32.const 0x0p+0)) (f32.const 0x1p+0)) +(assert_return (invoke "max" (f32.const -0x1p+0) (f32.const -0x1p-149)) (f32.const -0x1p-149)) +(assert_return (invoke "max" (f32.const -0x1p+0) (f32.const 0x1p-149)) (f32.const 0x1p-149)) +(assert_return (invoke "max" (f32.const 0x1p+0) (f32.const -0x1p-149)) (f32.const 0x1p+0)) +(assert_return (invoke "max" (f32.const 0x1p+0) (f32.const 0x1p-149)) (f32.const 0x1p+0)) +(assert_return (invoke "max" (f32.const -0x1p+0) (f32.const -0x1p-126)) (f32.const -0x1p-126)) +(assert_return (invoke "max" (f32.const -0x1p+0) (f32.const 0x1p-126)) (f32.const 0x1p-126)) +(assert_return (invoke "max" (f32.const 0x1p+0) (f32.const -0x1p-126)) (f32.const 0x1p+0)) +(assert_return (invoke "max" (f32.const 0x1p+0) (f32.const 0x1p-126)) (f32.const 0x1p+0)) +(assert_return (invoke "max" (f32.const -0x1p+0) (f32.const -0x1p-1)) (f32.const -0x1p-1)) +(assert_return (invoke "max" (f32.const -0x1p+0) (f32.const 0x1p-1)) (f32.const 0x1p-1)) +(assert_return (invoke "max" (f32.const 0x1p+0) (f32.const -0x1p-1)) (f32.const 0x1p+0)) +(assert_return (invoke "max" (f32.const 0x1p+0) (f32.const 0x1p-1)) (f32.const 0x1p+0)) +(assert_return (invoke "max" (f32.const -0x1p+0) (f32.const -0x1p+0)) (f32.const -0x1p+0)) +(assert_return (invoke "max" (f32.const -0x1p+0) (f32.const 0x1p+0)) (f32.const 0x1p+0)) +(assert_return (invoke "max" (f32.const 0x1p+0) (f32.const -0x1p+0)) (f32.const 0x1p+0)) +(assert_return (invoke "max" (f32.const 0x1p+0) (f32.const 0x1p+0)) (f32.const 0x1p+0)) +(assert_return (invoke "max" (f32.const -0x1p+0) (f32.const -0x1.921fb6p+2)) (f32.const -0x1p+0)) +(assert_return (invoke "max" (f32.const -0x1p+0) (f32.const 0x1.921fb6p+2)) (f32.const 0x1.921fb6p+2)) +(assert_return (invoke "max" (f32.const 0x1p+0) (f32.const -0x1.921fb6p+2)) (f32.const 0x1p+0)) +(assert_return (invoke "max" (f32.const 0x1p+0) (f32.const 0x1.921fb6p+2)) (f32.const 0x1.921fb6p+2)) +(assert_return (invoke "max" (f32.const -0x1p+0) (f32.const -0x1.fffffep+127)) (f32.const -0x1p+0)) +(assert_return (invoke "max" (f32.const -0x1p+0) (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127)) +(assert_return (invoke "max" (f32.const 0x1p+0) (f32.const -0x1.fffffep+127)) (f32.const 0x1p+0)) +(assert_return (invoke "max" (f32.const 0x1p+0) (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127)) +(assert_return (invoke "max" (f32.const -0x1p+0) (f32.const -inf)) (f32.const -0x1p+0)) +(assert_return (invoke "max" (f32.const -0x1p+0) (f32.const inf)) (f32.const inf)) +(assert_return (invoke "max" (f32.const 0x1p+0) (f32.const -inf)) (f32.const 0x1p+0)) +(assert_return (invoke "max" (f32.const 0x1p+0) (f32.const inf)) (f32.const inf)) +(assert_return (invoke "max" (f32.const -0x1p+0) (f32.const -nan)) (f32.const nan:canonical)) +(assert_return (invoke "max" (f32.const -0x1p+0) (f32.const -nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "max" (f32.const -0x1p+0) (f32.const nan)) (f32.const nan:canonical)) +(assert_return (invoke "max" (f32.const -0x1p+0) (f32.const nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "max" (f32.const 0x1p+0) (f32.const -nan)) (f32.const nan:canonical)) +(assert_return (invoke "max" (f32.const 0x1p+0) (f32.const -nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "max" (f32.const 0x1p+0) (f32.const nan)) (f32.const nan:canonical)) +(assert_return (invoke "max" (f32.const 0x1p+0) (f32.const nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "max" (f32.const -0x1.921fb6p+2) (f32.const -0x0p+0)) (f32.const -0x0p+0)) +(assert_return (invoke "max" (f32.const -0x1.921fb6p+2) (f32.const 0x0p+0)) (f32.const 0x0p+0)) +(assert_return (invoke "max" (f32.const 0x1.921fb6p+2) (f32.const -0x0p+0)) (f32.const 0x1.921fb6p+2)) +(assert_return (invoke "max" (f32.const 0x1.921fb6p+2) (f32.const 0x0p+0)) (f32.const 0x1.921fb6p+2)) +(assert_return (invoke "max" (f32.const -0x1.921fb6p+2) (f32.const -0x1p-149)) (f32.const -0x1p-149)) +(assert_return (invoke "max" (f32.const -0x1.921fb6p+2) (f32.const 0x1p-149)) (f32.const 0x1p-149)) +(assert_return (invoke "max" (f32.const 0x1.921fb6p+2) (f32.const -0x1p-149)) (f32.const 0x1.921fb6p+2)) +(assert_return (invoke "max" (f32.const 0x1.921fb6p+2) (f32.const 0x1p-149)) (f32.const 0x1.921fb6p+2)) +(assert_return (invoke "max" (f32.const -0x1.921fb6p+2) (f32.const -0x1p-126)) (f32.const -0x1p-126)) +(assert_return (invoke "max" (f32.const -0x1.921fb6p+2) (f32.const 0x1p-126)) (f32.const 0x1p-126)) +(assert_return (invoke "max" (f32.const 0x1.921fb6p+2) (f32.const -0x1p-126)) (f32.const 0x1.921fb6p+2)) +(assert_return (invoke "max" (f32.const 0x1.921fb6p+2) (f32.const 0x1p-126)) (f32.const 0x1.921fb6p+2)) +(assert_return (invoke "max" (f32.const -0x1.921fb6p+2) (f32.const -0x1p-1)) (f32.const -0x1p-1)) +(assert_return (invoke "max" (f32.const -0x1.921fb6p+2) (f32.const 0x1p-1)) (f32.const 0x1p-1)) +(assert_return (invoke "max" (f32.const 0x1.921fb6p+2) (f32.const -0x1p-1)) (f32.const 0x1.921fb6p+2)) +(assert_return (invoke "max" (f32.const 0x1.921fb6p+2) (f32.const 0x1p-1)) (f32.const 0x1.921fb6p+2)) +(assert_return (invoke "max" (f32.const -0x1.921fb6p+2) (f32.const -0x1p+0)) (f32.const -0x1p+0)) +(assert_return (invoke "max" (f32.const -0x1.921fb6p+2) (f32.const 0x1p+0)) (f32.const 0x1p+0)) +(assert_return (invoke "max" (f32.const 0x1.921fb6p+2) (f32.const -0x1p+0)) (f32.const 0x1.921fb6p+2)) +(assert_return (invoke "max" (f32.const 0x1.921fb6p+2) (f32.const 0x1p+0)) (f32.const 0x1.921fb6p+2)) +(assert_return (invoke "max" (f32.const -0x1.921fb6p+2) (f32.const -0x1.921fb6p+2)) (f32.const -0x1.921fb6p+2)) +(assert_return (invoke "max" (f32.const -0x1.921fb6p+2) (f32.const 0x1.921fb6p+2)) (f32.const 0x1.921fb6p+2)) +(assert_return (invoke "max" (f32.const 0x1.921fb6p+2) (f32.const -0x1.921fb6p+2)) (f32.const 0x1.921fb6p+2)) +(assert_return (invoke "max" (f32.const 0x1.921fb6p+2) (f32.const 0x1.921fb6p+2)) (f32.const 0x1.921fb6p+2)) +(assert_return (invoke "max" (f32.const -0x1.921fb6p+2) (f32.const -0x1.fffffep+127)) (f32.const -0x1.921fb6p+2)) +(assert_return (invoke "max" (f32.const -0x1.921fb6p+2) (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127)) +(assert_return (invoke "max" (f32.const 0x1.921fb6p+2) (f32.const -0x1.fffffep+127)) (f32.const 0x1.921fb6p+2)) +(assert_return (invoke "max" (f32.const 0x1.921fb6p+2) (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127)) +(assert_return (invoke "max" (f32.const -0x1.921fb6p+2) (f32.const -inf)) (f32.const -0x1.921fb6p+2)) +(assert_return (invoke "max" (f32.const -0x1.921fb6p+2) (f32.const inf)) (f32.const inf)) +(assert_return (invoke "max" (f32.const 0x1.921fb6p+2) (f32.const -inf)) (f32.const 0x1.921fb6p+2)) +(assert_return (invoke "max" (f32.const 0x1.921fb6p+2) (f32.const inf)) (f32.const inf)) +(assert_return (invoke "max" (f32.const -0x1.921fb6p+2) (f32.const -nan)) (f32.const nan:canonical)) +(assert_return (invoke "max" (f32.const -0x1.921fb6p+2) (f32.const -nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "max" (f32.const -0x1.921fb6p+2) (f32.const nan)) (f32.const nan:canonical)) +(assert_return (invoke "max" (f32.const -0x1.921fb6p+2) (f32.const nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "max" (f32.const 0x1.921fb6p+2) (f32.const -nan)) (f32.const nan:canonical)) +(assert_return (invoke "max" (f32.const 0x1.921fb6p+2) (f32.const -nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "max" (f32.const 0x1.921fb6p+2) (f32.const nan)) (f32.const nan:canonical)) +(assert_return (invoke "max" (f32.const 0x1.921fb6p+2) (f32.const nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "max" (f32.const -0x1.fffffep+127) (f32.const -0x0p+0)) (f32.const -0x0p+0)) +(assert_return (invoke "max" (f32.const -0x1.fffffep+127) (f32.const 0x0p+0)) (f32.const 0x0p+0)) +(assert_return (invoke "max" (f32.const 0x1.fffffep+127) (f32.const -0x0p+0)) (f32.const 0x1.fffffep+127)) +(assert_return (invoke "max" (f32.const 0x1.fffffep+127) (f32.const 0x0p+0)) (f32.const 0x1.fffffep+127)) +(assert_return (invoke "max" (f32.const -0x1.fffffep+127) (f32.const -0x1p-149)) (f32.const -0x1p-149)) +(assert_return (invoke "max" (f32.const -0x1.fffffep+127) (f32.const 0x1p-149)) (f32.const 0x1p-149)) +(assert_return (invoke "max" (f32.const 0x1.fffffep+127) (f32.const -0x1p-149)) (f32.const 0x1.fffffep+127)) +(assert_return (invoke "max" (f32.const 0x1.fffffep+127) (f32.const 0x1p-149)) (f32.const 0x1.fffffep+127)) +(assert_return (invoke "max" (f32.const -0x1.fffffep+127) (f32.const -0x1p-126)) (f32.const -0x1p-126)) +(assert_return (invoke "max" (f32.const -0x1.fffffep+127) (f32.const 0x1p-126)) (f32.const 0x1p-126)) +(assert_return (invoke "max" (f32.const 0x1.fffffep+127) (f32.const -0x1p-126)) (f32.const 0x1.fffffep+127)) +(assert_return (invoke "max" (f32.const 0x1.fffffep+127) (f32.const 0x1p-126)) (f32.const 0x1.fffffep+127)) +(assert_return (invoke "max" (f32.const -0x1.fffffep+127) (f32.const -0x1p-1)) (f32.const -0x1p-1)) +(assert_return (invoke "max" (f32.const -0x1.fffffep+127) (f32.const 0x1p-1)) (f32.const 0x1p-1)) +(assert_return (invoke "max" (f32.const 0x1.fffffep+127) (f32.const -0x1p-1)) (f32.const 0x1.fffffep+127)) +(assert_return (invoke "max" (f32.const 0x1.fffffep+127) (f32.const 0x1p-1)) (f32.const 0x1.fffffep+127)) +(assert_return (invoke "max" (f32.const -0x1.fffffep+127) (f32.const -0x1p+0)) (f32.const -0x1p+0)) +(assert_return (invoke "max" (f32.const -0x1.fffffep+127) (f32.const 0x1p+0)) (f32.const 0x1p+0)) +(assert_return (invoke "max" (f32.const 0x1.fffffep+127) (f32.const -0x1p+0)) (f32.const 0x1.fffffep+127)) +(assert_return (invoke "max" (f32.const 0x1.fffffep+127) (f32.const 0x1p+0)) (f32.const 0x1.fffffep+127)) +(assert_return (invoke "max" (f32.const -0x1.fffffep+127) (f32.const -0x1.921fb6p+2)) (f32.const -0x1.921fb6p+2)) +(assert_return (invoke "max" (f32.const -0x1.fffffep+127) (f32.const 0x1.921fb6p+2)) (f32.const 0x1.921fb6p+2)) +(assert_return (invoke "max" (f32.const 0x1.fffffep+127) (f32.const -0x1.921fb6p+2)) (f32.const 0x1.fffffep+127)) +(assert_return (invoke "max" (f32.const 0x1.fffffep+127) (f32.const 0x1.921fb6p+2)) (f32.const 0x1.fffffep+127)) +(assert_return (invoke "max" (f32.const -0x1.fffffep+127) (f32.const -0x1.fffffep+127)) (f32.const -0x1.fffffep+127)) +(assert_return (invoke "max" (f32.const -0x1.fffffep+127) (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127)) +(assert_return (invoke "max" (f32.const 0x1.fffffep+127) (f32.const -0x1.fffffep+127)) (f32.const 0x1.fffffep+127)) +(assert_return (invoke "max" (f32.const 0x1.fffffep+127) (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127)) +(assert_return (invoke "max" (f32.const -0x1.fffffep+127) (f32.const -inf)) (f32.const -0x1.fffffep+127)) +(assert_return (invoke "max" (f32.const -0x1.fffffep+127) (f32.const inf)) (f32.const inf)) +(assert_return (invoke "max" (f32.const 0x1.fffffep+127) (f32.const -inf)) (f32.const 0x1.fffffep+127)) +(assert_return (invoke "max" (f32.const 0x1.fffffep+127) (f32.const inf)) (f32.const inf)) +(assert_return (invoke "max" (f32.const -0x1.fffffep+127) (f32.const -nan)) (f32.const nan:canonical)) +(assert_return (invoke "max" (f32.const -0x1.fffffep+127) (f32.const -nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "max" (f32.const -0x1.fffffep+127) (f32.const nan)) (f32.const nan:canonical)) +(assert_return (invoke "max" (f32.const -0x1.fffffep+127) (f32.const nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "max" (f32.const 0x1.fffffep+127) (f32.const -nan)) (f32.const nan:canonical)) +(assert_return (invoke "max" (f32.const 0x1.fffffep+127) (f32.const -nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "max" (f32.const 0x1.fffffep+127) (f32.const nan)) (f32.const nan:canonical)) +(assert_return (invoke "max" (f32.const 0x1.fffffep+127) (f32.const nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "max" (f32.const -inf) (f32.const -0x0p+0)) (f32.const -0x0p+0)) +(assert_return (invoke "max" (f32.const -inf) (f32.const 0x0p+0)) (f32.const 0x0p+0)) +(assert_return (invoke "max" (f32.const inf) (f32.const -0x0p+0)) (f32.const inf)) +(assert_return (invoke "max" (f32.const inf) (f32.const 0x0p+0)) (f32.const inf)) +(assert_return (invoke "max" (f32.const -inf) (f32.const -0x1p-149)) (f32.const -0x1p-149)) +(assert_return (invoke "max" (f32.const -inf) (f32.const 0x1p-149)) (f32.const 0x1p-149)) +(assert_return (invoke "max" (f32.const inf) (f32.const -0x1p-149)) (f32.const inf)) +(assert_return (invoke "max" (f32.const inf) (f32.const 0x1p-149)) (f32.const inf)) +(assert_return (invoke "max" (f32.const -inf) (f32.const -0x1p-126)) (f32.const -0x1p-126)) +(assert_return (invoke "max" (f32.const -inf) (f32.const 0x1p-126)) (f32.const 0x1p-126)) +(assert_return (invoke "max" (f32.const inf) (f32.const -0x1p-126)) (f32.const inf)) +(assert_return (invoke "max" (f32.const inf) (f32.const 0x1p-126)) (f32.const inf)) +(assert_return (invoke "max" (f32.const -inf) (f32.const -0x1p-1)) (f32.const -0x1p-1)) +(assert_return (invoke "max" (f32.const -inf) (f32.const 0x1p-1)) (f32.const 0x1p-1)) +(assert_return (invoke "max" (f32.const inf) (f32.const -0x1p-1)) (f32.const inf)) +(assert_return (invoke "max" (f32.const inf) (f32.const 0x1p-1)) (f32.const inf)) +(assert_return (invoke "max" (f32.const -inf) (f32.const -0x1p+0)) (f32.const -0x1p+0)) +(assert_return (invoke "max" (f32.const -inf) (f32.const 0x1p+0)) (f32.const 0x1p+0)) +(assert_return (invoke "max" (f32.const inf) (f32.const -0x1p+0)) (f32.const inf)) +(assert_return (invoke "max" (f32.const inf) (f32.const 0x1p+0)) (f32.const inf)) +(assert_return (invoke "max" (f32.const -inf) (f32.const -0x1.921fb6p+2)) (f32.const -0x1.921fb6p+2)) +(assert_return (invoke "max" (f32.const -inf) (f32.const 0x1.921fb6p+2)) (f32.const 0x1.921fb6p+2)) +(assert_return (invoke "max" (f32.const inf) (f32.const -0x1.921fb6p+2)) (f32.const inf)) +(assert_return (invoke "max" (f32.const inf) (f32.const 0x1.921fb6p+2)) (f32.const inf)) +(assert_return (invoke "max" (f32.const -inf) (f32.const -0x1.fffffep+127)) (f32.const -0x1.fffffep+127)) +(assert_return (invoke "max" (f32.const -inf) (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127)) +(assert_return (invoke "max" (f32.const inf) (f32.const -0x1.fffffep+127)) (f32.const inf)) +(assert_return (invoke "max" (f32.const inf) (f32.const 0x1.fffffep+127)) (f32.const inf)) +(assert_return (invoke "max" (f32.const -inf) (f32.const -inf)) (f32.const -inf)) +(assert_return (invoke "max" (f32.const -inf) (f32.const inf)) (f32.const inf)) +(assert_return (invoke "max" (f32.const inf) (f32.const -inf)) (f32.const inf)) +(assert_return (invoke "max" (f32.const inf) (f32.const inf)) (f32.const inf)) +(assert_return (invoke "max" (f32.const -inf) (f32.const -nan)) (f32.const nan:canonical)) +(assert_return (invoke "max" (f32.const -inf) (f32.const -nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "max" (f32.const -inf) (f32.const nan)) (f32.const nan:canonical)) +(assert_return (invoke "max" (f32.const -inf) (f32.const nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "max" (f32.const inf) (f32.const -nan)) (f32.const nan:canonical)) +(assert_return (invoke "max" (f32.const inf) (f32.const -nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "max" (f32.const inf) (f32.const nan)) (f32.const nan:canonical)) +(assert_return (invoke "max" (f32.const inf) (f32.const nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "max" (f32.const -nan) (f32.const -0x0p+0)) (f32.const nan:canonical)) +(assert_return (invoke "max" (f32.const -nan:0x200000) (f32.const -0x0p+0)) (f32.const nan:arithmetic)) +(assert_return (invoke "max" (f32.const -nan) (f32.const 0x0p+0)) (f32.const nan:canonical)) +(assert_return (invoke "max" (f32.const -nan:0x200000) (f32.const 0x0p+0)) (f32.const nan:arithmetic)) +(assert_return (invoke "max" (f32.const nan) (f32.const -0x0p+0)) (f32.const nan:canonical)) +(assert_return (invoke "max" (f32.const nan:0x200000) (f32.const -0x0p+0)) (f32.const nan:arithmetic)) +(assert_return (invoke "max" (f32.const nan) (f32.const 0x0p+0)) (f32.const nan:canonical)) +(assert_return (invoke "max" (f32.const nan:0x200000) (f32.const 0x0p+0)) (f32.const nan:arithmetic)) +(assert_return (invoke "max" (f32.const -nan) (f32.const -0x1p-149)) (f32.const nan:canonical)) +(assert_return (invoke "max" (f32.const -nan:0x200000) (f32.const -0x1p-149)) (f32.const nan:arithmetic)) +(assert_return (invoke "max" (f32.const -nan) (f32.const 0x1p-149)) (f32.const nan:canonical)) +(assert_return (invoke "max" (f32.const -nan:0x200000) (f32.const 0x1p-149)) (f32.const nan:arithmetic)) +(assert_return (invoke "max" (f32.const nan) (f32.const -0x1p-149)) (f32.const nan:canonical)) +(assert_return (invoke "max" (f32.const nan:0x200000) (f32.const -0x1p-149)) (f32.const nan:arithmetic)) +(assert_return (invoke "max" (f32.const nan) (f32.const 0x1p-149)) (f32.const nan:canonical)) +(assert_return (invoke "max" (f32.const nan:0x200000) (f32.const 0x1p-149)) (f32.const nan:arithmetic)) +(assert_return (invoke "max" (f32.const -nan) (f32.const -0x1p-126)) (f32.const nan:canonical)) +(assert_return (invoke "max" (f32.const -nan:0x200000) (f32.const -0x1p-126)) (f32.const nan:arithmetic)) +(assert_return (invoke "max" (f32.const -nan) (f32.const 0x1p-126)) (f32.const nan:canonical)) +(assert_return (invoke "max" (f32.const -nan:0x200000) (f32.const 0x1p-126)) (f32.const nan:arithmetic)) +(assert_return (invoke "max" (f32.const nan) (f32.const -0x1p-126)) (f32.const nan:canonical)) +(assert_return (invoke "max" (f32.const nan:0x200000) (f32.const -0x1p-126)) (f32.const nan:arithmetic)) +(assert_return (invoke "max" (f32.const nan) (f32.const 0x1p-126)) (f32.const nan:canonical)) +(assert_return (invoke "max" (f32.const nan:0x200000) (f32.const 0x1p-126)) (f32.const nan:arithmetic)) +(assert_return (invoke "max" (f32.const -nan) (f32.const -0x1p-1)) (f32.const nan:canonical)) +(assert_return (invoke "max" (f32.const -nan:0x200000) (f32.const -0x1p-1)) (f32.const nan:arithmetic)) +(assert_return (invoke "max" (f32.const -nan) (f32.const 0x1p-1)) (f32.const nan:canonical)) +(assert_return (invoke "max" (f32.const -nan:0x200000) (f32.const 0x1p-1)) (f32.const nan:arithmetic)) +(assert_return (invoke "max" (f32.const nan) (f32.const -0x1p-1)) (f32.const nan:canonical)) +(assert_return (invoke "max" (f32.const nan:0x200000) (f32.const -0x1p-1)) (f32.const nan:arithmetic)) +(assert_return (invoke "max" (f32.const nan) (f32.const 0x1p-1)) (f32.const nan:canonical)) +(assert_return (invoke "max" (f32.const nan:0x200000) (f32.const 0x1p-1)) (f32.const nan:arithmetic)) +(assert_return (invoke "max" (f32.const -nan) (f32.const -0x1p+0)) (f32.const nan:canonical)) +(assert_return (invoke "max" (f32.const -nan:0x200000) (f32.const -0x1p+0)) (f32.const nan:arithmetic)) +(assert_return (invoke "max" (f32.const -nan) (f32.const 0x1p+0)) (f32.const nan:canonical)) +(assert_return (invoke "max" (f32.const -nan:0x200000) (f32.const 0x1p+0)) (f32.const nan:arithmetic)) +(assert_return (invoke "max" (f32.const nan) (f32.const -0x1p+0)) (f32.const nan:canonical)) +(assert_return (invoke "max" (f32.const nan:0x200000) (f32.const -0x1p+0)) (f32.const nan:arithmetic)) +(assert_return (invoke "max" (f32.const nan) (f32.const 0x1p+0)) (f32.const nan:canonical)) +(assert_return (invoke "max" (f32.const nan:0x200000) (f32.const 0x1p+0)) (f32.const nan:arithmetic)) +(assert_return (invoke "max" (f32.const -nan) (f32.const -0x1.921fb6p+2)) (f32.const nan:canonical)) +(assert_return (invoke "max" (f32.const -nan:0x200000) (f32.const -0x1.921fb6p+2)) (f32.const nan:arithmetic)) +(assert_return (invoke "max" (f32.const -nan) (f32.const 0x1.921fb6p+2)) (f32.const nan:canonical)) +(assert_return (invoke "max" (f32.const -nan:0x200000) (f32.const 0x1.921fb6p+2)) (f32.const nan:arithmetic)) +(assert_return (invoke "max" (f32.const nan) (f32.const -0x1.921fb6p+2)) (f32.const nan:canonical)) +(assert_return (invoke "max" (f32.const nan:0x200000) (f32.const -0x1.921fb6p+2)) (f32.const nan:arithmetic)) +(assert_return (invoke "max" (f32.const nan) (f32.const 0x1.921fb6p+2)) (f32.const nan:canonical)) +(assert_return (invoke "max" (f32.const nan:0x200000) (f32.const 0x1.921fb6p+2)) (f32.const nan:arithmetic)) +(assert_return (invoke "max" (f32.const -nan) (f32.const -0x1.fffffep+127)) (f32.const nan:canonical)) +(assert_return (invoke "max" (f32.const -nan:0x200000) (f32.const -0x1.fffffep+127)) (f32.const nan:arithmetic)) +(assert_return (invoke "max" (f32.const -nan) (f32.const 0x1.fffffep+127)) (f32.const nan:canonical)) +(assert_return (invoke "max" (f32.const -nan:0x200000) (f32.const 0x1.fffffep+127)) (f32.const nan:arithmetic)) +(assert_return (invoke "max" (f32.const nan) (f32.const -0x1.fffffep+127)) (f32.const nan:canonical)) +(assert_return (invoke "max" (f32.const nan:0x200000) (f32.const -0x1.fffffep+127)) (f32.const nan:arithmetic)) +(assert_return (invoke "max" (f32.const nan) (f32.const 0x1.fffffep+127)) (f32.const nan:canonical)) +(assert_return (invoke "max" (f32.const nan:0x200000) (f32.const 0x1.fffffep+127)) (f32.const nan:arithmetic)) +(assert_return (invoke "max" (f32.const -nan) (f32.const -inf)) (f32.const nan:canonical)) +(assert_return (invoke "max" (f32.const -nan:0x200000) (f32.const -inf)) (f32.const nan:arithmetic)) +(assert_return (invoke "max" (f32.const -nan) (f32.const inf)) (f32.const nan:canonical)) +(assert_return (invoke "max" (f32.const -nan:0x200000) (f32.const inf)) (f32.const nan:arithmetic)) +(assert_return (invoke "max" (f32.const nan) (f32.const -inf)) (f32.const nan:canonical)) +(assert_return (invoke "max" (f32.const nan:0x200000) (f32.const -inf)) (f32.const nan:arithmetic)) +(assert_return (invoke "max" (f32.const nan) (f32.const inf)) (f32.const nan:canonical)) +(assert_return (invoke "max" (f32.const nan:0x200000) (f32.const inf)) (f32.const nan:arithmetic)) +(assert_return (invoke "max" (f32.const -nan) (f32.const -nan)) (f32.const nan:canonical)) +(assert_return (invoke "max" (f32.const -nan:0x200000) (f32.const -nan)) (f32.const nan:arithmetic)) +(assert_return (invoke "max" (f32.const -nan) (f32.const -nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "max" (f32.const -nan:0x200000) (f32.const -nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "max" (f32.const -nan) (f32.const nan)) (f32.const nan:canonical)) +(assert_return (invoke "max" (f32.const -nan:0x200000) (f32.const nan)) (f32.const nan:arithmetic)) +(assert_return (invoke "max" (f32.const -nan) (f32.const nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "max" (f32.const -nan:0x200000) (f32.const nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "max" (f32.const nan) (f32.const -nan)) (f32.const nan:canonical)) +(assert_return (invoke "max" (f32.const nan:0x200000) (f32.const -nan)) (f32.const nan:arithmetic)) +(assert_return (invoke "max" (f32.const nan) (f32.const -nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "max" (f32.const nan:0x200000) (f32.const -nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "max" (f32.const nan) (f32.const nan)) (f32.const nan:canonical)) +(assert_return (invoke "max" (f32.const nan:0x200000) (f32.const nan)) (f32.const nan:arithmetic)) +(assert_return (invoke "max" (f32.const nan) (f32.const nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "max" (f32.const nan:0x200000) (f32.const nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "sqrt" (f32.const -0x0p+0)) (f32.const -0x0p+0)) +(assert_return (invoke "sqrt" (f32.const 0x0p+0)) (f32.const 0x0p+0)) +(assert_return (invoke "sqrt" (f32.const -0x1p-149)) (f32.const nan:canonical)) +(assert_return (invoke "sqrt" (f32.const 0x1p-149)) (f32.const 0x1.6a09e6p-75)) +(assert_return (invoke "sqrt" (f32.const -0x1p-126)) (f32.const nan:canonical)) +(assert_return (invoke "sqrt" (f32.const 0x1p-126)) (f32.const 0x1p-63)) +(assert_return (invoke "sqrt" (f32.const -0x1p-1)) (f32.const nan:canonical)) +(assert_return (invoke "sqrt" (f32.const 0x1p-1)) (f32.const 0x1.6a09e6p-1)) +(assert_return (invoke "sqrt" (f32.const -0x1p+0)) (f32.const nan:canonical)) +(assert_return (invoke "sqrt" (f32.const 0x1p+0)) (f32.const 0x1p+0)) +(assert_return (invoke "sqrt" (f32.const -0x1.921fb6p+2)) (f32.const nan:canonical)) +(assert_return (invoke "sqrt" (f32.const 0x1.921fb6p+2)) (f32.const 0x1.40d932p+1)) +(assert_return (invoke "sqrt" (f32.const -0x1.fffffep+127)) (f32.const nan:canonical)) +(assert_return (invoke "sqrt" (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+63)) +(assert_return (invoke "sqrt" (f32.const -inf)) (f32.const nan:canonical)) +(assert_return (invoke "sqrt" (f32.const inf)) (f32.const inf)) +(assert_return (invoke "sqrt" (f32.const -nan)) (f32.const nan:canonical)) +(assert_return (invoke "sqrt" (f32.const -nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "sqrt" (f32.const nan)) (f32.const nan:canonical)) +(assert_return (invoke "sqrt" (f32.const nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "floor" (f32.const -0x0p+0)) (f32.const -0x0p+0)) +(assert_return (invoke "floor" (f32.const 0x0p+0)) (f32.const 0x0p+0)) +(assert_return (invoke "floor" (f32.const -0x1p-149)) (f32.const -0x1p+0)) +(assert_return (invoke "floor" (f32.const 0x1p-149)) (f32.const 0x0p+0)) +(assert_return (invoke "floor" (f32.const -0x1p-126)) (f32.const -0x1p+0)) +(assert_return (invoke "floor" (f32.const 0x1p-126)) (f32.const 0x0p+0)) +(assert_return (invoke "floor" (f32.const -0x1p-1)) (f32.const -0x1p+0)) +(assert_return (invoke "floor" (f32.const 0x1p-1)) (f32.const 0x0p+0)) +(assert_return (invoke "floor" (f32.const -0x1p+0)) (f32.const -0x1p+0)) +(assert_return (invoke "floor" (f32.const 0x1p+0)) (f32.const 0x1p+0)) +(assert_return (invoke "floor" (f32.const -0x1.921fb6p+2)) (f32.const -0x1.cp+2)) +(assert_return (invoke "floor" (f32.const 0x1.921fb6p+2)) (f32.const 0x1.8p+2)) +(assert_return (invoke "floor" (f32.const -0x1.fffffep+127)) (f32.const -0x1.fffffep+127)) +(assert_return (invoke "floor" (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127)) +(assert_return (invoke "floor" (f32.const -inf)) (f32.const -inf)) +(assert_return (invoke "floor" (f32.const inf)) (f32.const inf)) +(assert_return (invoke "floor" (f32.const -nan)) (f32.const nan:canonical)) +(assert_return (invoke "floor" (f32.const -nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "floor" (f32.const nan)) (f32.const nan:canonical)) +(assert_return (invoke "floor" (f32.const nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "ceil" (f32.const -0x0p+0)) (f32.const -0x0p+0)) +(assert_return (invoke "ceil" (f32.const 0x0p+0)) (f32.const 0x0p+0)) +(assert_return (invoke "ceil" (f32.const -0x1p-149)) (f32.const -0x0p+0)) +(assert_return (invoke "ceil" (f32.const 0x1p-149)) (f32.const 0x1p+0)) +(assert_return (invoke "ceil" (f32.const -0x1p-126)) (f32.const -0x0p+0)) +(assert_return (invoke "ceil" (f32.const 0x1p-126)) (f32.const 0x1p+0)) +(assert_return (invoke "ceil" (f32.const -0x1p-1)) (f32.const -0x0p+0)) +(assert_return (invoke "ceil" (f32.const 0x1p-1)) (f32.const 0x1p+0)) +(assert_return (invoke "ceil" (f32.const -0x1p+0)) (f32.const -0x1p+0)) +(assert_return (invoke "ceil" (f32.const 0x1p+0)) (f32.const 0x1p+0)) +(assert_return (invoke "ceil" (f32.const -0x1.921fb6p+2)) (f32.const -0x1.8p+2)) +(assert_return (invoke "ceil" (f32.const 0x1.921fb6p+2)) (f32.const 0x1.cp+2)) +(assert_return (invoke "ceil" (f32.const -0x1.fffffep+127)) (f32.const -0x1.fffffep+127)) +(assert_return (invoke "ceil" (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127)) +(assert_return (invoke "ceil" (f32.const -inf)) (f32.const -inf)) +(assert_return (invoke "ceil" (f32.const inf)) (f32.const inf)) +(assert_return (invoke "ceil" (f32.const -nan)) (f32.const nan:canonical)) +(assert_return (invoke "ceil" (f32.const -nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "ceil" (f32.const nan)) (f32.const nan:canonical)) +(assert_return (invoke "ceil" (f32.const nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "trunc" (f32.const -0x0p+0)) (f32.const -0x0p+0)) +(assert_return (invoke "trunc" (f32.const 0x0p+0)) (f32.const 0x0p+0)) +(assert_return (invoke "trunc" (f32.const -0x1p-149)) (f32.const -0x0p+0)) +(assert_return (invoke "trunc" (f32.const 0x1p-149)) (f32.const 0x0p+0)) +(assert_return (invoke "trunc" (f32.const -0x1p-126)) (f32.const -0x0p+0)) +(assert_return (invoke "trunc" (f32.const 0x1p-126)) (f32.const 0x0p+0)) +(assert_return (invoke "trunc" (f32.const -0x1p-1)) (f32.const -0x0p+0)) +(assert_return (invoke "trunc" (f32.const 0x1p-1)) (f32.const 0x0p+0)) +(assert_return (invoke "trunc" (f32.const -0x1p+0)) (f32.const -0x1p+0)) +(assert_return (invoke "trunc" (f32.const 0x1p+0)) (f32.const 0x1p+0)) +(assert_return (invoke "trunc" (f32.const -0x1.921fb6p+2)) (f32.const -0x1.8p+2)) +(assert_return (invoke "trunc" (f32.const 0x1.921fb6p+2)) (f32.const 0x1.8p+2)) +(assert_return (invoke "trunc" (f32.const -0x1.fffffep+127)) (f32.const -0x1.fffffep+127)) +(assert_return (invoke "trunc" (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127)) +(assert_return (invoke "trunc" (f32.const -inf)) (f32.const -inf)) +(assert_return (invoke "trunc" (f32.const inf)) (f32.const inf)) +(assert_return (invoke "trunc" (f32.const -nan)) (f32.const nan:canonical)) +(assert_return (invoke "trunc" (f32.const -nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "trunc" (f32.const nan)) (f32.const nan:canonical)) +(assert_return (invoke "trunc" (f32.const nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "nearest" (f32.const -0x0p+0)) (f32.const -0x0p+0)) +(assert_return (invoke "nearest" (f32.const 0x0p+0)) (f32.const 0x0p+0)) +(assert_return (invoke "nearest" (f32.const -0x1p-149)) (f32.const -0x0p+0)) +(assert_return (invoke "nearest" (f32.const 0x1p-149)) (f32.const 0x0p+0)) +(assert_return (invoke "nearest" (f32.const -0x1p-126)) (f32.const -0x0p+0)) +(assert_return (invoke "nearest" (f32.const 0x1p-126)) (f32.const 0x0p+0)) +(assert_return (invoke "nearest" (f32.const -0x1p-1)) (f32.const -0x0p+0)) +(assert_return (invoke "nearest" (f32.const 0x1p-1)) (f32.const 0x0p+0)) +(assert_return (invoke "nearest" (f32.const -0x1p+0)) (f32.const -0x1p+0)) +(assert_return (invoke "nearest" (f32.const 0x1p+0)) (f32.const 0x1p+0)) +(assert_return (invoke "nearest" (f32.const -0x1.921fb6p+2)) (f32.const -0x1.8p+2)) +(assert_return (invoke "nearest" (f32.const 0x1.921fb6p+2)) (f32.const 0x1.8p+2)) +(assert_return (invoke "nearest" (f32.const -0x1.fffffep+127)) (f32.const -0x1.fffffep+127)) +(assert_return (invoke "nearest" (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127)) +(assert_return (invoke "nearest" (f32.const -inf)) (f32.const -inf)) +(assert_return (invoke "nearest" (f32.const inf)) (f32.const inf)) +(assert_return (invoke "nearest" (f32.const -nan)) (f32.const nan:canonical)) +(assert_return (invoke "nearest" (f32.const -nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "nearest" (f32.const nan)) (f32.const nan:canonical)) +(assert_return (invoke "nearest" (f32.const nan:0x200000)) (f32.const nan:arithmetic)) + + +;; Type check + +(assert_invalid (module (func (result f32) (f32.add (i64.const 0) (f64.const 0)))) "type mismatch") +(assert_invalid (module (func (result f32) (f32.div (i64.const 0) (f64.const 0)))) "type mismatch") +(assert_invalid (module (func (result f32) (f32.max (i64.const 0) (f64.const 0)))) "type mismatch") +(assert_invalid (module (func (result f32) (f32.min (i64.const 0) (f64.const 0)))) "type mismatch") +(assert_invalid (module (func (result f32) (f32.mul (i64.const 0) (f64.const 0)))) "type mismatch") +(assert_invalid (module (func (result f32) (f32.sub (i64.const 0) (f64.const 0)))) "type mismatch") +(assert_invalid (module (func (result f32) (f32.ceil (i64.const 0)))) "type mismatch") +(assert_invalid (module (func (result f32) (f32.floor (i64.const 0)))) "type mismatch") +(assert_invalid (module (func (result f32) (f32.nearest (i64.const 0)))) "type mismatch") +(assert_invalid (module (func (result f32) (f32.sqrt (i64.const 0)))) "type mismatch") +(assert_invalid (module (func (result f32) (f32.trunc (i64.const 0)))) "type mismatch") diff --git a/runtime/near-vm/tests/wast/spec/f32_bitwise.wast b/runtime/near-vm/tests/wast/spec/f32_bitwise.wast new file mode 100644 index 00000000000..8554d6741d0 --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/f32_bitwise.wast @@ -0,0 +1,376 @@ +;; Test all the f32 bitwise operators on major boundary values and all special +;; values. + +(module + (func (export "abs") (param $x f32) (result f32) (f32.abs (local.get $x))) + (func (export "neg") (param $x f32) (result f32) (f32.neg (local.get $x))) + (func (export "copysign") (param $x f32) (param $y f32) (result f32) (f32.copysign (local.get $x) (local.get $y))) +) + +(assert_return (invoke "copysign" (f32.const -0x0p+0) (f32.const -0x0p+0)) (f32.const -0x0p+0)) +(assert_return (invoke "copysign" (f32.const -0x0p+0) (f32.const 0x0p+0)) (f32.const 0x0p+0)) +(assert_return (invoke "copysign" (f32.const 0x0p+0) (f32.const -0x0p+0)) (f32.const -0x0p+0)) +(assert_return (invoke "copysign" (f32.const 0x0p+0) (f32.const 0x0p+0)) (f32.const 0x0p+0)) +(assert_return (invoke "copysign" (f32.const -0x0p+0) (f32.const -0x1p-149)) (f32.const -0x0p+0)) +(assert_return (invoke "copysign" (f32.const -0x0p+0) (f32.const 0x1p-149)) (f32.const 0x0p+0)) +(assert_return (invoke "copysign" (f32.const 0x0p+0) (f32.const -0x1p-149)) (f32.const -0x0p+0)) +(assert_return (invoke "copysign" (f32.const 0x0p+0) (f32.const 0x1p-149)) (f32.const 0x0p+0)) +(assert_return (invoke "copysign" (f32.const -0x0p+0) (f32.const -0x1p-126)) (f32.const -0x0p+0)) +(assert_return (invoke "copysign" (f32.const -0x0p+0) (f32.const 0x1p-126)) (f32.const 0x0p+0)) +(assert_return (invoke "copysign" (f32.const 0x0p+0) (f32.const -0x1p-126)) (f32.const -0x0p+0)) +(assert_return (invoke "copysign" (f32.const 0x0p+0) (f32.const 0x1p-126)) (f32.const 0x0p+0)) +(assert_return (invoke "copysign" (f32.const -0x0p+0) (f32.const -0x1p-1)) (f32.const -0x0p+0)) +(assert_return (invoke "copysign" (f32.const -0x0p+0) (f32.const 0x1p-1)) (f32.const 0x0p+0)) +(assert_return (invoke "copysign" (f32.const 0x0p+0) (f32.const -0x1p-1)) (f32.const -0x0p+0)) +(assert_return (invoke "copysign" (f32.const 0x0p+0) (f32.const 0x1p-1)) (f32.const 0x0p+0)) +(assert_return (invoke "copysign" (f32.const -0x0p+0) (f32.const -0x1p+0)) (f32.const -0x0p+0)) +(assert_return (invoke "copysign" (f32.const -0x0p+0) (f32.const 0x1p+0)) (f32.const 0x0p+0)) +(assert_return (invoke "copysign" (f32.const 0x0p+0) (f32.const -0x1p+0)) (f32.const -0x0p+0)) +(assert_return (invoke "copysign" (f32.const 0x0p+0) (f32.const 0x1p+0)) (f32.const 0x0p+0)) +(assert_return (invoke "copysign" (f32.const -0x0p+0) (f32.const -0x1.921fb6p+2)) (f32.const -0x0p+0)) +(assert_return (invoke "copysign" (f32.const -0x0p+0) (f32.const 0x1.921fb6p+2)) (f32.const 0x0p+0)) +(assert_return (invoke "copysign" (f32.const 0x0p+0) (f32.const -0x1.921fb6p+2)) (f32.const -0x0p+0)) +(assert_return (invoke "copysign" (f32.const 0x0p+0) (f32.const 0x1.921fb6p+2)) (f32.const 0x0p+0)) +(assert_return (invoke "copysign" (f32.const -0x0p+0) (f32.const -0x1.fffffep+127)) (f32.const -0x0p+0)) +(assert_return (invoke "copysign" (f32.const -0x0p+0) (f32.const 0x1.fffffep+127)) (f32.const 0x0p+0)) +(assert_return (invoke "copysign" (f32.const 0x0p+0) (f32.const -0x1.fffffep+127)) (f32.const -0x0p+0)) +(assert_return (invoke "copysign" (f32.const 0x0p+0) (f32.const 0x1.fffffep+127)) (f32.const 0x0p+0)) +(assert_return (invoke "copysign" (f32.const -0x0p+0) (f32.const -inf)) (f32.const -0x0p+0)) +(assert_return (invoke "copysign" (f32.const -0x0p+0) (f32.const inf)) (f32.const 0x0p+0)) +(assert_return (invoke "copysign" (f32.const 0x0p+0) (f32.const -inf)) (f32.const -0x0p+0)) +(assert_return (invoke "copysign" (f32.const 0x0p+0) (f32.const inf)) (f32.const 0x0p+0)) +(assert_return (invoke "copysign" (f32.const -0x0p+0) (f32.const -nan)) (f32.const -0x0p+0)) +(assert_return (invoke "copysign" (f32.const -0x0p+0) (f32.const nan)) (f32.const 0x0p+0)) +(assert_return (invoke "copysign" (f32.const 0x0p+0) (f32.const -nan)) (f32.const -0x0p+0)) +(assert_return (invoke "copysign" (f32.const 0x0p+0) (f32.const nan)) (f32.const 0x0p+0)) +(assert_return (invoke "copysign" (f32.const -0x1p-149) (f32.const -0x0p+0)) (f32.const -0x1p-149)) +(assert_return (invoke "copysign" (f32.const -0x1p-149) (f32.const 0x0p+0)) (f32.const 0x1p-149)) +(assert_return (invoke "copysign" (f32.const 0x1p-149) (f32.const -0x0p+0)) (f32.const -0x1p-149)) +(assert_return (invoke "copysign" (f32.const 0x1p-149) (f32.const 0x0p+0)) (f32.const 0x1p-149)) +(assert_return (invoke "copysign" (f32.const -0x1p-149) (f32.const -0x1p-149)) (f32.const -0x1p-149)) +(assert_return (invoke "copysign" (f32.const -0x1p-149) (f32.const 0x1p-149)) (f32.const 0x1p-149)) +(assert_return (invoke "copysign" (f32.const 0x1p-149) (f32.const -0x1p-149)) (f32.const -0x1p-149)) +(assert_return (invoke "copysign" (f32.const 0x1p-149) (f32.const 0x1p-149)) (f32.const 0x1p-149)) +(assert_return (invoke "copysign" (f32.const -0x1p-149) (f32.const -0x1p-126)) (f32.const -0x1p-149)) +(assert_return (invoke "copysign" (f32.const -0x1p-149) (f32.const 0x1p-126)) (f32.const 0x1p-149)) +(assert_return (invoke "copysign" (f32.const 0x1p-149) (f32.const -0x1p-126)) (f32.const -0x1p-149)) +(assert_return (invoke "copysign" (f32.const 0x1p-149) (f32.const 0x1p-126)) (f32.const 0x1p-149)) +(assert_return (invoke "copysign" (f32.const -0x1p-149) (f32.const -0x1p-1)) (f32.const -0x1p-149)) +(assert_return (invoke "copysign" (f32.const -0x1p-149) (f32.const 0x1p-1)) (f32.const 0x1p-149)) +(assert_return (invoke "copysign" (f32.const 0x1p-149) (f32.const -0x1p-1)) (f32.const -0x1p-149)) +(assert_return (invoke "copysign" (f32.const 0x1p-149) (f32.const 0x1p-1)) (f32.const 0x1p-149)) +(assert_return (invoke "copysign" (f32.const -0x1p-149) (f32.const -0x1p+0)) (f32.const -0x1p-149)) +(assert_return (invoke "copysign" (f32.const -0x1p-149) (f32.const 0x1p+0)) (f32.const 0x1p-149)) +(assert_return (invoke "copysign" (f32.const 0x1p-149) (f32.const -0x1p+0)) (f32.const -0x1p-149)) +(assert_return (invoke "copysign" (f32.const 0x1p-149) (f32.const 0x1p+0)) (f32.const 0x1p-149)) +(assert_return (invoke "copysign" (f32.const -0x1p-149) (f32.const -0x1.921fb6p+2)) (f32.const -0x1p-149)) +(assert_return (invoke "copysign" (f32.const -0x1p-149) (f32.const 0x1.921fb6p+2)) (f32.const 0x1p-149)) +(assert_return (invoke "copysign" (f32.const 0x1p-149) (f32.const -0x1.921fb6p+2)) (f32.const -0x1p-149)) +(assert_return (invoke "copysign" (f32.const 0x1p-149) (f32.const 0x1.921fb6p+2)) (f32.const 0x1p-149)) +(assert_return (invoke "copysign" (f32.const -0x1p-149) (f32.const -0x1.fffffep+127)) (f32.const -0x1p-149)) +(assert_return (invoke "copysign" (f32.const -0x1p-149) (f32.const 0x1.fffffep+127)) (f32.const 0x1p-149)) +(assert_return (invoke "copysign" (f32.const 0x1p-149) (f32.const -0x1.fffffep+127)) (f32.const -0x1p-149)) +(assert_return (invoke "copysign" (f32.const 0x1p-149) (f32.const 0x1.fffffep+127)) (f32.const 0x1p-149)) +(assert_return (invoke "copysign" (f32.const -0x1p-149) (f32.const -inf)) (f32.const -0x1p-149)) +(assert_return (invoke "copysign" (f32.const -0x1p-149) (f32.const inf)) (f32.const 0x1p-149)) +(assert_return (invoke "copysign" (f32.const 0x1p-149) (f32.const -inf)) (f32.const -0x1p-149)) +(assert_return (invoke "copysign" (f32.const 0x1p-149) (f32.const inf)) (f32.const 0x1p-149)) +(assert_return (invoke "copysign" (f32.const -0x1p-149) (f32.const -nan)) (f32.const -0x1p-149)) +(assert_return (invoke "copysign" (f32.const -0x1p-149) (f32.const nan)) (f32.const 0x1p-149)) +(assert_return (invoke "copysign" (f32.const 0x1p-149) (f32.const -nan)) (f32.const -0x1p-149)) +(assert_return (invoke "copysign" (f32.const 0x1p-149) (f32.const nan)) (f32.const 0x1p-149)) +(assert_return (invoke "copysign" (f32.const -0x1p-126) (f32.const -0x0p+0)) (f32.const -0x1p-126)) +(assert_return (invoke "copysign" (f32.const -0x1p-126) (f32.const 0x0p+0)) (f32.const 0x1p-126)) +(assert_return (invoke "copysign" (f32.const 0x1p-126) (f32.const -0x0p+0)) (f32.const -0x1p-126)) +(assert_return (invoke "copysign" (f32.const 0x1p-126) (f32.const 0x0p+0)) (f32.const 0x1p-126)) +(assert_return (invoke "copysign" (f32.const -0x1p-126) (f32.const -0x1p-149)) (f32.const -0x1p-126)) +(assert_return (invoke "copysign" (f32.const -0x1p-126) (f32.const 0x1p-149)) (f32.const 0x1p-126)) +(assert_return (invoke "copysign" (f32.const 0x1p-126) (f32.const -0x1p-149)) (f32.const -0x1p-126)) +(assert_return (invoke "copysign" (f32.const 0x1p-126) (f32.const 0x1p-149)) (f32.const 0x1p-126)) +(assert_return (invoke "copysign" (f32.const -0x1p-126) (f32.const -0x1p-126)) (f32.const -0x1p-126)) +(assert_return (invoke "copysign" (f32.const -0x1p-126) (f32.const 0x1p-126)) (f32.const 0x1p-126)) +(assert_return (invoke "copysign" (f32.const 0x1p-126) (f32.const -0x1p-126)) (f32.const -0x1p-126)) +(assert_return (invoke "copysign" (f32.const 0x1p-126) (f32.const 0x1p-126)) (f32.const 0x1p-126)) +(assert_return (invoke "copysign" (f32.const -0x1p-126) (f32.const -0x1p-1)) (f32.const -0x1p-126)) +(assert_return (invoke "copysign" (f32.const -0x1p-126) (f32.const 0x1p-1)) (f32.const 0x1p-126)) +(assert_return (invoke "copysign" (f32.const 0x1p-126) (f32.const -0x1p-1)) (f32.const -0x1p-126)) +(assert_return (invoke "copysign" (f32.const 0x1p-126) (f32.const 0x1p-1)) (f32.const 0x1p-126)) +(assert_return (invoke "copysign" (f32.const -0x1p-126) (f32.const -0x1p+0)) (f32.const -0x1p-126)) +(assert_return (invoke "copysign" (f32.const -0x1p-126) (f32.const 0x1p+0)) (f32.const 0x1p-126)) +(assert_return (invoke "copysign" (f32.const 0x1p-126) (f32.const -0x1p+0)) (f32.const -0x1p-126)) +(assert_return (invoke "copysign" (f32.const 0x1p-126) (f32.const 0x1p+0)) (f32.const 0x1p-126)) +(assert_return (invoke "copysign" (f32.const -0x1p-126) (f32.const -0x1.921fb6p+2)) (f32.const -0x1p-126)) +(assert_return (invoke "copysign" (f32.const -0x1p-126) (f32.const 0x1.921fb6p+2)) (f32.const 0x1p-126)) +(assert_return (invoke "copysign" (f32.const 0x1p-126) (f32.const -0x1.921fb6p+2)) (f32.const -0x1p-126)) +(assert_return (invoke "copysign" (f32.const 0x1p-126) (f32.const 0x1.921fb6p+2)) (f32.const 0x1p-126)) +(assert_return (invoke "copysign" (f32.const -0x1p-126) (f32.const -0x1.fffffep+127)) (f32.const -0x1p-126)) +(assert_return (invoke "copysign" (f32.const -0x1p-126) (f32.const 0x1.fffffep+127)) (f32.const 0x1p-126)) +(assert_return (invoke "copysign" (f32.const 0x1p-126) (f32.const -0x1.fffffep+127)) (f32.const -0x1p-126)) +(assert_return (invoke "copysign" (f32.const 0x1p-126) (f32.const 0x1.fffffep+127)) (f32.const 0x1p-126)) +(assert_return (invoke "copysign" (f32.const -0x1p-126) (f32.const -inf)) (f32.const -0x1p-126)) +(assert_return (invoke "copysign" (f32.const -0x1p-126) (f32.const inf)) (f32.const 0x1p-126)) +(assert_return (invoke "copysign" (f32.const 0x1p-126) (f32.const -inf)) (f32.const -0x1p-126)) +(assert_return (invoke "copysign" (f32.const 0x1p-126) (f32.const inf)) (f32.const 0x1p-126)) +(assert_return (invoke "copysign" (f32.const -0x1p-126) (f32.const -nan)) (f32.const -0x1p-126)) +(assert_return (invoke "copysign" (f32.const -0x1p-126) (f32.const nan)) (f32.const 0x1p-126)) +(assert_return (invoke "copysign" (f32.const 0x1p-126) (f32.const -nan)) (f32.const -0x1p-126)) +(assert_return (invoke "copysign" (f32.const 0x1p-126) (f32.const nan)) (f32.const 0x1p-126)) +(assert_return (invoke "copysign" (f32.const -0x1p-1) (f32.const -0x0p+0)) (f32.const -0x1p-1)) +(assert_return (invoke "copysign" (f32.const -0x1p-1) (f32.const 0x0p+0)) (f32.const 0x1p-1)) +(assert_return (invoke "copysign" (f32.const 0x1p-1) (f32.const -0x0p+0)) (f32.const -0x1p-1)) +(assert_return (invoke "copysign" (f32.const 0x1p-1) (f32.const 0x0p+0)) (f32.const 0x1p-1)) +(assert_return (invoke "copysign" (f32.const -0x1p-1) (f32.const -0x1p-149)) (f32.const -0x1p-1)) +(assert_return (invoke "copysign" (f32.const -0x1p-1) (f32.const 0x1p-149)) (f32.const 0x1p-1)) +(assert_return (invoke "copysign" (f32.const 0x1p-1) (f32.const -0x1p-149)) (f32.const -0x1p-1)) +(assert_return (invoke "copysign" (f32.const 0x1p-1) (f32.const 0x1p-149)) (f32.const 0x1p-1)) +(assert_return (invoke "copysign" (f32.const -0x1p-1) (f32.const -0x1p-126)) (f32.const -0x1p-1)) +(assert_return (invoke "copysign" (f32.const -0x1p-1) (f32.const 0x1p-126)) (f32.const 0x1p-1)) +(assert_return (invoke "copysign" (f32.const 0x1p-1) (f32.const -0x1p-126)) (f32.const -0x1p-1)) +(assert_return (invoke "copysign" (f32.const 0x1p-1) (f32.const 0x1p-126)) (f32.const 0x1p-1)) +(assert_return (invoke "copysign" (f32.const -0x1p-1) (f32.const -0x1p-1)) (f32.const -0x1p-1)) +(assert_return (invoke "copysign" (f32.const -0x1p-1) (f32.const 0x1p-1)) (f32.const 0x1p-1)) +(assert_return (invoke "copysign" (f32.const 0x1p-1) (f32.const -0x1p-1)) (f32.const -0x1p-1)) +(assert_return (invoke "copysign" (f32.const 0x1p-1) (f32.const 0x1p-1)) (f32.const 0x1p-1)) +(assert_return (invoke "copysign" (f32.const -0x1p-1) (f32.const -0x1p+0)) (f32.const -0x1p-1)) +(assert_return (invoke "copysign" (f32.const -0x1p-1) (f32.const 0x1p+0)) (f32.const 0x1p-1)) +(assert_return (invoke "copysign" (f32.const 0x1p-1) (f32.const -0x1p+0)) (f32.const -0x1p-1)) +(assert_return (invoke "copysign" (f32.const 0x1p-1) (f32.const 0x1p+0)) (f32.const 0x1p-1)) +(assert_return (invoke "copysign" (f32.const -0x1p-1) (f32.const -0x1.921fb6p+2)) (f32.const -0x1p-1)) +(assert_return (invoke "copysign" (f32.const -0x1p-1) (f32.const 0x1.921fb6p+2)) (f32.const 0x1p-1)) +(assert_return (invoke "copysign" (f32.const 0x1p-1) (f32.const -0x1.921fb6p+2)) (f32.const -0x1p-1)) +(assert_return (invoke "copysign" (f32.const 0x1p-1) (f32.const 0x1.921fb6p+2)) (f32.const 0x1p-1)) +(assert_return (invoke "copysign" (f32.const -0x1p-1) (f32.const -0x1.fffffep+127)) (f32.const -0x1p-1)) +(assert_return (invoke "copysign" (f32.const -0x1p-1) (f32.const 0x1.fffffep+127)) (f32.const 0x1p-1)) +(assert_return (invoke "copysign" (f32.const 0x1p-1) (f32.const -0x1.fffffep+127)) (f32.const -0x1p-1)) +(assert_return (invoke "copysign" (f32.const 0x1p-1) (f32.const 0x1.fffffep+127)) (f32.const 0x1p-1)) +(assert_return (invoke "copysign" (f32.const -0x1p-1) (f32.const -inf)) (f32.const -0x1p-1)) +(assert_return (invoke "copysign" (f32.const -0x1p-1) (f32.const inf)) (f32.const 0x1p-1)) +(assert_return (invoke "copysign" (f32.const 0x1p-1) (f32.const -inf)) (f32.const -0x1p-1)) +(assert_return (invoke "copysign" (f32.const 0x1p-1) (f32.const inf)) (f32.const 0x1p-1)) +(assert_return (invoke "copysign" (f32.const -0x1p-1) (f32.const -nan)) (f32.const -0x1p-1)) +(assert_return (invoke "copysign" (f32.const -0x1p-1) (f32.const nan)) (f32.const 0x1p-1)) +(assert_return (invoke "copysign" (f32.const 0x1p-1) (f32.const -nan)) (f32.const -0x1p-1)) +(assert_return (invoke "copysign" (f32.const 0x1p-1) (f32.const nan)) (f32.const 0x1p-1)) +(assert_return (invoke "copysign" (f32.const -0x1p+0) (f32.const -0x0p+0)) (f32.const -0x1p+0)) +(assert_return (invoke "copysign" (f32.const -0x1p+0) (f32.const 0x0p+0)) (f32.const 0x1p+0)) +(assert_return (invoke "copysign" (f32.const 0x1p+0) (f32.const -0x0p+0)) (f32.const -0x1p+0)) +(assert_return (invoke "copysign" (f32.const 0x1p+0) (f32.const 0x0p+0)) (f32.const 0x1p+0)) +(assert_return (invoke "copysign" (f32.const -0x1p+0) (f32.const -0x1p-149)) (f32.const -0x1p+0)) +(assert_return (invoke "copysign" (f32.const -0x1p+0) (f32.const 0x1p-149)) (f32.const 0x1p+0)) +(assert_return (invoke "copysign" (f32.const 0x1p+0) (f32.const -0x1p-149)) (f32.const -0x1p+0)) +(assert_return (invoke "copysign" (f32.const 0x1p+0) (f32.const 0x1p-149)) (f32.const 0x1p+0)) +(assert_return (invoke "copysign" (f32.const -0x1p+0) (f32.const -0x1p-126)) (f32.const -0x1p+0)) +(assert_return (invoke "copysign" (f32.const -0x1p+0) (f32.const 0x1p-126)) (f32.const 0x1p+0)) +(assert_return (invoke "copysign" (f32.const 0x1p+0) (f32.const -0x1p-126)) (f32.const -0x1p+0)) +(assert_return (invoke "copysign" (f32.const 0x1p+0) (f32.const 0x1p-126)) (f32.const 0x1p+0)) +(assert_return (invoke "copysign" (f32.const -0x1p+0) (f32.const -0x1p-1)) (f32.const -0x1p+0)) +(assert_return (invoke "copysign" (f32.const -0x1p+0) (f32.const 0x1p-1)) (f32.const 0x1p+0)) +(assert_return (invoke "copysign" (f32.const 0x1p+0) (f32.const -0x1p-1)) (f32.const -0x1p+0)) +(assert_return (invoke "copysign" (f32.const 0x1p+0) (f32.const 0x1p-1)) (f32.const 0x1p+0)) +(assert_return (invoke "copysign" (f32.const -0x1p+0) (f32.const -0x1p+0)) (f32.const -0x1p+0)) +(assert_return (invoke "copysign" (f32.const -0x1p+0) (f32.const 0x1p+0)) (f32.const 0x1p+0)) +(assert_return (invoke "copysign" (f32.const 0x1p+0) (f32.const -0x1p+0)) (f32.const -0x1p+0)) +(assert_return (invoke "copysign" (f32.const 0x1p+0) (f32.const 0x1p+0)) (f32.const 0x1p+0)) +(assert_return (invoke "copysign" (f32.const -0x1p+0) (f32.const -0x1.921fb6p+2)) (f32.const -0x1p+0)) +(assert_return (invoke "copysign" (f32.const -0x1p+0) (f32.const 0x1.921fb6p+2)) (f32.const 0x1p+0)) +(assert_return (invoke "copysign" (f32.const 0x1p+0) (f32.const -0x1.921fb6p+2)) (f32.const -0x1p+0)) +(assert_return (invoke "copysign" (f32.const 0x1p+0) (f32.const 0x1.921fb6p+2)) (f32.const 0x1p+0)) +(assert_return (invoke "copysign" (f32.const -0x1p+0) (f32.const -0x1.fffffep+127)) (f32.const -0x1p+0)) +(assert_return (invoke "copysign" (f32.const -0x1p+0) (f32.const 0x1.fffffep+127)) (f32.const 0x1p+0)) +(assert_return (invoke "copysign" (f32.const 0x1p+0) (f32.const -0x1.fffffep+127)) (f32.const -0x1p+0)) +(assert_return (invoke "copysign" (f32.const 0x1p+0) (f32.const 0x1.fffffep+127)) (f32.const 0x1p+0)) +(assert_return (invoke "copysign" (f32.const -0x1p+0) (f32.const -inf)) (f32.const -0x1p+0)) +(assert_return (invoke "copysign" (f32.const -0x1p+0) (f32.const inf)) (f32.const 0x1p+0)) +(assert_return (invoke "copysign" (f32.const 0x1p+0) (f32.const -inf)) (f32.const -0x1p+0)) +(assert_return (invoke "copysign" (f32.const 0x1p+0) (f32.const inf)) (f32.const 0x1p+0)) +(assert_return (invoke "copysign" (f32.const -0x1p+0) (f32.const -nan)) (f32.const -0x1p+0)) +(assert_return (invoke "copysign" (f32.const -0x1p+0) (f32.const nan)) (f32.const 0x1p+0)) +(assert_return (invoke "copysign" (f32.const 0x1p+0) (f32.const -nan)) (f32.const -0x1p+0)) +(assert_return (invoke "copysign" (f32.const 0x1p+0) (f32.const nan)) (f32.const 0x1p+0)) +(assert_return (invoke "copysign" (f32.const -0x1.921fb6p+2) (f32.const -0x0p+0)) (f32.const -0x1.921fb6p+2)) +(assert_return (invoke "copysign" (f32.const -0x1.921fb6p+2) (f32.const 0x0p+0)) (f32.const 0x1.921fb6p+2)) +(assert_return (invoke "copysign" (f32.const 0x1.921fb6p+2) (f32.const -0x0p+0)) (f32.const -0x1.921fb6p+2)) +(assert_return (invoke "copysign" (f32.const 0x1.921fb6p+2) (f32.const 0x0p+0)) (f32.const 0x1.921fb6p+2)) +(assert_return (invoke "copysign" (f32.const -0x1.921fb6p+2) (f32.const -0x1p-149)) (f32.const -0x1.921fb6p+2)) +(assert_return (invoke "copysign" (f32.const -0x1.921fb6p+2) (f32.const 0x1p-149)) (f32.const 0x1.921fb6p+2)) +(assert_return (invoke "copysign" (f32.const 0x1.921fb6p+2) (f32.const -0x1p-149)) (f32.const -0x1.921fb6p+2)) +(assert_return (invoke "copysign" (f32.const 0x1.921fb6p+2) (f32.const 0x1p-149)) (f32.const 0x1.921fb6p+2)) +(assert_return (invoke "copysign" (f32.const -0x1.921fb6p+2) (f32.const -0x1p-126)) (f32.const -0x1.921fb6p+2)) +(assert_return (invoke "copysign" (f32.const -0x1.921fb6p+2) (f32.const 0x1p-126)) (f32.const 0x1.921fb6p+2)) +(assert_return (invoke "copysign" (f32.const 0x1.921fb6p+2) (f32.const -0x1p-126)) (f32.const -0x1.921fb6p+2)) +(assert_return (invoke "copysign" (f32.const 0x1.921fb6p+2) (f32.const 0x1p-126)) (f32.const 0x1.921fb6p+2)) +(assert_return (invoke "copysign" (f32.const -0x1.921fb6p+2) (f32.const -0x1p-1)) (f32.const -0x1.921fb6p+2)) +(assert_return (invoke "copysign" (f32.const -0x1.921fb6p+2) (f32.const 0x1p-1)) (f32.const 0x1.921fb6p+2)) +(assert_return (invoke "copysign" (f32.const 0x1.921fb6p+2) (f32.const -0x1p-1)) (f32.const -0x1.921fb6p+2)) +(assert_return (invoke "copysign" (f32.const 0x1.921fb6p+2) (f32.const 0x1p-1)) (f32.const 0x1.921fb6p+2)) +(assert_return (invoke "copysign" (f32.const -0x1.921fb6p+2) (f32.const -0x1p+0)) (f32.const -0x1.921fb6p+2)) +(assert_return (invoke "copysign" (f32.const -0x1.921fb6p+2) (f32.const 0x1p+0)) (f32.const 0x1.921fb6p+2)) +(assert_return (invoke "copysign" (f32.const 0x1.921fb6p+2) (f32.const -0x1p+0)) (f32.const -0x1.921fb6p+2)) +(assert_return (invoke "copysign" (f32.const 0x1.921fb6p+2) (f32.const 0x1p+0)) (f32.const 0x1.921fb6p+2)) +(assert_return (invoke "copysign" (f32.const -0x1.921fb6p+2) (f32.const -0x1.921fb6p+2)) (f32.const -0x1.921fb6p+2)) +(assert_return (invoke "copysign" (f32.const -0x1.921fb6p+2) (f32.const 0x1.921fb6p+2)) (f32.const 0x1.921fb6p+2)) +(assert_return (invoke "copysign" (f32.const 0x1.921fb6p+2) (f32.const -0x1.921fb6p+2)) (f32.const -0x1.921fb6p+2)) +(assert_return (invoke "copysign" (f32.const 0x1.921fb6p+2) (f32.const 0x1.921fb6p+2)) (f32.const 0x1.921fb6p+2)) +(assert_return (invoke "copysign" (f32.const -0x1.921fb6p+2) (f32.const -0x1.fffffep+127)) (f32.const -0x1.921fb6p+2)) +(assert_return (invoke "copysign" (f32.const -0x1.921fb6p+2) (f32.const 0x1.fffffep+127)) (f32.const 0x1.921fb6p+2)) +(assert_return (invoke "copysign" (f32.const 0x1.921fb6p+2) (f32.const -0x1.fffffep+127)) (f32.const -0x1.921fb6p+2)) +(assert_return (invoke "copysign" (f32.const 0x1.921fb6p+2) (f32.const 0x1.fffffep+127)) (f32.const 0x1.921fb6p+2)) +(assert_return (invoke "copysign" (f32.const -0x1.921fb6p+2) (f32.const -inf)) (f32.const -0x1.921fb6p+2)) +(assert_return (invoke "copysign" (f32.const -0x1.921fb6p+2) (f32.const inf)) (f32.const 0x1.921fb6p+2)) +(assert_return (invoke "copysign" (f32.const 0x1.921fb6p+2) (f32.const -inf)) (f32.const -0x1.921fb6p+2)) +(assert_return (invoke "copysign" (f32.const 0x1.921fb6p+2) (f32.const inf)) (f32.const 0x1.921fb6p+2)) +(assert_return (invoke "copysign" (f32.const -0x1.921fb6p+2) (f32.const -nan)) (f32.const -0x1.921fb6p+2)) +(assert_return (invoke "copysign" (f32.const -0x1.921fb6p+2) (f32.const nan)) (f32.const 0x1.921fb6p+2)) +(assert_return (invoke "copysign" (f32.const 0x1.921fb6p+2) (f32.const -nan)) (f32.const -0x1.921fb6p+2)) +(assert_return (invoke "copysign" (f32.const 0x1.921fb6p+2) (f32.const nan)) (f32.const 0x1.921fb6p+2)) +(assert_return (invoke "copysign" (f32.const -0x1.fffffep+127) (f32.const -0x0p+0)) (f32.const -0x1.fffffep+127)) +(assert_return (invoke "copysign" (f32.const -0x1.fffffep+127) (f32.const 0x0p+0)) (f32.const 0x1.fffffep+127)) +(assert_return (invoke "copysign" (f32.const 0x1.fffffep+127) (f32.const -0x0p+0)) (f32.const -0x1.fffffep+127)) +(assert_return (invoke "copysign" (f32.const 0x1.fffffep+127) (f32.const 0x0p+0)) (f32.const 0x1.fffffep+127)) +(assert_return (invoke "copysign" (f32.const -0x1.fffffep+127) (f32.const -0x1p-149)) (f32.const -0x1.fffffep+127)) +(assert_return (invoke "copysign" (f32.const -0x1.fffffep+127) (f32.const 0x1p-149)) (f32.const 0x1.fffffep+127)) +(assert_return (invoke "copysign" (f32.const 0x1.fffffep+127) (f32.const -0x1p-149)) (f32.const -0x1.fffffep+127)) +(assert_return (invoke "copysign" (f32.const 0x1.fffffep+127) (f32.const 0x1p-149)) (f32.const 0x1.fffffep+127)) +(assert_return (invoke "copysign" (f32.const -0x1.fffffep+127) (f32.const -0x1p-126)) (f32.const -0x1.fffffep+127)) +(assert_return (invoke "copysign" (f32.const -0x1.fffffep+127) (f32.const 0x1p-126)) (f32.const 0x1.fffffep+127)) +(assert_return (invoke "copysign" (f32.const 0x1.fffffep+127) (f32.const -0x1p-126)) (f32.const -0x1.fffffep+127)) +(assert_return (invoke "copysign" (f32.const 0x1.fffffep+127) (f32.const 0x1p-126)) (f32.const 0x1.fffffep+127)) +(assert_return (invoke "copysign" (f32.const -0x1.fffffep+127) (f32.const -0x1p-1)) (f32.const -0x1.fffffep+127)) +(assert_return (invoke "copysign" (f32.const -0x1.fffffep+127) (f32.const 0x1p-1)) (f32.const 0x1.fffffep+127)) +(assert_return (invoke "copysign" (f32.const 0x1.fffffep+127) (f32.const -0x1p-1)) (f32.const -0x1.fffffep+127)) +(assert_return (invoke "copysign" (f32.const 0x1.fffffep+127) (f32.const 0x1p-1)) (f32.const 0x1.fffffep+127)) +(assert_return (invoke "copysign" (f32.const -0x1.fffffep+127) (f32.const -0x1p+0)) (f32.const -0x1.fffffep+127)) +(assert_return (invoke "copysign" (f32.const -0x1.fffffep+127) (f32.const 0x1p+0)) (f32.const 0x1.fffffep+127)) +(assert_return (invoke "copysign" (f32.const 0x1.fffffep+127) (f32.const -0x1p+0)) (f32.const -0x1.fffffep+127)) +(assert_return (invoke "copysign" (f32.const 0x1.fffffep+127) (f32.const 0x1p+0)) (f32.const 0x1.fffffep+127)) +(assert_return (invoke "copysign" (f32.const -0x1.fffffep+127) (f32.const -0x1.921fb6p+2)) (f32.const -0x1.fffffep+127)) +(assert_return (invoke "copysign" (f32.const -0x1.fffffep+127) (f32.const 0x1.921fb6p+2)) (f32.const 0x1.fffffep+127)) +(assert_return (invoke "copysign" (f32.const 0x1.fffffep+127) (f32.const -0x1.921fb6p+2)) (f32.const -0x1.fffffep+127)) +(assert_return (invoke "copysign" (f32.const 0x1.fffffep+127) (f32.const 0x1.921fb6p+2)) (f32.const 0x1.fffffep+127)) +(assert_return (invoke "copysign" (f32.const -0x1.fffffep+127) (f32.const -0x1.fffffep+127)) (f32.const -0x1.fffffep+127)) +(assert_return (invoke "copysign" (f32.const -0x1.fffffep+127) (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127)) +(assert_return (invoke "copysign" (f32.const 0x1.fffffep+127) (f32.const -0x1.fffffep+127)) (f32.const -0x1.fffffep+127)) +(assert_return (invoke "copysign" (f32.const 0x1.fffffep+127) (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127)) +(assert_return (invoke "copysign" (f32.const -0x1.fffffep+127) (f32.const -inf)) (f32.const -0x1.fffffep+127)) +(assert_return (invoke "copysign" (f32.const -0x1.fffffep+127) (f32.const inf)) (f32.const 0x1.fffffep+127)) +(assert_return (invoke "copysign" (f32.const 0x1.fffffep+127) (f32.const -inf)) (f32.const -0x1.fffffep+127)) +(assert_return (invoke "copysign" (f32.const 0x1.fffffep+127) (f32.const inf)) (f32.const 0x1.fffffep+127)) +(assert_return (invoke "copysign" (f32.const -0x1.fffffep+127) (f32.const -nan)) (f32.const -0x1.fffffep+127)) +(assert_return (invoke "copysign" (f32.const -0x1.fffffep+127) (f32.const nan)) (f32.const 0x1.fffffep+127)) +(assert_return (invoke "copysign" (f32.const 0x1.fffffep+127) (f32.const -nan)) (f32.const -0x1.fffffep+127)) +(assert_return (invoke "copysign" (f32.const 0x1.fffffep+127) (f32.const nan)) (f32.const 0x1.fffffep+127)) +(assert_return (invoke "copysign" (f32.const -inf) (f32.const -0x0p+0)) (f32.const -inf)) +(assert_return (invoke "copysign" (f32.const -inf) (f32.const 0x0p+0)) (f32.const inf)) +(assert_return (invoke "copysign" (f32.const inf) (f32.const -0x0p+0)) (f32.const -inf)) +(assert_return (invoke "copysign" (f32.const inf) (f32.const 0x0p+0)) (f32.const inf)) +(assert_return (invoke "copysign" (f32.const -inf) (f32.const -0x1p-149)) (f32.const -inf)) +(assert_return (invoke "copysign" (f32.const -inf) (f32.const 0x1p-149)) (f32.const inf)) +(assert_return (invoke "copysign" (f32.const inf) (f32.const -0x1p-149)) (f32.const -inf)) +(assert_return (invoke "copysign" (f32.const inf) (f32.const 0x1p-149)) (f32.const inf)) +(assert_return (invoke "copysign" (f32.const -inf) (f32.const -0x1p-126)) (f32.const -inf)) +(assert_return (invoke "copysign" (f32.const -inf) (f32.const 0x1p-126)) (f32.const inf)) +(assert_return (invoke "copysign" (f32.const inf) (f32.const -0x1p-126)) (f32.const -inf)) +(assert_return (invoke "copysign" (f32.const inf) (f32.const 0x1p-126)) (f32.const inf)) +(assert_return (invoke "copysign" (f32.const -inf) (f32.const -0x1p-1)) (f32.const -inf)) +(assert_return (invoke "copysign" (f32.const -inf) (f32.const 0x1p-1)) (f32.const inf)) +(assert_return (invoke "copysign" (f32.const inf) (f32.const -0x1p-1)) (f32.const -inf)) +(assert_return (invoke "copysign" (f32.const inf) (f32.const 0x1p-1)) (f32.const inf)) +(assert_return (invoke "copysign" (f32.const -inf) (f32.const -0x1p+0)) (f32.const -inf)) +(assert_return (invoke "copysign" (f32.const -inf) (f32.const 0x1p+0)) (f32.const inf)) +(assert_return (invoke "copysign" (f32.const inf) (f32.const -0x1p+0)) (f32.const -inf)) +(assert_return (invoke "copysign" (f32.const inf) (f32.const 0x1p+0)) (f32.const inf)) +(assert_return (invoke "copysign" (f32.const -inf) (f32.const -0x1.921fb6p+2)) (f32.const -inf)) +(assert_return (invoke "copysign" (f32.const -inf) (f32.const 0x1.921fb6p+2)) (f32.const inf)) +(assert_return (invoke "copysign" (f32.const inf) (f32.const -0x1.921fb6p+2)) (f32.const -inf)) +(assert_return (invoke "copysign" (f32.const inf) (f32.const 0x1.921fb6p+2)) (f32.const inf)) +(assert_return (invoke "copysign" (f32.const -inf) (f32.const -0x1.fffffep+127)) (f32.const -inf)) +(assert_return (invoke "copysign" (f32.const -inf) (f32.const 0x1.fffffep+127)) (f32.const inf)) +(assert_return (invoke "copysign" (f32.const inf) (f32.const -0x1.fffffep+127)) (f32.const -inf)) +(assert_return (invoke "copysign" (f32.const inf) (f32.const 0x1.fffffep+127)) (f32.const inf)) +(assert_return (invoke "copysign" (f32.const -inf) (f32.const -inf)) (f32.const -inf)) +(assert_return (invoke "copysign" (f32.const -inf) (f32.const inf)) (f32.const inf)) +(assert_return (invoke "copysign" (f32.const inf) (f32.const -inf)) (f32.const -inf)) +(assert_return (invoke "copysign" (f32.const inf) (f32.const inf)) (f32.const inf)) +(assert_return (invoke "copysign" (f32.const -inf) (f32.const -nan)) (f32.const -inf)) +(assert_return (invoke "copysign" (f32.const -inf) (f32.const nan)) (f32.const inf)) +(assert_return (invoke "copysign" (f32.const inf) (f32.const -nan)) (f32.const -inf)) +(assert_return (invoke "copysign" (f32.const inf) (f32.const nan)) (f32.const inf)) +(assert_return (invoke "copysign" (f32.const -nan) (f32.const -0x0p+0)) (f32.const -nan)) +(assert_return (invoke "copysign" (f32.const -nan) (f32.const 0x0p+0)) (f32.const nan)) +(assert_return (invoke "copysign" (f32.const nan) (f32.const -0x0p+0)) (f32.const -nan)) +(assert_return (invoke "copysign" (f32.const nan) (f32.const 0x0p+0)) (f32.const nan)) +(assert_return (invoke "copysign" (f32.const -nan) (f32.const -0x1p-149)) (f32.const -nan)) +(assert_return (invoke "copysign" (f32.const -nan) (f32.const 0x1p-149)) (f32.const nan)) +(assert_return (invoke "copysign" (f32.const nan) (f32.const -0x1p-149)) (f32.const -nan)) +(assert_return (invoke "copysign" (f32.const nan) (f32.const 0x1p-149)) (f32.const nan)) +(assert_return (invoke "copysign" (f32.const -nan) (f32.const -0x1p-126)) (f32.const -nan)) +(assert_return (invoke "copysign" (f32.const -nan) (f32.const 0x1p-126)) (f32.const nan)) +(assert_return (invoke "copysign" (f32.const nan) (f32.const -0x1p-126)) (f32.const -nan)) +(assert_return (invoke "copysign" (f32.const nan) (f32.const 0x1p-126)) (f32.const nan)) +(assert_return (invoke "copysign" (f32.const -nan) (f32.const -0x1p-1)) (f32.const -nan)) +(assert_return (invoke "copysign" (f32.const -nan) (f32.const 0x1p-1)) (f32.const nan)) +(assert_return (invoke "copysign" (f32.const nan) (f32.const -0x1p-1)) (f32.const -nan)) +(assert_return (invoke "copysign" (f32.const nan) (f32.const 0x1p-1)) (f32.const nan)) +(assert_return (invoke "copysign" (f32.const -nan) (f32.const -0x1p+0)) (f32.const -nan)) +(assert_return (invoke "copysign" (f32.const -nan) (f32.const 0x1p+0)) (f32.const nan)) +(assert_return (invoke "copysign" (f32.const nan) (f32.const -0x1p+0)) (f32.const -nan)) +(assert_return (invoke "copysign" (f32.const nan) (f32.const 0x1p+0)) (f32.const nan)) +(assert_return (invoke "copysign" (f32.const -nan) (f32.const -0x1.921fb6p+2)) (f32.const -nan)) +(assert_return (invoke "copysign" (f32.const -nan) (f32.const 0x1.921fb6p+2)) (f32.const nan)) +(assert_return (invoke "copysign" (f32.const nan) (f32.const -0x1.921fb6p+2)) (f32.const -nan)) +(assert_return (invoke "copysign" (f32.const nan) (f32.const 0x1.921fb6p+2)) (f32.const nan)) +(assert_return (invoke "copysign" (f32.const -nan) (f32.const -0x1.fffffep+127)) (f32.const -nan)) +(assert_return (invoke "copysign" (f32.const -nan) (f32.const 0x1.fffffep+127)) (f32.const nan)) +(assert_return (invoke "copysign" (f32.const nan) (f32.const -0x1.fffffep+127)) (f32.const -nan)) +(assert_return (invoke "copysign" (f32.const nan) (f32.const 0x1.fffffep+127)) (f32.const nan)) +(assert_return (invoke "copysign" (f32.const -nan) (f32.const -inf)) (f32.const -nan)) +(assert_return (invoke "copysign" (f32.const -nan) (f32.const inf)) (f32.const nan)) +(assert_return (invoke "copysign" (f32.const nan) (f32.const -inf)) (f32.const -nan)) +(assert_return (invoke "copysign" (f32.const nan) (f32.const inf)) (f32.const nan)) +(assert_return (invoke "copysign" (f32.const -nan) (f32.const -nan)) (f32.const -nan)) +(assert_return (invoke "copysign" (f32.const -nan) (f32.const nan)) (f32.const nan)) +(assert_return (invoke "copysign" (f32.const nan) (f32.const -nan)) (f32.const -nan)) +(assert_return (invoke "copysign" (f32.const nan) (f32.const nan)) (f32.const nan)) +(assert_return (invoke "abs" (f32.const -0x0p+0)) (f32.const 0x0p+0)) +(assert_return (invoke "abs" (f32.const 0x0p+0)) (f32.const 0x0p+0)) +(assert_return (invoke "abs" (f32.const -0x1p-149)) (f32.const 0x1p-149)) +(assert_return (invoke "abs" (f32.const 0x1p-149)) (f32.const 0x1p-149)) +(assert_return (invoke "abs" (f32.const -0x1p-126)) (f32.const 0x1p-126)) +(assert_return (invoke "abs" (f32.const 0x1p-126)) (f32.const 0x1p-126)) +(assert_return (invoke "abs" (f32.const -0x1p-1)) (f32.const 0x1p-1)) +(assert_return (invoke "abs" (f32.const 0x1p-1)) (f32.const 0x1p-1)) +(assert_return (invoke "abs" (f32.const -0x1p+0)) (f32.const 0x1p+0)) +(assert_return (invoke "abs" (f32.const 0x1p+0)) (f32.const 0x1p+0)) +(assert_return (invoke "abs" (f32.const -0x1.921fb6p+2)) (f32.const 0x1.921fb6p+2)) +(assert_return (invoke "abs" (f32.const 0x1.921fb6p+2)) (f32.const 0x1.921fb6p+2)) +(assert_return (invoke "abs" (f32.const -0x1.fffffep+127)) (f32.const 0x1.fffffep+127)) +(assert_return (invoke "abs" (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127)) +(assert_return (invoke "abs" (f32.const -inf)) (f32.const inf)) +(assert_return (invoke "abs" (f32.const inf)) (f32.const inf)) +(assert_return (invoke "abs" (f32.const -nan)) (f32.const nan)) +(assert_return (invoke "abs" (f32.const nan)) (f32.const nan)) +(assert_return (invoke "neg" (f32.const -0x0p+0)) (f32.const 0x0p+0)) +(assert_return (invoke "neg" (f32.const 0x0p+0)) (f32.const -0x0p+0)) +(assert_return (invoke "neg" (f32.const -0x1p-149)) (f32.const 0x1p-149)) +(assert_return (invoke "neg" (f32.const 0x1p-149)) (f32.const -0x1p-149)) +(assert_return (invoke "neg" (f32.const -0x1p-126)) (f32.const 0x1p-126)) +(assert_return (invoke "neg" (f32.const 0x1p-126)) (f32.const -0x1p-126)) +(assert_return (invoke "neg" (f32.const -0x1p-1)) (f32.const 0x1p-1)) +(assert_return (invoke "neg" (f32.const 0x1p-1)) (f32.const -0x1p-1)) +(assert_return (invoke "neg" (f32.const -0x1p+0)) (f32.const 0x1p+0)) +(assert_return (invoke "neg" (f32.const 0x1p+0)) (f32.const -0x1p+0)) +(assert_return (invoke "neg" (f32.const -0x1.921fb6p+2)) (f32.const 0x1.921fb6p+2)) +(assert_return (invoke "neg" (f32.const 0x1.921fb6p+2)) (f32.const -0x1.921fb6p+2)) +(assert_return (invoke "neg" (f32.const -0x1.fffffep+127)) (f32.const 0x1.fffffep+127)) +(assert_return (invoke "neg" (f32.const 0x1.fffffep+127)) (f32.const -0x1.fffffep+127)) +(assert_return (invoke "neg" (f32.const -inf)) (f32.const inf)) +(assert_return (invoke "neg" (f32.const inf)) (f32.const -inf)) +(assert_return (invoke "neg" (f32.const -nan)) (f32.const nan)) +(assert_return (invoke "neg" (f32.const nan)) (f32.const -nan)) + + +;; Type check + +(assert_invalid (module (func (result f32) (f32.copysign (i64.const 0) (f64.const 0)))) "type mismatch") +(assert_invalid (module (func (result f32) (f32.abs (i64.const 0)))) "type mismatch") +(assert_invalid (module (func (result f32) (f32.neg (i64.const 0)))) "type mismatch") diff --git a/runtime/near-vm/tests/wast/spec/f32_cmp.wast b/runtime/near-vm/tests/wast/spec/f32_cmp.wast new file mode 100644 index 00000000000..0dd7167c038 --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/f32_cmp.wast @@ -0,0 +1,2422 @@ +;; Test all the f32 comparison operators on major boundary values and all +;; special values. + +(module + (func (export "eq") (param $x f32) (param $y f32) (result i32) (f32.eq (local.get $x) (local.get $y))) + (func (export "ne") (param $x f32) (param $y f32) (result i32) (f32.ne (local.get $x) (local.get $y))) + (func (export "lt") (param $x f32) (param $y f32) (result i32) (f32.lt (local.get $x) (local.get $y))) + (func (export "le") (param $x f32) (param $y f32) (result i32) (f32.le (local.get $x) (local.get $y))) + (func (export "gt") (param $x f32) (param $y f32) (result i32) (f32.gt (local.get $x) (local.get $y))) + (func (export "ge") (param $x f32) (param $y f32) (result i32) (f32.ge (local.get $x) (local.get $y))) +) + +(assert_return (invoke "eq" (f32.const -0x0p+0) (f32.const -0x0p+0)) (i32.const 1)) +(assert_return (invoke "eq" (f32.const -0x0p+0) (f32.const 0x0p+0)) (i32.const 1)) +(assert_return (invoke "eq" (f32.const 0x0p+0) (f32.const -0x0p+0)) (i32.const 1)) +(assert_return (invoke "eq" (f32.const 0x0p+0) (f32.const 0x0p+0)) (i32.const 1)) +(assert_return (invoke "eq" (f32.const -0x0p+0) (f32.const -0x1p-149)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -0x0p+0) (f32.const 0x1p-149)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const 0x0p+0) (f32.const -0x1p-149)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const 0x0p+0) (f32.const 0x1p-149)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -0x0p+0) (f32.const -0x1p-126)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -0x0p+0) (f32.const 0x1p-126)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const 0x0p+0) (f32.const -0x1p-126)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const 0x0p+0) (f32.const 0x1p-126)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -0x0p+0) (f32.const -0x1p-1)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -0x0p+0) (f32.const 0x1p-1)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const 0x0p+0) (f32.const -0x1p-1)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const 0x0p+0) (f32.const 0x1p-1)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -0x0p+0) (f32.const -0x1p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -0x0p+0) (f32.const 0x1p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const 0x0p+0) (f32.const -0x1p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const 0x0p+0) (f32.const 0x1p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -0x0p+0) (f32.const -0x1.921fb6p+2)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -0x0p+0) (f32.const 0x1.921fb6p+2)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const 0x0p+0) (f32.const -0x1.921fb6p+2)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const 0x0p+0) (f32.const 0x1.921fb6p+2)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -0x0p+0) (f32.const -0x1.fffffep+127)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -0x0p+0) (f32.const 0x1.fffffep+127)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const 0x0p+0) (f32.const -0x1.fffffep+127)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const 0x0p+0) (f32.const 0x1.fffffep+127)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -0x0p+0) (f32.const -inf)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -0x0p+0) (f32.const inf)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const 0x0p+0) (f32.const -inf)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const 0x0p+0) (f32.const inf)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -0x0p+0) (f32.const -nan)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -0x0p+0) (f32.const -nan:0x200000)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -0x0p+0) (f32.const nan)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -0x0p+0) (f32.const nan:0x200000)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const 0x0p+0) (f32.const -nan)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const 0x0p+0) (f32.const -nan:0x200000)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const 0x0p+0) (f32.const nan)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const 0x0p+0) (f32.const nan:0x200000)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -0x1p-149) (f32.const -0x0p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -0x1p-149) (f32.const 0x0p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const 0x1p-149) (f32.const -0x0p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const 0x1p-149) (f32.const 0x0p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -0x1p-149) (f32.const -0x1p-149)) (i32.const 1)) +(assert_return (invoke "eq" (f32.const -0x1p-149) (f32.const 0x1p-149)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const 0x1p-149) (f32.const -0x1p-149)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const 0x1p-149) (f32.const 0x1p-149)) (i32.const 1)) +(assert_return (invoke "eq" (f32.const -0x1p-149) (f32.const -0x1p-126)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -0x1p-149) (f32.const 0x1p-126)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const 0x1p-149) (f32.const -0x1p-126)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const 0x1p-149) (f32.const 0x1p-126)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -0x1p-149) (f32.const -0x1p-1)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -0x1p-149) (f32.const 0x1p-1)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const 0x1p-149) (f32.const -0x1p-1)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const 0x1p-149) (f32.const 0x1p-1)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -0x1p-149) (f32.const -0x1p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -0x1p-149) (f32.const 0x1p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const 0x1p-149) (f32.const -0x1p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const 0x1p-149) (f32.const 0x1p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -0x1p-149) (f32.const -0x1.921fb6p+2)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -0x1p-149) (f32.const 0x1.921fb6p+2)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const 0x1p-149) (f32.const -0x1.921fb6p+2)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const 0x1p-149) (f32.const 0x1.921fb6p+2)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -0x1p-149) (f32.const -0x1.fffffep+127)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -0x1p-149) (f32.const 0x1.fffffep+127)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const 0x1p-149) (f32.const -0x1.fffffep+127)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const 0x1p-149) (f32.const 0x1.fffffep+127)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -0x1p-149) (f32.const -inf)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -0x1p-149) (f32.const inf)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const 0x1p-149) (f32.const -inf)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const 0x1p-149) (f32.const inf)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -0x1p-149) (f32.const -nan)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -0x1p-149) (f32.const -nan:0x200000)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -0x1p-149) (f32.const nan)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -0x1p-149) (f32.const nan:0x200000)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const 0x1p-149) (f32.const -nan)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const 0x1p-149) (f32.const -nan:0x200000)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const 0x1p-149) (f32.const nan)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const 0x1p-149) (f32.const nan:0x200000)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -0x1p-126) (f32.const -0x0p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -0x1p-126) (f32.const 0x0p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const 0x1p-126) (f32.const -0x0p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const 0x1p-126) (f32.const 0x0p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -0x1p-126) (f32.const -0x1p-149)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -0x1p-126) (f32.const 0x1p-149)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const 0x1p-126) (f32.const -0x1p-149)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const 0x1p-126) (f32.const 0x1p-149)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -0x1p-126) (f32.const -0x1p-126)) (i32.const 1)) +(assert_return (invoke "eq" (f32.const -0x1p-126) (f32.const 0x1p-126)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const 0x1p-126) (f32.const -0x1p-126)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const 0x1p-126) (f32.const 0x1p-126)) (i32.const 1)) +(assert_return (invoke "eq" (f32.const -0x1p-126) (f32.const -0x1p-1)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -0x1p-126) (f32.const 0x1p-1)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const 0x1p-126) (f32.const -0x1p-1)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const 0x1p-126) (f32.const 0x1p-1)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -0x1p-126) (f32.const -0x1p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -0x1p-126) (f32.const 0x1p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const 0x1p-126) (f32.const -0x1p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const 0x1p-126) (f32.const 0x1p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -0x1p-126) (f32.const -0x1.921fb6p+2)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -0x1p-126) (f32.const 0x1.921fb6p+2)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const 0x1p-126) (f32.const -0x1.921fb6p+2)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const 0x1p-126) (f32.const 0x1.921fb6p+2)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -0x1p-126) (f32.const -0x1.fffffep+127)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -0x1p-126) (f32.const 0x1.fffffep+127)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const 0x1p-126) (f32.const -0x1.fffffep+127)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const 0x1p-126) (f32.const 0x1.fffffep+127)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -0x1p-126) (f32.const -inf)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -0x1p-126) (f32.const inf)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const 0x1p-126) (f32.const -inf)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const 0x1p-126) (f32.const inf)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -0x1p-126) (f32.const -nan)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -0x1p-126) (f32.const -nan:0x200000)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -0x1p-126) (f32.const nan)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -0x1p-126) (f32.const nan:0x200000)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const 0x1p-126) (f32.const -nan)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const 0x1p-126) (f32.const -nan:0x200000)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const 0x1p-126) (f32.const nan)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const 0x1p-126) (f32.const nan:0x200000)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -0x1p-1) (f32.const -0x0p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -0x1p-1) (f32.const 0x0p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const 0x1p-1) (f32.const -0x0p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const 0x1p-1) (f32.const 0x0p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -0x1p-1) (f32.const -0x1p-149)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -0x1p-1) (f32.const 0x1p-149)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const 0x1p-1) (f32.const -0x1p-149)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const 0x1p-1) (f32.const 0x1p-149)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -0x1p-1) (f32.const -0x1p-126)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -0x1p-1) (f32.const 0x1p-126)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const 0x1p-1) (f32.const -0x1p-126)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const 0x1p-1) (f32.const 0x1p-126)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -0x1p-1) (f32.const -0x1p-1)) (i32.const 1)) +(assert_return (invoke "eq" (f32.const -0x1p-1) (f32.const 0x1p-1)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const 0x1p-1) (f32.const -0x1p-1)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const 0x1p-1) (f32.const 0x1p-1)) (i32.const 1)) +(assert_return (invoke "eq" (f32.const -0x1p-1) (f32.const -0x1p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -0x1p-1) (f32.const 0x1p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const 0x1p-1) (f32.const -0x1p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const 0x1p-1) (f32.const 0x1p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -0x1p-1) (f32.const -0x1.921fb6p+2)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -0x1p-1) (f32.const 0x1.921fb6p+2)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const 0x1p-1) (f32.const -0x1.921fb6p+2)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const 0x1p-1) (f32.const 0x1.921fb6p+2)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -0x1p-1) (f32.const -0x1.fffffep+127)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -0x1p-1) (f32.const 0x1.fffffep+127)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const 0x1p-1) (f32.const -0x1.fffffep+127)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const 0x1p-1) (f32.const 0x1.fffffep+127)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -0x1p-1) (f32.const -inf)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -0x1p-1) (f32.const inf)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const 0x1p-1) (f32.const -inf)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const 0x1p-1) (f32.const inf)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -0x1p-1) (f32.const -nan)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -0x1p-1) (f32.const -nan:0x200000)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -0x1p-1) (f32.const nan)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -0x1p-1) (f32.const nan:0x200000)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const 0x1p-1) (f32.const -nan)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const 0x1p-1) (f32.const -nan:0x200000)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const 0x1p-1) (f32.const nan)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const 0x1p-1) (f32.const nan:0x200000)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -0x1p+0) (f32.const -0x0p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -0x1p+0) (f32.const 0x0p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const 0x1p+0) (f32.const -0x0p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const 0x1p+0) (f32.const 0x0p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -0x1p+0) (f32.const -0x1p-149)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -0x1p+0) (f32.const 0x1p-149)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const 0x1p+0) (f32.const -0x1p-149)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const 0x1p+0) (f32.const 0x1p-149)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -0x1p+0) (f32.const -0x1p-126)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -0x1p+0) (f32.const 0x1p-126)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const 0x1p+0) (f32.const -0x1p-126)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const 0x1p+0) (f32.const 0x1p-126)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -0x1p+0) (f32.const -0x1p-1)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -0x1p+0) (f32.const 0x1p-1)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const 0x1p+0) (f32.const -0x1p-1)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const 0x1p+0) (f32.const 0x1p-1)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -0x1p+0) (f32.const -0x1p+0)) (i32.const 1)) +(assert_return (invoke "eq" (f32.const -0x1p+0) (f32.const 0x1p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const 0x1p+0) (f32.const -0x1p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const 0x1p+0) (f32.const 0x1p+0)) (i32.const 1)) +(assert_return (invoke "eq" (f32.const -0x1p+0) (f32.const -0x1.921fb6p+2)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -0x1p+0) (f32.const 0x1.921fb6p+2)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const 0x1p+0) (f32.const -0x1.921fb6p+2)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const 0x1p+0) (f32.const 0x1.921fb6p+2)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -0x1p+0) (f32.const -0x1.fffffep+127)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -0x1p+0) (f32.const 0x1.fffffep+127)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const 0x1p+0) (f32.const -0x1.fffffep+127)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const 0x1p+0) (f32.const 0x1.fffffep+127)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -0x1p+0) (f32.const -inf)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -0x1p+0) (f32.const inf)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const 0x1p+0) (f32.const -inf)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const 0x1p+0) (f32.const inf)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -0x1p+0) (f32.const -nan)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -0x1p+0) (f32.const -nan:0x200000)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -0x1p+0) (f32.const nan)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -0x1p+0) (f32.const nan:0x200000)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const 0x1p+0) (f32.const -nan)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const 0x1p+0) (f32.const -nan:0x200000)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const 0x1p+0) (f32.const nan)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const 0x1p+0) (f32.const nan:0x200000)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -0x1.921fb6p+2) (f32.const -0x0p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -0x1.921fb6p+2) (f32.const 0x0p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const 0x1.921fb6p+2) (f32.const -0x0p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const 0x1.921fb6p+2) (f32.const 0x0p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -0x1.921fb6p+2) (f32.const -0x1p-149)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -0x1.921fb6p+2) (f32.const 0x1p-149)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const 0x1.921fb6p+2) (f32.const -0x1p-149)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const 0x1.921fb6p+2) (f32.const 0x1p-149)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -0x1.921fb6p+2) (f32.const -0x1p-126)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -0x1.921fb6p+2) (f32.const 0x1p-126)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const 0x1.921fb6p+2) (f32.const -0x1p-126)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const 0x1.921fb6p+2) (f32.const 0x1p-126)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -0x1.921fb6p+2) (f32.const -0x1p-1)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -0x1.921fb6p+2) (f32.const 0x1p-1)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const 0x1.921fb6p+2) (f32.const -0x1p-1)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const 0x1.921fb6p+2) (f32.const 0x1p-1)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -0x1.921fb6p+2) (f32.const -0x1p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -0x1.921fb6p+2) (f32.const 0x1p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const 0x1.921fb6p+2) (f32.const -0x1p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const 0x1.921fb6p+2) (f32.const 0x1p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -0x1.921fb6p+2) (f32.const -0x1.921fb6p+2)) (i32.const 1)) +(assert_return (invoke "eq" (f32.const -0x1.921fb6p+2) (f32.const 0x1.921fb6p+2)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const 0x1.921fb6p+2) (f32.const -0x1.921fb6p+2)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const 0x1.921fb6p+2) (f32.const 0x1.921fb6p+2)) (i32.const 1)) +(assert_return (invoke "eq" (f32.const -0x1.921fb6p+2) (f32.const -0x1.fffffep+127)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -0x1.921fb6p+2) (f32.const 0x1.fffffep+127)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const 0x1.921fb6p+2) (f32.const -0x1.fffffep+127)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const 0x1.921fb6p+2) (f32.const 0x1.fffffep+127)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -0x1.921fb6p+2) (f32.const -inf)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -0x1.921fb6p+2) (f32.const inf)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const 0x1.921fb6p+2) (f32.const -inf)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const 0x1.921fb6p+2) (f32.const inf)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -0x1.921fb6p+2) (f32.const -nan)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -0x1.921fb6p+2) (f32.const -nan:0x200000)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -0x1.921fb6p+2) (f32.const nan)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -0x1.921fb6p+2) (f32.const nan:0x200000)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const 0x1.921fb6p+2) (f32.const -nan)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const 0x1.921fb6p+2) (f32.const -nan:0x200000)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const 0x1.921fb6p+2) (f32.const nan)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const 0x1.921fb6p+2) (f32.const nan:0x200000)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -0x1.fffffep+127) (f32.const -0x0p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -0x1.fffffep+127) (f32.const 0x0p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const 0x1.fffffep+127) (f32.const -0x0p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const 0x1.fffffep+127) (f32.const 0x0p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -0x1.fffffep+127) (f32.const -0x1p-149)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -0x1.fffffep+127) (f32.const 0x1p-149)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const 0x1.fffffep+127) (f32.const -0x1p-149)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const 0x1.fffffep+127) (f32.const 0x1p-149)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -0x1.fffffep+127) (f32.const -0x1p-126)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -0x1.fffffep+127) (f32.const 0x1p-126)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const 0x1.fffffep+127) (f32.const -0x1p-126)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const 0x1.fffffep+127) (f32.const 0x1p-126)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -0x1.fffffep+127) (f32.const -0x1p-1)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -0x1.fffffep+127) (f32.const 0x1p-1)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const 0x1.fffffep+127) (f32.const -0x1p-1)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const 0x1.fffffep+127) (f32.const 0x1p-1)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -0x1.fffffep+127) (f32.const -0x1p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -0x1.fffffep+127) (f32.const 0x1p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const 0x1.fffffep+127) (f32.const -0x1p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const 0x1.fffffep+127) (f32.const 0x1p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -0x1.fffffep+127) (f32.const -0x1.921fb6p+2)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -0x1.fffffep+127) (f32.const 0x1.921fb6p+2)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const 0x1.fffffep+127) (f32.const -0x1.921fb6p+2)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const 0x1.fffffep+127) (f32.const 0x1.921fb6p+2)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -0x1.fffffep+127) (f32.const -0x1.fffffep+127)) (i32.const 1)) +(assert_return (invoke "eq" (f32.const -0x1.fffffep+127) (f32.const 0x1.fffffep+127)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const 0x1.fffffep+127) (f32.const -0x1.fffffep+127)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const 0x1.fffffep+127) (f32.const 0x1.fffffep+127)) (i32.const 1)) +(assert_return (invoke "eq" (f32.const -0x1.fffffep+127) (f32.const -inf)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -0x1.fffffep+127) (f32.const inf)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const 0x1.fffffep+127) (f32.const -inf)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const 0x1.fffffep+127) (f32.const inf)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -0x1.fffffep+127) (f32.const -nan)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -0x1.fffffep+127) (f32.const -nan:0x200000)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -0x1.fffffep+127) (f32.const nan)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -0x1.fffffep+127) (f32.const nan:0x200000)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const 0x1.fffffep+127) (f32.const -nan)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const 0x1.fffffep+127) (f32.const -nan:0x200000)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const 0x1.fffffep+127) (f32.const nan)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const 0x1.fffffep+127) (f32.const nan:0x200000)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -inf) (f32.const -0x0p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -inf) (f32.const 0x0p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const inf) (f32.const -0x0p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const inf) (f32.const 0x0p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -inf) (f32.const -0x1p-149)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -inf) (f32.const 0x1p-149)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const inf) (f32.const -0x1p-149)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const inf) (f32.const 0x1p-149)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -inf) (f32.const -0x1p-126)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -inf) (f32.const 0x1p-126)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const inf) (f32.const -0x1p-126)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const inf) (f32.const 0x1p-126)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -inf) (f32.const -0x1p-1)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -inf) (f32.const 0x1p-1)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const inf) (f32.const -0x1p-1)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const inf) (f32.const 0x1p-1)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -inf) (f32.const -0x1p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -inf) (f32.const 0x1p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const inf) (f32.const -0x1p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const inf) (f32.const 0x1p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -inf) (f32.const -0x1.921fb6p+2)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -inf) (f32.const 0x1.921fb6p+2)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const inf) (f32.const -0x1.921fb6p+2)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const inf) (f32.const 0x1.921fb6p+2)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -inf) (f32.const -0x1.fffffep+127)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -inf) (f32.const 0x1.fffffep+127)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const inf) (f32.const -0x1.fffffep+127)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const inf) (f32.const 0x1.fffffep+127)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -inf) (f32.const -inf)) (i32.const 1)) +(assert_return (invoke "eq" (f32.const -inf) (f32.const inf)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const inf) (f32.const -inf)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const inf) (f32.const inf)) (i32.const 1)) +(assert_return (invoke "eq" (f32.const -inf) (f32.const -nan)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -inf) (f32.const -nan:0x200000)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -inf) (f32.const nan)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -inf) (f32.const nan:0x200000)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const inf) (f32.const -nan)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const inf) (f32.const -nan:0x200000)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const inf) (f32.const nan)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const inf) (f32.const nan:0x200000)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -nan) (f32.const -0x0p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -nan:0x200000) (f32.const -0x0p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -nan) (f32.const 0x0p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -nan:0x200000) (f32.const 0x0p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const nan) (f32.const -0x0p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const nan:0x200000) (f32.const -0x0p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const nan) (f32.const 0x0p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const nan:0x200000) (f32.const 0x0p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -nan) (f32.const -0x1p-149)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -nan:0x200000) (f32.const -0x1p-149)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -nan) (f32.const 0x1p-149)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -nan:0x200000) (f32.const 0x1p-149)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const nan) (f32.const -0x1p-149)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const nan:0x200000) (f32.const -0x1p-149)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const nan) (f32.const 0x1p-149)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const nan:0x200000) (f32.const 0x1p-149)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -nan) (f32.const -0x1p-126)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -nan:0x200000) (f32.const -0x1p-126)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -nan) (f32.const 0x1p-126)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -nan:0x200000) (f32.const 0x1p-126)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const nan) (f32.const -0x1p-126)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const nan:0x200000) (f32.const -0x1p-126)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const nan) (f32.const 0x1p-126)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const nan:0x200000) (f32.const 0x1p-126)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -nan) (f32.const -0x1p-1)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -nan:0x200000) (f32.const -0x1p-1)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -nan) (f32.const 0x1p-1)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -nan:0x200000) (f32.const 0x1p-1)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const nan) (f32.const -0x1p-1)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const nan:0x200000) (f32.const -0x1p-1)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const nan) (f32.const 0x1p-1)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const nan:0x200000) (f32.const 0x1p-1)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -nan) (f32.const -0x1p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -nan:0x200000) (f32.const -0x1p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -nan) (f32.const 0x1p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -nan:0x200000) (f32.const 0x1p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const nan) (f32.const -0x1p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const nan:0x200000) (f32.const -0x1p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const nan) (f32.const 0x1p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const nan:0x200000) (f32.const 0x1p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -nan) (f32.const -0x1.921fb6p+2)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -nan:0x200000) (f32.const -0x1.921fb6p+2)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -nan) (f32.const 0x1.921fb6p+2)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -nan:0x200000) (f32.const 0x1.921fb6p+2)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const nan) (f32.const -0x1.921fb6p+2)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const nan:0x200000) (f32.const -0x1.921fb6p+2)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const nan) (f32.const 0x1.921fb6p+2)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const nan:0x200000) (f32.const 0x1.921fb6p+2)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -nan) (f32.const -0x1.fffffep+127)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -nan:0x200000) (f32.const -0x1.fffffep+127)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -nan) (f32.const 0x1.fffffep+127)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -nan:0x200000) (f32.const 0x1.fffffep+127)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const nan) (f32.const -0x1.fffffep+127)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const nan:0x200000) (f32.const -0x1.fffffep+127)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const nan) (f32.const 0x1.fffffep+127)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const nan:0x200000) (f32.const 0x1.fffffep+127)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -nan) (f32.const -inf)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -nan:0x200000) (f32.const -inf)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -nan) (f32.const inf)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -nan:0x200000) (f32.const inf)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const nan) (f32.const -inf)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const nan:0x200000) (f32.const -inf)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const nan) (f32.const inf)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const nan:0x200000) (f32.const inf)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -nan) (f32.const -nan)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -nan:0x200000) (f32.const -nan)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -nan) (f32.const -nan:0x200000)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -nan:0x200000) (f32.const -nan:0x200000)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -nan) (f32.const nan)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -nan:0x200000) (f32.const nan)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -nan) (f32.const nan:0x200000)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const -nan:0x200000) (f32.const nan:0x200000)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const nan) (f32.const -nan)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const nan:0x200000) (f32.const -nan)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const nan) (f32.const -nan:0x200000)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const nan:0x200000) (f32.const -nan:0x200000)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const nan) (f32.const nan)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const nan:0x200000) (f32.const nan)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const nan) (f32.const nan:0x200000)) (i32.const 0)) +(assert_return (invoke "eq" (f32.const nan:0x200000) (f32.const nan:0x200000)) (i32.const 0)) +(assert_return (invoke "ne" (f32.const -0x0p+0) (f32.const -0x0p+0)) (i32.const 0)) +(assert_return (invoke "ne" (f32.const -0x0p+0) (f32.const 0x0p+0)) (i32.const 0)) +(assert_return (invoke "ne" (f32.const 0x0p+0) (f32.const -0x0p+0)) (i32.const 0)) +(assert_return (invoke "ne" (f32.const 0x0p+0) (f32.const 0x0p+0)) (i32.const 0)) +(assert_return (invoke "ne" (f32.const -0x0p+0) (f32.const -0x1p-149)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -0x0p+0) (f32.const 0x1p-149)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const 0x0p+0) (f32.const -0x1p-149)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const 0x0p+0) (f32.const 0x1p-149)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -0x0p+0) (f32.const -0x1p-126)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -0x0p+0) (f32.const 0x1p-126)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const 0x0p+0) (f32.const -0x1p-126)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const 0x0p+0) (f32.const 0x1p-126)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -0x0p+0) (f32.const -0x1p-1)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -0x0p+0) (f32.const 0x1p-1)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const 0x0p+0) (f32.const -0x1p-1)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const 0x0p+0) (f32.const 0x1p-1)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -0x0p+0) (f32.const -0x1p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -0x0p+0) (f32.const 0x1p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const 0x0p+0) (f32.const -0x1p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const 0x0p+0) (f32.const 0x1p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -0x0p+0) (f32.const -0x1.921fb6p+2)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -0x0p+0) (f32.const 0x1.921fb6p+2)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const 0x0p+0) (f32.const -0x1.921fb6p+2)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const 0x0p+0) (f32.const 0x1.921fb6p+2)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -0x0p+0) (f32.const -0x1.fffffep+127)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -0x0p+0) (f32.const 0x1.fffffep+127)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const 0x0p+0) (f32.const -0x1.fffffep+127)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const 0x0p+0) (f32.const 0x1.fffffep+127)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -0x0p+0) (f32.const -inf)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -0x0p+0) (f32.const inf)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const 0x0p+0) (f32.const -inf)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const 0x0p+0) (f32.const inf)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -0x0p+0) (f32.const -nan)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -0x0p+0) (f32.const -nan:0x200000)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -0x0p+0) (f32.const nan)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -0x0p+0) (f32.const nan:0x200000)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const 0x0p+0) (f32.const -nan)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const 0x0p+0) (f32.const -nan:0x200000)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const 0x0p+0) (f32.const nan)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const 0x0p+0) (f32.const nan:0x200000)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -0x1p-149) (f32.const -0x0p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -0x1p-149) (f32.const 0x0p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const 0x1p-149) (f32.const -0x0p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const 0x1p-149) (f32.const 0x0p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -0x1p-149) (f32.const -0x1p-149)) (i32.const 0)) +(assert_return (invoke "ne" (f32.const -0x1p-149) (f32.const 0x1p-149)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const 0x1p-149) (f32.const -0x1p-149)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const 0x1p-149) (f32.const 0x1p-149)) (i32.const 0)) +(assert_return (invoke "ne" (f32.const -0x1p-149) (f32.const -0x1p-126)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -0x1p-149) (f32.const 0x1p-126)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const 0x1p-149) (f32.const -0x1p-126)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const 0x1p-149) (f32.const 0x1p-126)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -0x1p-149) (f32.const -0x1p-1)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -0x1p-149) (f32.const 0x1p-1)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const 0x1p-149) (f32.const -0x1p-1)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const 0x1p-149) (f32.const 0x1p-1)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -0x1p-149) (f32.const -0x1p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -0x1p-149) (f32.const 0x1p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const 0x1p-149) (f32.const -0x1p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const 0x1p-149) (f32.const 0x1p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -0x1p-149) (f32.const -0x1.921fb6p+2)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -0x1p-149) (f32.const 0x1.921fb6p+2)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const 0x1p-149) (f32.const -0x1.921fb6p+2)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const 0x1p-149) (f32.const 0x1.921fb6p+2)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -0x1p-149) (f32.const -0x1.fffffep+127)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -0x1p-149) (f32.const 0x1.fffffep+127)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const 0x1p-149) (f32.const -0x1.fffffep+127)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const 0x1p-149) (f32.const 0x1.fffffep+127)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -0x1p-149) (f32.const -inf)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -0x1p-149) (f32.const inf)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const 0x1p-149) (f32.const -inf)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const 0x1p-149) (f32.const inf)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -0x1p-149) (f32.const -nan)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -0x1p-149) (f32.const -nan:0x200000)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -0x1p-149) (f32.const nan)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -0x1p-149) (f32.const nan:0x200000)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const 0x1p-149) (f32.const -nan)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const 0x1p-149) (f32.const -nan:0x200000)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const 0x1p-149) (f32.const nan)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const 0x1p-149) (f32.const nan:0x200000)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -0x1p-126) (f32.const -0x0p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -0x1p-126) (f32.const 0x0p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const 0x1p-126) (f32.const -0x0p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const 0x1p-126) (f32.const 0x0p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -0x1p-126) (f32.const -0x1p-149)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -0x1p-126) (f32.const 0x1p-149)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const 0x1p-126) (f32.const -0x1p-149)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const 0x1p-126) (f32.const 0x1p-149)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -0x1p-126) (f32.const -0x1p-126)) (i32.const 0)) +(assert_return (invoke "ne" (f32.const -0x1p-126) (f32.const 0x1p-126)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const 0x1p-126) (f32.const -0x1p-126)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const 0x1p-126) (f32.const 0x1p-126)) (i32.const 0)) +(assert_return (invoke "ne" (f32.const -0x1p-126) (f32.const -0x1p-1)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -0x1p-126) (f32.const 0x1p-1)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const 0x1p-126) (f32.const -0x1p-1)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const 0x1p-126) (f32.const 0x1p-1)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -0x1p-126) (f32.const -0x1p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -0x1p-126) (f32.const 0x1p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const 0x1p-126) (f32.const -0x1p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const 0x1p-126) (f32.const 0x1p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -0x1p-126) (f32.const -0x1.921fb6p+2)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -0x1p-126) (f32.const 0x1.921fb6p+2)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const 0x1p-126) (f32.const -0x1.921fb6p+2)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const 0x1p-126) (f32.const 0x1.921fb6p+2)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -0x1p-126) (f32.const -0x1.fffffep+127)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -0x1p-126) (f32.const 0x1.fffffep+127)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const 0x1p-126) (f32.const -0x1.fffffep+127)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const 0x1p-126) (f32.const 0x1.fffffep+127)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -0x1p-126) (f32.const -inf)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -0x1p-126) (f32.const inf)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const 0x1p-126) (f32.const -inf)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const 0x1p-126) (f32.const inf)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -0x1p-126) (f32.const -nan)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -0x1p-126) (f32.const -nan:0x200000)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -0x1p-126) (f32.const nan)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -0x1p-126) (f32.const nan:0x200000)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const 0x1p-126) (f32.const -nan)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const 0x1p-126) (f32.const -nan:0x200000)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const 0x1p-126) (f32.const nan)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const 0x1p-126) (f32.const nan:0x200000)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -0x1p-1) (f32.const -0x0p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -0x1p-1) (f32.const 0x0p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const 0x1p-1) (f32.const -0x0p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const 0x1p-1) (f32.const 0x0p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -0x1p-1) (f32.const -0x1p-149)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -0x1p-1) (f32.const 0x1p-149)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const 0x1p-1) (f32.const -0x1p-149)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const 0x1p-1) (f32.const 0x1p-149)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -0x1p-1) (f32.const -0x1p-126)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -0x1p-1) (f32.const 0x1p-126)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const 0x1p-1) (f32.const -0x1p-126)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const 0x1p-1) (f32.const 0x1p-126)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -0x1p-1) (f32.const -0x1p-1)) (i32.const 0)) +(assert_return (invoke "ne" (f32.const -0x1p-1) (f32.const 0x1p-1)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const 0x1p-1) (f32.const -0x1p-1)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const 0x1p-1) (f32.const 0x1p-1)) (i32.const 0)) +(assert_return (invoke "ne" (f32.const -0x1p-1) (f32.const -0x1p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -0x1p-1) (f32.const 0x1p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const 0x1p-1) (f32.const -0x1p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const 0x1p-1) (f32.const 0x1p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -0x1p-1) (f32.const -0x1.921fb6p+2)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -0x1p-1) (f32.const 0x1.921fb6p+2)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const 0x1p-1) (f32.const -0x1.921fb6p+2)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const 0x1p-1) (f32.const 0x1.921fb6p+2)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -0x1p-1) (f32.const -0x1.fffffep+127)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -0x1p-1) (f32.const 0x1.fffffep+127)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const 0x1p-1) (f32.const -0x1.fffffep+127)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const 0x1p-1) (f32.const 0x1.fffffep+127)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -0x1p-1) (f32.const -inf)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -0x1p-1) (f32.const inf)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const 0x1p-1) (f32.const -inf)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const 0x1p-1) (f32.const inf)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -0x1p-1) (f32.const -nan)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -0x1p-1) (f32.const -nan:0x200000)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -0x1p-1) (f32.const nan)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -0x1p-1) (f32.const nan:0x200000)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const 0x1p-1) (f32.const -nan)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const 0x1p-1) (f32.const -nan:0x200000)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const 0x1p-1) (f32.const nan)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const 0x1p-1) (f32.const nan:0x200000)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -0x1p+0) (f32.const -0x0p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -0x1p+0) (f32.const 0x0p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const 0x1p+0) (f32.const -0x0p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const 0x1p+0) (f32.const 0x0p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -0x1p+0) (f32.const -0x1p-149)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -0x1p+0) (f32.const 0x1p-149)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const 0x1p+0) (f32.const -0x1p-149)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const 0x1p+0) (f32.const 0x1p-149)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -0x1p+0) (f32.const -0x1p-126)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -0x1p+0) (f32.const 0x1p-126)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const 0x1p+0) (f32.const -0x1p-126)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const 0x1p+0) (f32.const 0x1p-126)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -0x1p+0) (f32.const -0x1p-1)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -0x1p+0) (f32.const 0x1p-1)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const 0x1p+0) (f32.const -0x1p-1)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const 0x1p+0) (f32.const 0x1p-1)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -0x1p+0) (f32.const -0x1p+0)) (i32.const 0)) +(assert_return (invoke "ne" (f32.const -0x1p+0) (f32.const 0x1p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const 0x1p+0) (f32.const -0x1p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const 0x1p+0) (f32.const 0x1p+0)) (i32.const 0)) +(assert_return (invoke "ne" (f32.const -0x1p+0) (f32.const -0x1.921fb6p+2)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -0x1p+0) (f32.const 0x1.921fb6p+2)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const 0x1p+0) (f32.const -0x1.921fb6p+2)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const 0x1p+0) (f32.const 0x1.921fb6p+2)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -0x1p+0) (f32.const -0x1.fffffep+127)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -0x1p+0) (f32.const 0x1.fffffep+127)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const 0x1p+0) (f32.const -0x1.fffffep+127)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const 0x1p+0) (f32.const 0x1.fffffep+127)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -0x1p+0) (f32.const -inf)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -0x1p+0) (f32.const inf)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const 0x1p+0) (f32.const -inf)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const 0x1p+0) (f32.const inf)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -0x1p+0) (f32.const -nan)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -0x1p+0) (f32.const -nan:0x200000)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -0x1p+0) (f32.const nan)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -0x1p+0) (f32.const nan:0x200000)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const 0x1p+0) (f32.const -nan)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const 0x1p+0) (f32.const -nan:0x200000)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const 0x1p+0) (f32.const nan)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const 0x1p+0) (f32.const nan:0x200000)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -0x1.921fb6p+2) (f32.const -0x0p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -0x1.921fb6p+2) (f32.const 0x0p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const 0x1.921fb6p+2) (f32.const -0x0p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const 0x1.921fb6p+2) (f32.const 0x0p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -0x1.921fb6p+2) (f32.const -0x1p-149)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -0x1.921fb6p+2) (f32.const 0x1p-149)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const 0x1.921fb6p+2) (f32.const -0x1p-149)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const 0x1.921fb6p+2) (f32.const 0x1p-149)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -0x1.921fb6p+2) (f32.const -0x1p-126)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -0x1.921fb6p+2) (f32.const 0x1p-126)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const 0x1.921fb6p+2) (f32.const -0x1p-126)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const 0x1.921fb6p+2) (f32.const 0x1p-126)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -0x1.921fb6p+2) (f32.const -0x1p-1)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -0x1.921fb6p+2) (f32.const 0x1p-1)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const 0x1.921fb6p+2) (f32.const -0x1p-1)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const 0x1.921fb6p+2) (f32.const 0x1p-1)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -0x1.921fb6p+2) (f32.const -0x1p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -0x1.921fb6p+2) (f32.const 0x1p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const 0x1.921fb6p+2) (f32.const -0x1p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const 0x1.921fb6p+2) (f32.const 0x1p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -0x1.921fb6p+2) (f32.const -0x1.921fb6p+2)) (i32.const 0)) +(assert_return (invoke "ne" (f32.const -0x1.921fb6p+2) (f32.const 0x1.921fb6p+2)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const 0x1.921fb6p+2) (f32.const -0x1.921fb6p+2)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const 0x1.921fb6p+2) (f32.const 0x1.921fb6p+2)) (i32.const 0)) +(assert_return (invoke "ne" (f32.const -0x1.921fb6p+2) (f32.const -0x1.fffffep+127)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -0x1.921fb6p+2) (f32.const 0x1.fffffep+127)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const 0x1.921fb6p+2) (f32.const -0x1.fffffep+127)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const 0x1.921fb6p+2) (f32.const 0x1.fffffep+127)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -0x1.921fb6p+2) (f32.const -inf)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -0x1.921fb6p+2) (f32.const inf)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const 0x1.921fb6p+2) (f32.const -inf)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const 0x1.921fb6p+2) (f32.const inf)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -0x1.921fb6p+2) (f32.const -nan)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -0x1.921fb6p+2) (f32.const -nan:0x200000)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -0x1.921fb6p+2) (f32.const nan)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -0x1.921fb6p+2) (f32.const nan:0x200000)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const 0x1.921fb6p+2) (f32.const -nan)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const 0x1.921fb6p+2) (f32.const -nan:0x200000)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const 0x1.921fb6p+2) (f32.const nan)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const 0x1.921fb6p+2) (f32.const nan:0x200000)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -0x1.fffffep+127) (f32.const -0x0p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -0x1.fffffep+127) (f32.const 0x0p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const 0x1.fffffep+127) (f32.const -0x0p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const 0x1.fffffep+127) (f32.const 0x0p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -0x1.fffffep+127) (f32.const -0x1p-149)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -0x1.fffffep+127) (f32.const 0x1p-149)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const 0x1.fffffep+127) (f32.const -0x1p-149)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const 0x1.fffffep+127) (f32.const 0x1p-149)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -0x1.fffffep+127) (f32.const -0x1p-126)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -0x1.fffffep+127) (f32.const 0x1p-126)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const 0x1.fffffep+127) (f32.const -0x1p-126)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const 0x1.fffffep+127) (f32.const 0x1p-126)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -0x1.fffffep+127) (f32.const -0x1p-1)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -0x1.fffffep+127) (f32.const 0x1p-1)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const 0x1.fffffep+127) (f32.const -0x1p-1)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const 0x1.fffffep+127) (f32.const 0x1p-1)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -0x1.fffffep+127) (f32.const -0x1p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -0x1.fffffep+127) (f32.const 0x1p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const 0x1.fffffep+127) (f32.const -0x1p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const 0x1.fffffep+127) (f32.const 0x1p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -0x1.fffffep+127) (f32.const -0x1.921fb6p+2)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -0x1.fffffep+127) (f32.const 0x1.921fb6p+2)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const 0x1.fffffep+127) (f32.const -0x1.921fb6p+2)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const 0x1.fffffep+127) (f32.const 0x1.921fb6p+2)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -0x1.fffffep+127) (f32.const -0x1.fffffep+127)) (i32.const 0)) +(assert_return (invoke "ne" (f32.const -0x1.fffffep+127) (f32.const 0x1.fffffep+127)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const 0x1.fffffep+127) (f32.const -0x1.fffffep+127)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const 0x1.fffffep+127) (f32.const 0x1.fffffep+127)) (i32.const 0)) +(assert_return (invoke "ne" (f32.const -0x1.fffffep+127) (f32.const -inf)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -0x1.fffffep+127) (f32.const inf)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const 0x1.fffffep+127) (f32.const -inf)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const 0x1.fffffep+127) (f32.const inf)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -0x1.fffffep+127) (f32.const -nan)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -0x1.fffffep+127) (f32.const -nan:0x200000)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -0x1.fffffep+127) (f32.const nan)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -0x1.fffffep+127) (f32.const nan:0x200000)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const 0x1.fffffep+127) (f32.const -nan)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const 0x1.fffffep+127) (f32.const -nan:0x200000)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const 0x1.fffffep+127) (f32.const nan)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const 0x1.fffffep+127) (f32.const nan:0x200000)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -inf) (f32.const -0x0p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -inf) (f32.const 0x0p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const inf) (f32.const -0x0p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const inf) (f32.const 0x0p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -inf) (f32.const -0x1p-149)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -inf) (f32.const 0x1p-149)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const inf) (f32.const -0x1p-149)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const inf) (f32.const 0x1p-149)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -inf) (f32.const -0x1p-126)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -inf) (f32.const 0x1p-126)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const inf) (f32.const -0x1p-126)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const inf) (f32.const 0x1p-126)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -inf) (f32.const -0x1p-1)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -inf) (f32.const 0x1p-1)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const inf) (f32.const -0x1p-1)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const inf) (f32.const 0x1p-1)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -inf) (f32.const -0x1p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -inf) (f32.const 0x1p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const inf) (f32.const -0x1p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const inf) (f32.const 0x1p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -inf) (f32.const -0x1.921fb6p+2)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -inf) (f32.const 0x1.921fb6p+2)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const inf) (f32.const -0x1.921fb6p+2)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const inf) (f32.const 0x1.921fb6p+2)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -inf) (f32.const -0x1.fffffep+127)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -inf) (f32.const 0x1.fffffep+127)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const inf) (f32.const -0x1.fffffep+127)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const inf) (f32.const 0x1.fffffep+127)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -inf) (f32.const -inf)) (i32.const 0)) +(assert_return (invoke "ne" (f32.const -inf) (f32.const inf)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const inf) (f32.const -inf)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const inf) (f32.const inf)) (i32.const 0)) +(assert_return (invoke "ne" (f32.const -inf) (f32.const -nan)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -inf) (f32.const -nan:0x200000)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -inf) (f32.const nan)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -inf) (f32.const nan:0x200000)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const inf) (f32.const -nan)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const inf) (f32.const -nan:0x200000)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const inf) (f32.const nan)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const inf) (f32.const nan:0x200000)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -nan) (f32.const -0x0p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -nan:0x200000) (f32.const -0x0p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -nan) (f32.const 0x0p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -nan:0x200000) (f32.const 0x0p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const nan) (f32.const -0x0p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const nan:0x200000) (f32.const -0x0p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const nan) (f32.const 0x0p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const nan:0x200000) (f32.const 0x0p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -nan) (f32.const -0x1p-149)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -nan:0x200000) (f32.const -0x1p-149)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -nan) (f32.const 0x1p-149)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -nan:0x200000) (f32.const 0x1p-149)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const nan) (f32.const -0x1p-149)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const nan:0x200000) (f32.const -0x1p-149)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const nan) (f32.const 0x1p-149)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const nan:0x200000) (f32.const 0x1p-149)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -nan) (f32.const -0x1p-126)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -nan:0x200000) (f32.const -0x1p-126)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -nan) (f32.const 0x1p-126)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -nan:0x200000) (f32.const 0x1p-126)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const nan) (f32.const -0x1p-126)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const nan:0x200000) (f32.const -0x1p-126)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const nan) (f32.const 0x1p-126)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const nan:0x200000) (f32.const 0x1p-126)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -nan) (f32.const -0x1p-1)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -nan:0x200000) (f32.const -0x1p-1)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -nan) (f32.const 0x1p-1)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -nan:0x200000) (f32.const 0x1p-1)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const nan) (f32.const -0x1p-1)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const nan:0x200000) (f32.const -0x1p-1)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const nan) (f32.const 0x1p-1)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const nan:0x200000) (f32.const 0x1p-1)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -nan) (f32.const -0x1p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -nan:0x200000) (f32.const -0x1p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -nan) (f32.const 0x1p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -nan:0x200000) (f32.const 0x1p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const nan) (f32.const -0x1p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const nan:0x200000) (f32.const -0x1p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const nan) (f32.const 0x1p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const nan:0x200000) (f32.const 0x1p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -nan) (f32.const -0x1.921fb6p+2)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -nan:0x200000) (f32.const -0x1.921fb6p+2)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -nan) (f32.const 0x1.921fb6p+2)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -nan:0x200000) (f32.const 0x1.921fb6p+2)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const nan) (f32.const -0x1.921fb6p+2)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const nan:0x200000) (f32.const -0x1.921fb6p+2)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const nan) (f32.const 0x1.921fb6p+2)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const nan:0x200000) (f32.const 0x1.921fb6p+2)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -nan) (f32.const -0x1.fffffep+127)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -nan:0x200000) (f32.const -0x1.fffffep+127)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -nan) (f32.const 0x1.fffffep+127)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -nan:0x200000) (f32.const 0x1.fffffep+127)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const nan) (f32.const -0x1.fffffep+127)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const nan:0x200000) (f32.const -0x1.fffffep+127)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const nan) (f32.const 0x1.fffffep+127)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const nan:0x200000) (f32.const 0x1.fffffep+127)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -nan) (f32.const -inf)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -nan:0x200000) (f32.const -inf)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -nan) (f32.const inf)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -nan:0x200000) (f32.const inf)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const nan) (f32.const -inf)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const nan:0x200000) (f32.const -inf)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const nan) (f32.const inf)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const nan:0x200000) (f32.const inf)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -nan) (f32.const -nan)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -nan:0x200000) (f32.const -nan)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -nan) (f32.const -nan:0x200000)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -nan:0x200000) (f32.const -nan:0x200000)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -nan) (f32.const nan)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -nan:0x200000) (f32.const nan)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -nan) (f32.const nan:0x200000)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const -nan:0x200000) (f32.const nan:0x200000)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const nan) (f32.const -nan)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const nan:0x200000) (f32.const -nan)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const nan) (f32.const -nan:0x200000)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const nan:0x200000) (f32.const -nan:0x200000)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const nan) (f32.const nan)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const nan:0x200000) (f32.const nan)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const nan) (f32.const nan:0x200000)) (i32.const 1)) +(assert_return (invoke "ne" (f32.const nan:0x200000) (f32.const nan:0x200000)) (i32.const 1)) +(assert_return (invoke "lt" (f32.const -0x0p+0) (f32.const -0x0p+0)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -0x0p+0) (f32.const 0x0p+0)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const 0x0p+0) (f32.const -0x0p+0)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const 0x0p+0) (f32.const 0x0p+0)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -0x0p+0) (f32.const -0x1p-149)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -0x0p+0) (f32.const 0x1p-149)) (i32.const 1)) +(assert_return (invoke "lt" (f32.const 0x0p+0) (f32.const -0x1p-149)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const 0x0p+0) (f32.const 0x1p-149)) (i32.const 1)) +(assert_return (invoke "lt" (f32.const -0x0p+0) (f32.const -0x1p-126)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -0x0p+0) (f32.const 0x1p-126)) (i32.const 1)) +(assert_return (invoke "lt" (f32.const 0x0p+0) (f32.const -0x1p-126)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const 0x0p+0) (f32.const 0x1p-126)) (i32.const 1)) +(assert_return (invoke "lt" (f32.const -0x0p+0) (f32.const -0x1p-1)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -0x0p+0) (f32.const 0x1p-1)) (i32.const 1)) +(assert_return (invoke "lt" (f32.const 0x0p+0) (f32.const -0x1p-1)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const 0x0p+0) (f32.const 0x1p-1)) (i32.const 1)) +(assert_return (invoke "lt" (f32.const -0x0p+0) (f32.const -0x1p+0)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -0x0p+0) (f32.const 0x1p+0)) (i32.const 1)) +(assert_return (invoke "lt" (f32.const 0x0p+0) (f32.const -0x1p+0)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const 0x0p+0) (f32.const 0x1p+0)) (i32.const 1)) +(assert_return (invoke "lt" (f32.const -0x0p+0) (f32.const -0x1.921fb6p+2)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -0x0p+0) (f32.const 0x1.921fb6p+2)) (i32.const 1)) +(assert_return (invoke "lt" (f32.const 0x0p+0) (f32.const -0x1.921fb6p+2)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const 0x0p+0) (f32.const 0x1.921fb6p+2)) (i32.const 1)) +(assert_return (invoke "lt" (f32.const -0x0p+0) (f32.const -0x1.fffffep+127)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -0x0p+0) (f32.const 0x1.fffffep+127)) (i32.const 1)) +(assert_return (invoke "lt" (f32.const 0x0p+0) (f32.const -0x1.fffffep+127)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const 0x0p+0) (f32.const 0x1.fffffep+127)) (i32.const 1)) +(assert_return (invoke "lt" (f32.const -0x0p+0) (f32.const -inf)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -0x0p+0) (f32.const inf)) (i32.const 1)) +(assert_return (invoke "lt" (f32.const 0x0p+0) (f32.const -inf)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const 0x0p+0) (f32.const inf)) (i32.const 1)) +(assert_return (invoke "lt" (f32.const -0x0p+0) (f32.const -nan)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -0x0p+0) (f32.const -nan:0x200000)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -0x0p+0) (f32.const nan)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -0x0p+0) (f32.const nan:0x200000)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const 0x0p+0) (f32.const -nan)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const 0x0p+0) (f32.const -nan:0x200000)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const 0x0p+0) (f32.const nan)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const 0x0p+0) (f32.const nan:0x200000)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -0x1p-149) (f32.const -0x0p+0)) (i32.const 1)) +(assert_return (invoke "lt" (f32.const -0x1p-149) (f32.const 0x0p+0)) (i32.const 1)) +(assert_return (invoke "lt" (f32.const 0x1p-149) (f32.const -0x0p+0)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const 0x1p-149) (f32.const 0x0p+0)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -0x1p-149) (f32.const -0x1p-149)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -0x1p-149) (f32.const 0x1p-149)) (i32.const 1)) +(assert_return (invoke "lt" (f32.const 0x1p-149) (f32.const -0x1p-149)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const 0x1p-149) (f32.const 0x1p-149)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -0x1p-149) (f32.const -0x1p-126)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -0x1p-149) (f32.const 0x1p-126)) (i32.const 1)) +(assert_return (invoke "lt" (f32.const 0x1p-149) (f32.const -0x1p-126)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const 0x1p-149) (f32.const 0x1p-126)) (i32.const 1)) +(assert_return (invoke "lt" (f32.const -0x1p-149) (f32.const -0x1p-1)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -0x1p-149) (f32.const 0x1p-1)) (i32.const 1)) +(assert_return (invoke "lt" (f32.const 0x1p-149) (f32.const -0x1p-1)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const 0x1p-149) (f32.const 0x1p-1)) (i32.const 1)) +(assert_return (invoke "lt" (f32.const -0x1p-149) (f32.const -0x1p+0)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -0x1p-149) (f32.const 0x1p+0)) (i32.const 1)) +(assert_return (invoke "lt" (f32.const 0x1p-149) (f32.const -0x1p+0)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const 0x1p-149) (f32.const 0x1p+0)) (i32.const 1)) +(assert_return (invoke "lt" (f32.const -0x1p-149) (f32.const -0x1.921fb6p+2)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -0x1p-149) (f32.const 0x1.921fb6p+2)) (i32.const 1)) +(assert_return (invoke "lt" (f32.const 0x1p-149) (f32.const -0x1.921fb6p+2)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const 0x1p-149) (f32.const 0x1.921fb6p+2)) (i32.const 1)) +(assert_return (invoke "lt" (f32.const -0x1p-149) (f32.const -0x1.fffffep+127)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -0x1p-149) (f32.const 0x1.fffffep+127)) (i32.const 1)) +(assert_return (invoke "lt" (f32.const 0x1p-149) (f32.const -0x1.fffffep+127)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const 0x1p-149) (f32.const 0x1.fffffep+127)) (i32.const 1)) +(assert_return (invoke "lt" (f32.const -0x1p-149) (f32.const -inf)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -0x1p-149) (f32.const inf)) (i32.const 1)) +(assert_return (invoke "lt" (f32.const 0x1p-149) (f32.const -inf)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const 0x1p-149) (f32.const inf)) (i32.const 1)) +(assert_return (invoke "lt" (f32.const -0x1p-149) (f32.const -nan)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -0x1p-149) (f32.const -nan:0x200000)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -0x1p-149) (f32.const nan)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -0x1p-149) (f32.const nan:0x200000)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const 0x1p-149) (f32.const -nan)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const 0x1p-149) (f32.const -nan:0x200000)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const 0x1p-149) (f32.const nan)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const 0x1p-149) (f32.const nan:0x200000)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -0x1p-126) (f32.const -0x0p+0)) (i32.const 1)) +(assert_return (invoke "lt" (f32.const -0x1p-126) (f32.const 0x0p+0)) (i32.const 1)) +(assert_return (invoke "lt" (f32.const 0x1p-126) (f32.const -0x0p+0)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const 0x1p-126) (f32.const 0x0p+0)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -0x1p-126) (f32.const -0x1p-149)) (i32.const 1)) +(assert_return (invoke "lt" (f32.const -0x1p-126) (f32.const 0x1p-149)) (i32.const 1)) +(assert_return (invoke "lt" (f32.const 0x1p-126) (f32.const -0x1p-149)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const 0x1p-126) (f32.const 0x1p-149)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -0x1p-126) (f32.const -0x1p-126)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -0x1p-126) (f32.const 0x1p-126)) (i32.const 1)) +(assert_return (invoke "lt" (f32.const 0x1p-126) (f32.const -0x1p-126)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const 0x1p-126) (f32.const 0x1p-126)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -0x1p-126) (f32.const -0x1p-1)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -0x1p-126) (f32.const 0x1p-1)) (i32.const 1)) +(assert_return (invoke "lt" (f32.const 0x1p-126) (f32.const -0x1p-1)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const 0x1p-126) (f32.const 0x1p-1)) (i32.const 1)) +(assert_return (invoke "lt" (f32.const -0x1p-126) (f32.const -0x1p+0)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -0x1p-126) (f32.const 0x1p+0)) (i32.const 1)) +(assert_return (invoke "lt" (f32.const 0x1p-126) (f32.const -0x1p+0)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const 0x1p-126) (f32.const 0x1p+0)) (i32.const 1)) +(assert_return (invoke "lt" (f32.const -0x1p-126) (f32.const -0x1.921fb6p+2)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -0x1p-126) (f32.const 0x1.921fb6p+2)) (i32.const 1)) +(assert_return (invoke "lt" (f32.const 0x1p-126) (f32.const -0x1.921fb6p+2)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const 0x1p-126) (f32.const 0x1.921fb6p+2)) (i32.const 1)) +(assert_return (invoke "lt" (f32.const -0x1p-126) (f32.const -0x1.fffffep+127)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -0x1p-126) (f32.const 0x1.fffffep+127)) (i32.const 1)) +(assert_return (invoke "lt" (f32.const 0x1p-126) (f32.const -0x1.fffffep+127)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const 0x1p-126) (f32.const 0x1.fffffep+127)) (i32.const 1)) +(assert_return (invoke "lt" (f32.const -0x1p-126) (f32.const -inf)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -0x1p-126) (f32.const inf)) (i32.const 1)) +(assert_return (invoke "lt" (f32.const 0x1p-126) (f32.const -inf)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const 0x1p-126) (f32.const inf)) (i32.const 1)) +(assert_return (invoke "lt" (f32.const -0x1p-126) (f32.const -nan)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -0x1p-126) (f32.const -nan:0x200000)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -0x1p-126) (f32.const nan)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -0x1p-126) (f32.const nan:0x200000)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const 0x1p-126) (f32.const -nan)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const 0x1p-126) (f32.const -nan:0x200000)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const 0x1p-126) (f32.const nan)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const 0x1p-126) (f32.const nan:0x200000)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -0x1p-1) (f32.const -0x0p+0)) (i32.const 1)) +(assert_return (invoke "lt" (f32.const -0x1p-1) (f32.const 0x0p+0)) (i32.const 1)) +(assert_return (invoke "lt" (f32.const 0x1p-1) (f32.const -0x0p+0)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const 0x1p-1) (f32.const 0x0p+0)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -0x1p-1) (f32.const -0x1p-149)) (i32.const 1)) +(assert_return (invoke "lt" (f32.const -0x1p-1) (f32.const 0x1p-149)) (i32.const 1)) +(assert_return (invoke "lt" (f32.const 0x1p-1) (f32.const -0x1p-149)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const 0x1p-1) (f32.const 0x1p-149)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -0x1p-1) (f32.const -0x1p-126)) (i32.const 1)) +(assert_return (invoke "lt" (f32.const -0x1p-1) (f32.const 0x1p-126)) (i32.const 1)) +(assert_return (invoke "lt" (f32.const 0x1p-1) (f32.const -0x1p-126)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const 0x1p-1) (f32.const 0x1p-126)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -0x1p-1) (f32.const -0x1p-1)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -0x1p-1) (f32.const 0x1p-1)) (i32.const 1)) +(assert_return (invoke "lt" (f32.const 0x1p-1) (f32.const -0x1p-1)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const 0x1p-1) (f32.const 0x1p-1)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -0x1p-1) (f32.const -0x1p+0)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -0x1p-1) (f32.const 0x1p+0)) (i32.const 1)) +(assert_return (invoke "lt" (f32.const 0x1p-1) (f32.const -0x1p+0)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const 0x1p-1) (f32.const 0x1p+0)) (i32.const 1)) +(assert_return (invoke "lt" (f32.const -0x1p-1) (f32.const -0x1.921fb6p+2)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -0x1p-1) (f32.const 0x1.921fb6p+2)) (i32.const 1)) +(assert_return (invoke "lt" (f32.const 0x1p-1) (f32.const -0x1.921fb6p+2)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const 0x1p-1) (f32.const 0x1.921fb6p+2)) (i32.const 1)) +(assert_return (invoke "lt" (f32.const -0x1p-1) (f32.const -0x1.fffffep+127)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -0x1p-1) (f32.const 0x1.fffffep+127)) (i32.const 1)) +(assert_return (invoke "lt" (f32.const 0x1p-1) (f32.const -0x1.fffffep+127)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const 0x1p-1) (f32.const 0x1.fffffep+127)) (i32.const 1)) +(assert_return (invoke "lt" (f32.const -0x1p-1) (f32.const -inf)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -0x1p-1) (f32.const inf)) (i32.const 1)) +(assert_return (invoke "lt" (f32.const 0x1p-1) (f32.const -inf)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const 0x1p-1) (f32.const inf)) (i32.const 1)) +(assert_return (invoke "lt" (f32.const -0x1p-1) (f32.const -nan)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -0x1p-1) (f32.const -nan:0x200000)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -0x1p-1) (f32.const nan)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -0x1p-1) (f32.const nan:0x200000)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const 0x1p-1) (f32.const -nan)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const 0x1p-1) (f32.const -nan:0x200000)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const 0x1p-1) (f32.const nan)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const 0x1p-1) (f32.const nan:0x200000)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -0x1p+0) (f32.const -0x0p+0)) (i32.const 1)) +(assert_return (invoke "lt" (f32.const -0x1p+0) (f32.const 0x0p+0)) (i32.const 1)) +(assert_return (invoke "lt" (f32.const 0x1p+0) (f32.const -0x0p+0)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const 0x1p+0) (f32.const 0x0p+0)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -0x1p+0) (f32.const -0x1p-149)) (i32.const 1)) +(assert_return (invoke "lt" (f32.const -0x1p+0) (f32.const 0x1p-149)) (i32.const 1)) +(assert_return (invoke "lt" (f32.const 0x1p+0) (f32.const -0x1p-149)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const 0x1p+0) (f32.const 0x1p-149)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -0x1p+0) (f32.const -0x1p-126)) (i32.const 1)) +(assert_return (invoke "lt" (f32.const -0x1p+0) (f32.const 0x1p-126)) (i32.const 1)) +(assert_return (invoke "lt" (f32.const 0x1p+0) (f32.const -0x1p-126)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const 0x1p+0) (f32.const 0x1p-126)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -0x1p+0) (f32.const -0x1p-1)) (i32.const 1)) +(assert_return (invoke "lt" (f32.const -0x1p+0) (f32.const 0x1p-1)) (i32.const 1)) +(assert_return (invoke "lt" (f32.const 0x1p+0) (f32.const -0x1p-1)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const 0x1p+0) (f32.const 0x1p-1)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -0x1p+0) (f32.const -0x1p+0)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -0x1p+0) (f32.const 0x1p+0)) (i32.const 1)) +(assert_return (invoke "lt" (f32.const 0x1p+0) (f32.const -0x1p+0)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const 0x1p+0) (f32.const 0x1p+0)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -0x1p+0) (f32.const -0x1.921fb6p+2)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -0x1p+0) (f32.const 0x1.921fb6p+2)) (i32.const 1)) +(assert_return (invoke "lt" (f32.const 0x1p+0) (f32.const -0x1.921fb6p+2)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const 0x1p+0) (f32.const 0x1.921fb6p+2)) (i32.const 1)) +(assert_return (invoke "lt" (f32.const -0x1p+0) (f32.const -0x1.fffffep+127)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -0x1p+0) (f32.const 0x1.fffffep+127)) (i32.const 1)) +(assert_return (invoke "lt" (f32.const 0x1p+0) (f32.const -0x1.fffffep+127)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const 0x1p+0) (f32.const 0x1.fffffep+127)) (i32.const 1)) +(assert_return (invoke "lt" (f32.const -0x1p+0) (f32.const -inf)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -0x1p+0) (f32.const inf)) (i32.const 1)) +(assert_return (invoke "lt" (f32.const 0x1p+0) (f32.const -inf)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const 0x1p+0) (f32.const inf)) (i32.const 1)) +(assert_return (invoke "lt" (f32.const -0x1p+0) (f32.const -nan)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -0x1p+0) (f32.const -nan:0x200000)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -0x1p+0) (f32.const nan)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -0x1p+0) (f32.const nan:0x200000)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const 0x1p+0) (f32.const -nan)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const 0x1p+0) (f32.const -nan:0x200000)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const 0x1p+0) (f32.const nan)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const 0x1p+0) (f32.const nan:0x200000)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -0x1.921fb6p+2) (f32.const -0x0p+0)) (i32.const 1)) +(assert_return (invoke "lt" (f32.const -0x1.921fb6p+2) (f32.const 0x0p+0)) (i32.const 1)) +(assert_return (invoke "lt" (f32.const 0x1.921fb6p+2) (f32.const -0x0p+0)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const 0x1.921fb6p+2) (f32.const 0x0p+0)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -0x1.921fb6p+2) (f32.const -0x1p-149)) (i32.const 1)) +(assert_return (invoke "lt" (f32.const -0x1.921fb6p+2) (f32.const 0x1p-149)) (i32.const 1)) +(assert_return (invoke "lt" (f32.const 0x1.921fb6p+2) (f32.const -0x1p-149)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const 0x1.921fb6p+2) (f32.const 0x1p-149)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -0x1.921fb6p+2) (f32.const -0x1p-126)) (i32.const 1)) +(assert_return (invoke "lt" (f32.const -0x1.921fb6p+2) (f32.const 0x1p-126)) (i32.const 1)) +(assert_return (invoke "lt" (f32.const 0x1.921fb6p+2) (f32.const -0x1p-126)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const 0x1.921fb6p+2) (f32.const 0x1p-126)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -0x1.921fb6p+2) (f32.const -0x1p-1)) (i32.const 1)) +(assert_return (invoke "lt" (f32.const -0x1.921fb6p+2) (f32.const 0x1p-1)) (i32.const 1)) +(assert_return (invoke "lt" (f32.const 0x1.921fb6p+2) (f32.const -0x1p-1)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const 0x1.921fb6p+2) (f32.const 0x1p-1)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -0x1.921fb6p+2) (f32.const -0x1p+0)) (i32.const 1)) +(assert_return (invoke "lt" (f32.const -0x1.921fb6p+2) (f32.const 0x1p+0)) (i32.const 1)) +(assert_return (invoke "lt" (f32.const 0x1.921fb6p+2) (f32.const -0x1p+0)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const 0x1.921fb6p+2) (f32.const 0x1p+0)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -0x1.921fb6p+2) (f32.const -0x1.921fb6p+2)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -0x1.921fb6p+2) (f32.const 0x1.921fb6p+2)) (i32.const 1)) +(assert_return (invoke "lt" (f32.const 0x1.921fb6p+2) (f32.const -0x1.921fb6p+2)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const 0x1.921fb6p+2) (f32.const 0x1.921fb6p+2)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -0x1.921fb6p+2) (f32.const -0x1.fffffep+127)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -0x1.921fb6p+2) (f32.const 0x1.fffffep+127)) (i32.const 1)) +(assert_return (invoke "lt" (f32.const 0x1.921fb6p+2) (f32.const -0x1.fffffep+127)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const 0x1.921fb6p+2) (f32.const 0x1.fffffep+127)) (i32.const 1)) +(assert_return (invoke "lt" (f32.const -0x1.921fb6p+2) (f32.const -inf)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -0x1.921fb6p+2) (f32.const inf)) (i32.const 1)) +(assert_return (invoke "lt" (f32.const 0x1.921fb6p+2) (f32.const -inf)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const 0x1.921fb6p+2) (f32.const inf)) (i32.const 1)) +(assert_return (invoke "lt" (f32.const -0x1.921fb6p+2) (f32.const -nan)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -0x1.921fb6p+2) (f32.const -nan:0x200000)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -0x1.921fb6p+2) (f32.const nan)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -0x1.921fb6p+2) (f32.const nan:0x200000)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const 0x1.921fb6p+2) (f32.const -nan)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const 0x1.921fb6p+2) (f32.const -nan:0x200000)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const 0x1.921fb6p+2) (f32.const nan)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const 0x1.921fb6p+2) (f32.const nan:0x200000)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -0x1.fffffep+127) (f32.const -0x0p+0)) (i32.const 1)) +(assert_return (invoke "lt" (f32.const -0x1.fffffep+127) (f32.const 0x0p+0)) (i32.const 1)) +(assert_return (invoke "lt" (f32.const 0x1.fffffep+127) (f32.const -0x0p+0)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const 0x1.fffffep+127) (f32.const 0x0p+0)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -0x1.fffffep+127) (f32.const -0x1p-149)) (i32.const 1)) +(assert_return (invoke "lt" (f32.const -0x1.fffffep+127) (f32.const 0x1p-149)) (i32.const 1)) +(assert_return (invoke "lt" (f32.const 0x1.fffffep+127) (f32.const -0x1p-149)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const 0x1.fffffep+127) (f32.const 0x1p-149)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -0x1.fffffep+127) (f32.const -0x1p-126)) (i32.const 1)) +(assert_return (invoke "lt" (f32.const -0x1.fffffep+127) (f32.const 0x1p-126)) (i32.const 1)) +(assert_return (invoke "lt" (f32.const 0x1.fffffep+127) (f32.const -0x1p-126)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const 0x1.fffffep+127) (f32.const 0x1p-126)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -0x1.fffffep+127) (f32.const -0x1p-1)) (i32.const 1)) +(assert_return (invoke "lt" (f32.const -0x1.fffffep+127) (f32.const 0x1p-1)) (i32.const 1)) +(assert_return (invoke "lt" (f32.const 0x1.fffffep+127) (f32.const -0x1p-1)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const 0x1.fffffep+127) (f32.const 0x1p-1)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -0x1.fffffep+127) (f32.const -0x1p+0)) (i32.const 1)) +(assert_return (invoke "lt" (f32.const -0x1.fffffep+127) (f32.const 0x1p+0)) (i32.const 1)) +(assert_return (invoke "lt" (f32.const 0x1.fffffep+127) (f32.const -0x1p+0)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const 0x1.fffffep+127) (f32.const 0x1p+0)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -0x1.fffffep+127) (f32.const -0x1.921fb6p+2)) (i32.const 1)) +(assert_return (invoke "lt" (f32.const -0x1.fffffep+127) (f32.const 0x1.921fb6p+2)) (i32.const 1)) +(assert_return (invoke "lt" (f32.const 0x1.fffffep+127) (f32.const -0x1.921fb6p+2)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const 0x1.fffffep+127) (f32.const 0x1.921fb6p+2)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -0x1.fffffep+127) (f32.const -0x1.fffffep+127)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -0x1.fffffep+127) (f32.const 0x1.fffffep+127)) (i32.const 1)) +(assert_return (invoke "lt" (f32.const 0x1.fffffep+127) (f32.const -0x1.fffffep+127)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const 0x1.fffffep+127) (f32.const 0x1.fffffep+127)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -0x1.fffffep+127) (f32.const -inf)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -0x1.fffffep+127) (f32.const inf)) (i32.const 1)) +(assert_return (invoke "lt" (f32.const 0x1.fffffep+127) (f32.const -inf)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const 0x1.fffffep+127) (f32.const inf)) (i32.const 1)) +(assert_return (invoke "lt" (f32.const -0x1.fffffep+127) (f32.const -nan)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -0x1.fffffep+127) (f32.const -nan:0x200000)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -0x1.fffffep+127) (f32.const nan)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -0x1.fffffep+127) (f32.const nan:0x200000)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const 0x1.fffffep+127) (f32.const -nan)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const 0x1.fffffep+127) (f32.const -nan:0x200000)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const 0x1.fffffep+127) (f32.const nan)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const 0x1.fffffep+127) (f32.const nan:0x200000)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -inf) (f32.const -0x0p+0)) (i32.const 1)) +(assert_return (invoke "lt" (f32.const -inf) (f32.const 0x0p+0)) (i32.const 1)) +(assert_return (invoke "lt" (f32.const inf) (f32.const -0x0p+0)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const inf) (f32.const 0x0p+0)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -inf) (f32.const -0x1p-149)) (i32.const 1)) +(assert_return (invoke "lt" (f32.const -inf) (f32.const 0x1p-149)) (i32.const 1)) +(assert_return (invoke "lt" (f32.const inf) (f32.const -0x1p-149)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const inf) (f32.const 0x1p-149)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -inf) (f32.const -0x1p-126)) (i32.const 1)) +(assert_return (invoke "lt" (f32.const -inf) (f32.const 0x1p-126)) (i32.const 1)) +(assert_return (invoke "lt" (f32.const inf) (f32.const -0x1p-126)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const inf) (f32.const 0x1p-126)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -inf) (f32.const -0x1p-1)) (i32.const 1)) +(assert_return (invoke "lt" (f32.const -inf) (f32.const 0x1p-1)) (i32.const 1)) +(assert_return (invoke "lt" (f32.const inf) (f32.const -0x1p-1)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const inf) (f32.const 0x1p-1)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -inf) (f32.const -0x1p+0)) (i32.const 1)) +(assert_return (invoke "lt" (f32.const -inf) (f32.const 0x1p+0)) (i32.const 1)) +(assert_return (invoke "lt" (f32.const inf) (f32.const -0x1p+0)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const inf) (f32.const 0x1p+0)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -inf) (f32.const -0x1.921fb6p+2)) (i32.const 1)) +(assert_return (invoke "lt" (f32.const -inf) (f32.const 0x1.921fb6p+2)) (i32.const 1)) +(assert_return (invoke "lt" (f32.const inf) (f32.const -0x1.921fb6p+2)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const inf) (f32.const 0x1.921fb6p+2)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -inf) (f32.const -0x1.fffffep+127)) (i32.const 1)) +(assert_return (invoke "lt" (f32.const -inf) (f32.const 0x1.fffffep+127)) (i32.const 1)) +(assert_return (invoke "lt" (f32.const inf) (f32.const -0x1.fffffep+127)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const inf) (f32.const 0x1.fffffep+127)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -inf) (f32.const -inf)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -inf) (f32.const inf)) (i32.const 1)) +(assert_return (invoke "lt" (f32.const inf) (f32.const -inf)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const inf) (f32.const inf)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -inf) (f32.const -nan)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -inf) (f32.const -nan:0x200000)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -inf) (f32.const nan)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -inf) (f32.const nan:0x200000)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const inf) (f32.const -nan)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const inf) (f32.const -nan:0x200000)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const inf) (f32.const nan)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const inf) (f32.const nan:0x200000)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -nan) (f32.const -0x0p+0)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -nan:0x200000) (f32.const -0x0p+0)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -nan) (f32.const 0x0p+0)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -nan:0x200000) (f32.const 0x0p+0)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const nan) (f32.const -0x0p+0)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const nan:0x200000) (f32.const -0x0p+0)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const nan) (f32.const 0x0p+0)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const nan:0x200000) (f32.const 0x0p+0)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -nan) (f32.const -0x1p-149)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -nan:0x200000) (f32.const -0x1p-149)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -nan) (f32.const 0x1p-149)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -nan:0x200000) (f32.const 0x1p-149)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const nan) (f32.const -0x1p-149)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const nan:0x200000) (f32.const -0x1p-149)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const nan) (f32.const 0x1p-149)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const nan:0x200000) (f32.const 0x1p-149)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -nan) (f32.const -0x1p-126)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -nan:0x200000) (f32.const -0x1p-126)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -nan) (f32.const 0x1p-126)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -nan:0x200000) (f32.const 0x1p-126)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const nan) (f32.const -0x1p-126)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const nan:0x200000) (f32.const -0x1p-126)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const nan) (f32.const 0x1p-126)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const nan:0x200000) (f32.const 0x1p-126)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -nan) (f32.const -0x1p-1)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -nan:0x200000) (f32.const -0x1p-1)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -nan) (f32.const 0x1p-1)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -nan:0x200000) (f32.const 0x1p-1)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const nan) (f32.const -0x1p-1)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const nan:0x200000) (f32.const -0x1p-1)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const nan) (f32.const 0x1p-1)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const nan:0x200000) (f32.const 0x1p-1)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -nan) (f32.const -0x1p+0)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -nan:0x200000) (f32.const -0x1p+0)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -nan) (f32.const 0x1p+0)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -nan:0x200000) (f32.const 0x1p+0)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const nan) (f32.const -0x1p+0)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const nan:0x200000) (f32.const -0x1p+0)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const nan) (f32.const 0x1p+0)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const nan:0x200000) (f32.const 0x1p+0)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -nan) (f32.const -0x1.921fb6p+2)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -nan:0x200000) (f32.const -0x1.921fb6p+2)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -nan) (f32.const 0x1.921fb6p+2)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -nan:0x200000) (f32.const 0x1.921fb6p+2)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const nan) (f32.const -0x1.921fb6p+2)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const nan:0x200000) (f32.const -0x1.921fb6p+2)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const nan) (f32.const 0x1.921fb6p+2)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const nan:0x200000) (f32.const 0x1.921fb6p+2)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -nan) (f32.const -0x1.fffffep+127)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -nan:0x200000) (f32.const -0x1.fffffep+127)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -nan) (f32.const 0x1.fffffep+127)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -nan:0x200000) (f32.const 0x1.fffffep+127)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const nan) (f32.const -0x1.fffffep+127)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const nan:0x200000) (f32.const -0x1.fffffep+127)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const nan) (f32.const 0x1.fffffep+127)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const nan:0x200000) (f32.const 0x1.fffffep+127)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -nan) (f32.const -inf)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -nan:0x200000) (f32.const -inf)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -nan) (f32.const inf)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -nan:0x200000) (f32.const inf)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const nan) (f32.const -inf)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const nan:0x200000) (f32.const -inf)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const nan) (f32.const inf)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const nan:0x200000) (f32.const inf)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -nan) (f32.const -nan)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -nan:0x200000) (f32.const -nan)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -nan) (f32.const -nan:0x200000)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -nan:0x200000) (f32.const -nan:0x200000)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -nan) (f32.const nan)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -nan:0x200000) (f32.const nan)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -nan) (f32.const nan:0x200000)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const -nan:0x200000) (f32.const nan:0x200000)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const nan) (f32.const -nan)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const nan:0x200000) (f32.const -nan)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const nan) (f32.const -nan:0x200000)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const nan:0x200000) (f32.const -nan:0x200000)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const nan) (f32.const nan)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const nan:0x200000) (f32.const nan)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const nan) (f32.const nan:0x200000)) (i32.const 0)) +(assert_return (invoke "lt" (f32.const nan:0x200000) (f32.const nan:0x200000)) (i32.const 0)) +(assert_return (invoke "le" (f32.const -0x0p+0) (f32.const -0x0p+0)) (i32.const 1)) +(assert_return (invoke "le" (f32.const -0x0p+0) (f32.const 0x0p+0)) (i32.const 1)) +(assert_return (invoke "le" (f32.const 0x0p+0) (f32.const -0x0p+0)) (i32.const 1)) +(assert_return (invoke "le" (f32.const 0x0p+0) (f32.const 0x0p+0)) (i32.const 1)) +(assert_return (invoke "le" (f32.const -0x0p+0) (f32.const -0x1p-149)) (i32.const 0)) +(assert_return (invoke "le" (f32.const -0x0p+0) (f32.const 0x1p-149)) (i32.const 1)) +(assert_return (invoke "le" (f32.const 0x0p+0) (f32.const -0x1p-149)) (i32.const 0)) +(assert_return (invoke "le" (f32.const 0x0p+0) (f32.const 0x1p-149)) (i32.const 1)) +(assert_return (invoke "le" (f32.const -0x0p+0) (f32.const -0x1p-126)) (i32.const 0)) +(assert_return (invoke "le" (f32.const -0x0p+0) (f32.const 0x1p-126)) (i32.const 1)) +(assert_return (invoke "le" (f32.const 0x0p+0) (f32.const -0x1p-126)) (i32.const 0)) +(assert_return (invoke "le" (f32.const 0x0p+0) (f32.const 0x1p-126)) (i32.const 1)) +(assert_return (invoke "le" (f32.const -0x0p+0) (f32.const -0x1p-1)) (i32.const 0)) +(assert_return (invoke "le" (f32.const -0x0p+0) (f32.const 0x1p-1)) (i32.const 1)) +(assert_return (invoke "le" (f32.const 0x0p+0) (f32.const -0x1p-1)) (i32.const 0)) +(assert_return (invoke "le" (f32.const 0x0p+0) (f32.const 0x1p-1)) (i32.const 1)) +(assert_return (invoke "le" (f32.const -0x0p+0) (f32.const -0x1p+0)) (i32.const 0)) +(assert_return (invoke "le" (f32.const -0x0p+0) (f32.const 0x1p+0)) (i32.const 1)) +(assert_return (invoke "le" (f32.const 0x0p+0) (f32.const -0x1p+0)) (i32.const 0)) +(assert_return (invoke "le" (f32.const 0x0p+0) (f32.const 0x1p+0)) (i32.const 1)) +(assert_return (invoke "le" (f32.const -0x0p+0) (f32.const -0x1.921fb6p+2)) (i32.const 0)) +(assert_return (invoke "le" (f32.const -0x0p+0) (f32.const 0x1.921fb6p+2)) (i32.const 1)) +(assert_return (invoke "le" (f32.const 0x0p+0) (f32.const -0x1.921fb6p+2)) (i32.const 0)) +(assert_return (invoke "le" (f32.const 0x0p+0) (f32.const 0x1.921fb6p+2)) (i32.const 1)) +(assert_return (invoke "le" (f32.const -0x0p+0) (f32.const -0x1.fffffep+127)) (i32.const 0)) +(assert_return (invoke "le" (f32.const -0x0p+0) (f32.const 0x1.fffffep+127)) (i32.const 1)) +(assert_return (invoke "le" (f32.const 0x0p+0) (f32.const -0x1.fffffep+127)) (i32.const 0)) +(assert_return (invoke "le" (f32.const 0x0p+0) (f32.const 0x1.fffffep+127)) (i32.const 1)) +(assert_return (invoke "le" (f32.const -0x0p+0) (f32.const -inf)) (i32.const 0)) +(assert_return (invoke "le" (f32.const -0x0p+0) (f32.const inf)) (i32.const 1)) +(assert_return (invoke "le" (f32.const 0x0p+0) (f32.const -inf)) (i32.const 0)) +(assert_return (invoke "le" (f32.const 0x0p+0) (f32.const inf)) (i32.const 1)) +(assert_return (invoke "le" (f32.const -0x0p+0) (f32.const -nan)) (i32.const 0)) +(assert_return (invoke "le" (f32.const -0x0p+0) (f32.const -nan:0x200000)) (i32.const 0)) +(assert_return (invoke "le" (f32.const -0x0p+0) (f32.const nan)) (i32.const 0)) +(assert_return (invoke "le" (f32.const -0x0p+0) (f32.const nan:0x200000)) (i32.const 0)) +(assert_return (invoke "le" (f32.const 0x0p+0) (f32.const -nan)) (i32.const 0)) +(assert_return (invoke "le" (f32.const 0x0p+0) (f32.const -nan:0x200000)) (i32.const 0)) +(assert_return (invoke "le" (f32.const 0x0p+0) (f32.const nan)) (i32.const 0)) +(assert_return (invoke "le" (f32.const 0x0p+0) (f32.const nan:0x200000)) (i32.const 0)) +(assert_return (invoke "le" (f32.const -0x1p-149) (f32.const -0x0p+0)) (i32.const 1)) +(assert_return (invoke "le" (f32.const -0x1p-149) (f32.const 0x0p+0)) (i32.const 1)) +(assert_return (invoke "le" (f32.const 0x1p-149) (f32.const -0x0p+0)) (i32.const 0)) +(assert_return (invoke "le" (f32.const 0x1p-149) (f32.const 0x0p+0)) (i32.const 0)) +(assert_return (invoke "le" (f32.const -0x1p-149) (f32.const -0x1p-149)) (i32.const 1)) +(assert_return (invoke "le" (f32.const -0x1p-149) (f32.const 0x1p-149)) (i32.const 1)) +(assert_return (invoke "le" (f32.const 0x1p-149) (f32.const -0x1p-149)) (i32.const 0)) +(assert_return (invoke "le" (f32.const 0x1p-149) (f32.const 0x1p-149)) (i32.const 1)) +(assert_return (invoke "le" (f32.const -0x1p-149) (f32.const -0x1p-126)) (i32.const 0)) +(assert_return (invoke "le" (f32.const -0x1p-149) (f32.const 0x1p-126)) (i32.const 1)) +(assert_return (invoke "le" (f32.const 0x1p-149) (f32.const -0x1p-126)) (i32.const 0)) +(assert_return (invoke "le" (f32.const 0x1p-149) (f32.const 0x1p-126)) (i32.const 1)) +(assert_return (invoke "le" (f32.const -0x1p-149) (f32.const -0x1p-1)) (i32.const 0)) +(assert_return (invoke "le" (f32.const -0x1p-149) (f32.const 0x1p-1)) (i32.const 1)) +(assert_return (invoke "le" (f32.const 0x1p-149) (f32.const -0x1p-1)) (i32.const 0)) +(assert_return (invoke "le" (f32.const 0x1p-149) (f32.const 0x1p-1)) (i32.const 1)) +(assert_return (invoke "le" (f32.const -0x1p-149) (f32.const -0x1p+0)) (i32.const 0)) +(assert_return (invoke "le" (f32.const -0x1p-149) (f32.const 0x1p+0)) (i32.const 1)) +(assert_return (invoke "le" (f32.const 0x1p-149) (f32.const -0x1p+0)) (i32.const 0)) +(assert_return (invoke "le" (f32.const 0x1p-149) (f32.const 0x1p+0)) (i32.const 1)) +(assert_return (invoke "le" (f32.const -0x1p-149) (f32.const -0x1.921fb6p+2)) (i32.const 0)) +(assert_return (invoke "le" (f32.const -0x1p-149) (f32.const 0x1.921fb6p+2)) (i32.const 1)) +(assert_return (invoke "le" (f32.const 0x1p-149) (f32.const -0x1.921fb6p+2)) (i32.const 0)) +(assert_return (invoke "le" (f32.const 0x1p-149) (f32.const 0x1.921fb6p+2)) (i32.const 1)) +(assert_return (invoke "le" (f32.const -0x1p-149) (f32.const -0x1.fffffep+127)) (i32.const 0)) +(assert_return (invoke "le" (f32.const -0x1p-149) (f32.const 0x1.fffffep+127)) (i32.const 1)) +(assert_return (invoke "le" (f32.const 0x1p-149) (f32.const -0x1.fffffep+127)) (i32.const 0)) +(assert_return (invoke "le" (f32.const 0x1p-149) (f32.const 0x1.fffffep+127)) (i32.const 1)) +(assert_return (invoke "le" (f32.const -0x1p-149) (f32.const -inf)) (i32.const 0)) +(assert_return (invoke "le" (f32.const -0x1p-149) (f32.const inf)) (i32.const 1)) +(assert_return (invoke "le" (f32.const 0x1p-149) (f32.const -inf)) (i32.const 0)) +(assert_return (invoke "le" (f32.const 0x1p-149) (f32.const inf)) (i32.const 1)) +(assert_return (invoke "le" (f32.const -0x1p-149) (f32.const -nan)) (i32.const 0)) +(assert_return (invoke "le" (f32.const -0x1p-149) (f32.const -nan:0x200000)) (i32.const 0)) +(assert_return (invoke "le" (f32.const -0x1p-149) (f32.const nan)) (i32.const 0)) +(assert_return (invoke "le" (f32.const -0x1p-149) (f32.const nan:0x200000)) (i32.const 0)) +(assert_return (invoke "le" (f32.const 0x1p-149) (f32.const -nan)) (i32.const 0)) +(assert_return (invoke "le" (f32.const 0x1p-149) (f32.const -nan:0x200000)) (i32.const 0)) +(assert_return (invoke "le" (f32.const 0x1p-149) (f32.const nan)) (i32.const 0)) +(assert_return (invoke "le" (f32.const 0x1p-149) (f32.const nan:0x200000)) (i32.const 0)) +(assert_return (invoke "le" (f32.const -0x1p-126) (f32.const -0x0p+0)) (i32.const 1)) +(assert_return (invoke "le" (f32.const -0x1p-126) (f32.const 0x0p+0)) (i32.const 1)) +(assert_return (invoke "le" (f32.const 0x1p-126) (f32.const -0x0p+0)) (i32.const 0)) +(assert_return (invoke "le" (f32.const 0x1p-126) (f32.const 0x0p+0)) (i32.const 0)) +(assert_return (invoke "le" (f32.const -0x1p-126) (f32.const -0x1p-149)) (i32.const 1)) +(assert_return (invoke "le" (f32.const -0x1p-126) (f32.const 0x1p-149)) (i32.const 1)) +(assert_return (invoke "le" (f32.const 0x1p-126) (f32.const -0x1p-149)) (i32.const 0)) +(assert_return (invoke "le" (f32.const 0x1p-126) (f32.const 0x1p-149)) (i32.const 0)) +(assert_return (invoke "le" (f32.const -0x1p-126) (f32.const -0x1p-126)) (i32.const 1)) +(assert_return (invoke "le" (f32.const -0x1p-126) (f32.const 0x1p-126)) (i32.const 1)) +(assert_return (invoke "le" (f32.const 0x1p-126) (f32.const -0x1p-126)) (i32.const 0)) +(assert_return (invoke "le" (f32.const 0x1p-126) (f32.const 0x1p-126)) (i32.const 1)) +(assert_return (invoke "le" (f32.const -0x1p-126) (f32.const -0x1p-1)) (i32.const 0)) +(assert_return (invoke "le" (f32.const -0x1p-126) (f32.const 0x1p-1)) (i32.const 1)) +(assert_return (invoke "le" (f32.const 0x1p-126) (f32.const -0x1p-1)) (i32.const 0)) +(assert_return (invoke "le" (f32.const 0x1p-126) (f32.const 0x1p-1)) (i32.const 1)) +(assert_return (invoke "le" (f32.const -0x1p-126) (f32.const -0x1p+0)) (i32.const 0)) +(assert_return (invoke "le" (f32.const -0x1p-126) (f32.const 0x1p+0)) (i32.const 1)) +(assert_return (invoke "le" (f32.const 0x1p-126) (f32.const -0x1p+0)) (i32.const 0)) +(assert_return (invoke "le" (f32.const 0x1p-126) (f32.const 0x1p+0)) (i32.const 1)) +(assert_return (invoke "le" (f32.const -0x1p-126) (f32.const -0x1.921fb6p+2)) (i32.const 0)) +(assert_return (invoke "le" (f32.const -0x1p-126) (f32.const 0x1.921fb6p+2)) (i32.const 1)) +(assert_return (invoke "le" (f32.const 0x1p-126) (f32.const -0x1.921fb6p+2)) (i32.const 0)) +(assert_return (invoke "le" (f32.const 0x1p-126) (f32.const 0x1.921fb6p+2)) (i32.const 1)) +(assert_return (invoke "le" (f32.const -0x1p-126) (f32.const -0x1.fffffep+127)) (i32.const 0)) +(assert_return (invoke "le" (f32.const -0x1p-126) (f32.const 0x1.fffffep+127)) (i32.const 1)) +(assert_return (invoke "le" (f32.const 0x1p-126) (f32.const -0x1.fffffep+127)) (i32.const 0)) +(assert_return (invoke "le" (f32.const 0x1p-126) (f32.const 0x1.fffffep+127)) (i32.const 1)) +(assert_return (invoke "le" (f32.const -0x1p-126) (f32.const -inf)) (i32.const 0)) +(assert_return (invoke "le" (f32.const -0x1p-126) (f32.const inf)) (i32.const 1)) +(assert_return (invoke "le" (f32.const 0x1p-126) (f32.const -inf)) (i32.const 0)) +(assert_return (invoke "le" (f32.const 0x1p-126) (f32.const inf)) (i32.const 1)) +(assert_return (invoke "le" (f32.const -0x1p-126) (f32.const -nan)) (i32.const 0)) +(assert_return (invoke "le" (f32.const -0x1p-126) (f32.const -nan:0x200000)) (i32.const 0)) +(assert_return (invoke "le" (f32.const -0x1p-126) (f32.const nan)) (i32.const 0)) +(assert_return (invoke "le" (f32.const -0x1p-126) (f32.const nan:0x200000)) (i32.const 0)) +(assert_return (invoke "le" (f32.const 0x1p-126) (f32.const -nan)) (i32.const 0)) +(assert_return (invoke "le" (f32.const 0x1p-126) (f32.const -nan:0x200000)) (i32.const 0)) +(assert_return (invoke "le" (f32.const 0x1p-126) (f32.const nan)) (i32.const 0)) +(assert_return (invoke "le" (f32.const 0x1p-126) (f32.const nan:0x200000)) (i32.const 0)) +(assert_return (invoke "le" (f32.const -0x1p-1) (f32.const -0x0p+0)) (i32.const 1)) +(assert_return (invoke "le" (f32.const -0x1p-1) (f32.const 0x0p+0)) (i32.const 1)) +(assert_return (invoke "le" (f32.const 0x1p-1) (f32.const -0x0p+0)) (i32.const 0)) +(assert_return (invoke "le" (f32.const 0x1p-1) (f32.const 0x0p+0)) (i32.const 0)) +(assert_return (invoke "le" (f32.const -0x1p-1) (f32.const -0x1p-149)) (i32.const 1)) +(assert_return (invoke "le" (f32.const -0x1p-1) (f32.const 0x1p-149)) (i32.const 1)) +(assert_return (invoke "le" (f32.const 0x1p-1) (f32.const -0x1p-149)) (i32.const 0)) +(assert_return (invoke "le" (f32.const 0x1p-1) (f32.const 0x1p-149)) (i32.const 0)) +(assert_return (invoke "le" (f32.const -0x1p-1) (f32.const -0x1p-126)) (i32.const 1)) +(assert_return (invoke "le" (f32.const -0x1p-1) (f32.const 0x1p-126)) (i32.const 1)) +(assert_return (invoke "le" (f32.const 0x1p-1) (f32.const -0x1p-126)) (i32.const 0)) +(assert_return (invoke "le" (f32.const 0x1p-1) (f32.const 0x1p-126)) (i32.const 0)) +(assert_return (invoke "le" (f32.const -0x1p-1) (f32.const -0x1p-1)) (i32.const 1)) +(assert_return (invoke "le" (f32.const -0x1p-1) (f32.const 0x1p-1)) (i32.const 1)) +(assert_return (invoke "le" (f32.const 0x1p-1) (f32.const -0x1p-1)) (i32.const 0)) +(assert_return (invoke "le" (f32.const 0x1p-1) (f32.const 0x1p-1)) (i32.const 1)) +(assert_return (invoke "le" (f32.const -0x1p-1) (f32.const -0x1p+0)) (i32.const 0)) +(assert_return (invoke "le" (f32.const -0x1p-1) (f32.const 0x1p+0)) (i32.const 1)) +(assert_return (invoke "le" (f32.const 0x1p-1) (f32.const -0x1p+0)) (i32.const 0)) +(assert_return (invoke "le" (f32.const 0x1p-1) (f32.const 0x1p+0)) (i32.const 1)) +(assert_return (invoke "le" (f32.const -0x1p-1) (f32.const -0x1.921fb6p+2)) (i32.const 0)) +(assert_return (invoke "le" (f32.const -0x1p-1) (f32.const 0x1.921fb6p+2)) (i32.const 1)) +(assert_return (invoke "le" (f32.const 0x1p-1) (f32.const -0x1.921fb6p+2)) (i32.const 0)) +(assert_return (invoke "le" (f32.const 0x1p-1) (f32.const 0x1.921fb6p+2)) (i32.const 1)) +(assert_return (invoke "le" (f32.const -0x1p-1) (f32.const -0x1.fffffep+127)) (i32.const 0)) +(assert_return (invoke "le" (f32.const -0x1p-1) (f32.const 0x1.fffffep+127)) (i32.const 1)) +(assert_return (invoke "le" (f32.const 0x1p-1) (f32.const -0x1.fffffep+127)) (i32.const 0)) +(assert_return (invoke "le" (f32.const 0x1p-1) (f32.const 0x1.fffffep+127)) (i32.const 1)) +(assert_return (invoke "le" (f32.const -0x1p-1) (f32.const -inf)) (i32.const 0)) +(assert_return (invoke "le" (f32.const -0x1p-1) (f32.const inf)) (i32.const 1)) +(assert_return (invoke "le" (f32.const 0x1p-1) (f32.const -inf)) (i32.const 0)) +(assert_return (invoke "le" (f32.const 0x1p-1) (f32.const inf)) (i32.const 1)) +(assert_return (invoke "le" (f32.const -0x1p-1) (f32.const -nan)) (i32.const 0)) +(assert_return (invoke "le" (f32.const -0x1p-1) (f32.const -nan:0x200000)) (i32.const 0)) +(assert_return (invoke "le" (f32.const -0x1p-1) (f32.const nan)) (i32.const 0)) +(assert_return (invoke "le" (f32.const -0x1p-1) (f32.const nan:0x200000)) (i32.const 0)) +(assert_return (invoke "le" (f32.const 0x1p-1) (f32.const -nan)) (i32.const 0)) +(assert_return (invoke "le" (f32.const 0x1p-1) (f32.const -nan:0x200000)) (i32.const 0)) +(assert_return (invoke "le" (f32.const 0x1p-1) (f32.const nan)) (i32.const 0)) +(assert_return (invoke "le" (f32.const 0x1p-1) (f32.const nan:0x200000)) (i32.const 0)) +(assert_return (invoke "le" (f32.const -0x1p+0) (f32.const -0x0p+0)) (i32.const 1)) +(assert_return (invoke "le" (f32.const -0x1p+0) (f32.const 0x0p+0)) (i32.const 1)) +(assert_return (invoke "le" (f32.const 0x1p+0) (f32.const -0x0p+0)) (i32.const 0)) +(assert_return (invoke "le" (f32.const 0x1p+0) (f32.const 0x0p+0)) (i32.const 0)) +(assert_return (invoke "le" (f32.const -0x1p+0) (f32.const -0x1p-149)) (i32.const 1)) +(assert_return (invoke "le" (f32.const -0x1p+0) (f32.const 0x1p-149)) (i32.const 1)) +(assert_return (invoke "le" (f32.const 0x1p+0) (f32.const -0x1p-149)) (i32.const 0)) +(assert_return (invoke "le" (f32.const 0x1p+0) (f32.const 0x1p-149)) (i32.const 0)) +(assert_return (invoke "le" (f32.const -0x1p+0) (f32.const -0x1p-126)) (i32.const 1)) +(assert_return (invoke "le" (f32.const -0x1p+0) (f32.const 0x1p-126)) (i32.const 1)) +(assert_return (invoke "le" (f32.const 0x1p+0) (f32.const -0x1p-126)) (i32.const 0)) +(assert_return (invoke "le" (f32.const 0x1p+0) (f32.const 0x1p-126)) (i32.const 0)) +(assert_return (invoke "le" (f32.const -0x1p+0) (f32.const -0x1p-1)) (i32.const 1)) +(assert_return (invoke "le" (f32.const -0x1p+0) (f32.const 0x1p-1)) (i32.const 1)) +(assert_return (invoke "le" (f32.const 0x1p+0) (f32.const -0x1p-1)) (i32.const 0)) +(assert_return (invoke "le" (f32.const 0x1p+0) (f32.const 0x1p-1)) (i32.const 0)) +(assert_return (invoke "le" (f32.const -0x1p+0) (f32.const -0x1p+0)) (i32.const 1)) +(assert_return (invoke "le" (f32.const -0x1p+0) (f32.const 0x1p+0)) (i32.const 1)) +(assert_return (invoke "le" (f32.const 0x1p+0) (f32.const -0x1p+0)) (i32.const 0)) +(assert_return (invoke "le" (f32.const 0x1p+0) (f32.const 0x1p+0)) (i32.const 1)) +(assert_return (invoke "le" (f32.const -0x1p+0) (f32.const -0x1.921fb6p+2)) (i32.const 0)) +(assert_return (invoke "le" (f32.const -0x1p+0) (f32.const 0x1.921fb6p+2)) (i32.const 1)) +(assert_return (invoke "le" (f32.const 0x1p+0) (f32.const -0x1.921fb6p+2)) (i32.const 0)) +(assert_return (invoke "le" (f32.const 0x1p+0) (f32.const 0x1.921fb6p+2)) (i32.const 1)) +(assert_return (invoke "le" (f32.const -0x1p+0) (f32.const -0x1.fffffep+127)) (i32.const 0)) +(assert_return (invoke "le" (f32.const -0x1p+0) (f32.const 0x1.fffffep+127)) (i32.const 1)) +(assert_return (invoke "le" (f32.const 0x1p+0) (f32.const -0x1.fffffep+127)) (i32.const 0)) +(assert_return (invoke "le" (f32.const 0x1p+0) (f32.const 0x1.fffffep+127)) (i32.const 1)) +(assert_return (invoke "le" (f32.const -0x1p+0) (f32.const -inf)) (i32.const 0)) +(assert_return (invoke "le" (f32.const -0x1p+0) (f32.const inf)) (i32.const 1)) +(assert_return (invoke "le" (f32.const 0x1p+0) (f32.const -inf)) (i32.const 0)) +(assert_return (invoke "le" (f32.const 0x1p+0) (f32.const inf)) (i32.const 1)) +(assert_return (invoke "le" (f32.const -0x1p+0) (f32.const -nan)) (i32.const 0)) +(assert_return (invoke "le" (f32.const -0x1p+0) (f32.const -nan:0x200000)) (i32.const 0)) +(assert_return (invoke "le" (f32.const -0x1p+0) (f32.const nan)) (i32.const 0)) +(assert_return (invoke "le" (f32.const -0x1p+0) (f32.const nan:0x200000)) (i32.const 0)) +(assert_return (invoke "le" (f32.const 0x1p+0) (f32.const -nan)) (i32.const 0)) +(assert_return (invoke "le" (f32.const 0x1p+0) (f32.const -nan:0x200000)) (i32.const 0)) +(assert_return (invoke "le" (f32.const 0x1p+0) (f32.const nan)) (i32.const 0)) +(assert_return (invoke "le" (f32.const 0x1p+0) (f32.const nan:0x200000)) (i32.const 0)) +(assert_return (invoke "le" (f32.const -0x1.921fb6p+2) (f32.const -0x0p+0)) (i32.const 1)) +(assert_return (invoke "le" (f32.const -0x1.921fb6p+2) (f32.const 0x0p+0)) (i32.const 1)) +(assert_return (invoke "le" (f32.const 0x1.921fb6p+2) (f32.const -0x0p+0)) (i32.const 0)) +(assert_return (invoke "le" (f32.const 0x1.921fb6p+2) (f32.const 0x0p+0)) (i32.const 0)) +(assert_return (invoke "le" (f32.const -0x1.921fb6p+2) (f32.const -0x1p-149)) (i32.const 1)) +(assert_return (invoke "le" (f32.const -0x1.921fb6p+2) (f32.const 0x1p-149)) (i32.const 1)) +(assert_return (invoke "le" (f32.const 0x1.921fb6p+2) (f32.const -0x1p-149)) (i32.const 0)) +(assert_return (invoke "le" (f32.const 0x1.921fb6p+2) (f32.const 0x1p-149)) (i32.const 0)) +(assert_return (invoke "le" (f32.const -0x1.921fb6p+2) (f32.const -0x1p-126)) (i32.const 1)) +(assert_return (invoke "le" (f32.const -0x1.921fb6p+2) (f32.const 0x1p-126)) (i32.const 1)) +(assert_return (invoke "le" (f32.const 0x1.921fb6p+2) (f32.const -0x1p-126)) (i32.const 0)) +(assert_return (invoke "le" (f32.const 0x1.921fb6p+2) (f32.const 0x1p-126)) (i32.const 0)) +(assert_return (invoke "le" (f32.const -0x1.921fb6p+2) (f32.const -0x1p-1)) (i32.const 1)) +(assert_return (invoke "le" (f32.const -0x1.921fb6p+2) (f32.const 0x1p-1)) (i32.const 1)) +(assert_return (invoke "le" (f32.const 0x1.921fb6p+2) (f32.const -0x1p-1)) (i32.const 0)) +(assert_return (invoke "le" (f32.const 0x1.921fb6p+2) (f32.const 0x1p-1)) (i32.const 0)) +(assert_return (invoke "le" (f32.const -0x1.921fb6p+2) (f32.const -0x1p+0)) (i32.const 1)) +(assert_return (invoke "le" (f32.const -0x1.921fb6p+2) (f32.const 0x1p+0)) (i32.const 1)) +(assert_return (invoke "le" (f32.const 0x1.921fb6p+2) (f32.const -0x1p+0)) (i32.const 0)) +(assert_return (invoke "le" (f32.const 0x1.921fb6p+2) (f32.const 0x1p+0)) (i32.const 0)) +(assert_return (invoke "le" (f32.const -0x1.921fb6p+2) (f32.const -0x1.921fb6p+2)) (i32.const 1)) +(assert_return (invoke "le" (f32.const -0x1.921fb6p+2) (f32.const 0x1.921fb6p+2)) (i32.const 1)) +(assert_return (invoke "le" (f32.const 0x1.921fb6p+2) (f32.const -0x1.921fb6p+2)) (i32.const 0)) +(assert_return (invoke "le" (f32.const 0x1.921fb6p+2) (f32.const 0x1.921fb6p+2)) (i32.const 1)) +(assert_return (invoke "le" (f32.const -0x1.921fb6p+2) (f32.const -0x1.fffffep+127)) (i32.const 0)) +(assert_return (invoke "le" (f32.const -0x1.921fb6p+2) (f32.const 0x1.fffffep+127)) (i32.const 1)) +(assert_return (invoke "le" (f32.const 0x1.921fb6p+2) (f32.const -0x1.fffffep+127)) (i32.const 0)) +(assert_return (invoke "le" (f32.const 0x1.921fb6p+2) (f32.const 0x1.fffffep+127)) (i32.const 1)) +(assert_return (invoke "le" (f32.const -0x1.921fb6p+2) (f32.const -inf)) (i32.const 0)) +(assert_return (invoke "le" (f32.const -0x1.921fb6p+2) (f32.const inf)) (i32.const 1)) +(assert_return (invoke "le" (f32.const 0x1.921fb6p+2) (f32.const -inf)) (i32.const 0)) +(assert_return (invoke "le" (f32.const 0x1.921fb6p+2) (f32.const inf)) (i32.const 1)) +(assert_return (invoke "le" (f32.const -0x1.921fb6p+2) (f32.const -nan)) (i32.const 0)) +(assert_return (invoke "le" (f32.const -0x1.921fb6p+2) (f32.const -nan:0x200000)) (i32.const 0)) +(assert_return (invoke "le" (f32.const -0x1.921fb6p+2) (f32.const nan)) (i32.const 0)) +(assert_return (invoke "le" (f32.const -0x1.921fb6p+2) (f32.const nan:0x200000)) (i32.const 0)) +(assert_return (invoke "le" (f32.const 0x1.921fb6p+2) (f32.const -nan)) (i32.const 0)) +(assert_return (invoke "le" (f32.const 0x1.921fb6p+2) (f32.const -nan:0x200000)) (i32.const 0)) +(assert_return (invoke "le" (f32.const 0x1.921fb6p+2) (f32.const nan)) (i32.const 0)) +(assert_return (invoke "le" (f32.const 0x1.921fb6p+2) (f32.const nan:0x200000)) (i32.const 0)) +(assert_return (invoke "le" (f32.const -0x1.fffffep+127) (f32.const -0x0p+0)) (i32.const 1)) +(assert_return (invoke "le" (f32.const -0x1.fffffep+127) (f32.const 0x0p+0)) (i32.const 1)) +(assert_return (invoke "le" (f32.const 0x1.fffffep+127) (f32.const -0x0p+0)) (i32.const 0)) +(assert_return (invoke "le" (f32.const 0x1.fffffep+127) (f32.const 0x0p+0)) (i32.const 0)) +(assert_return (invoke "le" (f32.const -0x1.fffffep+127) (f32.const -0x1p-149)) (i32.const 1)) +(assert_return (invoke "le" (f32.const -0x1.fffffep+127) (f32.const 0x1p-149)) (i32.const 1)) +(assert_return (invoke "le" (f32.const 0x1.fffffep+127) (f32.const -0x1p-149)) (i32.const 0)) +(assert_return (invoke "le" (f32.const 0x1.fffffep+127) (f32.const 0x1p-149)) (i32.const 0)) +(assert_return (invoke "le" (f32.const -0x1.fffffep+127) (f32.const -0x1p-126)) (i32.const 1)) +(assert_return (invoke "le" (f32.const -0x1.fffffep+127) (f32.const 0x1p-126)) (i32.const 1)) +(assert_return (invoke "le" (f32.const 0x1.fffffep+127) (f32.const -0x1p-126)) (i32.const 0)) +(assert_return (invoke "le" (f32.const 0x1.fffffep+127) (f32.const 0x1p-126)) (i32.const 0)) +(assert_return (invoke "le" (f32.const -0x1.fffffep+127) (f32.const -0x1p-1)) (i32.const 1)) +(assert_return (invoke "le" (f32.const -0x1.fffffep+127) (f32.const 0x1p-1)) (i32.const 1)) +(assert_return (invoke "le" (f32.const 0x1.fffffep+127) (f32.const -0x1p-1)) (i32.const 0)) +(assert_return (invoke "le" (f32.const 0x1.fffffep+127) (f32.const 0x1p-1)) (i32.const 0)) +(assert_return (invoke "le" (f32.const -0x1.fffffep+127) (f32.const -0x1p+0)) (i32.const 1)) +(assert_return (invoke "le" (f32.const -0x1.fffffep+127) (f32.const 0x1p+0)) (i32.const 1)) +(assert_return (invoke "le" (f32.const 0x1.fffffep+127) (f32.const -0x1p+0)) (i32.const 0)) +(assert_return (invoke "le" (f32.const 0x1.fffffep+127) (f32.const 0x1p+0)) (i32.const 0)) +(assert_return (invoke "le" (f32.const -0x1.fffffep+127) (f32.const -0x1.921fb6p+2)) (i32.const 1)) +(assert_return (invoke "le" (f32.const -0x1.fffffep+127) (f32.const 0x1.921fb6p+2)) (i32.const 1)) +(assert_return (invoke "le" (f32.const 0x1.fffffep+127) (f32.const -0x1.921fb6p+2)) (i32.const 0)) +(assert_return (invoke "le" (f32.const 0x1.fffffep+127) (f32.const 0x1.921fb6p+2)) (i32.const 0)) +(assert_return (invoke "le" (f32.const -0x1.fffffep+127) (f32.const -0x1.fffffep+127)) (i32.const 1)) +(assert_return (invoke "le" (f32.const -0x1.fffffep+127) (f32.const 0x1.fffffep+127)) (i32.const 1)) +(assert_return (invoke "le" (f32.const 0x1.fffffep+127) (f32.const -0x1.fffffep+127)) (i32.const 0)) +(assert_return (invoke "le" (f32.const 0x1.fffffep+127) (f32.const 0x1.fffffep+127)) (i32.const 1)) +(assert_return (invoke "le" (f32.const -0x1.fffffep+127) (f32.const -inf)) (i32.const 0)) +(assert_return (invoke "le" (f32.const -0x1.fffffep+127) (f32.const inf)) (i32.const 1)) +(assert_return (invoke "le" (f32.const 0x1.fffffep+127) (f32.const -inf)) (i32.const 0)) +(assert_return (invoke "le" (f32.const 0x1.fffffep+127) (f32.const inf)) (i32.const 1)) +(assert_return (invoke "le" (f32.const -0x1.fffffep+127) (f32.const -nan)) (i32.const 0)) +(assert_return (invoke "le" (f32.const -0x1.fffffep+127) (f32.const -nan:0x200000)) (i32.const 0)) +(assert_return (invoke "le" (f32.const -0x1.fffffep+127) (f32.const nan)) (i32.const 0)) +(assert_return (invoke "le" (f32.const -0x1.fffffep+127) (f32.const nan:0x200000)) (i32.const 0)) +(assert_return (invoke "le" (f32.const 0x1.fffffep+127) (f32.const -nan)) (i32.const 0)) +(assert_return (invoke "le" (f32.const 0x1.fffffep+127) (f32.const -nan:0x200000)) (i32.const 0)) +(assert_return (invoke "le" (f32.const 0x1.fffffep+127) (f32.const nan)) (i32.const 0)) +(assert_return (invoke "le" (f32.const 0x1.fffffep+127) (f32.const nan:0x200000)) (i32.const 0)) +(assert_return (invoke "le" (f32.const -inf) (f32.const -0x0p+0)) (i32.const 1)) +(assert_return (invoke "le" (f32.const -inf) (f32.const 0x0p+0)) (i32.const 1)) +(assert_return (invoke "le" (f32.const inf) (f32.const -0x0p+0)) (i32.const 0)) +(assert_return (invoke "le" (f32.const inf) (f32.const 0x0p+0)) (i32.const 0)) +(assert_return (invoke "le" (f32.const -inf) (f32.const -0x1p-149)) (i32.const 1)) +(assert_return (invoke "le" (f32.const -inf) (f32.const 0x1p-149)) (i32.const 1)) +(assert_return (invoke "le" (f32.const inf) (f32.const -0x1p-149)) (i32.const 0)) +(assert_return (invoke "le" (f32.const inf) (f32.const 0x1p-149)) (i32.const 0)) +(assert_return (invoke "le" (f32.const -inf) (f32.const -0x1p-126)) (i32.const 1)) +(assert_return (invoke "le" (f32.const -inf) (f32.const 0x1p-126)) (i32.const 1)) +(assert_return (invoke "le" (f32.const inf) (f32.const -0x1p-126)) (i32.const 0)) +(assert_return (invoke "le" (f32.const inf) (f32.const 0x1p-126)) (i32.const 0)) +(assert_return (invoke "le" (f32.const -inf) (f32.const -0x1p-1)) (i32.const 1)) +(assert_return (invoke "le" (f32.const -inf) (f32.const 0x1p-1)) (i32.const 1)) +(assert_return (invoke "le" (f32.const inf) (f32.const -0x1p-1)) (i32.const 0)) +(assert_return (invoke "le" (f32.const inf) (f32.const 0x1p-1)) (i32.const 0)) +(assert_return (invoke "le" (f32.const -inf) (f32.const -0x1p+0)) (i32.const 1)) +(assert_return (invoke "le" (f32.const -inf) (f32.const 0x1p+0)) (i32.const 1)) +(assert_return (invoke "le" (f32.const inf) (f32.const -0x1p+0)) (i32.const 0)) +(assert_return (invoke "le" (f32.const inf) (f32.const 0x1p+0)) (i32.const 0)) +(assert_return (invoke "le" (f32.const -inf) (f32.const -0x1.921fb6p+2)) (i32.const 1)) +(assert_return (invoke "le" (f32.const -inf) (f32.const 0x1.921fb6p+2)) (i32.const 1)) +(assert_return (invoke "le" (f32.const inf) (f32.const -0x1.921fb6p+2)) (i32.const 0)) +(assert_return (invoke "le" (f32.const inf) (f32.const 0x1.921fb6p+2)) (i32.const 0)) +(assert_return (invoke "le" (f32.const -inf) (f32.const -0x1.fffffep+127)) (i32.const 1)) +(assert_return (invoke "le" (f32.const -inf) (f32.const 0x1.fffffep+127)) (i32.const 1)) +(assert_return (invoke "le" (f32.const inf) (f32.const -0x1.fffffep+127)) (i32.const 0)) +(assert_return (invoke "le" (f32.const inf) (f32.const 0x1.fffffep+127)) (i32.const 0)) +(assert_return (invoke "le" (f32.const -inf) (f32.const -inf)) (i32.const 1)) +(assert_return (invoke "le" (f32.const -inf) (f32.const inf)) (i32.const 1)) +(assert_return (invoke "le" (f32.const inf) (f32.const -inf)) (i32.const 0)) +(assert_return (invoke "le" (f32.const inf) (f32.const inf)) (i32.const 1)) +(assert_return (invoke "le" (f32.const -inf) (f32.const -nan)) (i32.const 0)) +(assert_return (invoke "le" (f32.const -inf) (f32.const -nan:0x200000)) (i32.const 0)) +(assert_return (invoke "le" (f32.const -inf) (f32.const nan)) (i32.const 0)) +(assert_return (invoke "le" (f32.const -inf) (f32.const nan:0x200000)) (i32.const 0)) +(assert_return (invoke "le" (f32.const inf) (f32.const -nan)) (i32.const 0)) +(assert_return (invoke "le" (f32.const inf) (f32.const -nan:0x200000)) (i32.const 0)) +(assert_return (invoke "le" (f32.const inf) (f32.const nan)) (i32.const 0)) +(assert_return (invoke "le" (f32.const inf) (f32.const nan:0x200000)) (i32.const 0)) +(assert_return (invoke "le" (f32.const -nan) (f32.const -0x0p+0)) (i32.const 0)) +(assert_return (invoke "le" (f32.const -nan:0x200000) (f32.const -0x0p+0)) (i32.const 0)) +(assert_return (invoke "le" (f32.const -nan) (f32.const 0x0p+0)) (i32.const 0)) +(assert_return (invoke "le" (f32.const -nan:0x200000) (f32.const 0x0p+0)) (i32.const 0)) +(assert_return (invoke "le" (f32.const nan) (f32.const -0x0p+0)) (i32.const 0)) +(assert_return (invoke "le" (f32.const nan:0x200000) (f32.const -0x0p+0)) (i32.const 0)) +(assert_return (invoke "le" (f32.const nan) (f32.const 0x0p+0)) (i32.const 0)) +(assert_return (invoke "le" (f32.const nan:0x200000) (f32.const 0x0p+0)) (i32.const 0)) +(assert_return (invoke "le" (f32.const -nan) (f32.const -0x1p-149)) (i32.const 0)) +(assert_return (invoke "le" (f32.const -nan:0x200000) (f32.const -0x1p-149)) (i32.const 0)) +(assert_return (invoke "le" (f32.const -nan) (f32.const 0x1p-149)) (i32.const 0)) +(assert_return (invoke "le" (f32.const -nan:0x200000) (f32.const 0x1p-149)) (i32.const 0)) +(assert_return (invoke "le" (f32.const nan) (f32.const -0x1p-149)) (i32.const 0)) +(assert_return (invoke "le" (f32.const nan:0x200000) (f32.const -0x1p-149)) (i32.const 0)) +(assert_return (invoke "le" (f32.const nan) (f32.const 0x1p-149)) (i32.const 0)) +(assert_return (invoke "le" (f32.const nan:0x200000) (f32.const 0x1p-149)) (i32.const 0)) +(assert_return (invoke "le" (f32.const -nan) (f32.const -0x1p-126)) (i32.const 0)) +(assert_return (invoke "le" (f32.const -nan:0x200000) (f32.const -0x1p-126)) (i32.const 0)) +(assert_return (invoke "le" (f32.const -nan) (f32.const 0x1p-126)) (i32.const 0)) +(assert_return (invoke "le" (f32.const -nan:0x200000) (f32.const 0x1p-126)) (i32.const 0)) +(assert_return (invoke "le" (f32.const nan) (f32.const -0x1p-126)) (i32.const 0)) +(assert_return (invoke "le" (f32.const nan:0x200000) (f32.const -0x1p-126)) (i32.const 0)) +(assert_return (invoke "le" (f32.const nan) (f32.const 0x1p-126)) (i32.const 0)) +(assert_return (invoke "le" (f32.const nan:0x200000) (f32.const 0x1p-126)) (i32.const 0)) +(assert_return (invoke "le" (f32.const -nan) (f32.const -0x1p-1)) (i32.const 0)) +(assert_return (invoke "le" (f32.const -nan:0x200000) (f32.const -0x1p-1)) (i32.const 0)) +(assert_return (invoke "le" (f32.const -nan) (f32.const 0x1p-1)) (i32.const 0)) +(assert_return (invoke "le" (f32.const -nan:0x200000) (f32.const 0x1p-1)) (i32.const 0)) +(assert_return (invoke "le" (f32.const nan) (f32.const -0x1p-1)) (i32.const 0)) +(assert_return (invoke "le" (f32.const nan:0x200000) (f32.const -0x1p-1)) (i32.const 0)) +(assert_return (invoke "le" (f32.const nan) (f32.const 0x1p-1)) (i32.const 0)) +(assert_return (invoke "le" (f32.const nan:0x200000) (f32.const 0x1p-1)) (i32.const 0)) +(assert_return (invoke "le" (f32.const -nan) (f32.const -0x1p+0)) (i32.const 0)) +(assert_return (invoke "le" (f32.const -nan:0x200000) (f32.const -0x1p+0)) (i32.const 0)) +(assert_return (invoke "le" (f32.const -nan) (f32.const 0x1p+0)) (i32.const 0)) +(assert_return (invoke "le" (f32.const -nan:0x200000) (f32.const 0x1p+0)) (i32.const 0)) +(assert_return (invoke "le" (f32.const nan) (f32.const -0x1p+0)) (i32.const 0)) +(assert_return (invoke "le" (f32.const nan:0x200000) (f32.const -0x1p+0)) (i32.const 0)) +(assert_return (invoke "le" (f32.const nan) (f32.const 0x1p+0)) (i32.const 0)) +(assert_return (invoke "le" (f32.const nan:0x200000) (f32.const 0x1p+0)) (i32.const 0)) +(assert_return (invoke "le" (f32.const -nan) (f32.const -0x1.921fb6p+2)) (i32.const 0)) +(assert_return (invoke "le" (f32.const -nan:0x200000) (f32.const -0x1.921fb6p+2)) (i32.const 0)) +(assert_return (invoke "le" (f32.const -nan) (f32.const 0x1.921fb6p+2)) (i32.const 0)) +(assert_return (invoke "le" (f32.const -nan:0x200000) (f32.const 0x1.921fb6p+2)) (i32.const 0)) +(assert_return (invoke "le" (f32.const nan) (f32.const -0x1.921fb6p+2)) (i32.const 0)) +(assert_return (invoke "le" (f32.const nan:0x200000) (f32.const -0x1.921fb6p+2)) (i32.const 0)) +(assert_return (invoke "le" (f32.const nan) (f32.const 0x1.921fb6p+2)) (i32.const 0)) +(assert_return (invoke "le" (f32.const nan:0x200000) (f32.const 0x1.921fb6p+2)) (i32.const 0)) +(assert_return (invoke "le" (f32.const -nan) (f32.const -0x1.fffffep+127)) (i32.const 0)) +(assert_return (invoke "le" (f32.const -nan:0x200000) (f32.const -0x1.fffffep+127)) (i32.const 0)) +(assert_return (invoke "le" (f32.const -nan) (f32.const 0x1.fffffep+127)) (i32.const 0)) +(assert_return (invoke "le" (f32.const -nan:0x200000) (f32.const 0x1.fffffep+127)) (i32.const 0)) +(assert_return (invoke "le" (f32.const nan) (f32.const -0x1.fffffep+127)) (i32.const 0)) +(assert_return (invoke "le" (f32.const nan:0x200000) (f32.const -0x1.fffffep+127)) (i32.const 0)) +(assert_return (invoke "le" (f32.const nan) (f32.const 0x1.fffffep+127)) (i32.const 0)) +(assert_return (invoke "le" (f32.const nan:0x200000) (f32.const 0x1.fffffep+127)) (i32.const 0)) +(assert_return (invoke "le" (f32.const -nan) (f32.const -inf)) (i32.const 0)) +(assert_return (invoke "le" (f32.const -nan:0x200000) (f32.const -inf)) (i32.const 0)) +(assert_return (invoke "le" (f32.const -nan) (f32.const inf)) (i32.const 0)) +(assert_return (invoke "le" (f32.const -nan:0x200000) (f32.const inf)) (i32.const 0)) +(assert_return (invoke "le" (f32.const nan) (f32.const -inf)) (i32.const 0)) +(assert_return (invoke "le" (f32.const nan:0x200000) (f32.const -inf)) (i32.const 0)) +(assert_return (invoke "le" (f32.const nan) (f32.const inf)) (i32.const 0)) +(assert_return (invoke "le" (f32.const nan:0x200000) (f32.const inf)) (i32.const 0)) +(assert_return (invoke "le" (f32.const -nan) (f32.const -nan)) (i32.const 0)) +(assert_return (invoke "le" (f32.const -nan:0x200000) (f32.const -nan)) (i32.const 0)) +(assert_return (invoke "le" (f32.const -nan) (f32.const -nan:0x200000)) (i32.const 0)) +(assert_return (invoke "le" (f32.const -nan:0x200000) (f32.const -nan:0x200000)) (i32.const 0)) +(assert_return (invoke "le" (f32.const -nan) (f32.const nan)) (i32.const 0)) +(assert_return (invoke "le" (f32.const -nan:0x200000) (f32.const nan)) (i32.const 0)) +(assert_return (invoke "le" (f32.const -nan) (f32.const nan:0x200000)) (i32.const 0)) +(assert_return (invoke "le" (f32.const -nan:0x200000) (f32.const nan:0x200000)) (i32.const 0)) +(assert_return (invoke "le" (f32.const nan) (f32.const -nan)) (i32.const 0)) +(assert_return (invoke "le" (f32.const nan:0x200000) (f32.const -nan)) (i32.const 0)) +(assert_return (invoke "le" (f32.const nan) (f32.const -nan:0x200000)) (i32.const 0)) +(assert_return (invoke "le" (f32.const nan:0x200000) (f32.const -nan:0x200000)) (i32.const 0)) +(assert_return (invoke "le" (f32.const nan) (f32.const nan)) (i32.const 0)) +(assert_return (invoke "le" (f32.const nan:0x200000) (f32.const nan)) (i32.const 0)) +(assert_return (invoke "le" (f32.const nan) (f32.const nan:0x200000)) (i32.const 0)) +(assert_return (invoke "le" (f32.const nan:0x200000) (f32.const nan:0x200000)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -0x0p+0) (f32.const -0x0p+0)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -0x0p+0) (f32.const 0x0p+0)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const 0x0p+0) (f32.const -0x0p+0)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const 0x0p+0) (f32.const 0x0p+0)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -0x0p+0) (f32.const -0x1p-149)) (i32.const 1)) +(assert_return (invoke "gt" (f32.const -0x0p+0) (f32.const 0x1p-149)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const 0x0p+0) (f32.const -0x1p-149)) (i32.const 1)) +(assert_return (invoke "gt" (f32.const 0x0p+0) (f32.const 0x1p-149)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -0x0p+0) (f32.const -0x1p-126)) (i32.const 1)) +(assert_return (invoke "gt" (f32.const -0x0p+0) (f32.const 0x1p-126)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const 0x0p+0) (f32.const -0x1p-126)) (i32.const 1)) +(assert_return (invoke "gt" (f32.const 0x0p+0) (f32.const 0x1p-126)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -0x0p+0) (f32.const -0x1p-1)) (i32.const 1)) +(assert_return (invoke "gt" (f32.const -0x0p+0) (f32.const 0x1p-1)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const 0x0p+0) (f32.const -0x1p-1)) (i32.const 1)) +(assert_return (invoke "gt" (f32.const 0x0p+0) (f32.const 0x1p-1)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -0x0p+0) (f32.const -0x1p+0)) (i32.const 1)) +(assert_return (invoke "gt" (f32.const -0x0p+0) (f32.const 0x1p+0)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const 0x0p+0) (f32.const -0x1p+0)) (i32.const 1)) +(assert_return (invoke "gt" (f32.const 0x0p+0) (f32.const 0x1p+0)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -0x0p+0) (f32.const -0x1.921fb6p+2)) (i32.const 1)) +(assert_return (invoke "gt" (f32.const -0x0p+0) (f32.const 0x1.921fb6p+2)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const 0x0p+0) (f32.const -0x1.921fb6p+2)) (i32.const 1)) +(assert_return (invoke "gt" (f32.const 0x0p+0) (f32.const 0x1.921fb6p+2)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -0x0p+0) (f32.const -0x1.fffffep+127)) (i32.const 1)) +(assert_return (invoke "gt" (f32.const -0x0p+0) (f32.const 0x1.fffffep+127)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const 0x0p+0) (f32.const -0x1.fffffep+127)) (i32.const 1)) +(assert_return (invoke "gt" (f32.const 0x0p+0) (f32.const 0x1.fffffep+127)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -0x0p+0) (f32.const -inf)) (i32.const 1)) +(assert_return (invoke "gt" (f32.const -0x0p+0) (f32.const inf)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const 0x0p+0) (f32.const -inf)) (i32.const 1)) +(assert_return (invoke "gt" (f32.const 0x0p+0) (f32.const inf)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -0x0p+0) (f32.const -nan)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -0x0p+0) (f32.const -nan:0x200000)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -0x0p+0) (f32.const nan)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -0x0p+0) (f32.const nan:0x200000)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const 0x0p+0) (f32.const -nan)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const 0x0p+0) (f32.const -nan:0x200000)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const 0x0p+0) (f32.const nan)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const 0x0p+0) (f32.const nan:0x200000)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -0x1p-149) (f32.const -0x0p+0)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -0x1p-149) (f32.const 0x0p+0)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const 0x1p-149) (f32.const -0x0p+0)) (i32.const 1)) +(assert_return (invoke "gt" (f32.const 0x1p-149) (f32.const 0x0p+0)) (i32.const 1)) +(assert_return (invoke "gt" (f32.const -0x1p-149) (f32.const -0x1p-149)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -0x1p-149) (f32.const 0x1p-149)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const 0x1p-149) (f32.const -0x1p-149)) (i32.const 1)) +(assert_return (invoke "gt" (f32.const 0x1p-149) (f32.const 0x1p-149)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -0x1p-149) (f32.const -0x1p-126)) (i32.const 1)) +(assert_return (invoke "gt" (f32.const -0x1p-149) (f32.const 0x1p-126)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const 0x1p-149) (f32.const -0x1p-126)) (i32.const 1)) +(assert_return (invoke "gt" (f32.const 0x1p-149) (f32.const 0x1p-126)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -0x1p-149) (f32.const -0x1p-1)) (i32.const 1)) +(assert_return (invoke "gt" (f32.const -0x1p-149) (f32.const 0x1p-1)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const 0x1p-149) (f32.const -0x1p-1)) (i32.const 1)) +(assert_return (invoke "gt" (f32.const 0x1p-149) (f32.const 0x1p-1)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -0x1p-149) (f32.const -0x1p+0)) (i32.const 1)) +(assert_return (invoke "gt" (f32.const -0x1p-149) (f32.const 0x1p+0)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const 0x1p-149) (f32.const -0x1p+0)) (i32.const 1)) +(assert_return (invoke "gt" (f32.const 0x1p-149) (f32.const 0x1p+0)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -0x1p-149) (f32.const -0x1.921fb6p+2)) (i32.const 1)) +(assert_return (invoke "gt" (f32.const -0x1p-149) (f32.const 0x1.921fb6p+2)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const 0x1p-149) (f32.const -0x1.921fb6p+2)) (i32.const 1)) +(assert_return (invoke "gt" (f32.const 0x1p-149) (f32.const 0x1.921fb6p+2)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -0x1p-149) (f32.const -0x1.fffffep+127)) (i32.const 1)) +(assert_return (invoke "gt" (f32.const -0x1p-149) (f32.const 0x1.fffffep+127)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const 0x1p-149) (f32.const -0x1.fffffep+127)) (i32.const 1)) +(assert_return (invoke "gt" (f32.const 0x1p-149) (f32.const 0x1.fffffep+127)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -0x1p-149) (f32.const -inf)) (i32.const 1)) +(assert_return (invoke "gt" (f32.const -0x1p-149) (f32.const inf)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const 0x1p-149) (f32.const -inf)) (i32.const 1)) +(assert_return (invoke "gt" (f32.const 0x1p-149) (f32.const inf)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -0x1p-149) (f32.const -nan)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -0x1p-149) (f32.const -nan:0x200000)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -0x1p-149) (f32.const nan)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -0x1p-149) (f32.const nan:0x200000)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const 0x1p-149) (f32.const -nan)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const 0x1p-149) (f32.const -nan:0x200000)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const 0x1p-149) (f32.const nan)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const 0x1p-149) (f32.const nan:0x200000)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -0x1p-126) (f32.const -0x0p+0)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -0x1p-126) (f32.const 0x0p+0)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const 0x1p-126) (f32.const -0x0p+0)) (i32.const 1)) +(assert_return (invoke "gt" (f32.const 0x1p-126) (f32.const 0x0p+0)) (i32.const 1)) +(assert_return (invoke "gt" (f32.const -0x1p-126) (f32.const -0x1p-149)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -0x1p-126) (f32.const 0x1p-149)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const 0x1p-126) (f32.const -0x1p-149)) (i32.const 1)) +(assert_return (invoke "gt" (f32.const 0x1p-126) (f32.const 0x1p-149)) (i32.const 1)) +(assert_return (invoke "gt" (f32.const -0x1p-126) (f32.const -0x1p-126)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -0x1p-126) (f32.const 0x1p-126)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const 0x1p-126) (f32.const -0x1p-126)) (i32.const 1)) +(assert_return (invoke "gt" (f32.const 0x1p-126) (f32.const 0x1p-126)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -0x1p-126) (f32.const -0x1p-1)) (i32.const 1)) +(assert_return (invoke "gt" (f32.const -0x1p-126) (f32.const 0x1p-1)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const 0x1p-126) (f32.const -0x1p-1)) (i32.const 1)) +(assert_return (invoke "gt" (f32.const 0x1p-126) (f32.const 0x1p-1)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -0x1p-126) (f32.const -0x1p+0)) (i32.const 1)) +(assert_return (invoke "gt" (f32.const -0x1p-126) (f32.const 0x1p+0)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const 0x1p-126) (f32.const -0x1p+0)) (i32.const 1)) +(assert_return (invoke "gt" (f32.const 0x1p-126) (f32.const 0x1p+0)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -0x1p-126) (f32.const -0x1.921fb6p+2)) (i32.const 1)) +(assert_return (invoke "gt" (f32.const -0x1p-126) (f32.const 0x1.921fb6p+2)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const 0x1p-126) (f32.const -0x1.921fb6p+2)) (i32.const 1)) +(assert_return (invoke "gt" (f32.const 0x1p-126) (f32.const 0x1.921fb6p+2)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -0x1p-126) (f32.const -0x1.fffffep+127)) (i32.const 1)) +(assert_return (invoke "gt" (f32.const -0x1p-126) (f32.const 0x1.fffffep+127)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const 0x1p-126) (f32.const -0x1.fffffep+127)) (i32.const 1)) +(assert_return (invoke "gt" (f32.const 0x1p-126) (f32.const 0x1.fffffep+127)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -0x1p-126) (f32.const -inf)) (i32.const 1)) +(assert_return (invoke "gt" (f32.const -0x1p-126) (f32.const inf)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const 0x1p-126) (f32.const -inf)) (i32.const 1)) +(assert_return (invoke "gt" (f32.const 0x1p-126) (f32.const inf)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -0x1p-126) (f32.const -nan)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -0x1p-126) (f32.const -nan:0x200000)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -0x1p-126) (f32.const nan)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -0x1p-126) (f32.const nan:0x200000)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const 0x1p-126) (f32.const -nan)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const 0x1p-126) (f32.const -nan:0x200000)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const 0x1p-126) (f32.const nan)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const 0x1p-126) (f32.const nan:0x200000)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -0x1p-1) (f32.const -0x0p+0)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -0x1p-1) (f32.const 0x0p+0)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const 0x1p-1) (f32.const -0x0p+0)) (i32.const 1)) +(assert_return (invoke "gt" (f32.const 0x1p-1) (f32.const 0x0p+0)) (i32.const 1)) +(assert_return (invoke "gt" (f32.const -0x1p-1) (f32.const -0x1p-149)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -0x1p-1) (f32.const 0x1p-149)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const 0x1p-1) (f32.const -0x1p-149)) (i32.const 1)) +(assert_return (invoke "gt" (f32.const 0x1p-1) (f32.const 0x1p-149)) (i32.const 1)) +(assert_return (invoke "gt" (f32.const -0x1p-1) (f32.const -0x1p-126)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -0x1p-1) (f32.const 0x1p-126)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const 0x1p-1) (f32.const -0x1p-126)) (i32.const 1)) +(assert_return (invoke "gt" (f32.const 0x1p-1) (f32.const 0x1p-126)) (i32.const 1)) +(assert_return (invoke "gt" (f32.const -0x1p-1) (f32.const -0x1p-1)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -0x1p-1) (f32.const 0x1p-1)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const 0x1p-1) (f32.const -0x1p-1)) (i32.const 1)) +(assert_return (invoke "gt" (f32.const 0x1p-1) (f32.const 0x1p-1)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -0x1p-1) (f32.const -0x1p+0)) (i32.const 1)) +(assert_return (invoke "gt" (f32.const -0x1p-1) (f32.const 0x1p+0)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const 0x1p-1) (f32.const -0x1p+0)) (i32.const 1)) +(assert_return (invoke "gt" (f32.const 0x1p-1) (f32.const 0x1p+0)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -0x1p-1) (f32.const -0x1.921fb6p+2)) (i32.const 1)) +(assert_return (invoke "gt" (f32.const -0x1p-1) (f32.const 0x1.921fb6p+2)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const 0x1p-1) (f32.const -0x1.921fb6p+2)) (i32.const 1)) +(assert_return (invoke "gt" (f32.const 0x1p-1) (f32.const 0x1.921fb6p+2)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -0x1p-1) (f32.const -0x1.fffffep+127)) (i32.const 1)) +(assert_return (invoke "gt" (f32.const -0x1p-1) (f32.const 0x1.fffffep+127)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const 0x1p-1) (f32.const -0x1.fffffep+127)) (i32.const 1)) +(assert_return (invoke "gt" (f32.const 0x1p-1) (f32.const 0x1.fffffep+127)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -0x1p-1) (f32.const -inf)) (i32.const 1)) +(assert_return (invoke "gt" (f32.const -0x1p-1) (f32.const inf)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const 0x1p-1) (f32.const -inf)) (i32.const 1)) +(assert_return (invoke "gt" (f32.const 0x1p-1) (f32.const inf)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -0x1p-1) (f32.const -nan)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -0x1p-1) (f32.const -nan:0x200000)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -0x1p-1) (f32.const nan)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -0x1p-1) (f32.const nan:0x200000)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const 0x1p-1) (f32.const -nan)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const 0x1p-1) (f32.const -nan:0x200000)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const 0x1p-1) (f32.const nan)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const 0x1p-1) (f32.const nan:0x200000)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -0x1p+0) (f32.const -0x0p+0)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -0x1p+0) (f32.const 0x0p+0)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const 0x1p+0) (f32.const -0x0p+0)) (i32.const 1)) +(assert_return (invoke "gt" (f32.const 0x1p+0) (f32.const 0x0p+0)) (i32.const 1)) +(assert_return (invoke "gt" (f32.const -0x1p+0) (f32.const -0x1p-149)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -0x1p+0) (f32.const 0x1p-149)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const 0x1p+0) (f32.const -0x1p-149)) (i32.const 1)) +(assert_return (invoke "gt" (f32.const 0x1p+0) (f32.const 0x1p-149)) (i32.const 1)) +(assert_return (invoke "gt" (f32.const -0x1p+0) (f32.const -0x1p-126)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -0x1p+0) (f32.const 0x1p-126)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const 0x1p+0) (f32.const -0x1p-126)) (i32.const 1)) +(assert_return (invoke "gt" (f32.const 0x1p+0) (f32.const 0x1p-126)) (i32.const 1)) +(assert_return (invoke "gt" (f32.const -0x1p+0) (f32.const -0x1p-1)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -0x1p+0) (f32.const 0x1p-1)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const 0x1p+0) (f32.const -0x1p-1)) (i32.const 1)) +(assert_return (invoke "gt" (f32.const 0x1p+0) (f32.const 0x1p-1)) (i32.const 1)) +(assert_return (invoke "gt" (f32.const -0x1p+0) (f32.const -0x1p+0)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -0x1p+0) (f32.const 0x1p+0)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const 0x1p+0) (f32.const -0x1p+0)) (i32.const 1)) +(assert_return (invoke "gt" (f32.const 0x1p+0) (f32.const 0x1p+0)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -0x1p+0) (f32.const -0x1.921fb6p+2)) (i32.const 1)) +(assert_return (invoke "gt" (f32.const -0x1p+0) (f32.const 0x1.921fb6p+2)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const 0x1p+0) (f32.const -0x1.921fb6p+2)) (i32.const 1)) +(assert_return (invoke "gt" (f32.const 0x1p+0) (f32.const 0x1.921fb6p+2)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -0x1p+0) (f32.const -0x1.fffffep+127)) (i32.const 1)) +(assert_return (invoke "gt" (f32.const -0x1p+0) (f32.const 0x1.fffffep+127)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const 0x1p+0) (f32.const -0x1.fffffep+127)) (i32.const 1)) +(assert_return (invoke "gt" (f32.const 0x1p+0) (f32.const 0x1.fffffep+127)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -0x1p+0) (f32.const -inf)) (i32.const 1)) +(assert_return (invoke "gt" (f32.const -0x1p+0) (f32.const inf)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const 0x1p+0) (f32.const -inf)) (i32.const 1)) +(assert_return (invoke "gt" (f32.const 0x1p+0) (f32.const inf)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -0x1p+0) (f32.const -nan)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -0x1p+0) (f32.const -nan:0x200000)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -0x1p+0) (f32.const nan)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -0x1p+0) (f32.const nan:0x200000)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const 0x1p+0) (f32.const -nan)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const 0x1p+0) (f32.const -nan:0x200000)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const 0x1p+0) (f32.const nan)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const 0x1p+0) (f32.const nan:0x200000)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -0x1.921fb6p+2) (f32.const -0x0p+0)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -0x1.921fb6p+2) (f32.const 0x0p+0)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const 0x1.921fb6p+2) (f32.const -0x0p+0)) (i32.const 1)) +(assert_return (invoke "gt" (f32.const 0x1.921fb6p+2) (f32.const 0x0p+0)) (i32.const 1)) +(assert_return (invoke "gt" (f32.const -0x1.921fb6p+2) (f32.const -0x1p-149)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -0x1.921fb6p+2) (f32.const 0x1p-149)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const 0x1.921fb6p+2) (f32.const -0x1p-149)) (i32.const 1)) +(assert_return (invoke "gt" (f32.const 0x1.921fb6p+2) (f32.const 0x1p-149)) (i32.const 1)) +(assert_return (invoke "gt" (f32.const -0x1.921fb6p+2) (f32.const -0x1p-126)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -0x1.921fb6p+2) (f32.const 0x1p-126)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const 0x1.921fb6p+2) (f32.const -0x1p-126)) (i32.const 1)) +(assert_return (invoke "gt" (f32.const 0x1.921fb6p+2) (f32.const 0x1p-126)) (i32.const 1)) +(assert_return (invoke "gt" (f32.const -0x1.921fb6p+2) (f32.const -0x1p-1)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -0x1.921fb6p+2) (f32.const 0x1p-1)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const 0x1.921fb6p+2) (f32.const -0x1p-1)) (i32.const 1)) +(assert_return (invoke "gt" (f32.const 0x1.921fb6p+2) (f32.const 0x1p-1)) (i32.const 1)) +(assert_return (invoke "gt" (f32.const -0x1.921fb6p+2) (f32.const -0x1p+0)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -0x1.921fb6p+2) (f32.const 0x1p+0)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const 0x1.921fb6p+2) (f32.const -0x1p+0)) (i32.const 1)) +(assert_return (invoke "gt" (f32.const 0x1.921fb6p+2) (f32.const 0x1p+0)) (i32.const 1)) +(assert_return (invoke "gt" (f32.const -0x1.921fb6p+2) (f32.const -0x1.921fb6p+2)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -0x1.921fb6p+2) (f32.const 0x1.921fb6p+2)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const 0x1.921fb6p+2) (f32.const -0x1.921fb6p+2)) (i32.const 1)) +(assert_return (invoke "gt" (f32.const 0x1.921fb6p+2) (f32.const 0x1.921fb6p+2)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -0x1.921fb6p+2) (f32.const -0x1.fffffep+127)) (i32.const 1)) +(assert_return (invoke "gt" (f32.const -0x1.921fb6p+2) (f32.const 0x1.fffffep+127)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const 0x1.921fb6p+2) (f32.const -0x1.fffffep+127)) (i32.const 1)) +(assert_return (invoke "gt" (f32.const 0x1.921fb6p+2) (f32.const 0x1.fffffep+127)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -0x1.921fb6p+2) (f32.const -inf)) (i32.const 1)) +(assert_return (invoke "gt" (f32.const -0x1.921fb6p+2) (f32.const inf)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const 0x1.921fb6p+2) (f32.const -inf)) (i32.const 1)) +(assert_return (invoke "gt" (f32.const 0x1.921fb6p+2) (f32.const inf)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -0x1.921fb6p+2) (f32.const -nan)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -0x1.921fb6p+2) (f32.const -nan:0x200000)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -0x1.921fb6p+2) (f32.const nan)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -0x1.921fb6p+2) (f32.const nan:0x200000)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const 0x1.921fb6p+2) (f32.const -nan)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const 0x1.921fb6p+2) (f32.const -nan:0x200000)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const 0x1.921fb6p+2) (f32.const nan)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const 0x1.921fb6p+2) (f32.const nan:0x200000)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -0x1.fffffep+127) (f32.const -0x0p+0)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -0x1.fffffep+127) (f32.const 0x0p+0)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const 0x1.fffffep+127) (f32.const -0x0p+0)) (i32.const 1)) +(assert_return (invoke "gt" (f32.const 0x1.fffffep+127) (f32.const 0x0p+0)) (i32.const 1)) +(assert_return (invoke "gt" (f32.const -0x1.fffffep+127) (f32.const -0x1p-149)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -0x1.fffffep+127) (f32.const 0x1p-149)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const 0x1.fffffep+127) (f32.const -0x1p-149)) (i32.const 1)) +(assert_return (invoke "gt" (f32.const 0x1.fffffep+127) (f32.const 0x1p-149)) (i32.const 1)) +(assert_return (invoke "gt" (f32.const -0x1.fffffep+127) (f32.const -0x1p-126)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -0x1.fffffep+127) (f32.const 0x1p-126)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const 0x1.fffffep+127) (f32.const -0x1p-126)) (i32.const 1)) +(assert_return (invoke "gt" (f32.const 0x1.fffffep+127) (f32.const 0x1p-126)) (i32.const 1)) +(assert_return (invoke "gt" (f32.const -0x1.fffffep+127) (f32.const -0x1p-1)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -0x1.fffffep+127) (f32.const 0x1p-1)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const 0x1.fffffep+127) (f32.const -0x1p-1)) (i32.const 1)) +(assert_return (invoke "gt" (f32.const 0x1.fffffep+127) (f32.const 0x1p-1)) (i32.const 1)) +(assert_return (invoke "gt" (f32.const -0x1.fffffep+127) (f32.const -0x1p+0)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -0x1.fffffep+127) (f32.const 0x1p+0)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const 0x1.fffffep+127) (f32.const -0x1p+0)) (i32.const 1)) +(assert_return (invoke "gt" (f32.const 0x1.fffffep+127) (f32.const 0x1p+0)) (i32.const 1)) +(assert_return (invoke "gt" (f32.const -0x1.fffffep+127) (f32.const -0x1.921fb6p+2)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -0x1.fffffep+127) (f32.const 0x1.921fb6p+2)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const 0x1.fffffep+127) (f32.const -0x1.921fb6p+2)) (i32.const 1)) +(assert_return (invoke "gt" (f32.const 0x1.fffffep+127) (f32.const 0x1.921fb6p+2)) (i32.const 1)) +(assert_return (invoke "gt" (f32.const -0x1.fffffep+127) (f32.const -0x1.fffffep+127)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -0x1.fffffep+127) (f32.const 0x1.fffffep+127)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const 0x1.fffffep+127) (f32.const -0x1.fffffep+127)) (i32.const 1)) +(assert_return (invoke "gt" (f32.const 0x1.fffffep+127) (f32.const 0x1.fffffep+127)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -0x1.fffffep+127) (f32.const -inf)) (i32.const 1)) +(assert_return (invoke "gt" (f32.const -0x1.fffffep+127) (f32.const inf)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const 0x1.fffffep+127) (f32.const -inf)) (i32.const 1)) +(assert_return (invoke "gt" (f32.const 0x1.fffffep+127) (f32.const inf)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -0x1.fffffep+127) (f32.const -nan)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -0x1.fffffep+127) (f32.const -nan:0x200000)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -0x1.fffffep+127) (f32.const nan)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -0x1.fffffep+127) (f32.const nan:0x200000)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const 0x1.fffffep+127) (f32.const -nan)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const 0x1.fffffep+127) (f32.const -nan:0x200000)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const 0x1.fffffep+127) (f32.const nan)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const 0x1.fffffep+127) (f32.const nan:0x200000)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -inf) (f32.const -0x0p+0)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -inf) (f32.const 0x0p+0)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const inf) (f32.const -0x0p+0)) (i32.const 1)) +(assert_return (invoke "gt" (f32.const inf) (f32.const 0x0p+0)) (i32.const 1)) +(assert_return (invoke "gt" (f32.const -inf) (f32.const -0x1p-149)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -inf) (f32.const 0x1p-149)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const inf) (f32.const -0x1p-149)) (i32.const 1)) +(assert_return (invoke "gt" (f32.const inf) (f32.const 0x1p-149)) (i32.const 1)) +(assert_return (invoke "gt" (f32.const -inf) (f32.const -0x1p-126)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -inf) (f32.const 0x1p-126)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const inf) (f32.const -0x1p-126)) (i32.const 1)) +(assert_return (invoke "gt" (f32.const inf) (f32.const 0x1p-126)) (i32.const 1)) +(assert_return (invoke "gt" (f32.const -inf) (f32.const -0x1p-1)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -inf) (f32.const 0x1p-1)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const inf) (f32.const -0x1p-1)) (i32.const 1)) +(assert_return (invoke "gt" (f32.const inf) (f32.const 0x1p-1)) (i32.const 1)) +(assert_return (invoke "gt" (f32.const -inf) (f32.const -0x1p+0)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -inf) (f32.const 0x1p+0)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const inf) (f32.const -0x1p+0)) (i32.const 1)) +(assert_return (invoke "gt" (f32.const inf) (f32.const 0x1p+0)) (i32.const 1)) +(assert_return (invoke "gt" (f32.const -inf) (f32.const -0x1.921fb6p+2)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -inf) (f32.const 0x1.921fb6p+2)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const inf) (f32.const -0x1.921fb6p+2)) (i32.const 1)) +(assert_return (invoke "gt" (f32.const inf) (f32.const 0x1.921fb6p+2)) (i32.const 1)) +(assert_return (invoke "gt" (f32.const -inf) (f32.const -0x1.fffffep+127)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -inf) (f32.const 0x1.fffffep+127)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const inf) (f32.const -0x1.fffffep+127)) (i32.const 1)) +(assert_return (invoke "gt" (f32.const inf) (f32.const 0x1.fffffep+127)) (i32.const 1)) +(assert_return (invoke "gt" (f32.const -inf) (f32.const -inf)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -inf) (f32.const inf)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const inf) (f32.const -inf)) (i32.const 1)) +(assert_return (invoke "gt" (f32.const inf) (f32.const inf)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -inf) (f32.const -nan)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -inf) (f32.const -nan:0x200000)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -inf) (f32.const nan)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -inf) (f32.const nan:0x200000)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const inf) (f32.const -nan)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const inf) (f32.const -nan:0x200000)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const inf) (f32.const nan)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const inf) (f32.const nan:0x200000)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -nan) (f32.const -0x0p+0)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -nan:0x200000) (f32.const -0x0p+0)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -nan) (f32.const 0x0p+0)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -nan:0x200000) (f32.const 0x0p+0)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const nan) (f32.const -0x0p+0)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const nan:0x200000) (f32.const -0x0p+0)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const nan) (f32.const 0x0p+0)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const nan:0x200000) (f32.const 0x0p+0)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -nan) (f32.const -0x1p-149)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -nan:0x200000) (f32.const -0x1p-149)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -nan) (f32.const 0x1p-149)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -nan:0x200000) (f32.const 0x1p-149)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const nan) (f32.const -0x1p-149)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const nan:0x200000) (f32.const -0x1p-149)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const nan) (f32.const 0x1p-149)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const nan:0x200000) (f32.const 0x1p-149)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -nan) (f32.const -0x1p-126)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -nan:0x200000) (f32.const -0x1p-126)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -nan) (f32.const 0x1p-126)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -nan:0x200000) (f32.const 0x1p-126)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const nan) (f32.const -0x1p-126)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const nan:0x200000) (f32.const -0x1p-126)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const nan) (f32.const 0x1p-126)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const nan:0x200000) (f32.const 0x1p-126)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -nan) (f32.const -0x1p-1)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -nan:0x200000) (f32.const -0x1p-1)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -nan) (f32.const 0x1p-1)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -nan:0x200000) (f32.const 0x1p-1)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const nan) (f32.const -0x1p-1)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const nan:0x200000) (f32.const -0x1p-1)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const nan) (f32.const 0x1p-1)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const nan:0x200000) (f32.const 0x1p-1)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -nan) (f32.const -0x1p+0)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -nan:0x200000) (f32.const -0x1p+0)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -nan) (f32.const 0x1p+0)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -nan:0x200000) (f32.const 0x1p+0)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const nan) (f32.const -0x1p+0)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const nan:0x200000) (f32.const -0x1p+0)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const nan) (f32.const 0x1p+0)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const nan:0x200000) (f32.const 0x1p+0)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -nan) (f32.const -0x1.921fb6p+2)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -nan:0x200000) (f32.const -0x1.921fb6p+2)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -nan) (f32.const 0x1.921fb6p+2)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -nan:0x200000) (f32.const 0x1.921fb6p+2)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const nan) (f32.const -0x1.921fb6p+2)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const nan:0x200000) (f32.const -0x1.921fb6p+2)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const nan) (f32.const 0x1.921fb6p+2)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const nan:0x200000) (f32.const 0x1.921fb6p+2)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -nan) (f32.const -0x1.fffffep+127)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -nan:0x200000) (f32.const -0x1.fffffep+127)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -nan) (f32.const 0x1.fffffep+127)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -nan:0x200000) (f32.const 0x1.fffffep+127)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const nan) (f32.const -0x1.fffffep+127)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const nan:0x200000) (f32.const -0x1.fffffep+127)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const nan) (f32.const 0x1.fffffep+127)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const nan:0x200000) (f32.const 0x1.fffffep+127)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -nan) (f32.const -inf)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -nan:0x200000) (f32.const -inf)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -nan) (f32.const inf)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -nan:0x200000) (f32.const inf)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const nan) (f32.const -inf)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const nan:0x200000) (f32.const -inf)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const nan) (f32.const inf)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const nan:0x200000) (f32.const inf)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -nan) (f32.const -nan)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -nan:0x200000) (f32.const -nan)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -nan) (f32.const -nan:0x200000)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -nan:0x200000) (f32.const -nan:0x200000)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -nan) (f32.const nan)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -nan:0x200000) (f32.const nan)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -nan) (f32.const nan:0x200000)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const -nan:0x200000) (f32.const nan:0x200000)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const nan) (f32.const -nan)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const nan:0x200000) (f32.const -nan)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const nan) (f32.const -nan:0x200000)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const nan:0x200000) (f32.const -nan:0x200000)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const nan) (f32.const nan)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const nan:0x200000) (f32.const nan)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const nan) (f32.const nan:0x200000)) (i32.const 0)) +(assert_return (invoke "gt" (f32.const nan:0x200000) (f32.const nan:0x200000)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const -0x0p+0) (f32.const -0x0p+0)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const -0x0p+0) (f32.const 0x0p+0)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const 0x0p+0) (f32.const -0x0p+0)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const 0x0p+0) (f32.const 0x0p+0)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const -0x0p+0) (f32.const -0x1p-149)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const -0x0p+0) (f32.const 0x1p-149)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const 0x0p+0) (f32.const -0x1p-149)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const 0x0p+0) (f32.const 0x1p-149)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const -0x0p+0) (f32.const -0x1p-126)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const -0x0p+0) (f32.const 0x1p-126)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const 0x0p+0) (f32.const -0x1p-126)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const 0x0p+0) (f32.const 0x1p-126)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const -0x0p+0) (f32.const -0x1p-1)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const -0x0p+0) (f32.const 0x1p-1)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const 0x0p+0) (f32.const -0x1p-1)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const 0x0p+0) (f32.const 0x1p-1)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const -0x0p+0) (f32.const -0x1p+0)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const -0x0p+0) (f32.const 0x1p+0)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const 0x0p+0) (f32.const -0x1p+0)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const 0x0p+0) (f32.const 0x1p+0)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const -0x0p+0) (f32.const -0x1.921fb6p+2)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const -0x0p+0) (f32.const 0x1.921fb6p+2)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const 0x0p+0) (f32.const -0x1.921fb6p+2)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const 0x0p+0) (f32.const 0x1.921fb6p+2)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const -0x0p+0) (f32.const -0x1.fffffep+127)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const -0x0p+0) (f32.const 0x1.fffffep+127)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const 0x0p+0) (f32.const -0x1.fffffep+127)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const 0x0p+0) (f32.const 0x1.fffffep+127)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const -0x0p+0) (f32.const -inf)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const -0x0p+0) (f32.const inf)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const 0x0p+0) (f32.const -inf)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const 0x0p+0) (f32.const inf)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const -0x0p+0) (f32.const -nan)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const -0x0p+0) (f32.const -nan:0x200000)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const -0x0p+0) (f32.const nan)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const -0x0p+0) (f32.const nan:0x200000)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const 0x0p+0) (f32.const -nan)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const 0x0p+0) (f32.const -nan:0x200000)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const 0x0p+0) (f32.const nan)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const 0x0p+0) (f32.const nan:0x200000)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const -0x1p-149) (f32.const -0x0p+0)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const -0x1p-149) (f32.const 0x0p+0)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const 0x1p-149) (f32.const -0x0p+0)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const 0x1p-149) (f32.const 0x0p+0)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const -0x1p-149) (f32.const -0x1p-149)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const -0x1p-149) (f32.const 0x1p-149)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const 0x1p-149) (f32.const -0x1p-149)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const 0x1p-149) (f32.const 0x1p-149)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const -0x1p-149) (f32.const -0x1p-126)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const -0x1p-149) (f32.const 0x1p-126)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const 0x1p-149) (f32.const -0x1p-126)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const 0x1p-149) (f32.const 0x1p-126)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const -0x1p-149) (f32.const -0x1p-1)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const -0x1p-149) (f32.const 0x1p-1)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const 0x1p-149) (f32.const -0x1p-1)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const 0x1p-149) (f32.const 0x1p-1)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const -0x1p-149) (f32.const -0x1p+0)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const -0x1p-149) (f32.const 0x1p+0)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const 0x1p-149) (f32.const -0x1p+0)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const 0x1p-149) (f32.const 0x1p+0)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const -0x1p-149) (f32.const -0x1.921fb6p+2)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const -0x1p-149) (f32.const 0x1.921fb6p+2)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const 0x1p-149) (f32.const -0x1.921fb6p+2)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const 0x1p-149) (f32.const 0x1.921fb6p+2)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const -0x1p-149) (f32.const -0x1.fffffep+127)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const -0x1p-149) (f32.const 0x1.fffffep+127)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const 0x1p-149) (f32.const -0x1.fffffep+127)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const 0x1p-149) (f32.const 0x1.fffffep+127)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const -0x1p-149) (f32.const -inf)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const -0x1p-149) (f32.const inf)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const 0x1p-149) (f32.const -inf)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const 0x1p-149) (f32.const inf)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const -0x1p-149) (f32.const -nan)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const -0x1p-149) (f32.const -nan:0x200000)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const -0x1p-149) (f32.const nan)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const -0x1p-149) (f32.const nan:0x200000)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const 0x1p-149) (f32.const -nan)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const 0x1p-149) (f32.const -nan:0x200000)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const 0x1p-149) (f32.const nan)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const 0x1p-149) (f32.const nan:0x200000)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const -0x1p-126) (f32.const -0x0p+0)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const -0x1p-126) (f32.const 0x0p+0)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const 0x1p-126) (f32.const -0x0p+0)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const 0x1p-126) (f32.const 0x0p+0)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const -0x1p-126) (f32.const -0x1p-149)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const -0x1p-126) (f32.const 0x1p-149)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const 0x1p-126) (f32.const -0x1p-149)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const 0x1p-126) (f32.const 0x1p-149)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const -0x1p-126) (f32.const -0x1p-126)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const -0x1p-126) (f32.const 0x1p-126)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const 0x1p-126) (f32.const -0x1p-126)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const 0x1p-126) (f32.const 0x1p-126)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const -0x1p-126) (f32.const -0x1p-1)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const -0x1p-126) (f32.const 0x1p-1)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const 0x1p-126) (f32.const -0x1p-1)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const 0x1p-126) (f32.const 0x1p-1)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const -0x1p-126) (f32.const -0x1p+0)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const -0x1p-126) (f32.const 0x1p+0)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const 0x1p-126) (f32.const -0x1p+0)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const 0x1p-126) (f32.const 0x1p+0)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const -0x1p-126) (f32.const -0x1.921fb6p+2)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const -0x1p-126) (f32.const 0x1.921fb6p+2)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const 0x1p-126) (f32.const -0x1.921fb6p+2)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const 0x1p-126) (f32.const 0x1.921fb6p+2)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const -0x1p-126) (f32.const -0x1.fffffep+127)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const -0x1p-126) (f32.const 0x1.fffffep+127)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const 0x1p-126) (f32.const -0x1.fffffep+127)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const 0x1p-126) (f32.const 0x1.fffffep+127)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const -0x1p-126) (f32.const -inf)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const -0x1p-126) (f32.const inf)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const 0x1p-126) (f32.const -inf)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const 0x1p-126) (f32.const inf)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const -0x1p-126) (f32.const -nan)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const -0x1p-126) (f32.const -nan:0x200000)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const -0x1p-126) (f32.const nan)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const -0x1p-126) (f32.const nan:0x200000)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const 0x1p-126) (f32.const -nan)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const 0x1p-126) (f32.const -nan:0x200000)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const 0x1p-126) (f32.const nan)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const 0x1p-126) (f32.const nan:0x200000)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const -0x1p-1) (f32.const -0x0p+0)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const -0x1p-1) (f32.const 0x0p+0)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const 0x1p-1) (f32.const -0x0p+0)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const 0x1p-1) (f32.const 0x0p+0)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const -0x1p-1) (f32.const -0x1p-149)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const -0x1p-1) (f32.const 0x1p-149)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const 0x1p-1) (f32.const -0x1p-149)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const 0x1p-1) (f32.const 0x1p-149)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const -0x1p-1) (f32.const -0x1p-126)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const -0x1p-1) (f32.const 0x1p-126)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const 0x1p-1) (f32.const -0x1p-126)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const 0x1p-1) (f32.const 0x1p-126)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const -0x1p-1) (f32.const -0x1p-1)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const -0x1p-1) (f32.const 0x1p-1)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const 0x1p-1) (f32.const -0x1p-1)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const 0x1p-1) (f32.const 0x1p-1)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const -0x1p-1) (f32.const -0x1p+0)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const -0x1p-1) (f32.const 0x1p+0)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const 0x1p-1) (f32.const -0x1p+0)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const 0x1p-1) (f32.const 0x1p+0)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const -0x1p-1) (f32.const -0x1.921fb6p+2)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const -0x1p-1) (f32.const 0x1.921fb6p+2)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const 0x1p-1) (f32.const -0x1.921fb6p+2)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const 0x1p-1) (f32.const 0x1.921fb6p+2)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const -0x1p-1) (f32.const -0x1.fffffep+127)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const -0x1p-1) (f32.const 0x1.fffffep+127)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const 0x1p-1) (f32.const -0x1.fffffep+127)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const 0x1p-1) (f32.const 0x1.fffffep+127)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const -0x1p-1) (f32.const -inf)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const -0x1p-1) (f32.const inf)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const 0x1p-1) (f32.const -inf)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const 0x1p-1) (f32.const inf)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const -0x1p-1) (f32.const -nan)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const -0x1p-1) (f32.const -nan:0x200000)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const -0x1p-1) (f32.const nan)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const -0x1p-1) (f32.const nan:0x200000)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const 0x1p-1) (f32.const -nan)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const 0x1p-1) (f32.const -nan:0x200000)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const 0x1p-1) (f32.const nan)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const 0x1p-1) (f32.const nan:0x200000)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const -0x1p+0) (f32.const -0x0p+0)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const -0x1p+0) (f32.const 0x0p+0)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const 0x1p+0) (f32.const -0x0p+0)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const 0x1p+0) (f32.const 0x0p+0)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const -0x1p+0) (f32.const -0x1p-149)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const -0x1p+0) (f32.const 0x1p-149)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const 0x1p+0) (f32.const -0x1p-149)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const 0x1p+0) (f32.const 0x1p-149)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const -0x1p+0) (f32.const -0x1p-126)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const -0x1p+0) (f32.const 0x1p-126)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const 0x1p+0) (f32.const -0x1p-126)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const 0x1p+0) (f32.const 0x1p-126)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const -0x1p+0) (f32.const -0x1p-1)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const -0x1p+0) (f32.const 0x1p-1)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const 0x1p+0) (f32.const -0x1p-1)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const 0x1p+0) (f32.const 0x1p-1)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const -0x1p+0) (f32.const -0x1p+0)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const -0x1p+0) (f32.const 0x1p+0)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const 0x1p+0) (f32.const -0x1p+0)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const 0x1p+0) (f32.const 0x1p+0)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const -0x1p+0) (f32.const -0x1.921fb6p+2)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const -0x1p+0) (f32.const 0x1.921fb6p+2)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const 0x1p+0) (f32.const -0x1.921fb6p+2)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const 0x1p+0) (f32.const 0x1.921fb6p+2)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const -0x1p+0) (f32.const -0x1.fffffep+127)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const -0x1p+0) (f32.const 0x1.fffffep+127)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const 0x1p+0) (f32.const -0x1.fffffep+127)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const 0x1p+0) (f32.const 0x1.fffffep+127)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const -0x1p+0) (f32.const -inf)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const -0x1p+0) (f32.const inf)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const 0x1p+0) (f32.const -inf)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const 0x1p+0) (f32.const inf)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const -0x1p+0) (f32.const -nan)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const -0x1p+0) (f32.const -nan:0x200000)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const -0x1p+0) (f32.const nan)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const -0x1p+0) (f32.const nan:0x200000)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const 0x1p+0) (f32.const -nan)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const 0x1p+0) (f32.const -nan:0x200000)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const 0x1p+0) (f32.const nan)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const 0x1p+0) (f32.const nan:0x200000)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const -0x1.921fb6p+2) (f32.const -0x0p+0)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const -0x1.921fb6p+2) (f32.const 0x0p+0)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const 0x1.921fb6p+2) (f32.const -0x0p+0)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const 0x1.921fb6p+2) (f32.const 0x0p+0)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const -0x1.921fb6p+2) (f32.const -0x1p-149)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const -0x1.921fb6p+2) (f32.const 0x1p-149)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const 0x1.921fb6p+2) (f32.const -0x1p-149)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const 0x1.921fb6p+2) (f32.const 0x1p-149)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const -0x1.921fb6p+2) (f32.const -0x1p-126)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const -0x1.921fb6p+2) (f32.const 0x1p-126)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const 0x1.921fb6p+2) (f32.const -0x1p-126)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const 0x1.921fb6p+2) (f32.const 0x1p-126)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const -0x1.921fb6p+2) (f32.const -0x1p-1)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const -0x1.921fb6p+2) (f32.const 0x1p-1)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const 0x1.921fb6p+2) (f32.const -0x1p-1)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const 0x1.921fb6p+2) (f32.const 0x1p-1)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const -0x1.921fb6p+2) (f32.const -0x1p+0)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const -0x1.921fb6p+2) (f32.const 0x1p+0)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const 0x1.921fb6p+2) (f32.const -0x1p+0)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const 0x1.921fb6p+2) (f32.const 0x1p+0)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const -0x1.921fb6p+2) (f32.const -0x1.921fb6p+2)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const -0x1.921fb6p+2) (f32.const 0x1.921fb6p+2)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const 0x1.921fb6p+2) (f32.const -0x1.921fb6p+2)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const 0x1.921fb6p+2) (f32.const 0x1.921fb6p+2)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const -0x1.921fb6p+2) (f32.const -0x1.fffffep+127)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const -0x1.921fb6p+2) (f32.const 0x1.fffffep+127)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const 0x1.921fb6p+2) (f32.const -0x1.fffffep+127)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const 0x1.921fb6p+2) (f32.const 0x1.fffffep+127)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const -0x1.921fb6p+2) (f32.const -inf)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const -0x1.921fb6p+2) (f32.const inf)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const 0x1.921fb6p+2) (f32.const -inf)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const 0x1.921fb6p+2) (f32.const inf)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const -0x1.921fb6p+2) (f32.const -nan)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const -0x1.921fb6p+2) (f32.const -nan:0x200000)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const -0x1.921fb6p+2) (f32.const nan)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const -0x1.921fb6p+2) (f32.const nan:0x200000)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const 0x1.921fb6p+2) (f32.const -nan)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const 0x1.921fb6p+2) (f32.const -nan:0x200000)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const 0x1.921fb6p+2) (f32.const nan)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const 0x1.921fb6p+2) (f32.const nan:0x200000)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const -0x1.fffffep+127) (f32.const -0x0p+0)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const -0x1.fffffep+127) (f32.const 0x0p+0)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const 0x1.fffffep+127) (f32.const -0x0p+0)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const 0x1.fffffep+127) (f32.const 0x0p+0)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const -0x1.fffffep+127) (f32.const -0x1p-149)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const -0x1.fffffep+127) (f32.const 0x1p-149)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const 0x1.fffffep+127) (f32.const -0x1p-149)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const 0x1.fffffep+127) (f32.const 0x1p-149)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const -0x1.fffffep+127) (f32.const -0x1p-126)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const -0x1.fffffep+127) (f32.const 0x1p-126)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const 0x1.fffffep+127) (f32.const -0x1p-126)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const 0x1.fffffep+127) (f32.const 0x1p-126)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const -0x1.fffffep+127) (f32.const -0x1p-1)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const -0x1.fffffep+127) (f32.const 0x1p-1)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const 0x1.fffffep+127) (f32.const -0x1p-1)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const 0x1.fffffep+127) (f32.const 0x1p-1)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const -0x1.fffffep+127) (f32.const -0x1p+0)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const -0x1.fffffep+127) (f32.const 0x1p+0)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const 0x1.fffffep+127) (f32.const -0x1p+0)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const 0x1.fffffep+127) (f32.const 0x1p+0)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const -0x1.fffffep+127) (f32.const -0x1.921fb6p+2)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const -0x1.fffffep+127) (f32.const 0x1.921fb6p+2)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const 0x1.fffffep+127) (f32.const -0x1.921fb6p+2)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const 0x1.fffffep+127) (f32.const 0x1.921fb6p+2)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const -0x1.fffffep+127) (f32.const -0x1.fffffep+127)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const -0x1.fffffep+127) (f32.const 0x1.fffffep+127)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const 0x1.fffffep+127) (f32.const -0x1.fffffep+127)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const 0x1.fffffep+127) (f32.const 0x1.fffffep+127)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const -0x1.fffffep+127) (f32.const -inf)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const -0x1.fffffep+127) (f32.const inf)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const 0x1.fffffep+127) (f32.const -inf)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const 0x1.fffffep+127) (f32.const inf)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const -0x1.fffffep+127) (f32.const -nan)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const -0x1.fffffep+127) (f32.const -nan:0x200000)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const -0x1.fffffep+127) (f32.const nan)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const -0x1.fffffep+127) (f32.const nan:0x200000)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const 0x1.fffffep+127) (f32.const -nan)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const 0x1.fffffep+127) (f32.const -nan:0x200000)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const 0x1.fffffep+127) (f32.const nan)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const 0x1.fffffep+127) (f32.const nan:0x200000)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const -inf) (f32.const -0x0p+0)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const -inf) (f32.const 0x0p+0)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const inf) (f32.const -0x0p+0)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const inf) (f32.const 0x0p+0)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const -inf) (f32.const -0x1p-149)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const -inf) (f32.const 0x1p-149)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const inf) (f32.const -0x1p-149)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const inf) (f32.const 0x1p-149)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const -inf) (f32.const -0x1p-126)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const -inf) (f32.const 0x1p-126)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const inf) (f32.const -0x1p-126)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const inf) (f32.const 0x1p-126)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const -inf) (f32.const -0x1p-1)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const -inf) (f32.const 0x1p-1)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const inf) (f32.const -0x1p-1)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const inf) (f32.const 0x1p-1)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const -inf) (f32.const -0x1p+0)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const -inf) (f32.const 0x1p+0)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const inf) (f32.const -0x1p+0)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const inf) (f32.const 0x1p+0)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const -inf) (f32.const -0x1.921fb6p+2)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const -inf) (f32.const 0x1.921fb6p+2)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const inf) (f32.const -0x1.921fb6p+2)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const inf) (f32.const 0x1.921fb6p+2)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const -inf) (f32.const -0x1.fffffep+127)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const -inf) (f32.const 0x1.fffffep+127)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const inf) (f32.const -0x1.fffffep+127)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const inf) (f32.const 0x1.fffffep+127)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const -inf) (f32.const -inf)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const -inf) (f32.const inf)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const inf) (f32.const -inf)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const inf) (f32.const inf)) (i32.const 1)) +(assert_return (invoke "ge" (f32.const -inf) (f32.const -nan)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const -inf) (f32.const -nan:0x200000)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const -inf) (f32.const nan)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const -inf) (f32.const nan:0x200000)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const inf) (f32.const -nan)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const inf) (f32.const -nan:0x200000)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const inf) (f32.const nan)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const inf) (f32.const nan:0x200000)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const -nan) (f32.const -0x0p+0)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const -nan:0x200000) (f32.const -0x0p+0)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const -nan) (f32.const 0x0p+0)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const -nan:0x200000) (f32.const 0x0p+0)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const nan) (f32.const -0x0p+0)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const nan:0x200000) (f32.const -0x0p+0)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const nan) (f32.const 0x0p+0)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const nan:0x200000) (f32.const 0x0p+0)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const -nan) (f32.const -0x1p-149)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const -nan:0x200000) (f32.const -0x1p-149)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const -nan) (f32.const 0x1p-149)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const -nan:0x200000) (f32.const 0x1p-149)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const nan) (f32.const -0x1p-149)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const nan:0x200000) (f32.const -0x1p-149)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const nan) (f32.const 0x1p-149)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const nan:0x200000) (f32.const 0x1p-149)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const -nan) (f32.const -0x1p-126)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const -nan:0x200000) (f32.const -0x1p-126)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const -nan) (f32.const 0x1p-126)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const -nan:0x200000) (f32.const 0x1p-126)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const nan) (f32.const -0x1p-126)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const nan:0x200000) (f32.const -0x1p-126)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const nan) (f32.const 0x1p-126)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const nan:0x200000) (f32.const 0x1p-126)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const -nan) (f32.const -0x1p-1)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const -nan:0x200000) (f32.const -0x1p-1)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const -nan) (f32.const 0x1p-1)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const -nan:0x200000) (f32.const 0x1p-1)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const nan) (f32.const -0x1p-1)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const nan:0x200000) (f32.const -0x1p-1)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const nan) (f32.const 0x1p-1)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const nan:0x200000) (f32.const 0x1p-1)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const -nan) (f32.const -0x1p+0)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const -nan:0x200000) (f32.const -0x1p+0)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const -nan) (f32.const 0x1p+0)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const -nan:0x200000) (f32.const 0x1p+0)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const nan) (f32.const -0x1p+0)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const nan:0x200000) (f32.const -0x1p+0)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const nan) (f32.const 0x1p+0)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const nan:0x200000) (f32.const 0x1p+0)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const -nan) (f32.const -0x1.921fb6p+2)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const -nan:0x200000) (f32.const -0x1.921fb6p+2)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const -nan) (f32.const 0x1.921fb6p+2)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const -nan:0x200000) (f32.const 0x1.921fb6p+2)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const nan) (f32.const -0x1.921fb6p+2)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const nan:0x200000) (f32.const -0x1.921fb6p+2)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const nan) (f32.const 0x1.921fb6p+2)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const nan:0x200000) (f32.const 0x1.921fb6p+2)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const -nan) (f32.const -0x1.fffffep+127)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const -nan:0x200000) (f32.const -0x1.fffffep+127)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const -nan) (f32.const 0x1.fffffep+127)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const -nan:0x200000) (f32.const 0x1.fffffep+127)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const nan) (f32.const -0x1.fffffep+127)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const nan:0x200000) (f32.const -0x1.fffffep+127)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const nan) (f32.const 0x1.fffffep+127)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const nan:0x200000) (f32.const 0x1.fffffep+127)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const -nan) (f32.const -inf)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const -nan:0x200000) (f32.const -inf)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const -nan) (f32.const inf)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const -nan:0x200000) (f32.const inf)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const nan) (f32.const -inf)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const nan:0x200000) (f32.const -inf)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const nan) (f32.const inf)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const nan:0x200000) (f32.const inf)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const -nan) (f32.const -nan)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const -nan:0x200000) (f32.const -nan)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const -nan) (f32.const -nan:0x200000)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const -nan:0x200000) (f32.const -nan:0x200000)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const -nan) (f32.const nan)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const -nan:0x200000) (f32.const nan)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const -nan) (f32.const nan:0x200000)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const -nan:0x200000) (f32.const nan:0x200000)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const nan) (f32.const -nan)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const nan:0x200000) (f32.const -nan)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const nan) (f32.const -nan:0x200000)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const nan:0x200000) (f32.const -nan:0x200000)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const nan) (f32.const nan)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const nan:0x200000) (f32.const nan)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const nan) (f32.const nan:0x200000)) (i32.const 0)) +(assert_return (invoke "ge" (f32.const nan:0x200000) (f32.const nan:0x200000)) (i32.const 0)) + + +;; Type check + +(assert_invalid (module (func (result f32) (f32.eq (i64.const 0) (f64.const 0)))) "type mismatch") +(assert_invalid (module (func (result f32) (f32.ge (i64.const 0) (f64.const 0)))) "type mismatch") +(assert_invalid (module (func (result f32) (f32.gt (i64.const 0) (f64.const 0)))) "type mismatch") +(assert_invalid (module (func (result f32) (f32.le (i64.const 0) (f64.const 0)))) "type mismatch") +(assert_invalid (module (func (result f32) (f32.lt (i64.const 0) (f64.const 0)))) "type mismatch") +(assert_invalid (module (func (result f32) (f32.ne (i64.const 0) (f64.const 0)))) "type mismatch") diff --git a/runtime/near-vm/tests/wast/spec/f64.wast b/runtime/near-vm/tests/wast/spec/f64.wast new file mode 100644 index 00000000000..70bb477c77f --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/f64.wast @@ -0,0 +1,2533 @@ +;; Test all the f64 operators on major boundary values and all special +;; values (except comparison and bitwise operators, which are tested in +;; f64_bitwise.wast and f64_cmp.wast). + +(module + (func (export "add") (param $x f64) (param $y f64) (result f64) (f64.add (local.get $x) (local.get $y))) + (func (export "sub") (param $x f64) (param $y f64) (result f64) (f64.sub (local.get $x) (local.get $y))) + (func (export "mul") (param $x f64) (param $y f64) (result f64) (f64.mul (local.get $x) (local.get $y))) + (func (export "div") (param $x f64) (param $y f64) (result f64) (f64.div (local.get $x) (local.get $y))) + (func (export "sqrt") (param $x f64) (result f64) (f64.sqrt (local.get $x))) + (func (export "min") (param $x f64) (param $y f64) (result f64) (f64.min (local.get $x) (local.get $y))) + (func (export "max") (param $x f64) (param $y f64) (result f64) (f64.max (local.get $x) (local.get $y))) + (func (export "ceil") (param $x f64) (result f64) (f64.ceil (local.get $x))) + (func (export "floor") (param $x f64) (result f64) (f64.floor (local.get $x))) + (func (export "trunc") (param $x f64) (result f64) (f64.trunc (local.get $x))) + (func (export "nearest") (param $x f64) (result f64) (f64.nearest (local.get $x))) +) + +(assert_return (invoke "add" (f64.const -0x0p+0) (f64.const -0x0p+0)) (f64.const -0x0p+0)) +(assert_return (invoke "add" (f64.const -0x0p+0) (f64.const 0x0p+0)) (f64.const 0x0p+0)) +(assert_return (invoke "add" (f64.const 0x0p+0) (f64.const -0x0p+0)) (f64.const 0x0p+0)) +(assert_return (invoke "add" (f64.const 0x0p+0) (f64.const 0x0p+0)) (f64.const 0x0p+0)) +(assert_return (invoke "add" (f64.const -0x0p+0) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x0.0000000000001p-1022)) +(assert_return (invoke "add" (f64.const -0x0p+0) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x0.0000000000001p-1022)) +(assert_return (invoke "add" (f64.const 0x0p+0) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x0.0000000000001p-1022)) +(assert_return (invoke "add" (f64.const 0x0p+0) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x0.0000000000001p-1022)) +(assert_return (invoke "add" (f64.const -0x0p+0) (f64.const -0x1p-1022)) (f64.const -0x1p-1022)) +(assert_return (invoke "add" (f64.const -0x0p+0) (f64.const 0x1p-1022)) (f64.const 0x1p-1022)) +(assert_return (invoke "add" (f64.const 0x0p+0) (f64.const -0x1p-1022)) (f64.const -0x1p-1022)) +(assert_return (invoke "add" (f64.const 0x0p+0) (f64.const 0x1p-1022)) (f64.const 0x1p-1022)) +(assert_return (invoke "add" (f64.const -0x0p+0) (f64.const -0x1p-1)) (f64.const -0x1p-1)) +(assert_return (invoke "add" (f64.const -0x0p+0) (f64.const 0x1p-1)) (f64.const 0x1p-1)) +(assert_return (invoke "add" (f64.const 0x0p+0) (f64.const -0x1p-1)) (f64.const -0x1p-1)) +(assert_return (invoke "add" (f64.const 0x0p+0) (f64.const 0x1p-1)) (f64.const 0x1p-1)) +(assert_return (invoke "add" (f64.const -0x0p+0) (f64.const -0x1p+0)) (f64.const -0x1p+0)) +(assert_return (invoke "add" (f64.const -0x0p+0) (f64.const 0x1p+0)) (f64.const 0x1p+0)) +(assert_return (invoke "add" (f64.const 0x0p+0) (f64.const -0x1p+0)) (f64.const -0x1p+0)) +(assert_return (invoke "add" (f64.const 0x0p+0) (f64.const 0x1p+0)) (f64.const 0x1p+0)) +(assert_return (invoke "add" (f64.const -0x0p+0) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.921fb54442d18p+2)) +(assert_return (invoke "add" (f64.const -0x0p+0) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p+2)) +(assert_return (invoke "add" (f64.const 0x0p+0) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.921fb54442d18p+2)) +(assert_return (invoke "add" (f64.const 0x0p+0) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p+2)) +(assert_return (invoke "add" (f64.const -0x0p+0) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023)) +(assert_return (invoke "add" (f64.const -0x0p+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023)) +(assert_return (invoke "add" (f64.const 0x0p+0) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023)) +(assert_return (invoke "add" (f64.const 0x0p+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023)) +(assert_return (invoke "add" (f64.const -0x0p+0) (f64.const -inf)) (f64.const -inf)) +(assert_return (invoke "add" (f64.const -0x0p+0) (f64.const inf)) (f64.const inf)) +(assert_return (invoke "add" (f64.const 0x0p+0) (f64.const -inf)) (f64.const -inf)) +(assert_return (invoke "add" (f64.const 0x0p+0) (f64.const inf)) (f64.const inf)) +(assert_return (invoke "add" (f64.const -0x0p+0) (f64.const -nan)) (f64.const nan:canonical)) +(assert_return (invoke "add" (f64.const -0x0p+0) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "add" (f64.const -0x0p+0) (f64.const nan)) (f64.const nan:canonical)) +(assert_return (invoke "add" (f64.const -0x0p+0) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "add" (f64.const 0x0p+0) (f64.const -nan)) (f64.const nan:canonical)) +(assert_return (invoke "add" (f64.const 0x0p+0) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "add" (f64.const 0x0p+0) (f64.const nan)) (f64.const nan:canonical)) +(assert_return (invoke "add" (f64.const 0x0p+0) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "add" (f64.const -0x0.0000000000001p-1022) (f64.const -0x0p+0)) (f64.const -0x0.0000000000001p-1022)) +(assert_return (invoke "add" (f64.const -0x0.0000000000001p-1022) (f64.const 0x0p+0)) (f64.const -0x0.0000000000001p-1022)) +(assert_return (invoke "add" (f64.const 0x0.0000000000001p-1022) (f64.const -0x0p+0)) (f64.const 0x0.0000000000001p-1022)) +(assert_return (invoke "add" (f64.const 0x0.0000000000001p-1022) (f64.const 0x0p+0)) (f64.const 0x0.0000000000001p-1022)) +(assert_return (invoke "add" (f64.const -0x0.0000000000001p-1022) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x0.0000000000002p-1022)) +(assert_return (invoke "add" (f64.const -0x0.0000000000001p-1022) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x0p+0)) +(assert_return (invoke "add" (f64.const 0x0.0000000000001p-1022) (f64.const -0x0.0000000000001p-1022)) (f64.const 0x0p+0)) +(assert_return (invoke "add" (f64.const 0x0.0000000000001p-1022) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x0.0000000000002p-1022)) +(assert_return (invoke "add" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1p-1022)) (f64.const -0x1.0000000000001p-1022)) +(assert_return (invoke "add" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1p-1022)) (f64.const 0x0.fffffffffffffp-1022)) +(assert_return (invoke "add" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1p-1022)) (f64.const -0x0.fffffffffffffp-1022)) +(assert_return (invoke "add" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1p-1022)) (f64.const 0x1.0000000000001p-1022)) +(assert_return (invoke "add" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1p-1)) (f64.const -0x1p-1)) +(assert_return (invoke "add" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1p-1)) (f64.const 0x1p-1)) +(assert_return (invoke "add" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1p-1)) (f64.const -0x1p-1)) +(assert_return (invoke "add" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1p-1)) (f64.const 0x1p-1)) +(assert_return (invoke "add" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1p+0)) (f64.const -0x1p+0)) +(assert_return (invoke "add" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1p+0)) (f64.const 0x1p+0)) +(assert_return (invoke "add" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1p+0)) (f64.const -0x1p+0)) +(assert_return (invoke "add" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1p+0)) (f64.const 0x1p+0)) +(assert_return (invoke "add" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.921fb54442d18p+2)) +(assert_return (invoke "add" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p+2)) +(assert_return (invoke "add" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.921fb54442d18p+2)) +(assert_return (invoke "add" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p+2)) +(assert_return (invoke "add" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023)) +(assert_return (invoke "add" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023)) +(assert_return (invoke "add" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023)) +(assert_return (invoke "add" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023)) +(assert_return (invoke "add" (f64.const -0x0.0000000000001p-1022) (f64.const -inf)) (f64.const -inf)) +(assert_return (invoke "add" (f64.const -0x0.0000000000001p-1022) (f64.const inf)) (f64.const inf)) +(assert_return (invoke "add" (f64.const 0x0.0000000000001p-1022) (f64.const -inf)) (f64.const -inf)) +(assert_return (invoke "add" (f64.const 0x0.0000000000001p-1022) (f64.const inf)) (f64.const inf)) +(assert_return (invoke "add" (f64.const -0x0.0000000000001p-1022) (f64.const -nan)) (f64.const nan:canonical)) +(assert_return (invoke "add" (f64.const -0x0.0000000000001p-1022) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "add" (f64.const -0x0.0000000000001p-1022) (f64.const nan)) (f64.const nan:canonical)) +(assert_return (invoke "add" (f64.const -0x0.0000000000001p-1022) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "add" (f64.const 0x0.0000000000001p-1022) (f64.const -nan)) (f64.const nan:canonical)) +(assert_return (invoke "add" (f64.const 0x0.0000000000001p-1022) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "add" (f64.const 0x0.0000000000001p-1022) (f64.const nan)) (f64.const nan:canonical)) +(assert_return (invoke "add" (f64.const 0x0.0000000000001p-1022) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "add" (f64.const -0x1p-1022) (f64.const -0x0p+0)) (f64.const -0x1p-1022)) +(assert_return (invoke "add" (f64.const -0x1p-1022) (f64.const 0x0p+0)) (f64.const -0x1p-1022)) +(assert_return (invoke "add" (f64.const 0x1p-1022) (f64.const -0x0p+0)) (f64.const 0x1p-1022)) +(assert_return (invoke "add" (f64.const 0x1p-1022) (f64.const 0x0p+0)) (f64.const 0x1p-1022)) +(assert_return (invoke "add" (f64.const -0x1p-1022) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x1.0000000000001p-1022)) +(assert_return (invoke "add" (f64.const -0x1p-1022) (f64.const 0x0.0000000000001p-1022)) (f64.const -0x0.fffffffffffffp-1022)) +(assert_return (invoke "add" (f64.const 0x1p-1022) (f64.const -0x0.0000000000001p-1022)) (f64.const 0x0.fffffffffffffp-1022)) +(assert_return (invoke "add" (f64.const 0x1p-1022) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x1.0000000000001p-1022)) +(assert_return (invoke "add" (f64.const -0x1p-1022) (f64.const -0x1p-1022)) (f64.const -0x1p-1021)) +(assert_return (invoke "add" (f64.const -0x1p-1022) (f64.const 0x1p-1022)) (f64.const 0x0p+0)) +(assert_return (invoke "add" (f64.const 0x1p-1022) (f64.const -0x1p-1022)) (f64.const 0x0p+0)) +(assert_return (invoke "add" (f64.const 0x1p-1022) (f64.const 0x1p-1022)) (f64.const 0x1p-1021)) +(assert_return (invoke "add" (f64.const -0x1p-1022) (f64.const -0x1p-1)) (f64.const -0x1p-1)) +(assert_return (invoke "add" (f64.const -0x1p-1022) (f64.const 0x1p-1)) (f64.const 0x1p-1)) +(assert_return (invoke "add" (f64.const 0x1p-1022) (f64.const -0x1p-1)) (f64.const -0x1p-1)) +(assert_return (invoke "add" (f64.const 0x1p-1022) (f64.const 0x1p-1)) (f64.const 0x1p-1)) +(assert_return (invoke "add" (f64.const -0x1p-1022) (f64.const -0x1p+0)) (f64.const -0x1p+0)) +(assert_return (invoke "add" (f64.const -0x1p-1022) (f64.const 0x1p+0)) (f64.const 0x1p+0)) +(assert_return (invoke "add" (f64.const 0x1p-1022) (f64.const -0x1p+0)) (f64.const -0x1p+0)) +(assert_return (invoke "add" (f64.const 0x1p-1022) (f64.const 0x1p+0)) (f64.const 0x1p+0)) +(assert_return (invoke "add" (f64.const -0x1p-1022) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.921fb54442d18p+2)) +(assert_return (invoke "add" (f64.const -0x1p-1022) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p+2)) +(assert_return (invoke "add" (f64.const 0x1p-1022) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.921fb54442d18p+2)) +(assert_return (invoke "add" (f64.const 0x1p-1022) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p+2)) +(assert_return (invoke "add" (f64.const -0x1p-1022) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023)) +(assert_return (invoke "add" (f64.const -0x1p-1022) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023)) +(assert_return (invoke "add" (f64.const 0x1p-1022) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023)) +(assert_return (invoke "add" (f64.const 0x1p-1022) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023)) +(assert_return (invoke "add" (f64.const -0x1p-1022) (f64.const -inf)) (f64.const -inf)) +(assert_return (invoke "add" (f64.const -0x1p-1022) (f64.const inf)) (f64.const inf)) +(assert_return (invoke "add" (f64.const 0x1p-1022) (f64.const -inf)) (f64.const -inf)) +(assert_return (invoke "add" (f64.const 0x1p-1022) (f64.const inf)) (f64.const inf)) +(assert_return (invoke "add" (f64.const -0x1p-1022) (f64.const -nan)) (f64.const nan:canonical)) +(assert_return (invoke "add" (f64.const -0x1p-1022) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "add" (f64.const -0x1p-1022) (f64.const nan)) (f64.const nan:canonical)) +(assert_return (invoke "add" (f64.const -0x1p-1022) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "add" (f64.const 0x1p-1022) (f64.const -nan)) (f64.const nan:canonical)) +(assert_return (invoke "add" (f64.const 0x1p-1022) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "add" (f64.const 0x1p-1022) (f64.const nan)) (f64.const nan:canonical)) +(assert_return (invoke "add" (f64.const 0x1p-1022) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "add" (f64.const -0x1p-1) (f64.const -0x0p+0)) (f64.const -0x1p-1)) +(assert_return (invoke "add" (f64.const -0x1p-1) (f64.const 0x0p+0)) (f64.const -0x1p-1)) +(assert_return (invoke "add" (f64.const 0x1p-1) (f64.const -0x0p+0)) (f64.const 0x1p-1)) +(assert_return (invoke "add" (f64.const 0x1p-1) (f64.const 0x0p+0)) (f64.const 0x1p-1)) +(assert_return (invoke "add" (f64.const -0x1p-1) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x1p-1)) +(assert_return (invoke "add" (f64.const -0x1p-1) (f64.const 0x0.0000000000001p-1022)) (f64.const -0x1p-1)) +(assert_return (invoke "add" (f64.const 0x1p-1) (f64.const -0x0.0000000000001p-1022)) (f64.const 0x1p-1)) +(assert_return (invoke "add" (f64.const 0x1p-1) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x1p-1)) +(assert_return (invoke "add" (f64.const -0x1p-1) (f64.const -0x1p-1022)) (f64.const -0x1p-1)) +(assert_return (invoke "add" (f64.const -0x1p-1) (f64.const 0x1p-1022)) (f64.const -0x1p-1)) +(assert_return (invoke "add" (f64.const 0x1p-1) (f64.const -0x1p-1022)) (f64.const 0x1p-1)) +(assert_return (invoke "add" (f64.const 0x1p-1) (f64.const 0x1p-1022)) (f64.const 0x1p-1)) +(assert_return (invoke "add" (f64.const -0x1p-1) (f64.const -0x1p-1)) (f64.const -0x1p+0)) +(assert_return (invoke "add" (f64.const -0x1p-1) (f64.const 0x1p-1)) (f64.const 0x0p+0)) +(assert_return (invoke "add" (f64.const 0x1p-1) (f64.const -0x1p-1)) (f64.const 0x0p+0)) +(assert_return (invoke "add" (f64.const 0x1p-1) (f64.const 0x1p-1)) (f64.const 0x1p+0)) +(assert_return (invoke "add" (f64.const -0x1p-1) (f64.const -0x1p+0)) (f64.const -0x1.8p+0)) +(assert_return (invoke "add" (f64.const -0x1p-1) (f64.const 0x1p+0)) (f64.const 0x1p-1)) +(assert_return (invoke "add" (f64.const 0x1p-1) (f64.const -0x1p+0)) (f64.const -0x1p-1)) +(assert_return (invoke "add" (f64.const 0x1p-1) (f64.const 0x1p+0)) (f64.const 0x1.8p+0)) +(assert_return (invoke "add" (f64.const -0x1p-1) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.b21fb54442d18p+2)) +(assert_return (invoke "add" (f64.const -0x1p-1) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.721fb54442d18p+2)) +(assert_return (invoke "add" (f64.const 0x1p-1) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.721fb54442d18p+2)) +(assert_return (invoke "add" (f64.const 0x1p-1) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.b21fb54442d18p+2)) +(assert_return (invoke "add" (f64.const -0x1p-1) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023)) +(assert_return (invoke "add" (f64.const -0x1p-1) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023)) +(assert_return (invoke "add" (f64.const 0x1p-1) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023)) +(assert_return (invoke "add" (f64.const 0x1p-1) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023)) +(assert_return (invoke "add" (f64.const -0x1p-1) (f64.const -inf)) (f64.const -inf)) +(assert_return (invoke "add" (f64.const -0x1p-1) (f64.const inf)) (f64.const inf)) +(assert_return (invoke "add" (f64.const 0x1p-1) (f64.const -inf)) (f64.const -inf)) +(assert_return (invoke "add" (f64.const 0x1p-1) (f64.const inf)) (f64.const inf)) +(assert_return (invoke "add" (f64.const -0x1p-1) (f64.const -nan)) (f64.const nan:canonical)) +(assert_return (invoke "add" (f64.const -0x1p-1) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "add" (f64.const -0x1p-1) (f64.const nan)) (f64.const nan:canonical)) +(assert_return (invoke "add" (f64.const -0x1p-1) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "add" (f64.const 0x1p-1) (f64.const -nan)) (f64.const nan:canonical)) +(assert_return (invoke "add" (f64.const 0x1p-1) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "add" (f64.const 0x1p-1) (f64.const nan)) (f64.const nan:canonical)) +(assert_return (invoke "add" (f64.const 0x1p-1) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "add" (f64.const -0x1p+0) (f64.const -0x0p+0)) (f64.const -0x1p+0)) +(assert_return (invoke "add" (f64.const -0x1p+0) (f64.const 0x0p+0)) (f64.const -0x1p+0)) +(assert_return (invoke "add" (f64.const 0x1p+0) (f64.const -0x0p+0)) (f64.const 0x1p+0)) +(assert_return (invoke "add" (f64.const 0x1p+0) (f64.const 0x0p+0)) (f64.const 0x1p+0)) +(assert_return (invoke "add" (f64.const -0x1p+0) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x1p+0)) +(assert_return (invoke "add" (f64.const -0x1p+0) (f64.const 0x0.0000000000001p-1022)) (f64.const -0x1p+0)) +(assert_return (invoke "add" (f64.const 0x1p+0) (f64.const -0x0.0000000000001p-1022)) (f64.const 0x1p+0)) +(assert_return (invoke "add" (f64.const 0x1p+0) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x1p+0)) +(assert_return (invoke "add" (f64.const -0x1p+0) (f64.const -0x1p-1022)) (f64.const -0x1p+0)) +(assert_return (invoke "add" (f64.const -0x1p+0) (f64.const 0x1p-1022)) (f64.const -0x1p+0)) +(assert_return (invoke "add" (f64.const 0x1p+0) (f64.const -0x1p-1022)) (f64.const 0x1p+0)) +(assert_return (invoke "add" (f64.const 0x1p+0) (f64.const 0x1p-1022)) (f64.const 0x1p+0)) +(assert_return (invoke "add" (f64.const -0x1p+0) (f64.const -0x1p-1)) (f64.const -0x1.8p+0)) +(assert_return (invoke "add" (f64.const -0x1p+0) (f64.const 0x1p-1)) (f64.const -0x1p-1)) +(assert_return (invoke "add" (f64.const 0x1p+0) (f64.const -0x1p-1)) (f64.const 0x1p-1)) +(assert_return (invoke "add" (f64.const 0x1p+0) (f64.const 0x1p-1)) (f64.const 0x1.8p+0)) +(assert_return (invoke "add" (f64.const -0x1p+0) (f64.const -0x1p+0)) (f64.const -0x1p+1)) +(assert_return (invoke "add" (f64.const -0x1p+0) (f64.const 0x1p+0)) (f64.const 0x0p+0)) +(assert_return (invoke "add" (f64.const 0x1p+0) (f64.const -0x1p+0)) (f64.const 0x0p+0)) +(assert_return (invoke "add" (f64.const 0x1p+0) (f64.const 0x1p+0)) (f64.const 0x1p+1)) +(assert_return (invoke "add" (f64.const -0x1p+0) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.d21fb54442d18p+2)) +(assert_return (invoke "add" (f64.const -0x1p+0) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.521fb54442d18p+2)) +(assert_return (invoke "add" (f64.const 0x1p+0) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.521fb54442d18p+2)) +(assert_return (invoke "add" (f64.const 0x1p+0) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.d21fb54442d18p+2)) +(assert_return (invoke "add" (f64.const -0x1p+0) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023)) +(assert_return (invoke "add" (f64.const -0x1p+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023)) +(assert_return (invoke "add" (f64.const 0x1p+0) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023)) +(assert_return (invoke "add" (f64.const 0x1p+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023)) +(assert_return (invoke "add" (f64.const -0x1p+0) (f64.const -inf)) (f64.const -inf)) +(assert_return (invoke "add" (f64.const -0x1p+0) (f64.const inf)) (f64.const inf)) +(assert_return (invoke "add" (f64.const 0x1p+0) (f64.const -inf)) (f64.const -inf)) +(assert_return (invoke "add" (f64.const 0x1p+0) (f64.const inf)) (f64.const inf)) +(assert_return (invoke "add" (f64.const -0x1p+0) (f64.const -nan)) (f64.const nan:canonical)) +(assert_return (invoke "add" (f64.const -0x1p+0) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "add" (f64.const -0x1p+0) (f64.const nan)) (f64.const nan:canonical)) +(assert_return (invoke "add" (f64.const -0x1p+0) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "add" (f64.const 0x1p+0) (f64.const -nan)) (f64.const nan:canonical)) +(assert_return (invoke "add" (f64.const 0x1p+0) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "add" (f64.const 0x1p+0) (f64.const nan)) (f64.const nan:canonical)) +(assert_return (invoke "add" (f64.const 0x1p+0) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "add" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x0p+0)) (f64.const -0x1.921fb54442d18p+2)) +(assert_return (invoke "add" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x0p+0)) (f64.const -0x1.921fb54442d18p+2)) +(assert_return (invoke "add" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x0p+0)) (f64.const 0x1.921fb54442d18p+2)) +(assert_return (invoke "add" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x0p+0)) (f64.const 0x1.921fb54442d18p+2)) +(assert_return (invoke "add" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x1.921fb54442d18p+2)) +(assert_return (invoke "add" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x0.0000000000001p-1022)) (f64.const -0x1.921fb54442d18p+2)) +(assert_return (invoke "add" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x0.0000000000001p-1022)) (f64.const 0x1.921fb54442d18p+2)) +(assert_return (invoke "add" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x1.921fb54442d18p+2)) +(assert_return (invoke "add" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1p-1022)) (f64.const -0x1.921fb54442d18p+2)) +(assert_return (invoke "add" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1p-1022)) (f64.const -0x1.921fb54442d18p+2)) +(assert_return (invoke "add" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1p-1022)) (f64.const 0x1.921fb54442d18p+2)) +(assert_return (invoke "add" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1p-1022)) (f64.const 0x1.921fb54442d18p+2)) +(assert_return (invoke "add" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1p-1)) (f64.const -0x1.b21fb54442d18p+2)) +(assert_return (invoke "add" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1p-1)) (f64.const -0x1.721fb54442d18p+2)) +(assert_return (invoke "add" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1p-1)) (f64.const 0x1.721fb54442d18p+2)) +(assert_return (invoke "add" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1p-1)) (f64.const 0x1.b21fb54442d18p+2)) +(assert_return (invoke "add" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1p+0)) (f64.const -0x1.d21fb54442d18p+2)) +(assert_return (invoke "add" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1p+0)) (f64.const -0x1.521fb54442d18p+2)) +(assert_return (invoke "add" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1p+0)) (f64.const 0x1.521fb54442d18p+2)) +(assert_return (invoke "add" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1p+0)) (f64.const 0x1.d21fb54442d18p+2)) +(assert_return (invoke "add" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.921fb54442d18p+3)) +(assert_return (invoke "add" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x0p+0)) +(assert_return (invoke "add" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1.921fb54442d18p+2)) (f64.const 0x0p+0)) +(assert_return (invoke "add" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p+3)) +(assert_return (invoke "add" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023)) +(assert_return (invoke "add" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023)) +(assert_return (invoke "add" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023)) +(assert_return (invoke "add" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023)) +(assert_return (invoke "add" (f64.const -0x1.921fb54442d18p+2) (f64.const -inf)) (f64.const -inf)) +(assert_return (invoke "add" (f64.const -0x1.921fb54442d18p+2) (f64.const inf)) (f64.const inf)) +(assert_return (invoke "add" (f64.const 0x1.921fb54442d18p+2) (f64.const -inf)) (f64.const -inf)) +(assert_return (invoke "add" (f64.const 0x1.921fb54442d18p+2) (f64.const inf)) (f64.const inf)) +(assert_return (invoke "add" (f64.const -0x1.921fb54442d18p+2) (f64.const -nan)) (f64.const nan:canonical)) +(assert_return (invoke "add" (f64.const -0x1.921fb54442d18p+2) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "add" (f64.const -0x1.921fb54442d18p+2) (f64.const nan)) (f64.const nan:canonical)) +(assert_return (invoke "add" (f64.const -0x1.921fb54442d18p+2) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "add" (f64.const 0x1.921fb54442d18p+2) (f64.const -nan)) (f64.const nan:canonical)) +(assert_return (invoke "add" (f64.const 0x1.921fb54442d18p+2) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "add" (f64.const 0x1.921fb54442d18p+2) (f64.const nan)) (f64.const nan:canonical)) +(assert_return (invoke "add" (f64.const 0x1.921fb54442d18p+2) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "add" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x0p+0)) (f64.const -0x1.fffffffffffffp+1023)) +(assert_return (invoke "add" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x0p+0)) (f64.const -0x1.fffffffffffffp+1023)) +(assert_return (invoke "add" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x0p+0)) (f64.const 0x1.fffffffffffffp+1023)) +(assert_return (invoke "add" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x0p+0)) (f64.const 0x1.fffffffffffffp+1023)) +(assert_return (invoke "add" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x1.fffffffffffffp+1023)) +(assert_return (invoke "add" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x0.0000000000001p-1022)) (f64.const -0x1.fffffffffffffp+1023)) +(assert_return (invoke "add" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x0.0000000000001p-1022)) (f64.const 0x1.fffffffffffffp+1023)) +(assert_return (invoke "add" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x1.fffffffffffffp+1023)) +(assert_return (invoke "add" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1p-1022)) (f64.const -0x1.fffffffffffffp+1023)) +(assert_return (invoke "add" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1p-1022)) (f64.const -0x1.fffffffffffffp+1023)) +(assert_return (invoke "add" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1p-1022)) (f64.const 0x1.fffffffffffffp+1023)) +(assert_return (invoke "add" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1p-1022)) (f64.const 0x1.fffffffffffffp+1023)) +(assert_return (invoke "add" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1p-1)) (f64.const -0x1.fffffffffffffp+1023)) +(assert_return (invoke "add" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1p-1)) (f64.const -0x1.fffffffffffffp+1023)) +(assert_return (invoke "add" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1p-1)) (f64.const 0x1.fffffffffffffp+1023)) +(assert_return (invoke "add" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1p-1)) (f64.const 0x1.fffffffffffffp+1023)) +(assert_return (invoke "add" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1p+0)) (f64.const -0x1.fffffffffffffp+1023)) +(assert_return (invoke "add" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1p+0)) (f64.const -0x1.fffffffffffffp+1023)) +(assert_return (invoke "add" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1p+0)) (f64.const 0x1.fffffffffffffp+1023)) +(assert_return (invoke "add" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1p+0)) (f64.const 0x1.fffffffffffffp+1023)) +(assert_return (invoke "add" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.fffffffffffffp+1023)) +(assert_return (invoke "add" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1.921fb54442d18p+2)) (f64.const -0x1.fffffffffffffp+1023)) +(assert_return (invoke "add" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1.921fb54442d18p+2)) (f64.const 0x1.fffffffffffffp+1023)) +(assert_return (invoke "add" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.fffffffffffffp+1023)) +(assert_return (invoke "add" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -inf)) +(assert_return (invoke "add" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x0p+0)) +(assert_return (invoke "add" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x0p+0)) +(assert_return (invoke "add" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1.fffffffffffffp+1023)) (f64.const inf)) +(assert_return (invoke "add" (f64.const -0x1.fffffffffffffp+1023) (f64.const -inf)) (f64.const -inf)) +(assert_return (invoke "add" (f64.const -0x1.fffffffffffffp+1023) (f64.const inf)) (f64.const inf)) +(assert_return (invoke "add" (f64.const 0x1.fffffffffffffp+1023) (f64.const -inf)) (f64.const -inf)) +(assert_return (invoke "add" (f64.const 0x1.fffffffffffffp+1023) (f64.const inf)) (f64.const inf)) +(assert_return (invoke "add" (f64.const -0x1.fffffffffffffp+1023) (f64.const -nan)) (f64.const nan:canonical)) +(assert_return (invoke "add" (f64.const -0x1.fffffffffffffp+1023) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "add" (f64.const -0x1.fffffffffffffp+1023) (f64.const nan)) (f64.const nan:canonical)) +(assert_return (invoke "add" (f64.const -0x1.fffffffffffffp+1023) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "add" (f64.const 0x1.fffffffffffffp+1023) (f64.const -nan)) (f64.const nan:canonical)) +(assert_return (invoke "add" (f64.const 0x1.fffffffffffffp+1023) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "add" (f64.const 0x1.fffffffffffffp+1023) (f64.const nan)) (f64.const nan:canonical)) +(assert_return (invoke "add" (f64.const 0x1.fffffffffffffp+1023) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "add" (f64.const -inf) (f64.const -0x0p+0)) (f64.const -inf)) +(assert_return (invoke "add" (f64.const -inf) (f64.const 0x0p+0)) (f64.const -inf)) +(assert_return (invoke "add" (f64.const inf) (f64.const -0x0p+0)) (f64.const inf)) +(assert_return (invoke "add" (f64.const inf) (f64.const 0x0p+0)) (f64.const inf)) +(assert_return (invoke "add" (f64.const -inf) (f64.const -0x0.0000000000001p-1022)) (f64.const -inf)) +(assert_return (invoke "add" (f64.const -inf) (f64.const 0x0.0000000000001p-1022)) (f64.const -inf)) +(assert_return (invoke "add" (f64.const inf) (f64.const -0x0.0000000000001p-1022)) (f64.const inf)) +(assert_return (invoke "add" (f64.const inf) (f64.const 0x0.0000000000001p-1022)) (f64.const inf)) +(assert_return (invoke "add" (f64.const -inf) (f64.const -0x1p-1022)) (f64.const -inf)) +(assert_return (invoke "add" (f64.const -inf) (f64.const 0x1p-1022)) (f64.const -inf)) +(assert_return (invoke "add" (f64.const inf) (f64.const -0x1p-1022)) (f64.const inf)) +(assert_return (invoke "add" (f64.const inf) (f64.const 0x1p-1022)) (f64.const inf)) +(assert_return (invoke "add" (f64.const -inf) (f64.const -0x1p-1)) (f64.const -inf)) +(assert_return (invoke "add" (f64.const -inf) (f64.const 0x1p-1)) (f64.const -inf)) +(assert_return (invoke "add" (f64.const inf) (f64.const -0x1p-1)) (f64.const inf)) +(assert_return (invoke "add" (f64.const inf) (f64.const 0x1p-1)) (f64.const inf)) +(assert_return (invoke "add" (f64.const -inf) (f64.const -0x1p+0)) (f64.const -inf)) +(assert_return (invoke "add" (f64.const -inf) (f64.const 0x1p+0)) (f64.const -inf)) +(assert_return (invoke "add" (f64.const inf) (f64.const -0x1p+0)) (f64.const inf)) +(assert_return (invoke "add" (f64.const inf) (f64.const 0x1p+0)) (f64.const inf)) +(assert_return (invoke "add" (f64.const -inf) (f64.const -0x1.921fb54442d18p+2)) (f64.const -inf)) +(assert_return (invoke "add" (f64.const -inf) (f64.const 0x1.921fb54442d18p+2)) (f64.const -inf)) +(assert_return (invoke "add" (f64.const inf) (f64.const -0x1.921fb54442d18p+2)) (f64.const inf)) +(assert_return (invoke "add" (f64.const inf) (f64.const 0x1.921fb54442d18p+2)) (f64.const inf)) +(assert_return (invoke "add" (f64.const -inf) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -inf)) +(assert_return (invoke "add" (f64.const -inf) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -inf)) +(assert_return (invoke "add" (f64.const inf) (f64.const -0x1.fffffffffffffp+1023)) (f64.const inf)) +(assert_return (invoke "add" (f64.const inf) (f64.const 0x1.fffffffffffffp+1023)) (f64.const inf)) +(assert_return (invoke "add" (f64.const -inf) (f64.const -inf)) (f64.const -inf)) +(assert_return (invoke "add" (f64.const -inf) (f64.const inf)) (f64.const nan:canonical)) +(assert_return (invoke "add" (f64.const inf) (f64.const -inf)) (f64.const nan:canonical)) +(assert_return (invoke "add" (f64.const inf) (f64.const inf)) (f64.const inf)) +(assert_return (invoke "add" (f64.const -inf) (f64.const -nan)) (f64.const nan:canonical)) +(assert_return (invoke "add" (f64.const -inf) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "add" (f64.const -inf) (f64.const nan)) (f64.const nan:canonical)) +(assert_return (invoke "add" (f64.const -inf) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "add" (f64.const inf) (f64.const -nan)) (f64.const nan:canonical)) +(assert_return (invoke "add" (f64.const inf) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "add" (f64.const inf) (f64.const nan)) (f64.const nan:canonical)) +(assert_return (invoke "add" (f64.const inf) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "add" (f64.const -nan) (f64.const -0x0p+0)) (f64.const nan:canonical)) +(assert_return (invoke "add" (f64.const -nan:0x4000000000000) (f64.const -0x0p+0)) (f64.const nan:arithmetic)) +(assert_return (invoke "add" (f64.const -nan) (f64.const 0x0p+0)) (f64.const nan:canonical)) +(assert_return (invoke "add" (f64.const -nan:0x4000000000000) (f64.const 0x0p+0)) (f64.const nan:arithmetic)) +(assert_return (invoke "add" (f64.const nan) (f64.const -0x0p+0)) (f64.const nan:canonical)) +(assert_return (invoke "add" (f64.const nan:0x4000000000000) (f64.const -0x0p+0)) (f64.const nan:arithmetic)) +(assert_return (invoke "add" (f64.const nan) (f64.const 0x0p+0)) (f64.const nan:canonical)) +(assert_return (invoke "add" (f64.const nan:0x4000000000000) (f64.const 0x0p+0)) (f64.const nan:arithmetic)) +(assert_return (invoke "add" (f64.const -nan) (f64.const -0x0.0000000000001p-1022)) (f64.const nan:canonical)) +(assert_return (invoke "add" (f64.const -nan:0x4000000000000) (f64.const -0x0.0000000000001p-1022)) (f64.const nan:arithmetic)) +(assert_return (invoke "add" (f64.const -nan) (f64.const 0x0.0000000000001p-1022)) (f64.const nan:canonical)) +(assert_return (invoke "add" (f64.const -nan:0x4000000000000) (f64.const 0x0.0000000000001p-1022)) (f64.const nan:arithmetic)) +(assert_return (invoke "add" (f64.const nan) (f64.const -0x0.0000000000001p-1022)) (f64.const nan:canonical)) +(assert_return (invoke "add" (f64.const nan:0x4000000000000) (f64.const -0x0.0000000000001p-1022)) (f64.const nan:arithmetic)) +(assert_return (invoke "add" (f64.const nan) (f64.const 0x0.0000000000001p-1022)) (f64.const nan:canonical)) +(assert_return (invoke "add" (f64.const nan:0x4000000000000) (f64.const 0x0.0000000000001p-1022)) (f64.const nan:arithmetic)) +(assert_return (invoke "add" (f64.const -nan) (f64.const -0x1p-1022)) (f64.const nan:canonical)) +(assert_return (invoke "add" (f64.const -nan:0x4000000000000) (f64.const -0x1p-1022)) (f64.const nan:arithmetic)) +(assert_return (invoke "add" (f64.const -nan) (f64.const 0x1p-1022)) (f64.const nan:canonical)) +(assert_return (invoke "add" (f64.const -nan:0x4000000000000) (f64.const 0x1p-1022)) (f64.const nan:arithmetic)) +(assert_return (invoke "add" (f64.const nan) (f64.const -0x1p-1022)) (f64.const nan:canonical)) +(assert_return (invoke "add" (f64.const nan:0x4000000000000) (f64.const -0x1p-1022)) (f64.const nan:arithmetic)) +(assert_return (invoke "add" (f64.const nan) (f64.const 0x1p-1022)) (f64.const nan:canonical)) +(assert_return (invoke "add" (f64.const nan:0x4000000000000) (f64.const 0x1p-1022)) (f64.const nan:arithmetic)) +(assert_return (invoke "add" (f64.const -nan) (f64.const -0x1p-1)) (f64.const nan:canonical)) +(assert_return (invoke "add" (f64.const -nan:0x4000000000000) (f64.const -0x1p-1)) (f64.const nan:arithmetic)) +(assert_return (invoke "add" (f64.const -nan) (f64.const 0x1p-1)) (f64.const nan:canonical)) +(assert_return (invoke "add" (f64.const -nan:0x4000000000000) (f64.const 0x1p-1)) (f64.const nan:arithmetic)) +(assert_return (invoke "add" (f64.const nan) (f64.const -0x1p-1)) (f64.const nan:canonical)) +(assert_return (invoke "add" (f64.const nan:0x4000000000000) (f64.const -0x1p-1)) (f64.const nan:arithmetic)) +(assert_return (invoke "add" (f64.const nan) (f64.const 0x1p-1)) (f64.const nan:canonical)) +(assert_return (invoke "add" (f64.const nan:0x4000000000000) (f64.const 0x1p-1)) (f64.const nan:arithmetic)) +(assert_return (invoke "add" (f64.const -nan) (f64.const -0x1p+0)) (f64.const nan:canonical)) +(assert_return (invoke "add" (f64.const -nan:0x4000000000000) (f64.const -0x1p+0)) (f64.const nan:arithmetic)) +(assert_return (invoke "add" (f64.const -nan) (f64.const 0x1p+0)) (f64.const nan:canonical)) +(assert_return (invoke "add" (f64.const -nan:0x4000000000000) (f64.const 0x1p+0)) (f64.const nan:arithmetic)) +(assert_return (invoke "add" (f64.const nan) (f64.const -0x1p+0)) (f64.const nan:canonical)) +(assert_return (invoke "add" (f64.const nan:0x4000000000000) (f64.const -0x1p+0)) (f64.const nan:arithmetic)) +(assert_return (invoke "add" (f64.const nan) (f64.const 0x1p+0)) (f64.const nan:canonical)) +(assert_return (invoke "add" (f64.const nan:0x4000000000000) (f64.const 0x1p+0)) (f64.const nan:arithmetic)) +(assert_return (invoke "add" (f64.const -nan) (f64.const -0x1.921fb54442d18p+2)) (f64.const nan:canonical)) +(assert_return (invoke "add" (f64.const -nan:0x4000000000000) (f64.const -0x1.921fb54442d18p+2)) (f64.const nan:arithmetic)) +(assert_return (invoke "add" (f64.const -nan) (f64.const 0x1.921fb54442d18p+2)) (f64.const nan:canonical)) +(assert_return (invoke "add" (f64.const -nan:0x4000000000000) (f64.const 0x1.921fb54442d18p+2)) (f64.const nan:arithmetic)) +(assert_return (invoke "add" (f64.const nan) (f64.const -0x1.921fb54442d18p+2)) (f64.const nan:canonical)) +(assert_return (invoke "add" (f64.const nan:0x4000000000000) (f64.const -0x1.921fb54442d18p+2)) (f64.const nan:arithmetic)) +(assert_return (invoke "add" (f64.const nan) (f64.const 0x1.921fb54442d18p+2)) (f64.const nan:canonical)) +(assert_return (invoke "add" (f64.const nan:0x4000000000000) (f64.const 0x1.921fb54442d18p+2)) (f64.const nan:arithmetic)) +(assert_return (invoke "add" (f64.const -nan) (f64.const -0x1.fffffffffffffp+1023)) (f64.const nan:canonical)) +(assert_return (invoke "add" (f64.const -nan:0x4000000000000) (f64.const -0x1.fffffffffffffp+1023)) (f64.const nan:arithmetic)) +(assert_return (invoke "add" (f64.const -nan) (f64.const 0x1.fffffffffffffp+1023)) (f64.const nan:canonical)) +(assert_return (invoke "add" (f64.const -nan:0x4000000000000) (f64.const 0x1.fffffffffffffp+1023)) (f64.const nan:arithmetic)) +(assert_return (invoke "add" (f64.const nan) (f64.const -0x1.fffffffffffffp+1023)) (f64.const nan:canonical)) +(assert_return (invoke "add" (f64.const nan:0x4000000000000) (f64.const -0x1.fffffffffffffp+1023)) (f64.const nan:arithmetic)) +(assert_return (invoke "add" (f64.const nan) (f64.const 0x1.fffffffffffffp+1023)) (f64.const nan:canonical)) +(assert_return (invoke "add" (f64.const nan:0x4000000000000) (f64.const 0x1.fffffffffffffp+1023)) (f64.const nan:arithmetic)) +(assert_return (invoke "add" (f64.const -nan) (f64.const -inf)) (f64.const nan:canonical)) +(assert_return (invoke "add" (f64.const -nan:0x4000000000000) (f64.const -inf)) (f64.const nan:arithmetic)) +(assert_return (invoke "add" (f64.const -nan) (f64.const inf)) (f64.const nan:canonical)) +(assert_return (invoke "add" (f64.const -nan:0x4000000000000) (f64.const inf)) (f64.const nan:arithmetic)) +(assert_return (invoke "add" (f64.const nan) (f64.const -inf)) (f64.const nan:canonical)) +(assert_return (invoke "add" (f64.const nan:0x4000000000000) (f64.const -inf)) (f64.const nan:arithmetic)) +(assert_return (invoke "add" (f64.const nan) (f64.const inf)) (f64.const nan:canonical)) +(assert_return (invoke "add" (f64.const nan:0x4000000000000) (f64.const inf)) (f64.const nan:arithmetic)) +(assert_return (invoke "add" (f64.const -nan) (f64.const -nan)) (f64.const nan:canonical)) +(assert_return (invoke "add" (f64.const -nan:0x4000000000000) (f64.const -nan)) (f64.const nan:arithmetic)) +(assert_return (invoke "add" (f64.const -nan) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "add" (f64.const -nan:0x4000000000000) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "add" (f64.const -nan) (f64.const nan)) (f64.const nan:canonical)) +(assert_return (invoke "add" (f64.const -nan:0x4000000000000) (f64.const nan)) (f64.const nan:arithmetic)) +(assert_return (invoke "add" (f64.const -nan) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "add" (f64.const -nan:0x4000000000000) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "add" (f64.const nan) (f64.const -nan)) (f64.const nan:canonical)) +(assert_return (invoke "add" (f64.const nan:0x4000000000000) (f64.const -nan)) (f64.const nan:arithmetic)) +(assert_return (invoke "add" (f64.const nan) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "add" (f64.const nan:0x4000000000000) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "add" (f64.const nan) (f64.const nan)) (f64.const nan:canonical)) +(assert_return (invoke "add" (f64.const nan:0x4000000000000) (f64.const nan)) (f64.const nan:arithmetic)) +(assert_return (invoke "add" (f64.const nan) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "add" (f64.const nan:0x4000000000000) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "sub" (f64.const -0x0p+0) (f64.const -0x0p+0)) (f64.const 0x0p+0)) +(assert_return (invoke "sub" (f64.const -0x0p+0) (f64.const 0x0p+0)) (f64.const -0x0p+0)) +(assert_return (invoke "sub" (f64.const 0x0p+0) (f64.const -0x0p+0)) (f64.const 0x0p+0)) +(assert_return (invoke "sub" (f64.const 0x0p+0) (f64.const 0x0p+0)) (f64.const 0x0p+0)) +(assert_return (invoke "sub" (f64.const -0x0p+0) (f64.const -0x0.0000000000001p-1022)) (f64.const 0x0.0000000000001p-1022)) +(assert_return (invoke "sub" (f64.const -0x0p+0) (f64.const 0x0.0000000000001p-1022)) (f64.const -0x0.0000000000001p-1022)) +(assert_return (invoke "sub" (f64.const 0x0p+0) (f64.const -0x0.0000000000001p-1022)) (f64.const 0x0.0000000000001p-1022)) +(assert_return (invoke "sub" (f64.const 0x0p+0) (f64.const 0x0.0000000000001p-1022)) (f64.const -0x0.0000000000001p-1022)) +(assert_return (invoke "sub" (f64.const -0x0p+0) (f64.const -0x1p-1022)) (f64.const 0x1p-1022)) +(assert_return (invoke "sub" (f64.const -0x0p+0) (f64.const 0x1p-1022)) (f64.const -0x1p-1022)) +(assert_return (invoke "sub" (f64.const 0x0p+0) (f64.const -0x1p-1022)) (f64.const 0x1p-1022)) +(assert_return (invoke "sub" (f64.const 0x0p+0) (f64.const 0x1p-1022)) (f64.const -0x1p-1022)) +(assert_return (invoke "sub" (f64.const -0x0p+0) (f64.const -0x1p-1)) (f64.const 0x1p-1)) +(assert_return (invoke "sub" (f64.const -0x0p+0) (f64.const 0x1p-1)) (f64.const -0x1p-1)) +(assert_return (invoke "sub" (f64.const 0x0p+0) (f64.const -0x1p-1)) (f64.const 0x1p-1)) +(assert_return (invoke "sub" (f64.const 0x0p+0) (f64.const 0x1p-1)) (f64.const -0x1p-1)) +(assert_return (invoke "sub" (f64.const -0x0p+0) (f64.const -0x1p+0)) (f64.const 0x1p+0)) +(assert_return (invoke "sub" (f64.const -0x0p+0) (f64.const 0x1p+0)) (f64.const -0x1p+0)) +(assert_return (invoke "sub" (f64.const 0x0p+0) (f64.const -0x1p+0)) (f64.const 0x1p+0)) +(assert_return (invoke "sub" (f64.const 0x0p+0) (f64.const 0x1p+0)) (f64.const -0x1p+0)) +(assert_return (invoke "sub" (f64.const -0x0p+0) (f64.const -0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p+2)) +(assert_return (invoke "sub" (f64.const -0x0p+0) (f64.const 0x1.921fb54442d18p+2)) (f64.const -0x1.921fb54442d18p+2)) +(assert_return (invoke "sub" (f64.const 0x0p+0) (f64.const -0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p+2)) +(assert_return (invoke "sub" (f64.const 0x0p+0) (f64.const 0x1.921fb54442d18p+2)) (f64.const -0x1.921fb54442d18p+2)) +(assert_return (invoke "sub" (f64.const -0x0p+0) (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023)) +(assert_return (invoke "sub" (f64.const -0x0p+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023)) +(assert_return (invoke "sub" (f64.const 0x0p+0) (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023)) +(assert_return (invoke "sub" (f64.const 0x0p+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023)) +(assert_return (invoke "sub" (f64.const -0x0p+0) (f64.const -inf)) (f64.const inf)) +(assert_return (invoke "sub" (f64.const -0x0p+0) (f64.const inf)) (f64.const -inf)) +(assert_return (invoke "sub" (f64.const 0x0p+0) (f64.const -inf)) (f64.const inf)) +(assert_return (invoke "sub" (f64.const 0x0p+0) (f64.const inf)) (f64.const -inf)) +(assert_return (invoke "sub" (f64.const -0x0p+0) (f64.const -nan)) (f64.const nan:canonical)) +(assert_return (invoke "sub" (f64.const -0x0p+0) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "sub" (f64.const -0x0p+0) (f64.const nan)) (f64.const nan:canonical)) +(assert_return (invoke "sub" (f64.const -0x0p+0) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "sub" (f64.const 0x0p+0) (f64.const -nan)) (f64.const nan:canonical)) +(assert_return (invoke "sub" (f64.const 0x0p+0) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "sub" (f64.const 0x0p+0) (f64.const nan)) (f64.const nan:canonical)) +(assert_return (invoke "sub" (f64.const 0x0p+0) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "sub" (f64.const -0x0.0000000000001p-1022) (f64.const -0x0p+0)) (f64.const -0x0.0000000000001p-1022)) +(assert_return (invoke "sub" (f64.const -0x0.0000000000001p-1022) (f64.const 0x0p+0)) (f64.const -0x0.0000000000001p-1022)) +(assert_return (invoke "sub" (f64.const 0x0.0000000000001p-1022) (f64.const -0x0p+0)) (f64.const 0x0.0000000000001p-1022)) +(assert_return (invoke "sub" (f64.const 0x0.0000000000001p-1022) (f64.const 0x0p+0)) (f64.const 0x0.0000000000001p-1022)) +(assert_return (invoke "sub" (f64.const -0x0.0000000000001p-1022) (f64.const -0x0.0000000000001p-1022)) (f64.const 0x0p+0)) +(assert_return (invoke "sub" (f64.const -0x0.0000000000001p-1022) (f64.const 0x0.0000000000001p-1022)) (f64.const -0x0.0000000000002p-1022)) +(assert_return (invoke "sub" (f64.const 0x0.0000000000001p-1022) (f64.const -0x0.0000000000001p-1022)) (f64.const 0x0.0000000000002p-1022)) +(assert_return (invoke "sub" (f64.const 0x0.0000000000001p-1022) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x0p+0)) +(assert_return (invoke "sub" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1p-1022)) (f64.const 0x0.fffffffffffffp-1022)) +(assert_return (invoke "sub" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1p-1022)) (f64.const -0x1.0000000000001p-1022)) +(assert_return (invoke "sub" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1p-1022)) (f64.const 0x1.0000000000001p-1022)) +(assert_return (invoke "sub" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1p-1022)) (f64.const -0x0.fffffffffffffp-1022)) +(assert_return (invoke "sub" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1p-1)) (f64.const 0x1p-1)) +(assert_return (invoke "sub" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1p-1)) (f64.const -0x1p-1)) +(assert_return (invoke "sub" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1p-1)) (f64.const 0x1p-1)) +(assert_return (invoke "sub" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1p-1)) (f64.const -0x1p-1)) +(assert_return (invoke "sub" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1p+0)) (f64.const 0x1p+0)) +(assert_return (invoke "sub" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1p+0)) (f64.const -0x1p+0)) +(assert_return (invoke "sub" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1p+0)) (f64.const 0x1p+0)) +(assert_return (invoke "sub" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1p+0)) (f64.const -0x1p+0)) +(assert_return (invoke "sub" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p+2)) +(assert_return (invoke "sub" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1.921fb54442d18p+2)) (f64.const -0x1.921fb54442d18p+2)) +(assert_return (invoke "sub" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p+2)) +(assert_return (invoke "sub" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1.921fb54442d18p+2)) (f64.const -0x1.921fb54442d18p+2)) +(assert_return (invoke "sub" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023)) +(assert_return (invoke "sub" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023)) +(assert_return (invoke "sub" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023)) +(assert_return (invoke "sub" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023)) +(assert_return (invoke "sub" (f64.const -0x0.0000000000001p-1022) (f64.const -inf)) (f64.const inf)) +(assert_return (invoke "sub" (f64.const -0x0.0000000000001p-1022) (f64.const inf)) (f64.const -inf)) +(assert_return (invoke "sub" (f64.const 0x0.0000000000001p-1022) (f64.const -inf)) (f64.const inf)) +(assert_return (invoke "sub" (f64.const 0x0.0000000000001p-1022) (f64.const inf)) (f64.const -inf)) +(assert_return (invoke "sub" (f64.const -0x0.0000000000001p-1022) (f64.const -nan)) (f64.const nan:canonical)) +(assert_return (invoke "sub" (f64.const -0x0.0000000000001p-1022) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "sub" (f64.const -0x0.0000000000001p-1022) (f64.const nan)) (f64.const nan:canonical)) +(assert_return (invoke "sub" (f64.const -0x0.0000000000001p-1022) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "sub" (f64.const 0x0.0000000000001p-1022) (f64.const -nan)) (f64.const nan:canonical)) +(assert_return (invoke "sub" (f64.const 0x0.0000000000001p-1022) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "sub" (f64.const 0x0.0000000000001p-1022) (f64.const nan)) (f64.const nan:canonical)) +(assert_return (invoke "sub" (f64.const 0x0.0000000000001p-1022) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "sub" (f64.const -0x1p-1022) (f64.const -0x0p+0)) (f64.const -0x1p-1022)) +(assert_return (invoke "sub" (f64.const -0x1p-1022) (f64.const 0x0p+0)) (f64.const -0x1p-1022)) +(assert_return (invoke "sub" (f64.const 0x1p-1022) (f64.const -0x0p+0)) (f64.const 0x1p-1022)) +(assert_return (invoke "sub" (f64.const 0x1p-1022) (f64.const 0x0p+0)) (f64.const 0x1p-1022)) +(assert_return (invoke "sub" (f64.const -0x1p-1022) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x0.fffffffffffffp-1022)) +(assert_return (invoke "sub" (f64.const -0x1p-1022) (f64.const 0x0.0000000000001p-1022)) (f64.const -0x1.0000000000001p-1022)) +(assert_return (invoke "sub" (f64.const 0x1p-1022) (f64.const -0x0.0000000000001p-1022)) (f64.const 0x1.0000000000001p-1022)) +(assert_return (invoke "sub" (f64.const 0x1p-1022) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x0.fffffffffffffp-1022)) +(assert_return (invoke "sub" (f64.const -0x1p-1022) (f64.const -0x1p-1022)) (f64.const 0x0p+0)) +(assert_return (invoke "sub" (f64.const -0x1p-1022) (f64.const 0x1p-1022)) (f64.const -0x1p-1021)) +(assert_return (invoke "sub" (f64.const 0x1p-1022) (f64.const -0x1p-1022)) (f64.const 0x1p-1021)) +(assert_return (invoke "sub" (f64.const 0x1p-1022) (f64.const 0x1p-1022)) (f64.const 0x0p+0)) +(assert_return (invoke "sub" (f64.const -0x1p-1022) (f64.const -0x1p-1)) (f64.const 0x1p-1)) +(assert_return (invoke "sub" (f64.const -0x1p-1022) (f64.const 0x1p-1)) (f64.const -0x1p-1)) +(assert_return (invoke "sub" (f64.const 0x1p-1022) (f64.const -0x1p-1)) (f64.const 0x1p-1)) +(assert_return (invoke "sub" (f64.const 0x1p-1022) (f64.const 0x1p-1)) (f64.const -0x1p-1)) +(assert_return (invoke "sub" (f64.const -0x1p-1022) (f64.const -0x1p+0)) (f64.const 0x1p+0)) +(assert_return (invoke "sub" (f64.const -0x1p-1022) (f64.const 0x1p+0)) (f64.const -0x1p+0)) +(assert_return (invoke "sub" (f64.const 0x1p-1022) (f64.const -0x1p+0)) (f64.const 0x1p+0)) +(assert_return (invoke "sub" (f64.const 0x1p-1022) (f64.const 0x1p+0)) (f64.const -0x1p+0)) +(assert_return (invoke "sub" (f64.const -0x1p-1022) (f64.const -0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p+2)) +(assert_return (invoke "sub" (f64.const -0x1p-1022) (f64.const 0x1.921fb54442d18p+2)) (f64.const -0x1.921fb54442d18p+2)) +(assert_return (invoke "sub" (f64.const 0x1p-1022) (f64.const -0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p+2)) +(assert_return (invoke "sub" (f64.const 0x1p-1022) (f64.const 0x1.921fb54442d18p+2)) (f64.const -0x1.921fb54442d18p+2)) +(assert_return (invoke "sub" (f64.const -0x1p-1022) (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023)) +(assert_return (invoke "sub" (f64.const -0x1p-1022) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023)) +(assert_return (invoke "sub" (f64.const 0x1p-1022) (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023)) +(assert_return (invoke "sub" (f64.const 0x1p-1022) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023)) +(assert_return (invoke "sub" (f64.const -0x1p-1022) (f64.const -inf)) (f64.const inf)) +(assert_return (invoke "sub" (f64.const -0x1p-1022) (f64.const inf)) (f64.const -inf)) +(assert_return (invoke "sub" (f64.const 0x1p-1022) (f64.const -inf)) (f64.const inf)) +(assert_return (invoke "sub" (f64.const 0x1p-1022) (f64.const inf)) (f64.const -inf)) +(assert_return (invoke "sub" (f64.const -0x1p-1022) (f64.const -nan)) (f64.const nan:canonical)) +(assert_return (invoke "sub" (f64.const -0x1p-1022) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "sub" (f64.const -0x1p-1022) (f64.const nan)) (f64.const nan:canonical)) +(assert_return (invoke "sub" (f64.const -0x1p-1022) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "sub" (f64.const 0x1p-1022) (f64.const -nan)) (f64.const nan:canonical)) +(assert_return (invoke "sub" (f64.const 0x1p-1022) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "sub" (f64.const 0x1p-1022) (f64.const nan)) (f64.const nan:canonical)) +(assert_return (invoke "sub" (f64.const 0x1p-1022) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "sub" (f64.const -0x1p-1) (f64.const -0x0p+0)) (f64.const -0x1p-1)) +(assert_return (invoke "sub" (f64.const -0x1p-1) (f64.const 0x0p+0)) (f64.const -0x1p-1)) +(assert_return (invoke "sub" (f64.const 0x1p-1) (f64.const -0x0p+0)) (f64.const 0x1p-1)) +(assert_return (invoke "sub" (f64.const 0x1p-1) (f64.const 0x0p+0)) (f64.const 0x1p-1)) +(assert_return (invoke "sub" (f64.const -0x1p-1) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x1p-1)) +(assert_return (invoke "sub" (f64.const -0x1p-1) (f64.const 0x0.0000000000001p-1022)) (f64.const -0x1p-1)) +(assert_return (invoke "sub" (f64.const 0x1p-1) (f64.const -0x0.0000000000001p-1022)) (f64.const 0x1p-1)) +(assert_return (invoke "sub" (f64.const 0x1p-1) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x1p-1)) +(assert_return (invoke "sub" (f64.const -0x1p-1) (f64.const -0x1p-1022)) (f64.const -0x1p-1)) +(assert_return (invoke "sub" (f64.const -0x1p-1) (f64.const 0x1p-1022)) (f64.const -0x1p-1)) +(assert_return (invoke "sub" (f64.const 0x1p-1) (f64.const -0x1p-1022)) (f64.const 0x1p-1)) +(assert_return (invoke "sub" (f64.const 0x1p-1) (f64.const 0x1p-1022)) (f64.const 0x1p-1)) +(assert_return (invoke "sub" (f64.const -0x1p-1) (f64.const -0x1p-1)) (f64.const 0x0p+0)) +(assert_return (invoke "sub" (f64.const -0x1p-1) (f64.const 0x1p-1)) (f64.const -0x1p+0)) +(assert_return (invoke "sub" (f64.const 0x1p-1) (f64.const -0x1p-1)) (f64.const 0x1p+0)) +(assert_return (invoke "sub" (f64.const 0x1p-1) (f64.const 0x1p-1)) (f64.const 0x0p+0)) +(assert_return (invoke "sub" (f64.const -0x1p-1) (f64.const -0x1p+0)) (f64.const 0x1p-1)) +(assert_return (invoke "sub" (f64.const -0x1p-1) (f64.const 0x1p+0)) (f64.const -0x1.8p+0)) +(assert_return (invoke "sub" (f64.const 0x1p-1) (f64.const -0x1p+0)) (f64.const 0x1.8p+0)) +(assert_return (invoke "sub" (f64.const 0x1p-1) (f64.const 0x1p+0)) (f64.const -0x1p-1)) +(assert_return (invoke "sub" (f64.const -0x1p-1) (f64.const -0x1.921fb54442d18p+2)) (f64.const 0x1.721fb54442d18p+2)) +(assert_return (invoke "sub" (f64.const -0x1p-1) (f64.const 0x1.921fb54442d18p+2)) (f64.const -0x1.b21fb54442d18p+2)) +(assert_return (invoke "sub" (f64.const 0x1p-1) (f64.const -0x1.921fb54442d18p+2)) (f64.const 0x1.b21fb54442d18p+2)) +(assert_return (invoke "sub" (f64.const 0x1p-1) (f64.const 0x1.921fb54442d18p+2)) (f64.const -0x1.721fb54442d18p+2)) +(assert_return (invoke "sub" (f64.const -0x1p-1) (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023)) +(assert_return (invoke "sub" (f64.const -0x1p-1) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023)) +(assert_return (invoke "sub" (f64.const 0x1p-1) (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023)) +(assert_return (invoke "sub" (f64.const 0x1p-1) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023)) +(assert_return (invoke "sub" (f64.const -0x1p-1) (f64.const -inf)) (f64.const inf)) +(assert_return (invoke "sub" (f64.const -0x1p-1) (f64.const inf)) (f64.const -inf)) +(assert_return (invoke "sub" (f64.const 0x1p-1) (f64.const -inf)) (f64.const inf)) +(assert_return (invoke "sub" (f64.const 0x1p-1) (f64.const inf)) (f64.const -inf)) +(assert_return (invoke "sub" (f64.const -0x1p-1) (f64.const -nan)) (f64.const nan:canonical)) +(assert_return (invoke "sub" (f64.const -0x1p-1) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "sub" (f64.const -0x1p-1) (f64.const nan)) (f64.const nan:canonical)) +(assert_return (invoke "sub" (f64.const -0x1p-1) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "sub" (f64.const 0x1p-1) (f64.const -nan)) (f64.const nan:canonical)) +(assert_return (invoke "sub" (f64.const 0x1p-1) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "sub" (f64.const 0x1p-1) (f64.const nan)) (f64.const nan:canonical)) +(assert_return (invoke "sub" (f64.const 0x1p-1) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "sub" (f64.const -0x1p+0) (f64.const -0x0p+0)) (f64.const -0x1p+0)) +(assert_return (invoke "sub" (f64.const -0x1p+0) (f64.const 0x0p+0)) (f64.const -0x1p+0)) +(assert_return (invoke "sub" (f64.const 0x1p+0) (f64.const -0x0p+0)) (f64.const 0x1p+0)) +(assert_return (invoke "sub" (f64.const 0x1p+0) (f64.const 0x0p+0)) (f64.const 0x1p+0)) +(assert_return (invoke "sub" (f64.const -0x1p+0) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x1p+0)) +(assert_return (invoke "sub" (f64.const -0x1p+0) (f64.const 0x0.0000000000001p-1022)) (f64.const -0x1p+0)) +(assert_return (invoke "sub" (f64.const 0x1p+0) (f64.const -0x0.0000000000001p-1022)) (f64.const 0x1p+0)) +(assert_return (invoke "sub" (f64.const 0x1p+0) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x1p+0)) +(assert_return (invoke "sub" (f64.const -0x1p+0) (f64.const -0x1p-1022)) (f64.const -0x1p+0)) +(assert_return (invoke "sub" (f64.const -0x1p+0) (f64.const 0x1p-1022)) (f64.const -0x1p+0)) +(assert_return (invoke "sub" (f64.const 0x1p+0) (f64.const -0x1p-1022)) (f64.const 0x1p+0)) +(assert_return (invoke "sub" (f64.const 0x1p+0) (f64.const 0x1p-1022)) (f64.const 0x1p+0)) +(assert_return (invoke "sub" (f64.const -0x1p+0) (f64.const -0x1p-1)) (f64.const -0x1p-1)) +(assert_return (invoke "sub" (f64.const -0x1p+0) (f64.const 0x1p-1)) (f64.const -0x1.8p+0)) +(assert_return (invoke "sub" (f64.const 0x1p+0) (f64.const -0x1p-1)) (f64.const 0x1.8p+0)) +(assert_return (invoke "sub" (f64.const 0x1p+0) (f64.const 0x1p-1)) (f64.const 0x1p-1)) +(assert_return (invoke "sub" (f64.const -0x1p+0) (f64.const -0x1p+0)) (f64.const 0x0p+0)) +(assert_return (invoke "sub" (f64.const -0x1p+0) (f64.const 0x1p+0)) (f64.const -0x1p+1)) +(assert_return (invoke "sub" (f64.const 0x1p+0) (f64.const -0x1p+0)) (f64.const 0x1p+1)) +(assert_return (invoke "sub" (f64.const 0x1p+0) (f64.const 0x1p+0)) (f64.const 0x0p+0)) +(assert_return (invoke "sub" (f64.const -0x1p+0) (f64.const -0x1.921fb54442d18p+2)) (f64.const 0x1.521fb54442d18p+2)) +(assert_return (invoke "sub" (f64.const -0x1p+0) (f64.const 0x1.921fb54442d18p+2)) (f64.const -0x1.d21fb54442d18p+2)) +(assert_return (invoke "sub" (f64.const 0x1p+0) (f64.const -0x1.921fb54442d18p+2)) (f64.const 0x1.d21fb54442d18p+2)) +(assert_return (invoke "sub" (f64.const 0x1p+0) (f64.const 0x1.921fb54442d18p+2)) (f64.const -0x1.521fb54442d18p+2)) +(assert_return (invoke "sub" (f64.const -0x1p+0) (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023)) +(assert_return (invoke "sub" (f64.const -0x1p+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023)) +(assert_return (invoke "sub" (f64.const 0x1p+0) (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023)) +(assert_return (invoke "sub" (f64.const 0x1p+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023)) +(assert_return (invoke "sub" (f64.const -0x1p+0) (f64.const -inf)) (f64.const inf)) +(assert_return (invoke "sub" (f64.const -0x1p+0) (f64.const inf)) (f64.const -inf)) +(assert_return (invoke "sub" (f64.const 0x1p+0) (f64.const -inf)) (f64.const inf)) +(assert_return (invoke "sub" (f64.const 0x1p+0) (f64.const inf)) (f64.const -inf)) +(assert_return (invoke "sub" (f64.const -0x1p+0) (f64.const -nan)) (f64.const nan:canonical)) +(assert_return (invoke "sub" (f64.const -0x1p+0) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "sub" (f64.const -0x1p+0) (f64.const nan)) (f64.const nan:canonical)) +(assert_return (invoke "sub" (f64.const -0x1p+0) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "sub" (f64.const 0x1p+0) (f64.const -nan)) (f64.const nan:canonical)) +(assert_return (invoke "sub" (f64.const 0x1p+0) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "sub" (f64.const 0x1p+0) (f64.const nan)) (f64.const nan:canonical)) +(assert_return (invoke "sub" (f64.const 0x1p+0) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "sub" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x0p+0)) (f64.const -0x1.921fb54442d18p+2)) +(assert_return (invoke "sub" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x0p+0)) (f64.const -0x1.921fb54442d18p+2)) +(assert_return (invoke "sub" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x0p+0)) (f64.const 0x1.921fb54442d18p+2)) +(assert_return (invoke "sub" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x0p+0)) (f64.const 0x1.921fb54442d18p+2)) +(assert_return (invoke "sub" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x1.921fb54442d18p+2)) +(assert_return (invoke "sub" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x0.0000000000001p-1022)) (f64.const -0x1.921fb54442d18p+2)) +(assert_return (invoke "sub" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x0.0000000000001p-1022)) (f64.const 0x1.921fb54442d18p+2)) +(assert_return (invoke "sub" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x1.921fb54442d18p+2)) +(assert_return (invoke "sub" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1p-1022)) (f64.const -0x1.921fb54442d18p+2)) +(assert_return (invoke "sub" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1p-1022)) (f64.const -0x1.921fb54442d18p+2)) +(assert_return (invoke "sub" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1p-1022)) (f64.const 0x1.921fb54442d18p+2)) +(assert_return (invoke "sub" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1p-1022)) (f64.const 0x1.921fb54442d18p+2)) +(assert_return (invoke "sub" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1p-1)) (f64.const -0x1.721fb54442d18p+2)) +(assert_return (invoke "sub" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1p-1)) (f64.const -0x1.b21fb54442d18p+2)) +(assert_return (invoke "sub" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1p-1)) (f64.const 0x1.b21fb54442d18p+2)) +(assert_return (invoke "sub" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1p-1)) (f64.const 0x1.721fb54442d18p+2)) +(assert_return (invoke "sub" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1p+0)) (f64.const -0x1.521fb54442d18p+2)) +(assert_return (invoke "sub" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1p+0)) (f64.const -0x1.d21fb54442d18p+2)) +(assert_return (invoke "sub" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1p+0)) (f64.const 0x1.d21fb54442d18p+2)) +(assert_return (invoke "sub" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1p+0)) (f64.const 0x1.521fb54442d18p+2)) +(assert_return (invoke "sub" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1.921fb54442d18p+2)) (f64.const 0x0p+0)) +(assert_return (invoke "sub" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1.921fb54442d18p+2)) (f64.const -0x1.921fb54442d18p+3)) +(assert_return (invoke "sub" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p+3)) +(assert_return (invoke "sub" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x0p+0)) +(assert_return (invoke "sub" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023)) +(assert_return (invoke "sub" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023)) +(assert_return (invoke "sub" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023)) +(assert_return (invoke "sub" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023)) +(assert_return (invoke "sub" (f64.const -0x1.921fb54442d18p+2) (f64.const -inf)) (f64.const inf)) +(assert_return (invoke "sub" (f64.const -0x1.921fb54442d18p+2) (f64.const inf)) (f64.const -inf)) +(assert_return (invoke "sub" (f64.const 0x1.921fb54442d18p+2) (f64.const -inf)) (f64.const inf)) +(assert_return (invoke "sub" (f64.const 0x1.921fb54442d18p+2) (f64.const inf)) (f64.const -inf)) +(assert_return (invoke "sub" (f64.const -0x1.921fb54442d18p+2) (f64.const -nan)) (f64.const nan:canonical)) +(assert_return (invoke "sub" (f64.const -0x1.921fb54442d18p+2) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "sub" (f64.const -0x1.921fb54442d18p+2) (f64.const nan)) (f64.const nan:canonical)) +(assert_return (invoke "sub" (f64.const -0x1.921fb54442d18p+2) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "sub" (f64.const 0x1.921fb54442d18p+2) (f64.const -nan)) (f64.const nan:canonical)) +(assert_return (invoke "sub" (f64.const 0x1.921fb54442d18p+2) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "sub" (f64.const 0x1.921fb54442d18p+2) (f64.const nan)) (f64.const nan:canonical)) +(assert_return (invoke "sub" (f64.const 0x1.921fb54442d18p+2) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "sub" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x0p+0)) (f64.const -0x1.fffffffffffffp+1023)) +(assert_return (invoke "sub" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x0p+0)) (f64.const -0x1.fffffffffffffp+1023)) +(assert_return (invoke "sub" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x0p+0)) (f64.const 0x1.fffffffffffffp+1023)) +(assert_return (invoke "sub" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x0p+0)) (f64.const 0x1.fffffffffffffp+1023)) +(assert_return (invoke "sub" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x1.fffffffffffffp+1023)) +(assert_return (invoke "sub" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x0.0000000000001p-1022)) (f64.const -0x1.fffffffffffffp+1023)) +(assert_return (invoke "sub" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x0.0000000000001p-1022)) (f64.const 0x1.fffffffffffffp+1023)) +(assert_return (invoke "sub" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x1.fffffffffffffp+1023)) +(assert_return (invoke "sub" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1p-1022)) (f64.const -0x1.fffffffffffffp+1023)) +(assert_return (invoke "sub" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1p-1022)) (f64.const -0x1.fffffffffffffp+1023)) +(assert_return (invoke "sub" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1p-1022)) (f64.const 0x1.fffffffffffffp+1023)) +(assert_return (invoke "sub" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1p-1022)) (f64.const 0x1.fffffffffffffp+1023)) +(assert_return (invoke "sub" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1p-1)) (f64.const -0x1.fffffffffffffp+1023)) +(assert_return (invoke "sub" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1p-1)) (f64.const -0x1.fffffffffffffp+1023)) +(assert_return (invoke "sub" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1p-1)) (f64.const 0x1.fffffffffffffp+1023)) +(assert_return (invoke "sub" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1p-1)) (f64.const 0x1.fffffffffffffp+1023)) +(assert_return (invoke "sub" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1p+0)) (f64.const -0x1.fffffffffffffp+1023)) +(assert_return (invoke "sub" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1p+0)) (f64.const -0x1.fffffffffffffp+1023)) +(assert_return (invoke "sub" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1p+0)) (f64.const 0x1.fffffffffffffp+1023)) +(assert_return (invoke "sub" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1p+0)) (f64.const 0x1.fffffffffffffp+1023)) +(assert_return (invoke "sub" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.fffffffffffffp+1023)) +(assert_return (invoke "sub" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1.921fb54442d18p+2)) (f64.const -0x1.fffffffffffffp+1023)) +(assert_return (invoke "sub" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1.921fb54442d18p+2)) (f64.const 0x1.fffffffffffffp+1023)) +(assert_return (invoke "sub" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.fffffffffffffp+1023)) +(assert_return (invoke "sub" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x0p+0)) +(assert_return (invoke "sub" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -inf)) +(assert_return (invoke "sub" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1.fffffffffffffp+1023)) (f64.const inf)) +(assert_return (invoke "sub" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x0p+0)) +(assert_return (invoke "sub" (f64.const -0x1.fffffffffffffp+1023) (f64.const -inf)) (f64.const inf)) +(assert_return (invoke "sub" (f64.const -0x1.fffffffffffffp+1023) (f64.const inf)) (f64.const -inf)) +(assert_return (invoke "sub" (f64.const 0x1.fffffffffffffp+1023) (f64.const -inf)) (f64.const inf)) +(assert_return (invoke "sub" (f64.const 0x1.fffffffffffffp+1023) (f64.const inf)) (f64.const -inf)) +(assert_return (invoke "sub" (f64.const -0x1.fffffffffffffp+1023) (f64.const -nan)) (f64.const nan:canonical)) +(assert_return (invoke "sub" (f64.const -0x1.fffffffffffffp+1023) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "sub" (f64.const -0x1.fffffffffffffp+1023) (f64.const nan)) (f64.const nan:canonical)) +(assert_return (invoke "sub" (f64.const -0x1.fffffffffffffp+1023) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "sub" (f64.const 0x1.fffffffffffffp+1023) (f64.const -nan)) (f64.const nan:canonical)) +(assert_return (invoke "sub" (f64.const 0x1.fffffffffffffp+1023) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "sub" (f64.const 0x1.fffffffffffffp+1023) (f64.const nan)) (f64.const nan:canonical)) +(assert_return (invoke "sub" (f64.const 0x1.fffffffffffffp+1023) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "sub" (f64.const -inf) (f64.const -0x0p+0)) (f64.const -inf)) +(assert_return (invoke "sub" (f64.const -inf) (f64.const 0x0p+0)) (f64.const -inf)) +(assert_return (invoke "sub" (f64.const inf) (f64.const -0x0p+0)) (f64.const inf)) +(assert_return (invoke "sub" (f64.const inf) (f64.const 0x0p+0)) (f64.const inf)) +(assert_return (invoke "sub" (f64.const -inf) (f64.const -0x0.0000000000001p-1022)) (f64.const -inf)) +(assert_return (invoke "sub" (f64.const -inf) (f64.const 0x0.0000000000001p-1022)) (f64.const -inf)) +(assert_return (invoke "sub" (f64.const inf) (f64.const -0x0.0000000000001p-1022)) (f64.const inf)) +(assert_return (invoke "sub" (f64.const inf) (f64.const 0x0.0000000000001p-1022)) (f64.const inf)) +(assert_return (invoke "sub" (f64.const -inf) (f64.const -0x1p-1022)) (f64.const -inf)) +(assert_return (invoke "sub" (f64.const -inf) (f64.const 0x1p-1022)) (f64.const -inf)) +(assert_return (invoke "sub" (f64.const inf) (f64.const -0x1p-1022)) (f64.const inf)) +(assert_return (invoke "sub" (f64.const inf) (f64.const 0x1p-1022)) (f64.const inf)) +(assert_return (invoke "sub" (f64.const -inf) (f64.const -0x1p-1)) (f64.const -inf)) +(assert_return (invoke "sub" (f64.const -inf) (f64.const 0x1p-1)) (f64.const -inf)) +(assert_return (invoke "sub" (f64.const inf) (f64.const -0x1p-1)) (f64.const inf)) +(assert_return (invoke "sub" (f64.const inf) (f64.const 0x1p-1)) (f64.const inf)) +(assert_return (invoke "sub" (f64.const -inf) (f64.const -0x1p+0)) (f64.const -inf)) +(assert_return (invoke "sub" (f64.const -inf) (f64.const 0x1p+0)) (f64.const -inf)) +(assert_return (invoke "sub" (f64.const inf) (f64.const -0x1p+0)) (f64.const inf)) +(assert_return (invoke "sub" (f64.const inf) (f64.const 0x1p+0)) (f64.const inf)) +(assert_return (invoke "sub" (f64.const -inf) (f64.const -0x1.921fb54442d18p+2)) (f64.const -inf)) +(assert_return (invoke "sub" (f64.const -inf) (f64.const 0x1.921fb54442d18p+2)) (f64.const -inf)) +(assert_return (invoke "sub" (f64.const inf) (f64.const -0x1.921fb54442d18p+2)) (f64.const inf)) +(assert_return (invoke "sub" (f64.const inf) (f64.const 0x1.921fb54442d18p+2)) (f64.const inf)) +(assert_return (invoke "sub" (f64.const -inf) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -inf)) +(assert_return (invoke "sub" (f64.const -inf) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -inf)) +(assert_return (invoke "sub" (f64.const inf) (f64.const -0x1.fffffffffffffp+1023)) (f64.const inf)) +(assert_return (invoke "sub" (f64.const inf) (f64.const 0x1.fffffffffffffp+1023)) (f64.const inf)) +(assert_return (invoke "sub" (f64.const -inf) (f64.const -inf)) (f64.const nan:canonical)) +(assert_return (invoke "sub" (f64.const -inf) (f64.const inf)) (f64.const -inf)) +(assert_return (invoke "sub" (f64.const inf) (f64.const -inf)) (f64.const inf)) +(assert_return (invoke "sub" (f64.const inf) (f64.const inf)) (f64.const nan:canonical)) +(assert_return (invoke "sub" (f64.const -inf) (f64.const -nan)) (f64.const nan:canonical)) +(assert_return (invoke "sub" (f64.const -inf) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "sub" (f64.const -inf) (f64.const nan)) (f64.const nan:canonical)) +(assert_return (invoke "sub" (f64.const -inf) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "sub" (f64.const inf) (f64.const -nan)) (f64.const nan:canonical)) +(assert_return (invoke "sub" (f64.const inf) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "sub" (f64.const inf) (f64.const nan)) (f64.const nan:canonical)) +(assert_return (invoke "sub" (f64.const inf) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "sub" (f64.const -nan) (f64.const -0x0p+0)) (f64.const nan:canonical)) +(assert_return (invoke "sub" (f64.const -nan:0x4000000000000) (f64.const -0x0p+0)) (f64.const nan:arithmetic)) +(assert_return (invoke "sub" (f64.const -nan) (f64.const 0x0p+0)) (f64.const nan:canonical)) +(assert_return (invoke "sub" (f64.const -nan:0x4000000000000) (f64.const 0x0p+0)) (f64.const nan:arithmetic)) +(assert_return (invoke "sub" (f64.const nan) (f64.const -0x0p+0)) (f64.const nan:canonical)) +(assert_return (invoke "sub" (f64.const nan:0x4000000000000) (f64.const -0x0p+0)) (f64.const nan:arithmetic)) +(assert_return (invoke "sub" (f64.const nan) (f64.const 0x0p+0)) (f64.const nan:canonical)) +(assert_return (invoke "sub" (f64.const nan:0x4000000000000) (f64.const 0x0p+0)) (f64.const nan:arithmetic)) +(assert_return (invoke "sub" (f64.const -nan) (f64.const -0x0.0000000000001p-1022)) (f64.const nan:canonical)) +(assert_return (invoke "sub" (f64.const -nan:0x4000000000000) (f64.const -0x0.0000000000001p-1022)) (f64.const nan:arithmetic)) +(assert_return (invoke "sub" (f64.const -nan) (f64.const 0x0.0000000000001p-1022)) (f64.const nan:canonical)) +(assert_return (invoke "sub" (f64.const -nan:0x4000000000000) (f64.const 0x0.0000000000001p-1022)) (f64.const nan:arithmetic)) +(assert_return (invoke "sub" (f64.const nan) (f64.const -0x0.0000000000001p-1022)) (f64.const nan:canonical)) +(assert_return (invoke "sub" (f64.const nan:0x4000000000000) (f64.const -0x0.0000000000001p-1022)) (f64.const nan:arithmetic)) +(assert_return (invoke "sub" (f64.const nan) (f64.const 0x0.0000000000001p-1022)) (f64.const nan:canonical)) +(assert_return (invoke "sub" (f64.const nan:0x4000000000000) (f64.const 0x0.0000000000001p-1022)) (f64.const nan:arithmetic)) +(assert_return (invoke "sub" (f64.const -nan) (f64.const -0x1p-1022)) (f64.const nan:canonical)) +(assert_return (invoke "sub" (f64.const -nan:0x4000000000000) (f64.const -0x1p-1022)) (f64.const nan:arithmetic)) +(assert_return (invoke "sub" (f64.const -nan) (f64.const 0x1p-1022)) (f64.const nan:canonical)) +(assert_return (invoke "sub" (f64.const -nan:0x4000000000000) (f64.const 0x1p-1022)) (f64.const nan:arithmetic)) +(assert_return (invoke "sub" (f64.const nan) (f64.const -0x1p-1022)) (f64.const nan:canonical)) +(assert_return (invoke "sub" (f64.const nan:0x4000000000000) (f64.const -0x1p-1022)) (f64.const nan:arithmetic)) +(assert_return (invoke "sub" (f64.const nan) (f64.const 0x1p-1022)) (f64.const nan:canonical)) +(assert_return (invoke "sub" (f64.const nan:0x4000000000000) (f64.const 0x1p-1022)) (f64.const nan:arithmetic)) +(assert_return (invoke "sub" (f64.const -nan) (f64.const -0x1p-1)) (f64.const nan:canonical)) +(assert_return (invoke "sub" (f64.const -nan:0x4000000000000) (f64.const -0x1p-1)) (f64.const nan:arithmetic)) +(assert_return (invoke "sub" (f64.const -nan) (f64.const 0x1p-1)) (f64.const nan:canonical)) +(assert_return (invoke "sub" (f64.const -nan:0x4000000000000) (f64.const 0x1p-1)) (f64.const nan:arithmetic)) +(assert_return (invoke "sub" (f64.const nan) (f64.const -0x1p-1)) (f64.const nan:canonical)) +(assert_return (invoke "sub" (f64.const nan:0x4000000000000) (f64.const -0x1p-1)) (f64.const nan:arithmetic)) +(assert_return (invoke "sub" (f64.const nan) (f64.const 0x1p-1)) (f64.const nan:canonical)) +(assert_return (invoke "sub" (f64.const nan:0x4000000000000) (f64.const 0x1p-1)) (f64.const nan:arithmetic)) +(assert_return (invoke "sub" (f64.const -nan) (f64.const -0x1p+0)) (f64.const nan:canonical)) +(assert_return (invoke "sub" (f64.const -nan:0x4000000000000) (f64.const -0x1p+0)) (f64.const nan:arithmetic)) +(assert_return (invoke "sub" (f64.const -nan) (f64.const 0x1p+0)) (f64.const nan:canonical)) +(assert_return (invoke "sub" (f64.const -nan:0x4000000000000) (f64.const 0x1p+0)) (f64.const nan:arithmetic)) +(assert_return (invoke "sub" (f64.const nan) (f64.const -0x1p+0)) (f64.const nan:canonical)) +(assert_return (invoke "sub" (f64.const nan:0x4000000000000) (f64.const -0x1p+0)) (f64.const nan:arithmetic)) +(assert_return (invoke "sub" (f64.const nan) (f64.const 0x1p+0)) (f64.const nan:canonical)) +(assert_return (invoke "sub" (f64.const nan:0x4000000000000) (f64.const 0x1p+0)) (f64.const nan:arithmetic)) +(assert_return (invoke "sub" (f64.const -nan) (f64.const -0x1.921fb54442d18p+2)) (f64.const nan:canonical)) +(assert_return (invoke "sub" (f64.const -nan:0x4000000000000) (f64.const -0x1.921fb54442d18p+2)) (f64.const nan:arithmetic)) +(assert_return (invoke "sub" (f64.const -nan) (f64.const 0x1.921fb54442d18p+2)) (f64.const nan:canonical)) +(assert_return (invoke "sub" (f64.const -nan:0x4000000000000) (f64.const 0x1.921fb54442d18p+2)) (f64.const nan:arithmetic)) +(assert_return (invoke "sub" (f64.const nan) (f64.const -0x1.921fb54442d18p+2)) (f64.const nan:canonical)) +(assert_return (invoke "sub" (f64.const nan:0x4000000000000) (f64.const -0x1.921fb54442d18p+2)) (f64.const nan:arithmetic)) +(assert_return (invoke "sub" (f64.const nan) (f64.const 0x1.921fb54442d18p+2)) (f64.const nan:canonical)) +(assert_return (invoke "sub" (f64.const nan:0x4000000000000) (f64.const 0x1.921fb54442d18p+2)) (f64.const nan:arithmetic)) +(assert_return (invoke "sub" (f64.const -nan) (f64.const -0x1.fffffffffffffp+1023)) (f64.const nan:canonical)) +(assert_return (invoke "sub" (f64.const -nan:0x4000000000000) (f64.const -0x1.fffffffffffffp+1023)) (f64.const nan:arithmetic)) +(assert_return (invoke "sub" (f64.const -nan) (f64.const 0x1.fffffffffffffp+1023)) (f64.const nan:canonical)) +(assert_return (invoke "sub" (f64.const -nan:0x4000000000000) (f64.const 0x1.fffffffffffffp+1023)) (f64.const nan:arithmetic)) +(assert_return (invoke "sub" (f64.const nan) (f64.const -0x1.fffffffffffffp+1023)) (f64.const nan:canonical)) +(assert_return (invoke "sub" (f64.const nan:0x4000000000000) (f64.const -0x1.fffffffffffffp+1023)) (f64.const nan:arithmetic)) +(assert_return (invoke "sub" (f64.const nan) (f64.const 0x1.fffffffffffffp+1023)) (f64.const nan:canonical)) +(assert_return (invoke "sub" (f64.const nan:0x4000000000000) (f64.const 0x1.fffffffffffffp+1023)) (f64.const nan:arithmetic)) +(assert_return (invoke "sub" (f64.const -nan) (f64.const -inf)) (f64.const nan:canonical)) +(assert_return (invoke "sub" (f64.const -nan:0x4000000000000) (f64.const -inf)) (f64.const nan:arithmetic)) +(assert_return (invoke "sub" (f64.const -nan) (f64.const inf)) (f64.const nan:canonical)) +(assert_return (invoke "sub" (f64.const -nan:0x4000000000000) (f64.const inf)) (f64.const nan:arithmetic)) +(assert_return (invoke "sub" (f64.const nan) (f64.const -inf)) (f64.const nan:canonical)) +(assert_return (invoke "sub" (f64.const nan:0x4000000000000) (f64.const -inf)) (f64.const nan:arithmetic)) +(assert_return (invoke "sub" (f64.const nan) (f64.const inf)) (f64.const nan:canonical)) +(assert_return (invoke "sub" (f64.const nan:0x4000000000000) (f64.const inf)) (f64.const nan:arithmetic)) +(assert_return (invoke "sub" (f64.const -nan) (f64.const -nan)) (f64.const nan:canonical)) +(assert_return (invoke "sub" (f64.const -nan:0x4000000000000) (f64.const -nan)) (f64.const nan:arithmetic)) +(assert_return (invoke "sub" (f64.const -nan) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "sub" (f64.const -nan:0x4000000000000) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "sub" (f64.const -nan) (f64.const nan)) (f64.const nan:canonical)) +(assert_return (invoke "sub" (f64.const -nan:0x4000000000000) (f64.const nan)) (f64.const nan:arithmetic)) +(assert_return (invoke "sub" (f64.const -nan) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "sub" (f64.const -nan:0x4000000000000) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "sub" (f64.const nan) (f64.const -nan)) (f64.const nan:canonical)) +(assert_return (invoke "sub" (f64.const nan:0x4000000000000) (f64.const -nan)) (f64.const nan:arithmetic)) +(assert_return (invoke "sub" (f64.const nan) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "sub" (f64.const nan:0x4000000000000) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "sub" (f64.const nan) (f64.const nan)) (f64.const nan:canonical)) +(assert_return (invoke "sub" (f64.const nan:0x4000000000000) (f64.const nan)) (f64.const nan:arithmetic)) +(assert_return (invoke "sub" (f64.const nan) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "sub" (f64.const nan:0x4000000000000) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "mul" (f64.const -0x0p+0) (f64.const -0x0p+0)) (f64.const 0x0p+0)) +(assert_return (invoke "mul" (f64.const -0x0p+0) (f64.const 0x0p+0)) (f64.const -0x0p+0)) +(assert_return (invoke "mul" (f64.const 0x0p+0) (f64.const -0x0p+0)) (f64.const -0x0p+0)) +(assert_return (invoke "mul" (f64.const 0x0p+0) (f64.const 0x0p+0)) (f64.const 0x0p+0)) +(assert_return (invoke "mul" (f64.const -0x0p+0) (f64.const -0x0.0000000000001p-1022)) (f64.const 0x0p+0)) +(assert_return (invoke "mul" (f64.const -0x0p+0) (f64.const 0x0.0000000000001p-1022)) (f64.const -0x0p+0)) +(assert_return (invoke "mul" (f64.const 0x0p+0) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x0p+0)) +(assert_return (invoke "mul" (f64.const 0x0p+0) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x0p+0)) +(assert_return (invoke "mul" (f64.const -0x0p+0) (f64.const -0x1p-1022)) (f64.const 0x0p+0)) +(assert_return (invoke "mul" (f64.const -0x0p+0) (f64.const 0x1p-1022)) (f64.const -0x0p+0)) +(assert_return (invoke "mul" (f64.const 0x0p+0) (f64.const -0x1p-1022)) (f64.const -0x0p+0)) +(assert_return (invoke "mul" (f64.const 0x0p+0) (f64.const 0x1p-1022)) (f64.const 0x0p+0)) +(assert_return (invoke "mul" (f64.const -0x0p+0) (f64.const -0x1p-1)) (f64.const 0x0p+0)) +(assert_return (invoke "mul" (f64.const -0x0p+0) (f64.const 0x1p-1)) (f64.const -0x0p+0)) +(assert_return (invoke "mul" (f64.const 0x0p+0) (f64.const -0x1p-1)) (f64.const -0x0p+0)) +(assert_return (invoke "mul" (f64.const 0x0p+0) (f64.const 0x1p-1)) (f64.const 0x0p+0)) +(assert_return (invoke "mul" (f64.const -0x0p+0) (f64.const -0x1p+0)) (f64.const 0x0p+0)) +(assert_return (invoke "mul" (f64.const -0x0p+0) (f64.const 0x1p+0)) (f64.const -0x0p+0)) +(assert_return (invoke "mul" (f64.const 0x0p+0) (f64.const -0x1p+0)) (f64.const -0x0p+0)) +(assert_return (invoke "mul" (f64.const 0x0p+0) (f64.const 0x1p+0)) (f64.const 0x0p+0)) +(assert_return (invoke "mul" (f64.const -0x0p+0) (f64.const -0x1.921fb54442d18p+2)) (f64.const 0x0p+0)) +(assert_return (invoke "mul" (f64.const -0x0p+0) (f64.const 0x1.921fb54442d18p+2)) (f64.const -0x0p+0)) +(assert_return (invoke "mul" (f64.const 0x0p+0) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x0p+0)) +(assert_return (invoke "mul" (f64.const 0x0p+0) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x0p+0)) +(assert_return (invoke "mul" (f64.const -0x0p+0) (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x0p+0)) +(assert_return (invoke "mul" (f64.const -0x0p+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x0p+0)) +(assert_return (invoke "mul" (f64.const 0x0p+0) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x0p+0)) +(assert_return (invoke "mul" (f64.const 0x0p+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x0p+0)) +(assert_return (invoke "mul" (f64.const -0x0p+0) (f64.const -inf)) (f64.const nan:canonical)) +(assert_return (invoke "mul" (f64.const -0x0p+0) (f64.const inf)) (f64.const nan:canonical)) +(assert_return (invoke "mul" (f64.const 0x0p+0) (f64.const -inf)) (f64.const nan:canonical)) +(assert_return (invoke "mul" (f64.const 0x0p+0) (f64.const inf)) (f64.const nan:canonical)) +(assert_return (invoke "mul" (f64.const -0x0p+0) (f64.const -nan)) (f64.const nan:canonical)) +(assert_return (invoke "mul" (f64.const -0x0p+0) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "mul" (f64.const -0x0p+0) (f64.const nan)) (f64.const nan:canonical)) +(assert_return (invoke "mul" (f64.const -0x0p+0) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "mul" (f64.const 0x0p+0) (f64.const -nan)) (f64.const nan:canonical)) +(assert_return (invoke "mul" (f64.const 0x0p+0) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "mul" (f64.const 0x0p+0) (f64.const nan)) (f64.const nan:canonical)) +(assert_return (invoke "mul" (f64.const 0x0p+0) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "mul" (f64.const -0x0.0000000000001p-1022) (f64.const -0x0p+0)) (f64.const 0x0p+0)) +(assert_return (invoke "mul" (f64.const -0x0.0000000000001p-1022) (f64.const 0x0p+0)) (f64.const -0x0p+0)) +(assert_return (invoke "mul" (f64.const 0x0.0000000000001p-1022) (f64.const -0x0p+0)) (f64.const -0x0p+0)) +(assert_return (invoke "mul" (f64.const 0x0.0000000000001p-1022) (f64.const 0x0p+0)) (f64.const 0x0p+0)) +(assert_return (invoke "mul" (f64.const -0x0.0000000000001p-1022) (f64.const -0x0.0000000000001p-1022)) (f64.const 0x0p+0)) +(assert_return (invoke "mul" (f64.const -0x0.0000000000001p-1022) (f64.const 0x0.0000000000001p-1022)) (f64.const -0x0p+0)) +(assert_return (invoke "mul" (f64.const 0x0.0000000000001p-1022) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x0p+0)) +(assert_return (invoke "mul" (f64.const 0x0.0000000000001p-1022) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x0p+0)) +(assert_return (invoke "mul" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1p-1022)) (f64.const 0x0p+0)) +(assert_return (invoke "mul" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1p-1022)) (f64.const -0x0p+0)) +(assert_return (invoke "mul" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1p-1022)) (f64.const -0x0p+0)) +(assert_return (invoke "mul" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1p-1022)) (f64.const 0x0p+0)) +(assert_return (invoke "mul" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1p-1)) (f64.const 0x0p+0)) +(assert_return (invoke "mul" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1p-1)) (f64.const -0x0p+0)) +(assert_return (invoke "mul" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1p-1)) (f64.const -0x0p+0)) +(assert_return (invoke "mul" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1p-1)) (f64.const 0x0p+0)) +(assert_return (invoke "mul" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1p+0)) (f64.const 0x0.0000000000001p-1022)) +(assert_return (invoke "mul" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1p+0)) (f64.const -0x0.0000000000001p-1022)) +(assert_return (invoke "mul" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1p+0)) (f64.const -0x0.0000000000001p-1022)) +(assert_return (invoke "mul" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1p+0)) (f64.const 0x0.0000000000001p-1022)) +(assert_return (invoke "mul" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1.921fb54442d18p+2)) (f64.const 0x0.0000000000006p-1022)) +(assert_return (invoke "mul" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1.921fb54442d18p+2)) (f64.const -0x0.0000000000006p-1022)) +(assert_return (invoke "mul" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x0.0000000000006p-1022)) +(assert_return (invoke "mul" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x0.0000000000006p-1022)) +(assert_return (invoke "mul" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp-51)) +(assert_return (invoke "mul" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp-51)) +(assert_return (invoke "mul" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp-51)) +(assert_return (invoke "mul" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp-51)) +(assert_return (invoke "mul" (f64.const -0x0.0000000000001p-1022) (f64.const -inf)) (f64.const inf)) +(assert_return (invoke "mul" (f64.const -0x0.0000000000001p-1022) (f64.const inf)) (f64.const -inf)) +(assert_return (invoke "mul" (f64.const 0x0.0000000000001p-1022) (f64.const -inf)) (f64.const -inf)) +(assert_return (invoke "mul" (f64.const 0x0.0000000000001p-1022) (f64.const inf)) (f64.const inf)) +(assert_return (invoke "mul" (f64.const -0x0.0000000000001p-1022) (f64.const -nan)) (f64.const nan:canonical)) +(assert_return (invoke "mul" (f64.const -0x0.0000000000001p-1022) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "mul" (f64.const -0x0.0000000000001p-1022) (f64.const nan)) (f64.const nan:canonical)) +(assert_return (invoke "mul" (f64.const -0x0.0000000000001p-1022) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "mul" (f64.const 0x0.0000000000001p-1022) (f64.const -nan)) (f64.const nan:canonical)) +(assert_return (invoke "mul" (f64.const 0x0.0000000000001p-1022) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "mul" (f64.const 0x0.0000000000001p-1022) (f64.const nan)) (f64.const nan:canonical)) +(assert_return (invoke "mul" (f64.const 0x0.0000000000001p-1022) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "mul" (f64.const -0x1p-1022) (f64.const -0x0p+0)) (f64.const 0x0p+0)) +(assert_return (invoke "mul" (f64.const -0x1p-1022) (f64.const 0x0p+0)) (f64.const -0x0p+0)) +(assert_return (invoke "mul" (f64.const 0x1p-1022) (f64.const -0x0p+0)) (f64.const -0x0p+0)) +(assert_return (invoke "mul" (f64.const 0x1p-1022) (f64.const 0x0p+0)) (f64.const 0x0p+0)) +(assert_return (invoke "mul" (f64.const -0x1p-1022) (f64.const -0x0.0000000000001p-1022)) (f64.const 0x0p+0)) +(assert_return (invoke "mul" (f64.const -0x1p-1022) (f64.const 0x0.0000000000001p-1022)) (f64.const -0x0p+0)) +(assert_return (invoke "mul" (f64.const 0x1p-1022) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x0p+0)) +(assert_return (invoke "mul" (f64.const 0x1p-1022) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x0p+0)) +(assert_return (invoke "mul" (f64.const -0x1p-1022) (f64.const -0x1p-1022)) (f64.const 0x0p+0)) +(assert_return (invoke "mul" (f64.const -0x1p-1022) (f64.const 0x1p-1022)) (f64.const -0x0p+0)) +(assert_return (invoke "mul" (f64.const 0x1p-1022) (f64.const -0x1p-1022)) (f64.const -0x0p+0)) +(assert_return (invoke "mul" (f64.const 0x1p-1022) (f64.const 0x1p-1022)) (f64.const 0x0p+0)) +(assert_return (invoke "mul" (f64.const -0x1p-1022) (f64.const -0x1p-1)) (f64.const 0x0.8p-1022)) +(assert_return (invoke "mul" (f64.const -0x1p-1022) (f64.const 0x1p-1)) (f64.const -0x0.8p-1022)) +(assert_return (invoke "mul" (f64.const 0x1p-1022) (f64.const -0x1p-1)) (f64.const -0x0.8p-1022)) +(assert_return (invoke "mul" (f64.const 0x1p-1022) (f64.const 0x1p-1)) (f64.const 0x0.8p-1022)) +(assert_return (invoke "mul" (f64.const -0x1p-1022) (f64.const -0x1p+0)) (f64.const 0x1p-1022)) +(assert_return (invoke "mul" (f64.const -0x1p-1022) (f64.const 0x1p+0)) (f64.const -0x1p-1022)) +(assert_return (invoke "mul" (f64.const 0x1p-1022) (f64.const -0x1p+0)) (f64.const -0x1p-1022)) +(assert_return (invoke "mul" (f64.const 0x1p-1022) (f64.const 0x1p+0)) (f64.const 0x1p-1022)) +(assert_return (invoke "mul" (f64.const -0x1p-1022) (f64.const -0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p-1020)) +(assert_return (invoke "mul" (f64.const -0x1p-1022) (f64.const 0x1.921fb54442d18p+2)) (f64.const -0x1.921fb54442d18p-1020)) +(assert_return (invoke "mul" (f64.const 0x1p-1022) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.921fb54442d18p-1020)) +(assert_return (invoke "mul" (f64.const 0x1p-1022) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p-1020)) +(assert_return (invoke "mul" (f64.const -0x1p-1022) (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1)) +(assert_return (invoke "mul" (f64.const -0x1p-1022) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1)) +(assert_return (invoke "mul" (f64.const 0x1p-1022) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1)) +(assert_return (invoke "mul" (f64.const 0x1p-1022) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1)) +(assert_return (invoke "mul" (f64.const -0x1p-1022) (f64.const -inf)) (f64.const inf)) +(assert_return (invoke "mul" (f64.const -0x1p-1022) (f64.const inf)) (f64.const -inf)) +(assert_return (invoke "mul" (f64.const 0x1p-1022) (f64.const -inf)) (f64.const -inf)) +(assert_return (invoke "mul" (f64.const 0x1p-1022) (f64.const inf)) (f64.const inf)) +(assert_return (invoke "mul" (f64.const -0x1p-1022) (f64.const -nan)) (f64.const nan:canonical)) +(assert_return (invoke "mul" (f64.const -0x1p-1022) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "mul" (f64.const -0x1p-1022) (f64.const nan)) (f64.const nan:canonical)) +(assert_return (invoke "mul" (f64.const -0x1p-1022) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "mul" (f64.const 0x1p-1022) (f64.const -nan)) (f64.const nan:canonical)) +(assert_return (invoke "mul" (f64.const 0x1p-1022) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "mul" (f64.const 0x1p-1022) (f64.const nan)) (f64.const nan:canonical)) +(assert_return (invoke "mul" (f64.const 0x1p-1022) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "mul" (f64.const -0x1p-1) (f64.const -0x0p+0)) (f64.const 0x0p+0)) +(assert_return (invoke "mul" (f64.const -0x1p-1) (f64.const 0x0p+0)) (f64.const -0x0p+0)) +(assert_return (invoke "mul" (f64.const 0x1p-1) (f64.const -0x0p+0)) (f64.const -0x0p+0)) +(assert_return (invoke "mul" (f64.const 0x1p-1) (f64.const 0x0p+0)) (f64.const 0x0p+0)) +(assert_return (invoke "mul" (f64.const -0x1p-1) (f64.const -0x0.0000000000001p-1022)) (f64.const 0x0p+0)) +(assert_return (invoke "mul" (f64.const -0x1p-1) (f64.const 0x0.0000000000001p-1022)) (f64.const -0x0p+0)) +(assert_return (invoke "mul" (f64.const 0x1p-1) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x0p+0)) +(assert_return (invoke "mul" (f64.const 0x1p-1) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x0p+0)) +(assert_return (invoke "mul" (f64.const -0x1p-1) (f64.const -0x1p-1022)) (f64.const 0x0.8p-1022)) +(assert_return (invoke "mul" (f64.const -0x1p-1) (f64.const 0x1p-1022)) (f64.const -0x0.8p-1022)) +(assert_return (invoke "mul" (f64.const 0x1p-1) (f64.const -0x1p-1022)) (f64.const -0x0.8p-1022)) +(assert_return (invoke "mul" (f64.const 0x1p-1) (f64.const 0x1p-1022)) (f64.const 0x0.8p-1022)) +(assert_return (invoke "mul" (f64.const -0x1p-1) (f64.const -0x1p-1)) (f64.const 0x1p-2)) +(assert_return (invoke "mul" (f64.const -0x1p-1) (f64.const 0x1p-1)) (f64.const -0x1p-2)) +(assert_return (invoke "mul" (f64.const 0x1p-1) (f64.const -0x1p-1)) (f64.const -0x1p-2)) +(assert_return (invoke "mul" (f64.const 0x1p-1) (f64.const 0x1p-1)) (f64.const 0x1p-2)) +(assert_return (invoke "mul" (f64.const -0x1p-1) (f64.const -0x1p+0)) (f64.const 0x1p-1)) +(assert_return (invoke "mul" (f64.const -0x1p-1) (f64.const 0x1p+0)) (f64.const -0x1p-1)) +(assert_return (invoke "mul" (f64.const 0x1p-1) (f64.const -0x1p+0)) (f64.const -0x1p-1)) +(assert_return (invoke "mul" (f64.const 0x1p-1) (f64.const 0x1p+0)) (f64.const 0x1p-1)) +(assert_return (invoke "mul" (f64.const -0x1p-1) (f64.const -0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p+1)) +(assert_return (invoke "mul" (f64.const -0x1p-1) (f64.const 0x1.921fb54442d18p+2)) (f64.const -0x1.921fb54442d18p+1)) +(assert_return (invoke "mul" (f64.const 0x1p-1) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.921fb54442d18p+1)) +(assert_return (invoke "mul" (f64.const 0x1p-1) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p+1)) +(assert_return (invoke "mul" (f64.const -0x1p-1) (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1022)) +(assert_return (invoke "mul" (f64.const -0x1p-1) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1022)) +(assert_return (invoke "mul" (f64.const 0x1p-1) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1022)) +(assert_return (invoke "mul" (f64.const 0x1p-1) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1022)) +(assert_return (invoke "mul" (f64.const -0x1p-1) (f64.const -inf)) (f64.const inf)) +(assert_return (invoke "mul" (f64.const -0x1p-1) (f64.const inf)) (f64.const -inf)) +(assert_return (invoke "mul" (f64.const 0x1p-1) (f64.const -inf)) (f64.const -inf)) +(assert_return (invoke "mul" (f64.const 0x1p-1) (f64.const inf)) (f64.const inf)) +(assert_return (invoke "mul" (f64.const -0x1p-1) (f64.const -nan)) (f64.const nan:canonical)) +(assert_return (invoke "mul" (f64.const -0x1p-1) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "mul" (f64.const -0x1p-1) (f64.const nan)) (f64.const nan:canonical)) +(assert_return (invoke "mul" (f64.const -0x1p-1) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "mul" (f64.const 0x1p-1) (f64.const -nan)) (f64.const nan:canonical)) +(assert_return (invoke "mul" (f64.const 0x1p-1) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "mul" (f64.const 0x1p-1) (f64.const nan)) (f64.const nan:canonical)) +(assert_return (invoke "mul" (f64.const 0x1p-1) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "mul" (f64.const -0x1p+0) (f64.const -0x0p+0)) (f64.const 0x0p+0)) +(assert_return (invoke "mul" (f64.const -0x1p+0) (f64.const 0x0p+0)) (f64.const -0x0p+0)) +(assert_return (invoke "mul" (f64.const 0x1p+0) (f64.const -0x0p+0)) (f64.const -0x0p+0)) +(assert_return (invoke "mul" (f64.const 0x1p+0) (f64.const 0x0p+0)) (f64.const 0x0p+0)) +(assert_return (invoke "mul" (f64.const -0x1p+0) (f64.const -0x0.0000000000001p-1022)) (f64.const 0x0.0000000000001p-1022)) +(assert_return (invoke "mul" (f64.const -0x1p+0) (f64.const 0x0.0000000000001p-1022)) (f64.const -0x0.0000000000001p-1022)) +(assert_return (invoke "mul" (f64.const 0x1p+0) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x0.0000000000001p-1022)) +(assert_return (invoke "mul" (f64.const 0x1p+0) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x0.0000000000001p-1022)) +(assert_return (invoke "mul" (f64.const -0x1p+0) (f64.const -0x1p-1022)) (f64.const 0x1p-1022)) +(assert_return (invoke "mul" (f64.const -0x1p+0) (f64.const 0x1p-1022)) (f64.const -0x1p-1022)) +(assert_return (invoke "mul" (f64.const 0x1p+0) (f64.const -0x1p-1022)) (f64.const -0x1p-1022)) +(assert_return (invoke "mul" (f64.const 0x1p+0) (f64.const 0x1p-1022)) (f64.const 0x1p-1022)) +(assert_return (invoke "mul" (f64.const -0x1p+0) (f64.const -0x1p-1)) (f64.const 0x1p-1)) +(assert_return (invoke "mul" (f64.const -0x1p+0) (f64.const 0x1p-1)) (f64.const -0x1p-1)) +(assert_return (invoke "mul" (f64.const 0x1p+0) (f64.const -0x1p-1)) (f64.const -0x1p-1)) +(assert_return (invoke "mul" (f64.const 0x1p+0) (f64.const 0x1p-1)) (f64.const 0x1p-1)) +(assert_return (invoke "mul" (f64.const -0x1p+0) (f64.const -0x1p+0)) (f64.const 0x1p+0)) +(assert_return (invoke "mul" (f64.const -0x1p+0) (f64.const 0x1p+0)) (f64.const -0x1p+0)) +(assert_return (invoke "mul" (f64.const 0x1p+0) (f64.const -0x1p+0)) (f64.const -0x1p+0)) +(assert_return (invoke "mul" (f64.const 0x1p+0) (f64.const 0x1p+0)) (f64.const 0x1p+0)) +(assert_return (invoke "mul" (f64.const -0x1p+0) (f64.const -0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p+2)) +(assert_return (invoke "mul" (f64.const -0x1p+0) (f64.const 0x1.921fb54442d18p+2)) (f64.const -0x1.921fb54442d18p+2)) +(assert_return (invoke "mul" (f64.const 0x1p+0) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.921fb54442d18p+2)) +(assert_return (invoke "mul" (f64.const 0x1p+0) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p+2)) +(assert_return (invoke "mul" (f64.const -0x1p+0) (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023)) +(assert_return (invoke "mul" (f64.const -0x1p+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023)) +(assert_return (invoke "mul" (f64.const 0x1p+0) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023)) +(assert_return (invoke "mul" (f64.const 0x1p+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023)) +(assert_return (invoke "mul" (f64.const -0x1p+0) (f64.const -inf)) (f64.const inf)) +(assert_return (invoke "mul" (f64.const -0x1p+0) (f64.const inf)) (f64.const -inf)) +(assert_return (invoke "mul" (f64.const 0x1p+0) (f64.const -inf)) (f64.const -inf)) +(assert_return (invoke "mul" (f64.const 0x1p+0) (f64.const inf)) (f64.const inf)) +(assert_return (invoke "mul" (f64.const -0x1p+0) (f64.const -nan)) (f64.const nan:canonical)) +(assert_return (invoke "mul" (f64.const -0x1p+0) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "mul" (f64.const -0x1p+0) (f64.const nan)) (f64.const nan:canonical)) +(assert_return (invoke "mul" (f64.const -0x1p+0) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "mul" (f64.const 0x1p+0) (f64.const -nan)) (f64.const nan:canonical)) +(assert_return (invoke "mul" (f64.const 0x1p+0) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "mul" (f64.const 0x1p+0) (f64.const nan)) (f64.const nan:canonical)) +(assert_return (invoke "mul" (f64.const 0x1p+0) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "mul" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x0p+0)) (f64.const 0x0p+0)) +(assert_return (invoke "mul" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x0p+0)) (f64.const -0x0p+0)) +(assert_return (invoke "mul" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x0p+0)) (f64.const -0x0p+0)) +(assert_return (invoke "mul" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x0p+0)) (f64.const 0x0p+0)) +(assert_return (invoke "mul" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x0.0000000000001p-1022)) (f64.const 0x0.0000000000006p-1022)) +(assert_return (invoke "mul" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x0.0000000000001p-1022)) (f64.const -0x0.0000000000006p-1022)) +(assert_return (invoke "mul" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x0.0000000000006p-1022)) +(assert_return (invoke "mul" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x0.0000000000006p-1022)) +(assert_return (invoke "mul" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1p-1022)) (f64.const 0x1.921fb54442d18p-1020)) +(assert_return (invoke "mul" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1p-1022)) (f64.const -0x1.921fb54442d18p-1020)) +(assert_return (invoke "mul" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1p-1022)) (f64.const -0x1.921fb54442d18p-1020)) +(assert_return (invoke "mul" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1p-1022)) (f64.const 0x1.921fb54442d18p-1020)) +(assert_return (invoke "mul" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1p-1)) (f64.const 0x1.921fb54442d18p+1)) +(assert_return (invoke "mul" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1p-1)) (f64.const -0x1.921fb54442d18p+1)) +(assert_return (invoke "mul" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1p-1)) (f64.const -0x1.921fb54442d18p+1)) +(assert_return (invoke "mul" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1p-1)) (f64.const 0x1.921fb54442d18p+1)) +(assert_return (invoke "mul" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1p+0)) (f64.const 0x1.921fb54442d18p+2)) +(assert_return (invoke "mul" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1p+0)) (f64.const -0x1.921fb54442d18p+2)) +(assert_return (invoke "mul" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1p+0)) (f64.const -0x1.921fb54442d18p+2)) +(assert_return (invoke "mul" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1p+0)) (f64.const 0x1.921fb54442d18p+2)) +(assert_return (invoke "mul" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1.921fb54442d18p+2)) (f64.const 0x1.3bd3cc9be45dep+5)) +(assert_return (invoke "mul" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1.921fb54442d18p+2)) (f64.const -0x1.3bd3cc9be45dep+5)) +(assert_return (invoke "mul" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.3bd3cc9be45dep+5)) +(assert_return (invoke "mul" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.3bd3cc9be45dep+5)) +(assert_return (invoke "mul" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1.fffffffffffffp+1023)) (f64.const inf)) +(assert_return (invoke "mul" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -inf)) +(assert_return (invoke "mul" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -inf)) +(assert_return (invoke "mul" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1.fffffffffffffp+1023)) (f64.const inf)) +(assert_return (invoke "mul" (f64.const -0x1.921fb54442d18p+2) (f64.const -inf)) (f64.const inf)) +(assert_return (invoke "mul" (f64.const -0x1.921fb54442d18p+2) (f64.const inf)) (f64.const -inf)) +(assert_return (invoke "mul" (f64.const 0x1.921fb54442d18p+2) (f64.const -inf)) (f64.const -inf)) +(assert_return (invoke "mul" (f64.const 0x1.921fb54442d18p+2) (f64.const inf)) (f64.const inf)) +(assert_return (invoke "mul" (f64.const -0x1.921fb54442d18p+2) (f64.const -nan)) (f64.const nan:canonical)) +(assert_return (invoke "mul" (f64.const -0x1.921fb54442d18p+2) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "mul" (f64.const -0x1.921fb54442d18p+2) (f64.const nan)) (f64.const nan:canonical)) +(assert_return (invoke "mul" (f64.const -0x1.921fb54442d18p+2) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "mul" (f64.const 0x1.921fb54442d18p+2) (f64.const -nan)) (f64.const nan:canonical)) +(assert_return (invoke "mul" (f64.const 0x1.921fb54442d18p+2) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "mul" (f64.const 0x1.921fb54442d18p+2) (f64.const nan)) (f64.const nan:canonical)) +(assert_return (invoke "mul" (f64.const 0x1.921fb54442d18p+2) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "mul" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x0p+0)) (f64.const 0x0p+0)) +(assert_return (invoke "mul" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x0p+0)) (f64.const -0x0p+0)) +(assert_return (invoke "mul" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x0p+0)) (f64.const -0x0p+0)) +(assert_return (invoke "mul" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x0p+0)) (f64.const 0x0p+0)) +(assert_return (invoke "mul" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x0.0000000000001p-1022)) (f64.const 0x1.fffffffffffffp-51)) +(assert_return (invoke "mul" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x0.0000000000001p-1022)) (f64.const -0x1.fffffffffffffp-51)) +(assert_return (invoke "mul" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x1.fffffffffffffp-51)) +(assert_return (invoke "mul" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x1.fffffffffffffp-51)) +(assert_return (invoke "mul" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1p-1022)) (f64.const 0x1.fffffffffffffp+1)) +(assert_return (invoke "mul" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1p-1022)) (f64.const -0x1.fffffffffffffp+1)) +(assert_return (invoke "mul" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1p-1022)) (f64.const -0x1.fffffffffffffp+1)) +(assert_return (invoke "mul" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1p-1022)) (f64.const 0x1.fffffffffffffp+1)) +(assert_return (invoke "mul" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1p-1)) (f64.const 0x1.fffffffffffffp+1022)) +(assert_return (invoke "mul" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1p-1)) (f64.const -0x1.fffffffffffffp+1022)) +(assert_return (invoke "mul" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1p-1)) (f64.const -0x1.fffffffffffffp+1022)) +(assert_return (invoke "mul" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1p-1)) (f64.const 0x1.fffffffffffffp+1022)) +(assert_return (invoke "mul" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1p+0)) (f64.const 0x1.fffffffffffffp+1023)) +(assert_return (invoke "mul" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1p+0)) (f64.const -0x1.fffffffffffffp+1023)) +(assert_return (invoke "mul" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1p+0)) (f64.const -0x1.fffffffffffffp+1023)) +(assert_return (invoke "mul" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1p+0)) (f64.const 0x1.fffffffffffffp+1023)) +(assert_return (invoke "mul" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1.921fb54442d18p+2)) (f64.const inf)) +(assert_return (invoke "mul" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1.921fb54442d18p+2)) (f64.const -inf)) +(assert_return (invoke "mul" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1.921fb54442d18p+2)) (f64.const -inf)) +(assert_return (invoke "mul" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1.921fb54442d18p+2)) (f64.const inf)) +(assert_return (invoke "mul" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1.fffffffffffffp+1023)) (f64.const inf)) +(assert_return (invoke "mul" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -inf)) +(assert_return (invoke "mul" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -inf)) +(assert_return (invoke "mul" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1.fffffffffffffp+1023)) (f64.const inf)) +(assert_return (invoke "mul" (f64.const -0x1.fffffffffffffp+1023) (f64.const -inf)) (f64.const inf)) +(assert_return (invoke "mul" (f64.const -0x1.fffffffffffffp+1023) (f64.const inf)) (f64.const -inf)) +(assert_return (invoke "mul" (f64.const 0x1.fffffffffffffp+1023) (f64.const -inf)) (f64.const -inf)) +(assert_return (invoke "mul" (f64.const 0x1.fffffffffffffp+1023) (f64.const inf)) (f64.const inf)) +(assert_return (invoke "mul" (f64.const -0x1.fffffffffffffp+1023) (f64.const -nan)) (f64.const nan:canonical)) +(assert_return (invoke "mul" (f64.const -0x1.fffffffffffffp+1023) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "mul" (f64.const -0x1.fffffffffffffp+1023) (f64.const nan)) (f64.const nan:canonical)) +(assert_return (invoke "mul" (f64.const -0x1.fffffffffffffp+1023) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "mul" (f64.const 0x1.fffffffffffffp+1023) (f64.const -nan)) (f64.const nan:canonical)) +(assert_return (invoke "mul" (f64.const 0x1.fffffffffffffp+1023) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "mul" (f64.const 0x1.fffffffffffffp+1023) (f64.const nan)) (f64.const nan:canonical)) +(assert_return (invoke "mul" (f64.const 0x1.fffffffffffffp+1023) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "mul" (f64.const -inf) (f64.const -0x0p+0)) (f64.const nan:canonical)) +(assert_return (invoke "mul" (f64.const -inf) (f64.const 0x0p+0)) (f64.const nan:canonical)) +(assert_return (invoke "mul" (f64.const inf) (f64.const -0x0p+0)) (f64.const nan:canonical)) +(assert_return (invoke "mul" (f64.const inf) (f64.const 0x0p+0)) (f64.const nan:canonical)) +(assert_return (invoke "mul" (f64.const -inf) (f64.const -0x0.0000000000001p-1022)) (f64.const inf)) +(assert_return (invoke "mul" (f64.const -inf) (f64.const 0x0.0000000000001p-1022)) (f64.const -inf)) +(assert_return (invoke "mul" (f64.const inf) (f64.const -0x0.0000000000001p-1022)) (f64.const -inf)) +(assert_return (invoke "mul" (f64.const inf) (f64.const 0x0.0000000000001p-1022)) (f64.const inf)) +(assert_return (invoke "mul" (f64.const -inf) (f64.const -0x1p-1022)) (f64.const inf)) +(assert_return (invoke "mul" (f64.const -inf) (f64.const 0x1p-1022)) (f64.const -inf)) +(assert_return (invoke "mul" (f64.const inf) (f64.const -0x1p-1022)) (f64.const -inf)) +(assert_return (invoke "mul" (f64.const inf) (f64.const 0x1p-1022)) (f64.const inf)) +(assert_return (invoke "mul" (f64.const -inf) (f64.const -0x1p-1)) (f64.const inf)) +(assert_return (invoke "mul" (f64.const -inf) (f64.const 0x1p-1)) (f64.const -inf)) +(assert_return (invoke "mul" (f64.const inf) (f64.const -0x1p-1)) (f64.const -inf)) +(assert_return (invoke "mul" (f64.const inf) (f64.const 0x1p-1)) (f64.const inf)) +(assert_return (invoke "mul" (f64.const -inf) (f64.const -0x1p+0)) (f64.const inf)) +(assert_return (invoke "mul" (f64.const -inf) (f64.const 0x1p+0)) (f64.const -inf)) +(assert_return (invoke "mul" (f64.const inf) (f64.const -0x1p+0)) (f64.const -inf)) +(assert_return (invoke "mul" (f64.const inf) (f64.const 0x1p+0)) (f64.const inf)) +(assert_return (invoke "mul" (f64.const -inf) (f64.const -0x1.921fb54442d18p+2)) (f64.const inf)) +(assert_return (invoke "mul" (f64.const -inf) (f64.const 0x1.921fb54442d18p+2)) (f64.const -inf)) +(assert_return (invoke "mul" (f64.const inf) (f64.const -0x1.921fb54442d18p+2)) (f64.const -inf)) +(assert_return (invoke "mul" (f64.const inf) (f64.const 0x1.921fb54442d18p+2)) (f64.const inf)) +(assert_return (invoke "mul" (f64.const -inf) (f64.const -0x1.fffffffffffffp+1023)) (f64.const inf)) +(assert_return (invoke "mul" (f64.const -inf) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -inf)) +(assert_return (invoke "mul" (f64.const inf) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -inf)) +(assert_return (invoke "mul" (f64.const inf) (f64.const 0x1.fffffffffffffp+1023)) (f64.const inf)) +(assert_return (invoke "mul" (f64.const -inf) (f64.const -inf)) (f64.const inf)) +(assert_return (invoke "mul" (f64.const -inf) (f64.const inf)) (f64.const -inf)) +(assert_return (invoke "mul" (f64.const inf) (f64.const -inf)) (f64.const -inf)) +(assert_return (invoke "mul" (f64.const inf) (f64.const inf)) (f64.const inf)) +(assert_return (invoke "mul" (f64.const -inf) (f64.const -nan)) (f64.const nan:canonical)) +(assert_return (invoke "mul" (f64.const -inf) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "mul" (f64.const -inf) (f64.const nan)) (f64.const nan:canonical)) +(assert_return (invoke "mul" (f64.const -inf) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "mul" (f64.const inf) (f64.const -nan)) (f64.const nan:canonical)) +(assert_return (invoke "mul" (f64.const inf) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "mul" (f64.const inf) (f64.const nan)) (f64.const nan:canonical)) +(assert_return (invoke "mul" (f64.const inf) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "mul" (f64.const -nan) (f64.const -0x0p+0)) (f64.const nan:canonical)) +(assert_return (invoke "mul" (f64.const -nan:0x4000000000000) (f64.const -0x0p+0)) (f64.const nan:arithmetic)) +(assert_return (invoke "mul" (f64.const -nan) (f64.const 0x0p+0)) (f64.const nan:canonical)) +(assert_return (invoke "mul" (f64.const -nan:0x4000000000000) (f64.const 0x0p+0)) (f64.const nan:arithmetic)) +(assert_return (invoke "mul" (f64.const nan) (f64.const -0x0p+0)) (f64.const nan:canonical)) +(assert_return (invoke "mul" (f64.const nan:0x4000000000000) (f64.const -0x0p+0)) (f64.const nan:arithmetic)) +(assert_return (invoke "mul" (f64.const nan) (f64.const 0x0p+0)) (f64.const nan:canonical)) +(assert_return (invoke "mul" (f64.const nan:0x4000000000000) (f64.const 0x0p+0)) (f64.const nan:arithmetic)) +(assert_return (invoke "mul" (f64.const -nan) (f64.const -0x0.0000000000001p-1022)) (f64.const nan:canonical)) +(assert_return (invoke "mul" (f64.const -nan:0x4000000000000) (f64.const -0x0.0000000000001p-1022)) (f64.const nan:arithmetic)) +(assert_return (invoke "mul" (f64.const -nan) (f64.const 0x0.0000000000001p-1022)) (f64.const nan:canonical)) +(assert_return (invoke "mul" (f64.const -nan:0x4000000000000) (f64.const 0x0.0000000000001p-1022)) (f64.const nan:arithmetic)) +(assert_return (invoke "mul" (f64.const nan) (f64.const -0x0.0000000000001p-1022)) (f64.const nan:canonical)) +(assert_return (invoke "mul" (f64.const nan:0x4000000000000) (f64.const -0x0.0000000000001p-1022)) (f64.const nan:arithmetic)) +(assert_return (invoke "mul" (f64.const nan) (f64.const 0x0.0000000000001p-1022)) (f64.const nan:canonical)) +(assert_return (invoke "mul" (f64.const nan:0x4000000000000) (f64.const 0x0.0000000000001p-1022)) (f64.const nan:arithmetic)) +(assert_return (invoke "mul" (f64.const -nan) (f64.const -0x1p-1022)) (f64.const nan:canonical)) +(assert_return (invoke "mul" (f64.const -nan:0x4000000000000) (f64.const -0x1p-1022)) (f64.const nan:arithmetic)) +(assert_return (invoke "mul" (f64.const -nan) (f64.const 0x1p-1022)) (f64.const nan:canonical)) +(assert_return (invoke "mul" (f64.const -nan:0x4000000000000) (f64.const 0x1p-1022)) (f64.const nan:arithmetic)) +(assert_return (invoke "mul" (f64.const nan) (f64.const -0x1p-1022)) (f64.const nan:canonical)) +(assert_return (invoke "mul" (f64.const nan:0x4000000000000) (f64.const -0x1p-1022)) (f64.const nan:arithmetic)) +(assert_return (invoke "mul" (f64.const nan) (f64.const 0x1p-1022)) (f64.const nan:canonical)) +(assert_return (invoke "mul" (f64.const nan:0x4000000000000) (f64.const 0x1p-1022)) (f64.const nan:arithmetic)) +(assert_return (invoke "mul" (f64.const -nan) (f64.const -0x1p-1)) (f64.const nan:canonical)) +(assert_return (invoke "mul" (f64.const -nan:0x4000000000000) (f64.const -0x1p-1)) (f64.const nan:arithmetic)) +(assert_return (invoke "mul" (f64.const -nan) (f64.const 0x1p-1)) (f64.const nan:canonical)) +(assert_return (invoke "mul" (f64.const -nan:0x4000000000000) (f64.const 0x1p-1)) (f64.const nan:arithmetic)) +(assert_return (invoke "mul" (f64.const nan) (f64.const -0x1p-1)) (f64.const nan:canonical)) +(assert_return (invoke "mul" (f64.const nan:0x4000000000000) (f64.const -0x1p-1)) (f64.const nan:arithmetic)) +(assert_return (invoke "mul" (f64.const nan) (f64.const 0x1p-1)) (f64.const nan:canonical)) +(assert_return (invoke "mul" (f64.const nan:0x4000000000000) (f64.const 0x1p-1)) (f64.const nan:arithmetic)) +(assert_return (invoke "mul" (f64.const -nan) (f64.const -0x1p+0)) (f64.const nan:canonical)) +(assert_return (invoke "mul" (f64.const -nan:0x4000000000000) (f64.const -0x1p+0)) (f64.const nan:arithmetic)) +(assert_return (invoke "mul" (f64.const -nan) (f64.const 0x1p+0)) (f64.const nan:canonical)) +(assert_return (invoke "mul" (f64.const -nan:0x4000000000000) (f64.const 0x1p+0)) (f64.const nan:arithmetic)) +(assert_return (invoke "mul" (f64.const nan) (f64.const -0x1p+0)) (f64.const nan:canonical)) +(assert_return (invoke "mul" (f64.const nan:0x4000000000000) (f64.const -0x1p+0)) (f64.const nan:arithmetic)) +(assert_return (invoke "mul" (f64.const nan) (f64.const 0x1p+0)) (f64.const nan:canonical)) +(assert_return (invoke "mul" (f64.const nan:0x4000000000000) (f64.const 0x1p+0)) (f64.const nan:arithmetic)) +(assert_return (invoke "mul" (f64.const -nan) (f64.const -0x1.921fb54442d18p+2)) (f64.const nan:canonical)) +(assert_return (invoke "mul" (f64.const -nan:0x4000000000000) (f64.const -0x1.921fb54442d18p+2)) (f64.const nan:arithmetic)) +(assert_return (invoke "mul" (f64.const -nan) (f64.const 0x1.921fb54442d18p+2)) (f64.const nan:canonical)) +(assert_return (invoke "mul" (f64.const -nan:0x4000000000000) (f64.const 0x1.921fb54442d18p+2)) (f64.const nan:arithmetic)) +(assert_return (invoke "mul" (f64.const nan) (f64.const -0x1.921fb54442d18p+2)) (f64.const nan:canonical)) +(assert_return (invoke "mul" (f64.const nan:0x4000000000000) (f64.const -0x1.921fb54442d18p+2)) (f64.const nan:arithmetic)) +(assert_return (invoke "mul" (f64.const nan) (f64.const 0x1.921fb54442d18p+2)) (f64.const nan:canonical)) +(assert_return (invoke "mul" (f64.const nan:0x4000000000000) (f64.const 0x1.921fb54442d18p+2)) (f64.const nan:arithmetic)) +(assert_return (invoke "mul" (f64.const -nan) (f64.const -0x1.fffffffffffffp+1023)) (f64.const nan:canonical)) +(assert_return (invoke "mul" (f64.const -nan:0x4000000000000) (f64.const -0x1.fffffffffffffp+1023)) (f64.const nan:arithmetic)) +(assert_return (invoke "mul" (f64.const -nan) (f64.const 0x1.fffffffffffffp+1023)) (f64.const nan:canonical)) +(assert_return (invoke "mul" (f64.const -nan:0x4000000000000) (f64.const 0x1.fffffffffffffp+1023)) (f64.const nan:arithmetic)) +(assert_return (invoke "mul" (f64.const nan) (f64.const -0x1.fffffffffffffp+1023)) (f64.const nan:canonical)) +(assert_return (invoke "mul" (f64.const nan:0x4000000000000) (f64.const -0x1.fffffffffffffp+1023)) (f64.const nan:arithmetic)) +(assert_return (invoke "mul" (f64.const nan) (f64.const 0x1.fffffffffffffp+1023)) (f64.const nan:canonical)) +(assert_return (invoke "mul" (f64.const nan:0x4000000000000) (f64.const 0x1.fffffffffffffp+1023)) (f64.const nan:arithmetic)) +(assert_return (invoke "mul" (f64.const -nan) (f64.const -inf)) (f64.const nan:canonical)) +(assert_return (invoke "mul" (f64.const -nan:0x4000000000000) (f64.const -inf)) (f64.const nan:arithmetic)) +(assert_return (invoke "mul" (f64.const -nan) (f64.const inf)) (f64.const nan:canonical)) +(assert_return (invoke "mul" (f64.const -nan:0x4000000000000) (f64.const inf)) (f64.const nan:arithmetic)) +(assert_return (invoke "mul" (f64.const nan) (f64.const -inf)) (f64.const nan:canonical)) +(assert_return (invoke "mul" (f64.const nan:0x4000000000000) (f64.const -inf)) (f64.const nan:arithmetic)) +(assert_return (invoke "mul" (f64.const nan) (f64.const inf)) (f64.const nan:canonical)) +(assert_return (invoke "mul" (f64.const nan:0x4000000000000) (f64.const inf)) (f64.const nan:arithmetic)) +(assert_return (invoke "mul" (f64.const -nan) (f64.const -nan)) (f64.const nan:canonical)) +(assert_return (invoke "mul" (f64.const -nan:0x4000000000000) (f64.const -nan)) (f64.const nan:arithmetic)) +(assert_return (invoke "mul" (f64.const -nan) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "mul" (f64.const -nan:0x4000000000000) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "mul" (f64.const -nan) (f64.const nan)) (f64.const nan:canonical)) +(assert_return (invoke "mul" (f64.const -nan:0x4000000000000) (f64.const nan)) (f64.const nan:arithmetic)) +(assert_return (invoke "mul" (f64.const -nan) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "mul" (f64.const -nan:0x4000000000000) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "mul" (f64.const nan) (f64.const -nan)) (f64.const nan:canonical)) +(assert_return (invoke "mul" (f64.const nan:0x4000000000000) (f64.const -nan)) (f64.const nan:arithmetic)) +(assert_return (invoke "mul" (f64.const nan) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "mul" (f64.const nan:0x4000000000000) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "mul" (f64.const nan) (f64.const nan)) (f64.const nan:canonical)) +(assert_return (invoke "mul" (f64.const nan:0x4000000000000) (f64.const nan)) (f64.const nan:arithmetic)) +(assert_return (invoke "mul" (f64.const nan) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "mul" (f64.const nan:0x4000000000000) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "div" (f64.const -0x0p+0) (f64.const -0x0p+0)) (f64.const nan:canonical)) +(assert_return (invoke "div" (f64.const -0x0p+0) (f64.const 0x0p+0)) (f64.const nan:canonical)) +(assert_return (invoke "div" (f64.const 0x0p+0) (f64.const -0x0p+0)) (f64.const nan:canonical)) +(assert_return (invoke "div" (f64.const 0x0p+0) (f64.const 0x0p+0)) (f64.const nan:canonical)) +(assert_return (invoke "div" (f64.const -0x0p+0) (f64.const -0x0.0000000000001p-1022)) (f64.const 0x0p+0)) +(assert_return (invoke "div" (f64.const -0x0p+0) (f64.const 0x0.0000000000001p-1022)) (f64.const -0x0p+0)) +(assert_return (invoke "div" (f64.const 0x0p+0) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x0p+0)) +(assert_return (invoke "div" (f64.const 0x0p+0) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x0p+0)) +(assert_return (invoke "div" (f64.const -0x0p+0) (f64.const -0x1p-1022)) (f64.const 0x0p+0)) +(assert_return (invoke "div" (f64.const -0x0p+0) (f64.const 0x1p-1022)) (f64.const -0x0p+0)) +(assert_return (invoke "div" (f64.const 0x0p+0) (f64.const -0x1p-1022)) (f64.const -0x0p+0)) +(assert_return (invoke "div" (f64.const 0x0p+0) (f64.const 0x1p-1022)) (f64.const 0x0p+0)) +(assert_return (invoke "div" (f64.const -0x0p+0) (f64.const -0x1p-1)) (f64.const 0x0p+0)) +(assert_return (invoke "div" (f64.const -0x0p+0) (f64.const 0x1p-1)) (f64.const -0x0p+0)) +(assert_return (invoke "div" (f64.const 0x0p+0) (f64.const -0x1p-1)) (f64.const -0x0p+0)) +(assert_return (invoke "div" (f64.const 0x0p+0) (f64.const 0x1p-1)) (f64.const 0x0p+0)) +(assert_return (invoke "div" (f64.const -0x0p+0) (f64.const -0x1p+0)) (f64.const 0x0p+0)) +(assert_return (invoke "div" (f64.const -0x0p+0) (f64.const 0x1p+0)) (f64.const -0x0p+0)) +(assert_return (invoke "div" (f64.const 0x0p+0) (f64.const -0x1p+0)) (f64.const -0x0p+0)) +(assert_return (invoke "div" (f64.const 0x0p+0) (f64.const 0x1p+0)) (f64.const 0x0p+0)) +(assert_return (invoke "div" (f64.const -0x0p+0) (f64.const -0x1.921fb54442d18p+2)) (f64.const 0x0p+0)) +(assert_return (invoke "div" (f64.const -0x0p+0) (f64.const 0x1.921fb54442d18p+2)) (f64.const -0x0p+0)) +(assert_return (invoke "div" (f64.const 0x0p+0) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x0p+0)) +(assert_return (invoke "div" (f64.const 0x0p+0) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x0p+0)) +(assert_return (invoke "div" (f64.const -0x0p+0) (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x0p+0)) +(assert_return (invoke "div" (f64.const -0x0p+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x0p+0)) +(assert_return (invoke "div" (f64.const 0x0p+0) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x0p+0)) +(assert_return (invoke "div" (f64.const 0x0p+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x0p+0)) +(assert_return (invoke "div" (f64.const -0x0p+0) (f64.const -inf)) (f64.const 0x0p+0)) +(assert_return (invoke "div" (f64.const -0x0p+0) (f64.const inf)) (f64.const -0x0p+0)) +(assert_return (invoke "div" (f64.const 0x0p+0) (f64.const -inf)) (f64.const -0x0p+0)) +(assert_return (invoke "div" (f64.const 0x0p+0) (f64.const inf)) (f64.const 0x0p+0)) +(assert_return (invoke "div" (f64.const -0x0p+0) (f64.const -nan)) (f64.const nan:canonical)) +(assert_return (invoke "div" (f64.const -0x0p+0) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "div" (f64.const -0x0p+0) (f64.const nan)) (f64.const nan:canonical)) +(assert_return (invoke "div" (f64.const -0x0p+0) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "div" (f64.const 0x0p+0) (f64.const -nan)) (f64.const nan:canonical)) +(assert_return (invoke "div" (f64.const 0x0p+0) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "div" (f64.const 0x0p+0) (f64.const nan)) (f64.const nan:canonical)) +(assert_return (invoke "div" (f64.const 0x0p+0) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "div" (f64.const -0x0.0000000000001p-1022) (f64.const -0x0p+0)) (f64.const inf)) +(assert_return (invoke "div" (f64.const -0x0.0000000000001p-1022) (f64.const 0x0p+0)) (f64.const -inf)) +(assert_return (invoke "div" (f64.const 0x0.0000000000001p-1022) (f64.const -0x0p+0)) (f64.const -inf)) +(assert_return (invoke "div" (f64.const 0x0.0000000000001p-1022) (f64.const 0x0p+0)) (f64.const inf)) +(assert_return (invoke "div" (f64.const -0x0.0000000000001p-1022) (f64.const -0x0.0000000000001p-1022)) (f64.const 0x1p+0)) +(assert_return (invoke "div" (f64.const -0x0.0000000000001p-1022) (f64.const 0x0.0000000000001p-1022)) (f64.const -0x1p+0)) +(assert_return (invoke "div" (f64.const 0x0.0000000000001p-1022) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x1p+0)) +(assert_return (invoke "div" (f64.const 0x0.0000000000001p-1022) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x1p+0)) +(assert_return (invoke "div" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1p-1022)) (f64.const 0x1p-52)) +(assert_return (invoke "div" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1p-1022)) (f64.const -0x1p-52)) +(assert_return (invoke "div" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1p-1022)) (f64.const -0x1p-52)) +(assert_return (invoke "div" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1p-1022)) (f64.const 0x1p-52)) +(assert_return (invoke "div" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1p-1)) (f64.const 0x0.0000000000002p-1022)) +(assert_return (invoke "div" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1p-1)) (f64.const -0x0.0000000000002p-1022)) +(assert_return (invoke "div" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1p-1)) (f64.const -0x0.0000000000002p-1022)) +(assert_return (invoke "div" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1p-1)) (f64.const 0x0.0000000000002p-1022)) +(assert_return (invoke "div" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1p+0)) (f64.const 0x0.0000000000001p-1022)) +(assert_return (invoke "div" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1p+0)) (f64.const -0x0.0000000000001p-1022)) +(assert_return (invoke "div" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1p+0)) (f64.const -0x0.0000000000001p-1022)) +(assert_return (invoke "div" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1p+0)) (f64.const 0x0.0000000000001p-1022)) +(assert_return (invoke "div" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1.921fb54442d18p+2)) (f64.const 0x0p+0)) +(assert_return (invoke "div" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1.921fb54442d18p+2)) (f64.const -0x0p+0)) +(assert_return (invoke "div" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x0p+0)) +(assert_return (invoke "div" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x0p+0)) +(assert_return (invoke "div" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x0p+0)) +(assert_return (invoke "div" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x0p+0)) +(assert_return (invoke "div" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x0p+0)) +(assert_return (invoke "div" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x0p+0)) +(assert_return (invoke "div" (f64.const -0x0.0000000000001p-1022) (f64.const -inf)) (f64.const 0x0p+0)) +(assert_return (invoke "div" (f64.const -0x0.0000000000001p-1022) (f64.const inf)) (f64.const -0x0p+0)) +(assert_return (invoke "div" (f64.const 0x0.0000000000001p-1022) (f64.const -inf)) (f64.const -0x0p+0)) +(assert_return (invoke "div" (f64.const 0x0.0000000000001p-1022) (f64.const inf)) (f64.const 0x0p+0)) +(assert_return (invoke "div" (f64.const -0x0.0000000000001p-1022) (f64.const -nan)) (f64.const nan:canonical)) +(assert_return (invoke "div" (f64.const -0x0.0000000000001p-1022) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "div" (f64.const -0x0.0000000000001p-1022) (f64.const nan)) (f64.const nan:canonical)) +(assert_return (invoke "div" (f64.const -0x0.0000000000001p-1022) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "div" (f64.const 0x0.0000000000001p-1022) (f64.const -nan)) (f64.const nan:canonical)) +(assert_return (invoke "div" (f64.const 0x0.0000000000001p-1022) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "div" (f64.const 0x0.0000000000001p-1022) (f64.const nan)) (f64.const nan:canonical)) +(assert_return (invoke "div" (f64.const 0x0.0000000000001p-1022) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "div" (f64.const -0x1p-1022) (f64.const -0x0p+0)) (f64.const inf)) +(assert_return (invoke "div" (f64.const -0x1p-1022) (f64.const 0x0p+0)) (f64.const -inf)) +(assert_return (invoke "div" (f64.const 0x1p-1022) (f64.const -0x0p+0)) (f64.const -inf)) +(assert_return (invoke "div" (f64.const 0x1p-1022) (f64.const 0x0p+0)) (f64.const inf)) +(assert_return (invoke "div" (f64.const -0x1p-1022) (f64.const -0x0.0000000000001p-1022)) (f64.const 0x1p+52)) +(assert_return (invoke "div" (f64.const -0x1p-1022) (f64.const 0x0.0000000000001p-1022)) (f64.const -0x1p+52)) +(assert_return (invoke "div" (f64.const 0x1p-1022) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x1p+52)) +(assert_return (invoke "div" (f64.const 0x1p-1022) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x1p+52)) +(assert_return (invoke "div" (f64.const -0x1p-1022) (f64.const -0x1p-1022)) (f64.const 0x1p+0)) +(assert_return (invoke "div" (f64.const -0x1p-1022) (f64.const 0x1p-1022)) (f64.const -0x1p+0)) +(assert_return (invoke "div" (f64.const 0x1p-1022) (f64.const -0x1p-1022)) (f64.const -0x1p+0)) +(assert_return (invoke "div" (f64.const 0x1p-1022) (f64.const 0x1p-1022)) (f64.const 0x1p+0)) +(assert_return (invoke "div" (f64.const -0x1p-1022) (f64.const -0x1p-1)) (f64.const 0x1p-1021)) +(assert_return (invoke "div" (f64.const -0x1p-1022) (f64.const 0x1p-1)) (f64.const -0x1p-1021)) +(assert_return (invoke "div" (f64.const 0x1p-1022) (f64.const -0x1p-1)) (f64.const -0x1p-1021)) +(assert_return (invoke "div" (f64.const 0x1p-1022) (f64.const 0x1p-1)) (f64.const 0x1p-1021)) +(assert_return (invoke "div" (f64.const -0x1p-1022) (f64.const -0x1p+0)) (f64.const 0x1p-1022)) +(assert_return (invoke "div" (f64.const -0x1p-1022) (f64.const 0x1p+0)) (f64.const -0x1p-1022)) +(assert_return (invoke "div" (f64.const 0x1p-1022) (f64.const -0x1p+0)) (f64.const -0x1p-1022)) +(assert_return (invoke "div" (f64.const 0x1p-1022) (f64.const 0x1p+0)) (f64.const 0x1p-1022)) +(assert_return (invoke "div" (f64.const -0x1p-1022) (f64.const -0x1.921fb54442d18p+2)) (f64.const 0x0.28be60db9391p-1022)) +(assert_return (invoke "div" (f64.const -0x1p-1022) (f64.const 0x1.921fb54442d18p+2)) (f64.const -0x0.28be60db9391p-1022)) +(assert_return (invoke "div" (f64.const 0x1p-1022) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x0.28be60db9391p-1022)) +(assert_return (invoke "div" (f64.const 0x1p-1022) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x0.28be60db9391p-1022)) +(assert_return (invoke "div" (f64.const -0x1p-1022) (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x0p+0)) +(assert_return (invoke "div" (f64.const -0x1p-1022) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x0p+0)) +(assert_return (invoke "div" (f64.const 0x1p-1022) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x0p+0)) +(assert_return (invoke "div" (f64.const 0x1p-1022) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x0p+0)) +(assert_return (invoke "div" (f64.const -0x1p-1022) (f64.const -inf)) (f64.const 0x0p+0)) +(assert_return (invoke "div" (f64.const -0x1p-1022) (f64.const inf)) (f64.const -0x0p+0)) +(assert_return (invoke "div" (f64.const 0x1p-1022) (f64.const -inf)) (f64.const -0x0p+0)) +(assert_return (invoke "div" (f64.const 0x1p-1022) (f64.const inf)) (f64.const 0x0p+0)) +(assert_return (invoke "div" (f64.const -0x1p-1022) (f64.const -nan)) (f64.const nan:canonical)) +(assert_return (invoke "div" (f64.const -0x1p-1022) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "div" (f64.const -0x1p-1022) (f64.const nan)) (f64.const nan:canonical)) +(assert_return (invoke "div" (f64.const -0x1p-1022) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "div" (f64.const 0x1p-1022) (f64.const -nan)) (f64.const nan:canonical)) +(assert_return (invoke "div" (f64.const 0x1p-1022) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "div" (f64.const 0x1p-1022) (f64.const nan)) (f64.const nan:canonical)) +(assert_return (invoke "div" (f64.const 0x1p-1022) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "div" (f64.const -0x1p-1) (f64.const -0x0p+0)) (f64.const inf)) +(assert_return (invoke "div" (f64.const -0x1p-1) (f64.const 0x0p+0)) (f64.const -inf)) +(assert_return (invoke "div" (f64.const 0x1p-1) (f64.const -0x0p+0)) (f64.const -inf)) +(assert_return (invoke "div" (f64.const 0x1p-1) (f64.const 0x0p+0)) (f64.const inf)) +(assert_return (invoke "div" (f64.const -0x1p-1) (f64.const -0x0.0000000000001p-1022)) (f64.const inf)) +(assert_return (invoke "div" (f64.const -0x1p-1) (f64.const 0x0.0000000000001p-1022)) (f64.const -inf)) +(assert_return (invoke "div" (f64.const 0x1p-1) (f64.const -0x0.0000000000001p-1022)) (f64.const -inf)) +(assert_return (invoke "div" (f64.const 0x1p-1) (f64.const 0x0.0000000000001p-1022)) (f64.const inf)) +(assert_return (invoke "div" (f64.const -0x1p-1) (f64.const -0x1p-1022)) (f64.const 0x1p+1021)) +(assert_return (invoke "div" (f64.const -0x1p-1) (f64.const 0x1p-1022)) (f64.const -0x1p+1021)) +(assert_return (invoke "div" (f64.const 0x1p-1) (f64.const -0x1p-1022)) (f64.const -0x1p+1021)) +(assert_return (invoke "div" (f64.const 0x1p-1) (f64.const 0x1p-1022)) (f64.const 0x1p+1021)) +(assert_return (invoke "div" (f64.const -0x1p-1) (f64.const -0x1p-1)) (f64.const 0x1p+0)) +(assert_return (invoke "div" (f64.const -0x1p-1) (f64.const 0x1p-1)) (f64.const -0x1p+0)) +(assert_return (invoke "div" (f64.const 0x1p-1) (f64.const -0x1p-1)) (f64.const -0x1p+0)) +(assert_return (invoke "div" (f64.const 0x1p-1) (f64.const 0x1p-1)) (f64.const 0x1p+0)) +(assert_return (invoke "div" (f64.const -0x1p-1) (f64.const -0x1p+0)) (f64.const 0x1p-1)) +(assert_return (invoke "div" (f64.const -0x1p-1) (f64.const 0x1p+0)) (f64.const -0x1p-1)) +(assert_return (invoke "div" (f64.const 0x1p-1) (f64.const -0x1p+0)) (f64.const -0x1p-1)) +(assert_return (invoke "div" (f64.const 0x1p-1) (f64.const 0x1p+0)) (f64.const 0x1p-1)) +(assert_return (invoke "div" (f64.const -0x1p-1) (f64.const -0x1.921fb54442d18p+2)) (f64.const 0x1.45f306dc9c883p-4)) +(assert_return (invoke "div" (f64.const -0x1p-1) (f64.const 0x1.921fb54442d18p+2)) (f64.const -0x1.45f306dc9c883p-4)) +(assert_return (invoke "div" (f64.const 0x1p-1) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.45f306dc9c883p-4)) +(assert_return (invoke "div" (f64.const 0x1p-1) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.45f306dc9c883p-4)) +(assert_return (invoke "div" (f64.const -0x1p-1) (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x0.2p-1022)) +(assert_return (invoke "div" (f64.const -0x1p-1) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x0.2p-1022)) +(assert_return (invoke "div" (f64.const 0x1p-1) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x0.2p-1022)) +(assert_return (invoke "div" (f64.const 0x1p-1) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x0.2p-1022)) +(assert_return (invoke "div" (f64.const -0x1p-1) (f64.const -inf)) (f64.const 0x0p+0)) +(assert_return (invoke "div" (f64.const -0x1p-1) (f64.const inf)) (f64.const -0x0p+0)) +(assert_return (invoke "div" (f64.const 0x1p-1) (f64.const -inf)) (f64.const -0x0p+0)) +(assert_return (invoke "div" (f64.const 0x1p-1) (f64.const inf)) (f64.const 0x0p+0)) +(assert_return (invoke "div" (f64.const -0x1p-1) (f64.const -nan)) (f64.const nan:canonical)) +(assert_return (invoke "div" (f64.const -0x1p-1) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "div" (f64.const -0x1p-1) (f64.const nan)) (f64.const nan:canonical)) +(assert_return (invoke "div" (f64.const -0x1p-1) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "div" (f64.const 0x1p-1) (f64.const -nan)) (f64.const nan:canonical)) +(assert_return (invoke "div" (f64.const 0x1p-1) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "div" (f64.const 0x1p-1) (f64.const nan)) (f64.const nan:canonical)) +(assert_return (invoke "div" (f64.const 0x1p-1) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "div" (f64.const -0x1p+0) (f64.const -0x0p+0)) (f64.const inf)) +(assert_return (invoke "div" (f64.const -0x1p+0) (f64.const 0x0p+0)) (f64.const -inf)) +(assert_return (invoke "div" (f64.const 0x1p+0) (f64.const -0x0p+0)) (f64.const -inf)) +(assert_return (invoke "div" (f64.const 0x1p+0) (f64.const 0x0p+0)) (f64.const inf)) +(assert_return (invoke "div" (f64.const -0x1p+0) (f64.const -0x0.0000000000001p-1022)) (f64.const inf)) +(assert_return (invoke "div" (f64.const -0x1p+0) (f64.const 0x0.0000000000001p-1022)) (f64.const -inf)) +(assert_return (invoke "div" (f64.const 0x1p+0) (f64.const -0x0.0000000000001p-1022)) (f64.const -inf)) +(assert_return (invoke "div" (f64.const 0x1p+0) (f64.const 0x0.0000000000001p-1022)) (f64.const inf)) +(assert_return (invoke "div" (f64.const -0x1p+0) (f64.const -0x1p-1022)) (f64.const 0x1p+1022)) +(assert_return (invoke "div" (f64.const -0x1p+0) (f64.const 0x1p-1022)) (f64.const -0x1p+1022)) +(assert_return (invoke "div" (f64.const 0x1p+0) (f64.const -0x1p-1022)) (f64.const -0x1p+1022)) +(assert_return (invoke "div" (f64.const 0x1p+0) (f64.const 0x1p-1022)) (f64.const 0x1p+1022)) +(assert_return (invoke "div" (f64.const -0x1p+0) (f64.const -0x1p-1)) (f64.const 0x1p+1)) +(assert_return (invoke "div" (f64.const -0x1p+0) (f64.const 0x1p-1)) (f64.const -0x1p+1)) +(assert_return (invoke "div" (f64.const 0x1p+0) (f64.const -0x1p-1)) (f64.const -0x1p+1)) +(assert_return (invoke "div" (f64.const 0x1p+0) (f64.const 0x1p-1)) (f64.const 0x1p+1)) +(assert_return (invoke "div" (f64.const -0x1p+0) (f64.const -0x1p+0)) (f64.const 0x1p+0)) +(assert_return (invoke "div" (f64.const -0x1p+0) (f64.const 0x1p+0)) (f64.const -0x1p+0)) +(assert_return (invoke "div" (f64.const 0x1p+0) (f64.const -0x1p+0)) (f64.const -0x1p+0)) +(assert_return (invoke "div" (f64.const 0x1p+0) (f64.const 0x1p+0)) (f64.const 0x1p+0)) +(assert_return (invoke "div" (f64.const -0x1p+0) (f64.const -0x1.921fb54442d18p+2)) (f64.const 0x1.45f306dc9c883p-3)) +(assert_return (invoke "div" (f64.const -0x1p+0) (f64.const 0x1.921fb54442d18p+2)) (f64.const -0x1.45f306dc9c883p-3)) +(assert_return (invoke "div" (f64.const 0x1p+0) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.45f306dc9c883p-3)) +(assert_return (invoke "div" (f64.const 0x1p+0) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.45f306dc9c883p-3)) +(assert_return (invoke "div" (f64.const -0x1p+0) (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x0.4p-1022)) +(assert_return (invoke "div" (f64.const -0x1p+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x0.4p-1022)) +(assert_return (invoke "div" (f64.const 0x1p+0) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x0.4p-1022)) +(assert_return (invoke "div" (f64.const 0x1p+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x0.4p-1022)) +(assert_return (invoke "div" (f64.const -0x1p+0) (f64.const -inf)) (f64.const 0x0p+0)) +(assert_return (invoke "div" (f64.const -0x1p+0) (f64.const inf)) (f64.const -0x0p+0)) +(assert_return (invoke "div" (f64.const 0x1p+0) (f64.const -inf)) (f64.const -0x0p+0)) +(assert_return (invoke "div" (f64.const 0x1p+0) (f64.const inf)) (f64.const 0x0p+0)) +(assert_return (invoke "div" (f64.const -0x1p+0) (f64.const -nan)) (f64.const nan:canonical)) +(assert_return (invoke "div" (f64.const -0x1p+0) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "div" (f64.const -0x1p+0) (f64.const nan)) (f64.const nan:canonical)) +(assert_return (invoke "div" (f64.const -0x1p+0) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "div" (f64.const 0x1p+0) (f64.const -nan)) (f64.const nan:canonical)) +(assert_return (invoke "div" (f64.const 0x1p+0) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "div" (f64.const 0x1p+0) (f64.const nan)) (f64.const nan:canonical)) +(assert_return (invoke "div" (f64.const 0x1p+0) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "div" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x0p+0)) (f64.const inf)) +(assert_return (invoke "div" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x0p+0)) (f64.const -inf)) +(assert_return (invoke "div" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x0p+0)) (f64.const -inf)) +(assert_return (invoke "div" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x0p+0)) (f64.const inf)) +(assert_return (invoke "div" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x0.0000000000001p-1022)) (f64.const inf)) +(assert_return (invoke "div" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x0.0000000000001p-1022)) (f64.const -inf)) +(assert_return (invoke "div" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x0.0000000000001p-1022)) (f64.const -inf)) +(assert_return (invoke "div" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x0.0000000000001p-1022)) (f64.const inf)) +(assert_return (invoke "div" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1p-1022)) (f64.const inf)) +(assert_return (invoke "div" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1p-1022)) (f64.const -inf)) +(assert_return (invoke "div" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1p-1022)) (f64.const -inf)) +(assert_return (invoke "div" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1p-1022)) (f64.const inf)) +(assert_return (invoke "div" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1p-1)) (f64.const 0x1.921fb54442d18p+3)) +(assert_return (invoke "div" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1p-1)) (f64.const -0x1.921fb54442d18p+3)) +(assert_return (invoke "div" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1p-1)) (f64.const -0x1.921fb54442d18p+3)) +(assert_return (invoke "div" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1p-1)) (f64.const 0x1.921fb54442d18p+3)) +(assert_return (invoke "div" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1p+0)) (f64.const 0x1.921fb54442d18p+2)) +(assert_return (invoke "div" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1p+0)) (f64.const -0x1.921fb54442d18p+2)) +(assert_return (invoke "div" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1p+0)) (f64.const -0x1.921fb54442d18p+2)) +(assert_return (invoke "div" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1p+0)) (f64.const 0x1.921fb54442d18p+2)) +(assert_return (invoke "div" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1.921fb54442d18p+2)) (f64.const 0x1p+0)) +(assert_return (invoke "div" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1.921fb54442d18p+2)) (f64.const -0x1p+0)) +(assert_return (invoke "div" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1p+0)) +(assert_return (invoke "div" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1p+0)) +(assert_return (invoke "div" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x1.921fb54442d19p-1022)) +(assert_return (invoke "div" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x1.921fb54442d19p-1022)) +(assert_return (invoke "div" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.921fb54442d19p-1022)) +(assert_return (invoke "div" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.921fb54442d19p-1022)) +(assert_return (invoke "div" (f64.const -0x1.921fb54442d18p+2) (f64.const -inf)) (f64.const 0x0p+0)) +(assert_return (invoke "div" (f64.const -0x1.921fb54442d18p+2) (f64.const inf)) (f64.const -0x0p+0)) +(assert_return (invoke "div" (f64.const 0x1.921fb54442d18p+2) (f64.const -inf)) (f64.const -0x0p+0)) +(assert_return (invoke "div" (f64.const 0x1.921fb54442d18p+2) (f64.const inf)) (f64.const 0x0p+0)) +(assert_return (invoke "div" (f64.const -0x1.921fb54442d18p+2) (f64.const -nan)) (f64.const nan:canonical)) +(assert_return (invoke "div" (f64.const -0x1.921fb54442d18p+2) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "div" (f64.const -0x1.921fb54442d18p+2) (f64.const nan)) (f64.const nan:canonical)) +(assert_return (invoke "div" (f64.const -0x1.921fb54442d18p+2) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "div" (f64.const 0x1.921fb54442d18p+2) (f64.const -nan)) (f64.const nan:canonical)) +(assert_return (invoke "div" (f64.const 0x1.921fb54442d18p+2) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "div" (f64.const 0x1.921fb54442d18p+2) (f64.const nan)) (f64.const nan:canonical)) +(assert_return (invoke "div" (f64.const 0x1.921fb54442d18p+2) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "div" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x0p+0)) (f64.const inf)) +(assert_return (invoke "div" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x0p+0)) (f64.const -inf)) +(assert_return (invoke "div" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x0p+0)) (f64.const -inf)) +(assert_return (invoke "div" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x0p+0)) (f64.const inf)) +(assert_return (invoke "div" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x0.0000000000001p-1022)) (f64.const inf)) +(assert_return (invoke "div" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x0.0000000000001p-1022)) (f64.const -inf)) +(assert_return (invoke "div" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x0.0000000000001p-1022)) (f64.const -inf)) +(assert_return (invoke "div" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x0.0000000000001p-1022)) (f64.const inf)) +(assert_return (invoke "div" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1p-1022)) (f64.const inf)) +(assert_return (invoke "div" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1p-1022)) (f64.const -inf)) +(assert_return (invoke "div" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1p-1022)) (f64.const -inf)) +(assert_return (invoke "div" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1p-1022)) (f64.const inf)) +(assert_return (invoke "div" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1p-1)) (f64.const inf)) +(assert_return (invoke "div" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1p-1)) (f64.const -inf)) +(assert_return (invoke "div" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1p-1)) (f64.const -inf)) +(assert_return (invoke "div" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1p-1)) (f64.const inf)) +(assert_return (invoke "div" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1p+0)) (f64.const 0x1.fffffffffffffp+1023)) +(assert_return (invoke "div" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1p+0)) (f64.const -0x1.fffffffffffffp+1023)) +(assert_return (invoke "div" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1p+0)) (f64.const -0x1.fffffffffffffp+1023)) +(assert_return (invoke "div" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1p+0)) (f64.const 0x1.fffffffffffffp+1023)) +(assert_return (invoke "div" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1.921fb54442d18p+2)) (f64.const 0x1.45f306dc9c882p+1021)) +(assert_return (invoke "div" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1.921fb54442d18p+2)) (f64.const -0x1.45f306dc9c882p+1021)) +(assert_return (invoke "div" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.45f306dc9c882p+1021)) +(assert_return (invoke "div" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.45f306dc9c882p+1021)) +(assert_return (invoke "div" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x1p+0)) +(assert_return (invoke "div" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x1p+0)) +(assert_return (invoke "div" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1p+0)) +(assert_return (invoke "div" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1p+0)) +(assert_return (invoke "div" (f64.const -0x1.fffffffffffffp+1023) (f64.const -inf)) (f64.const 0x0p+0)) +(assert_return (invoke "div" (f64.const -0x1.fffffffffffffp+1023) (f64.const inf)) (f64.const -0x0p+0)) +(assert_return (invoke "div" (f64.const 0x1.fffffffffffffp+1023) (f64.const -inf)) (f64.const -0x0p+0)) +(assert_return (invoke "div" (f64.const 0x1.fffffffffffffp+1023) (f64.const inf)) (f64.const 0x0p+0)) +(assert_return (invoke "div" (f64.const -0x1.fffffffffffffp+1023) (f64.const -nan)) (f64.const nan:canonical)) +(assert_return (invoke "div" (f64.const -0x1.fffffffffffffp+1023) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "div" (f64.const -0x1.fffffffffffffp+1023) (f64.const nan)) (f64.const nan:canonical)) +(assert_return (invoke "div" (f64.const -0x1.fffffffffffffp+1023) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "div" (f64.const 0x1.fffffffffffffp+1023) (f64.const -nan)) (f64.const nan:canonical)) +(assert_return (invoke "div" (f64.const 0x1.fffffffffffffp+1023) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "div" (f64.const 0x1.fffffffffffffp+1023) (f64.const nan)) (f64.const nan:canonical)) +(assert_return (invoke "div" (f64.const 0x1.fffffffffffffp+1023) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "div" (f64.const -inf) (f64.const -0x0p+0)) (f64.const inf)) +(assert_return (invoke "div" (f64.const -inf) (f64.const 0x0p+0)) (f64.const -inf)) +(assert_return (invoke "div" (f64.const inf) (f64.const -0x0p+0)) (f64.const -inf)) +(assert_return (invoke "div" (f64.const inf) (f64.const 0x0p+0)) (f64.const inf)) +(assert_return (invoke "div" (f64.const -inf) (f64.const -0x0.0000000000001p-1022)) (f64.const inf)) +(assert_return (invoke "div" (f64.const -inf) (f64.const 0x0.0000000000001p-1022)) (f64.const -inf)) +(assert_return (invoke "div" (f64.const inf) (f64.const -0x0.0000000000001p-1022)) (f64.const -inf)) +(assert_return (invoke "div" (f64.const inf) (f64.const 0x0.0000000000001p-1022)) (f64.const inf)) +(assert_return (invoke "div" (f64.const -inf) (f64.const -0x1p-1022)) (f64.const inf)) +(assert_return (invoke "div" (f64.const -inf) (f64.const 0x1p-1022)) (f64.const -inf)) +(assert_return (invoke "div" (f64.const inf) (f64.const -0x1p-1022)) (f64.const -inf)) +(assert_return (invoke "div" (f64.const inf) (f64.const 0x1p-1022)) (f64.const inf)) +(assert_return (invoke "div" (f64.const -inf) (f64.const -0x1p-1)) (f64.const inf)) +(assert_return (invoke "div" (f64.const -inf) (f64.const 0x1p-1)) (f64.const -inf)) +(assert_return (invoke "div" (f64.const inf) (f64.const -0x1p-1)) (f64.const -inf)) +(assert_return (invoke "div" (f64.const inf) (f64.const 0x1p-1)) (f64.const inf)) +(assert_return (invoke "div" (f64.const -inf) (f64.const -0x1p+0)) (f64.const inf)) +(assert_return (invoke "div" (f64.const -inf) (f64.const 0x1p+0)) (f64.const -inf)) +(assert_return (invoke "div" (f64.const inf) (f64.const -0x1p+0)) (f64.const -inf)) +(assert_return (invoke "div" (f64.const inf) (f64.const 0x1p+0)) (f64.const inf)) +(assert_return (invoke "div" (f64.const -inf) (f64.const -0x1.921fb54442d18p+2)) (f64.const inf)) +(assert_return (invoke "div" (f64.const -inf) (f64.const 0x1.921fb54442d18p+2)) (f64.const -inf)) +(assert_return (invoke "div" (f64.const inf) (f64.const -0x1.921fb54442d18p+2)) (f64.const -inf)) +(assert_return (invoke "div" (f64.const inf) (f64.const 0x1.921fb54442d18p+2)) (f64.const inf)) +(assert_return (invoke "div" (f64.const -inf) (f64.const -0x1.fffffffffffffp+1023)) (f64.const inf)) +(assert_return (invoke "div" (f64.const -inf) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -inf)) +(assert_return (invoke "div" (f64.const inf) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -inf)) +(assert_return (invoke "div" (f64.const inf) (f64.const 0x1.fffffffffffffp+1023)) (f64.const inf)) +(assert_return (invoke "div" (f64.const -inf) (f64.const -inf)) (f64.const nan:canonical)) +(assert_return (invoke "div" (f64.const -inf) (f64.const inf)) (f64.const nan:canonical)) +(assert_return (invoke "div" (f64.const inf) (f64.const -inf)) (f64.const nan:canonical)) +(assert_return (invoke "div" (f64.const inf) (f64.const inf)) (f64.const nan:canonical)) +(assert_return (invoke "div" (f64.const -inf) (f64.const -nan)) (f64.const nan:canonical)) +(assert_return (invoke "div" (f64.const -inf) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "div" (f64.const -inf) (f64.const nan)) (f64.const nan:canonical)) +(assert_return (invoke "div" (f64.const -inf) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "div" (f64.const inf) (f64.const -nan)) (f64.const nan:canonical)) +(assert_return (invoke "div" (f64.const inf) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "div" (f64.const inf) (f64.const nan)) (f64.const nan:canonical)) +(assert_return (invoke "div" (f64.const inf) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "div" (f64.const -nan) (f64.const -0x0p+0)) (f64.const nan:canonical)) +(assert_return (invoke "div" (f64.const -nan:0x4000000000000) (f64.const -0x0p+0)) (f64.const nan:arithmetic)) +(assert_return (invoke "div" (f64.const -nan) (f64.const 0x0p+0)) (f64.const nan:canonical)) +(assert_return (invoke "div" (f64.const -nan:0x4000000000000) (f64.const 0x0p+0)) (f64.const nan:arithmetic)) +(assert_return (invoke "div" (f64.const nan) (f64.const -0x0p+0)) (f64.const nan:canonical)) +(assert_return (invoke "div" (f64.const nan:0x4000000000000) (f64.const -0x0p+0)) (f64.const nan:arithmetic)) +(assert_return (invoke "div" (f64.const nan) (f64.const 0x0p+0)) (f64.const nan:canonical)) +(assert_return (invoke "div" (f64.const nan:0x4000000000000) (f64.const 0x0p+0)) (f64.const nan:arithmetic)) +(assert_return (invoke "div" (f64.const -nan) (f64.const -0x0.0000000000001p-1022)) (f64.const nan:canonical)) +(assert_return (invoke "div" (f64.const -nan:0x4000000000000) (f64.const -0x0.0000000000001p-1022)) (f64.const nan:arithmetic)) +(assert_return (invoke "div" (f64.const -nan) (f64.const 0x0.0000000000001p-1022)) (f64.const nan:canonical)) +(assert_return (invoke "div" (f64.const -nan:0x4000000000000) (f64.const 0x0.0000000000001p-1022)) (f64.const nan:arithmetic)) +(assert_return (invoke "div" (f64.const nan) (f64.const -0x0.0000000000001p-1022)) (f64.const nan:canonical)) +(assert_return (invoke "div" (f64.const nan:0x4000000000000) (f64.const -0x0.0000000000001p-1022)) (f64.const nan:arithmetic)) +(assert_return (invoke "div" (f64.const nan) (f64.const 0x0.0000000000001p-1022)) (f64.const nan:canonical)) +(assert_return (invoke "div" (f64.const nan:0x4000000000000) (f64.const 0x0.0000000000001p-1022)) (f64.const nan:arithmetic)) +(assert_return (invoke "div" (f64.const -nan) (f64.const -0x1p-1022)) (f64.const nan:canonical)) +(assert_return (invoke "div" (f64.const -nan:0x4000000000000) (f64.const -0x1p-1022)) (f64.const nan:arithmetic)) +(assert_return (invoke "div" (f64.const -nan) (f64.const 0x1p-1022)) (f64.const nan:canonical)) +(assert_return (invoke "div" (f64.const -nan:0x4000000000000) (f64.const 0x1p-1022)) (f64.const nan:arithmetic)) +(assert_return (invoke "div" (f64.const nan) (f64.const -0x1p-1022)) (f64.const nan:canonical)) +(assert_return (invoke "div" (f64.const nan:0x4000000000000) (f64.const -0x1p-1022)) (f64.const nan:arithmetic)) +(assert_return (invoke "div" (f64.const nan) (f64.const 0x1p-1022)) (f64.const nan:canonical)) +(assert_return (invoke "div" (f64.const nan:0x4000000000000) (f64.const 0x1p-1022)) (f64.const nan:arithmetic)) +(assert_return (invoke "div" (f64.const -nan) (f64.const -0x1p-1)) (f64.const nan:canonical)) +(assert_return (invoke "div" (f64.const -nan:0x4000000000000) (f64.const -0x1p-1)) (f64.const nan:arithmetic)) +(assert_return (invoke "div" (f64.const -nan) (f64.const 0x1p-1)) (f64.const nan:canonical)) +(assert_return (invoke "div" (f64.const -nan:0x4000000000000) (f64.const 0x1p-1)) (f64.const nan:arithmetic)) +(assert_return (invoke "div" (f64.const nan) (f64.const -0x1p-1)) (f64.const nan:canonical)) +(assert_return (invoke "div" (f64.const nan:0x4000000000000) (f64.const -0x1p-1)) (f64.const nan:arithmetic)) +(assert_return (invoke "div" (f64.const nan) (f64.const 0x1p-1)) (f64.const nan:canonical)) +(assert_return (invoke "div" (f64.const nan:0x4000000000000) (f64.const 0x1p-1)) (f64.const nan:arithmetic)) +(assert_return (invoke "div" (f64.const -nan) (f64.const -0x1p+0)) (f64.const nan:canonical)) +(assert_return (invoke "div" (f64.const -nan:0x4000000000000) (f64.const -0x1p+0)) (f64.const nan:arithmetic)) +(assert_return (invoke "div" (f64.const -nan) (f64.const 0x1p+0)) (f64.const nan:canonical)) +(assert_return (invoke "div" (f64.const -nan:0x4000000000000) (f64.const 0x1p+0)) (f64.const nan:arithmetic)) +(assert_return (invoke "div" (f64.const nan) (f64.const -0x1p+0)) (f64.const nan:canonical)) +(assert_return (invoke "div" (f64.const nan:0x4000000000000) (f64.const -0x1p+0)) (f64.const nan:arithmetic)) +(assert_return (invoke "div" (f64.const nan) (f64.const 0x1p+0)) (f64.const nan:canonical)) +(assert_return (invoke "div" (f64.const nan:0x4000000000000) (f64.const 0x1p+0)) (f64.const nan:arithmetic)) +(assert_return (invoke "div" (f64.const -nan) (f64.const -0x1.921fb54442d18p+2)) (f64.const nan:canonical)) +(assert_return (invoke "div" (f64.const -nan:0x4000000000000) (f64.const -0x1.921fb54442d18p+2)) (f64.const nan:arithmetic)) +(assert_return (invoke "div" (f64.const -nan) (f64.const 0x1.921fb54442d18p+2)) (f64.const nan:canonical)) +(assert_return (invoke "div" (f64.const -nan:0x4000000000000) (f64.const 0x1.921fb54442d18p+2)) (f64.const nan:arithmetic)) +(assert_return (invoke "div" (f64.const nan) (f64.const -0x1.921fb54442d18p+2)) (f64.const nan:canonical)) +(assert_return (invoke "div" (f64.const nan:0x4000000000000) (f64.const -0x1.921fb54442d18p+2)) (f64.const nan:arithmetic)) +(assert_return (invoke "div" (f64.const nan) (f64.const 0x1.921fb54442d18p+2)) (f64.const nan:canonical)) +(assert_return (invoke "div" (f64.const nan:0x4000000000000) (f64.const 0x1.921fb54442d18p+2)) (f64.const nan:arithmetic)) +(assert_return (invoke "div" (f64.const -nan) (f64.const -0x1.fffffffffffffp+1023)) (f64.const nan:canonical)) +(assert_return (invoke "div" (f64.const -nan:0x4000000000000) (f64.const -0x1.fffffffffffffp+1023)) (f64.const nan:arithmetic)) +(assert_return (invoke "div" (f64.const -nan) (f64.const 0x1.fffffffffffffp+1023)) (f64.const nan:canonical)) +(assert_return (invoke "div" (f64.const -nan:0x4000000000000) (f64.const 0x1.fffffffffffffp+1023)) (f64.const nan:arithmetic)) +(assert_return (invoke "div" (f64.const nan) (f64.const -0x1.fffffffffffffp+1023)) (f64.const nan:canonical)) +(assert_return (invoke "div" (f64.const nan:0x4000000000000) (f64.const -0x1.fffffffffffffp+1023)) (f64.const nan:arithmetic)) +(assert_return (invoke "div" (f64.const nan) (f64.const 0x1.fffffffffffffp+1023)) (f64.const nan:canonical)) +(assert_return (invoke "div" (f64.const nan:0x4000000000000) (f64.const 0x1.fffffffffffffp+1023)) (f64.const nan:arithmetic)) +(assert_return (invoke "div" (f64.const -nan) (f64.const -inf)) (f64.const nan:canonical)) +(assert_return (invoke "div" (f64.const -nan:0x4000000000000) (f64.const -inf)) (f64.const nan:arithmetic)) +(assert_return (invoke "div" (f64.const -nan) (f64.const inf)) (f64.const nan:canonical)) +(assert_return (invoke "div" (f64.const -nan:0x4000000000000) (f64.const inf)) (f64.const nan:arithmetic)) +(assert_return (invoke "div" (f64.const nan) (f64.const -inf)) (f64.const nan:canonical)) +(assert_return (invoke "div" (f64.const nan:0x4000000000000) (f64.const -inf)) (f64.const nan:arithmetic)) +(assert_return (invoke "div" (f64.const nan) (f64.const inf)) (f64.const nan:canonical)) +(assert_return (invoke "div" (f64.const nan:0x4000000000000) (f64.const inf)) (f64.const nan:arithmetic)) +(assert_return (invoke "div" (f64.const -nan) (f64.const -nan)) (f64.const nan:canonical)) +(assert_return (invoke "div" (f64.const -nan:0x4000000000000) (f64.const -nan)) (f64.const nan:arithmetic)) +(assert_return (invoke "div" (f64.const -nan) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "div" (f64.const -nan:0x4000000000000) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "div" (f64.const -nan) (f64.const nan)) (f64.const nan:canonical)) +(assert_return (invoke "div" (f64.const -nan:0x4000000000000) (f64.const nan)) (f64.const nan:arithmetic)) +(assert_return (invoke "div" (f64.const -nan) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "div" (f64.const -nan:0x4000000000000) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "div" (f64.const nan) (f64.const -nan)) (f64.const nan:canonical)) +(assert_return (invoke "div" (f64.const nan:0x4000000000000) (f64.const -nan)) (f64.const nan:arithmetic)) +(assert_return (invoke "div" (f64.const nan) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "div" (f64.const nan:0x4000000000000) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "div" (f64.const nan) (f64.const nan)) (f64.const nan:canonical)) +(assert_return (invoke "div" (f64.const nan:0x4000000000000) (f64.const nan)) (f64.const nan:arithmetic)) +(assert_return (invoke "div" (f64.const nan) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "div" (f64.const nan:0x4000000000000) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "min" (f64.const -0x0p+0) (f64.const -0x0p+0)) (f64.const -0x0p+0)) +(assert_return (invoke "min" (f64.const -0x0p+0) (f64.const 0x0p+0)) (f64.const -0x0p+0)) +(assert_return (invoke "min" (f64.const 0x0p+0) (f64.const -0x0p+0)) (f64.const -0x0p+0)) +(assert_return (invoke "min" (f64.const 0x0p+0) (f64.const 0x0p+0)) (f64.const 0x0p+0)) +(assert_return (invoke "min" (f64.const -0x0p+0) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x0.0000000000001p-1022)) +(assert_return (invoke "min" (f64.const -0x0p+0) (f64.const 0x0.0000000000001p-1022)) (f64.const -0x0p+0)) +(assert_return (invoke "min" (f64.const 0x0p+0) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x0.0000000000001p-1022)) +(assert_return (invoke "min" (f64.const 0x0p+0) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x0p+0)) +(assert_return (invoke "min" (f64.const -0x0p+0) (f64.const -0x1p-1022)) (f64.const -0x1p-1022)) +(assert_return (invoke "min" (f64.const -0x0p+0) (f64.const 0x1p-1022)) (f64.const -0x0p+0)) +(assert_return (invoke "min" (f64.const 0x0p+0) (f64.const -0x1p-1022)) (f64.const -0x1p-1022)) +(assert_return (invoke "min" (f64.const 0x0p+0) (f64.const 0x1p-1022)) (f64.const 0x0p+0)) +(assert_return (invoke "min" (f64.const -0x0p+0) (f64.const -0x1p-1)) (f64.const -0x1p-1)) +(assert_return (invoke "min" (f64.const -0x0p+0) (f64.const 0x1p-1)) (f64.const -0x0p+0)) +(assert_return (invoke "min" (f64.const 0x0p+0) (f64.const -0x1p-1)) (f64.const -0x1p-1)) +(assert_return (invoke "min" (f64.const 0x0p+0) (f64.const 0x1p-1)) (f64.const 0x0p+0)) +(assert_return (invoke "min" (f64.const -0x0p+0) (f64.const -0x1p+0)) (f64.const -0x1p+0)) +(assert_return (invoke "min" (f64.const -0x0p+0) (f64.const 0x1p+0)) (f64.const -0x0p+0)) +(assert_return (invoke "min" (f64.const 0x0p+0) (f64.const -0x1p+0)) (f64.const -0x1p+0)) +(assert_return (invoke "min" (f64.const 0x0p+0) (f64.const 0x1p+0)) (f64.const 0x0p+0)) +(assert_return (invoke "min" (f64.const -0x0p+0) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.921fb54442d18p+2)) +(assert_return (invoke "min" (f64.const -0x0p+0) (f64.const 0x1.921fb54442d18p+2)) (f64.const -0x0p+0)) +(assert_return (invoke "min" (f64.const 0x0p+0) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.921fb54442d18p+2)) +(assert_return (invoke "min" (f64.const 0x0p+0) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x0p+0)) +(assert_return (invoke "min" (f64.const -0x0p+0) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023)) +(assert_return (invoke "min" (f64.const -0x0p+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x0p+0)) +(assert_return (invoke "min" (f64.const 0x0p+0) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023)) +(assert_return (invoke "min" (f64.const 0x0p+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x0p+0)) +(assert_return (invoke "min" (f64.const -0x0p+0) (f64.const -inf)) (f64.const -inf)) +(assert_return (invoke "min" (f64.const -0x0p+0) (f64.const inf)) (f64.const -0x0p+0)) +(assert_return (invoke "min" (f64.const 0x0p+0) (f64.const -inf)) (f64.const -inf)) +(assert_return (invoke "min" (f64.const 0x0p+0) (f64.const inf)) (f64.const 0x0p+0)) +(assert_return (invoke "min" (f64.const -0x0p+0) (f64.const -nan)) (f64.const nan:canonical)) +(assert_return (invoke "min" (f64.const -0x0p+0) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "min" (f64.const -0x0p+0) (f64.const nan)) (f64.const nan:canonical)) +(assert_return (invoke "min" (f64.const -0x0p+0) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "min" (f64.const 0x0p+0) (f64.const -nan)) (f64.const nan:canonical)) +(assert_return (invoke "min" (f64.const 0x0p+0) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "min" (f64.const 0x0p+0) (f64.const nan)) (f64.const nan:canonical)) +(assert_return (invoke "min" (f64.const 0x0p+0) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "min" (f64.const -0x0.0000000000001p-1022) (f64.const -0x0p+0)) (f64.const -0x0.0000000000001p-1022)) +(assert_return (invoke "min" (f64.const -0x0.0000000000001p-1022) (f64.const 0x0p+0)) (f64.const -0x0.0000000000001p-1022)) +(assert_return (invoke "min" (f64.const 0x0.0000000000001p-1022) (f64.const -0x0p+0)) (f64.const -0x0p+0)) +(assert_return (invoke "min" (f64.const 0x0.0000000000001p-1022) (f64.const 0x0p+0)) (f64.const 0x0p+0)) +(assert_return (invoke "min" (f64.const -0x0.0000000000001p-1022) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x0.0000000000001p-1022)) +(assert_return (invoke "min" (f64.const -0x0.0000000000001p-1022) (f64.const 0x0.0000000000001p-1022)) (f64.const -0x0.0000000000001p-1022)) +(assert_return (invoke "min" (f64.const 0x0.0000000000001p-1022) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x0.0000000000001p-1022)) +(assert_return (invoke "min" (f64.const 0x0.0000000000001p-1022) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x0.0000000000001p-1022)) +(assert_return (invoke "min" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1p-1022)) (f64.const -0x1p-1022)) +(assert_return (invoke "min" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1p-1022)) (f64.const -0x0.0000000000001p-1022)) +(assert_return (invoke "min" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1p-1022)) (f64.const -0x1p-1022)) +(assert_return (invoke "min" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1p-1022)) (f64.const 0x0.0000000000001p-1022)) +(assert_return (invoke "min" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1p-1)) (f64.const -0x1p-1)) +(assert_return (invoke "min" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1p-1)) (f64.const -0x0.0000000000001p-1022)) +(assert_return (invoke "min" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1p-1)) (f64.const -0x1p-1)) +(assert_return (invoke "min" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1p-1)) (f64.const 0x0.0000000000001p-1022)) +(assert_return (invoke "min" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1p+0)) (f64.const -0x1p+0)) +(assert_return (invoke "min" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1p+0)) (f64.const -0x0.0000000000001p-1022)) +(assert_return (invoke "min" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1p+0)) (f64.const -0x1p+0)) +(assert_return (invoke "min" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1p+0)) (f64.const 0x0.0000000000001p-1022)) +(assert_return (invoke "min" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.921fb54442d18p+2)) +(assert_return (invoke "min" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1.921fb54442d18p+2)) (f64.const -0x0.0000000000001p-1022)) +(assert_return (invoke "min" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.921fb54442d18p+2)) +(assert_return (invoke "min" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x0.0000000000001p-1022)) +(assert_return (invoke "min" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023)) +(assert_return (invoke "min" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x0.0000000000001p-1022)) +(assert_return (invoke "min" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023)) +(assert_return (invoke "min" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x0.0000000000001p-1022)) +(assert_return (invoke "min" (f64.const -0x0.0000000000001p-1022) (f64.const -inf)) (f64.const -inf)) +(assert_return (invoke "min" (f64.const -0x0.0000000000001p-1022) (f64.const inf)) (f64.const -0x0.0000000000001p-1022)) +(assert_return (invoke "min" (f64.const 0x0.0000000000001p-1022) (f64.const -inf)) (f64.const -inf)) +(assert_return (invoke "min" (f64.const 0x0.0000000000001p-1022) (f64.const inf)) (f64.const 0x0.0000000000001p-1022)) +(assert_return (invoke "min" (f64.const -0x0.0000000000001p-1022) (f64.const -nan)) (f64.const nan:canonical)) +(assert_return (invoke "min" (f64.const -0x0.0000000000001p-1022) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "min" (f64.const -0x0.0000000000001p-1022) (f64.const nan)) (f64.const nan:canonical)) +(assert_return (invoke "min" (f64.const -0x0.0000000000001p-1022) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "min" (f64.const 0x0.0000000000001p-1022) (f64.const -nan)) (f64.const nan:canonical)) +(assert_return (invoke "min" (f64.const 0x0.0000000000001p-1022) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "min" (f64.const 0x0.0000000000001p-1022) (f64.const nan)) (f64.const nan:canonical)) +(assert_return (invoke "min" (f64.const 0x0.0000000000001p-1022) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "min" (f64.const -0x1p-1022) (f64.const -0x0p+0)) (f64.const -0x1p-1022)) +(assert_return (invoke "min" (f64.const -0x1p-1022) (f64.const 0x0p+0)) (f64.const -0x1p-1022)) +(assert_return (invoke "min" (f64.const 0x1p-1022) (f64.const -0x0p+0)) (f64.const -0x0p+0)) +(assert_return (invoke "min" (f64.const 0x1p-1022) (f64.const 0x0p+0)) (f64.const 0x0p+0)) +(assert_return (invoke "min" (f64.const -0x1p-1022) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x1p-1022)) +(assert_return (invoke "min" (f64.const -0x1p-1022) (f64.const 0x0.0000000000001p-1022)) (f64.const -0x1p-1022)) +(assert_return (invoke "min" (f64.const 0x1p-1022) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x0.0000000000001p-1022)) +(assert_return (invoke "min" (f64.const 0x1p-1022) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x0.0000000000001p-1022)) +(assert_return (invoke "min" (f64.const -0x1p-1022) (f64.const -0x1p-1022)) (f64.const -0x1p-1022)) +(assert_return (invoke "min" (f64.const -0x1p-1022) (f64.const 0x1p-1022)) (f64.const -0x1p-1022)) +(assert_return (invoke "min" (f64.const 0x1p-1022) (f64.const -0x1p-1022)) (f64.const -0x1p-1022)) +(assert_return (invoke "min" (f64.const 0x1p-1022) (f64.const 0x1p-1022)) (f64.const 0x1p-1022)) +(assert_return (invoke "min" (f64.const -0x1p-1022) (f64.const -0x1p-1)) (f64.const -0x1p-1)) +(assert_return (invoke "min" (f64.const -0x1p-1022) (f64.const 0x1p-1)) (f64.const -0x1p-1022)) +(assert_return (invoke "min" (f64.const 0x1p-1022) (f64.const -0x1p-1)) (f64.const -0x1p-1)) +(assert_return (invoke "min" (f64.const 0x1p-1022) (f64.const 0x1p-1)) (f64.const 0x1p-1022)) +(assert_return (invoke "min" (f64.const -0x1p-1022) (f64.const -0x1p+0)) (f64.const -0x1p+0)) +(assert_return (invoke "min" (f64.const -0x1p-1022) (f64.const 0x1p+0)) (f64.const -0x1p-1022)) +(assert_return (invoke "min" (f64.const 0x1p-1022) (f64.const -0x1p+0)) (f64.const -0x1p+0)) +(assert_return (invoke "min" (f64.const 0x1p-1022) (f64.const 0x1p+0)) (f64.const 0x1p-1022)) +(assert_return (invoke "min" (f64.const -0x1p-1022) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.921fb54442d18p+2)) +(assert_return (invoke "min" (f64.const -0x1p-1022) (f64.const 0x1.921fb54442d18p+2)) (f64.const -0x1p-1022)) +(assert_return (invoke "min" (f64.const 0x1p-1022) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.921fb54442d18p+2)) +(assert_return (invoke "min" (f64.const 0x1p-1022) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1p-1022)) +(assert_return (invoke "min" (f64.const -0x1p-1022) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023)) +(assert_return (invoke "min" (f64.const -0x1p-1022) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x1p-1022)) +(assert_return (invoke "min" (f64.const 0x1p-1022) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023)) +(assert_return (invoke "min" (f64.const 0x1p-1022) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1p-1022)) +(assert_return (invoke "min" (f64.const -0x1p-1022) (f64.const -inf)) (f64.const -inf)) +(assert_return (invoke "min" (f64.const -0x1p-1022) (f64.const inf)) (f64.const -0x1p-1022)) +(assert_return (invoke "min" (f64.const 0x1p-1022) (f64.const -inf)) (f64.const -inf)) +(assert_return (invoke "min" (f64.const 0x1p-1022) (f64.const inf)) (f64.const 0x1p-1022)) +(assert_return (invoke "min" (f64.const -0x1p-1022) (f64.const -nan)) (f64.const nan:canonical)) +(assert_return (invoke "min" (f64.const -0x1p-1022) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "min" (f64.const -0x1p-1022) (f64.const nan)) (f64.const nan:canonical)) +(assert_return (invoke "min" (f64.const -0x1p-1022) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "min" (f64.const 0x1p-1022) (f64.const -nan)) (f64.const nan:canonical)) +(assert_return (invoke "min" (f64.const 0x1p-1022) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "min" (f64.const 0x1p-1022) (f64.const nan)) (f64.const nan:canonical)) +(assert_return (invoke "min" (f64.const 0x1p-1022) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "min" (f64.const -0x1p-1) (f64.const -0x0p+0)) (f64.const -0x1p-1)) +(assert_return (invoke "min" (f64.const -0x1p-1) (f64.const 0x0p+0)) (f64.const -0x1p-1)) +(assert_return (invoke "min" (f64.const 0x1p-1) (f64.const -0x0p+0)) (f64.const -0x0p+0)) +(assert_return (invoke "min" (f64.const 0x1p-1) (f64.const 0x0p+0)) (f64.const 0x0p+0)) +(assert_return (invoke "min" (f64.const -0x1p-1) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x1p-1)) +(assert_return (invoke "min" (f64.const -0x1p-1) (f64.const 0x0.0000000000001p-1022)) (f64.const -0x1p-1)) +(assert_return (invoke "min" (f64.const 0x1p-1) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x0.0000000000001p-1022)) +(assert_return (invoke "min" (f64.const 0x1p-1) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x0.0000000000001p-1022)) +(assert_return (invoke "min" (f64.const -0x1p-1) (f64.const -0x1p-1022)) (f64.const -0x1p-1)) +(assert_return (invoke "min" (f64.const -0x1p-1) (f64.const 0x1p-1022)) (f64.const -0x1p-1)) +(assert_return (invoke "min" (f64.const 0x1p-1) (f64.const -0x1p-1022)) (f64.const -0x1p-1022)) +(assert_return (invoke "min" (f64.const 0x1p-1) (f64.const 0x1p-1022)) (f64.const 0x1p-1022)) +(assert_return (invoke "min" (f64.const -0x1p-1) (f64.const -0x1p-1)) (f64.const -0x1p-1)) +(assert_return (invoke "min" (f64.const -0x1p-1) (f64.const 0x1p-1)) (f64.const -0x1p-1)) +(assert_return (invoke "min" (f64.const 0x1p-1) (f64.const -0x1p-1)) (f64.const -0x1p-1)) +(assert_return (invoke "min" (f64.const 0x1p-1) (f64.const 0x1p-1)) (f64.const 0x1p-1)) +(assert_return (invoke "min" (f64.const -0x1p-1) (f64.const -0x1p+0)) (f64.const -0x1p+0)) +(assert_return (invoke "min" (f64.const -0x1p-1) (f64.const 0x1p+0)) (f64.const -0x1p-1)) +(assert_return (invoke "min" (f64.const 0x1p-1) (f64.const -0x1p+0)) (f64.const -0x1p+0)) +(assert_return (invoke "min" (f64.const 0x1p-1) (f64.const 0x1p+0)) (f64.const 0x1p-1)) +(assert_return (invoke "min" (f64.const -0x1p-1) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.921fb54442d18p+2)) +(assert_return (invoke "min" (f64.const -0x1p-1) (f64.const 0x1.921fb54442d18p+2)) (f64.const -0x1p-1)) +(assert_return (invoke "min" (f64.const 0x1p-1) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.921fb54442d18p+2)) +(assert_return (invoke "min" (f64.const 0x1p-1) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1p-1)) +(assert_return (invoke "min" (f64.const -0x1p-1) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023)) +(assert_return (invoke "min" (f64.const -0x1p-1) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x1p-1)) +(assert_return (invoke "min" (f64.const 0x1p-1) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023)) +(assert_return (invoke "min" (f64.const 0x1p-1) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1p-1)) +(assert_return (invoke "min" (f64.const -0x1p-1) (f64.const -inf)) (f64.const -inf)) +(assert_return (invoke "min" (f64.const -0x1p-1) (f64.const inf)) (f64.const -0x1p-1)) +(assert_return (invoke "min" (f64.const 0x1p-1) (f64.const -inf)) (f64.const -inf)) +(assert_return (invoke "min" (f64.const 0x1p-1) (f64.const inf)) (f64.const 0x1p-1)) +(assert_return (invoke "min" (f64.const -0x1p-1) (f64.const -nan)) (f64.const nan:canonical)) +(assert_return (invoke "min" (f64.const -0x1p-1) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "min" (f64.const -0x1p-1) (f64.const nan)) (f64.const nan:canonical)) +(assert_return (invoke "min" (f64.const -0x1p-1) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "min" (f64.const 0x1p-1) (f64.const -nan)) (f64.const nan:canonical)) +(assert_return (invoke "min" (f64.const 0x1p-1) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "min" (f64.const 0x1p-1) (f64.const nan)) (f64.const nan:canonical)) +(assert_return (invoke "min" (f64.const 0x1p-1) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "min" (f64.const -0x1p+0) (f64.const -0x0p+0)) (f64.const -0x1p+0)) +(assert_return (invoke "min" (f64.const -0x1p+0) (f64.const 0x0p+0)) (f64.const -0x1p+0)) +(assert_return (invoke "min" (f64.const 0x1p+0) (f64.const -0x0p+0)) (f64.const -0x0p+0)) +(assert_return (invoke "min" (f64.const 0x1p+0) (f64.const 0x0p+0)) (f64.const 0x0p+0)) +(assert_return (invoke "min" (f64.const -0x1p+0) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x1p+0)) +(assert_return (invoke "min" (f64.const -0x1p+0) (f64.const 0x0.0000000000001p-1022)) (f64.const -0x1p+0)) +(assert_return (invoke "min" (f64.const 0x1p+0) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x0.0000000000001p-1022)) +(assert_return (invoke "min" (f64.const 0x1p+0) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x0.0000000000001p-1022)) +(assert_return (invoke "min" (f64.const -0x1p+0) (f64.const -0x1p-1022)) (f64.const -0x1p+0)) +(assert_return (invoke "min" (f64.const -0x1p+0) (f64.const 0x1p-1022)) (f64.const -0x1p+0)) +(assert_return (invoke "min" (f64.const 0x1p+0) (f64.const -0x1p-1022)) (f64.const -0x1p-1022)) +(assert_return (invoke "min" (f64.const 0x1p+0) (f64.const 0x1p-1022)) (f64.const 0x1p-1022)) +(assert_return (invoke "min" (f64.const -0x1p+0) (f64.const -0x1p-1)) (f64.const -0x1p+0)) +(assert_return (invoke "min" (f64.const -0x1p+0) (f64.const 0x1p-1)) (f64.const -0x1p+0)) +(assert_return (invoke "min" (f64.const 0x1p+0) (f64.const -0x1p-1)) (f64.const -0x1p-1)) +(assert_return (invoke "min" (f64.const 0x1p+0) (f64.const 0x1p-1)) (f64.const 0x1p-1)) +(assert_return (invoke "min" (f64.const -0x1p+0) (f64.const -0x1p+0)) (f64.const -0x1p+0)) +(assert_return (invoke "min" (f64.const -0x1p+0) (f64.const 0x1p+0)) (f64.const -0x1p+0)) +(assert_return (invoke "min" (f64.const 0x1p+0) (f64.const -0x1p+0)) (f64.const -0x1p+0)) +(assert_return (invoke "min" (f64.const 0x1p+0) (f64.const 0x1p+0)) (f64.const 0x1p+0)) +(assert_return (invoke "min" (f64.const -0x1p+0) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.921fb54442d18p+2)) +(assert_return (invoke "min" (f64.const -0x1p+0) (f64.const 0x1.921fb54442d18p+2)) (f64.const -0x1p+0)) +(assert_return (invoke "min" (f64.const 0x1p+0) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.921fb54442d18p+2)) +(assert_return (invoke "min" (f64.const 0x1p+0) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1p+0)) +(assert_return (invoke "min" (f64.const -0x1p+0) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023)) +(assert_return (invoke "min" (f64.const -0x1p+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x1p+0)) +(assert_return (invoke "min" (f64.const 0x1p+0) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023)) +(assert_return (invoke "min" (f64.const 0x1p+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1p+0)) +(assert_return (invoke "min" (f64.const -0x1p+0) (f64.const -inf)) (f64.const -inf)) +(assert_return (invoke "min" (f64.const -0x1p+0) (f64.const inf)) (f64.const -0x1p+0)) +(assert_return (invoke "min" (f64.const 0x1p+0) (f64.const -inf)) (f64.const -inf)) +(assert_return (invoke "min" (f64.const 0x1p+0) (f64.const inf)) (f64.const 0x1p+0)) +(assert_return (invoke "min" (f64.const -0x1p+0) (f64.const -nan)) (f64.const nan:canonical)) +(assert_return (invoke "min" (f64.const -0x1p+0) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "min" (f64.const -0x1p+0) (f64.const nan)) (f64.const nan:canonical)) +(assert_return (invoke "min" (f64.const -0x1p+0) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "min" (f64.const 0x1p+0) (f64.const -nan)) (f64.const nan:canonical)) +(assert_return (invoke "min" (f64.const 0x1p+0) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "min" (f64.const 0x1p+0) (f64.const nan)) (f64.const nan:canonical)) +(assert_return (invoke "min" (f64.const 0x1p+0) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "min" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x0p+0)) (f64.const -0x1.921fb54442d18p+2)) +(assert_return (invoke "min" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x0p+0)) (f64.const -0x1.921fb54442d18p+2)) +(assert_return (invoke "min" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x0p+0)) (f64.const -0x0p+0)) +(assert_return (invoke "min" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x0p+0)) (f64.const 0x0p+0)) +(assert_return (invoke "min" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x1.921fb54442d18p+2)) +(assert_return (invoke "min" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x0.0000000000001p-1022)) (f64.const -0x1.921fb54442d18p+2)) +(assert_return (invoke "min" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x0.0000000000001p-1022)) +(assert_return (invoke "min" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x0.0000000000001p-1022)) +(assert_return (invoke "min" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1p-1022)) (f64.const -0x1.921fb54442d18p+2)) +(assert_return (invoke "min" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1p-1022)) (f64.const -0x1.921fb54442d18p+2)) +(assert_return (invoke "min" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1p-1022)) (f64.const -0x1p-1022)) +(assert_return (invoke "min" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1p-1022)) (f64.const 0x1p-1022)) +(assert_return (invoke "min" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1p-1)) (f64.const -0x1.921fb54442d18p+2)) +(assert_return (invoke "min" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1p-1)) (f64.const -0x1.921fb54442d18p+2)) +(assert_return (invoke "min" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1p-1)) (f64.const -0x1p-1)) +(assert_return (invoke "min" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1p-1)) (f64.const 0x1p-1)) +(assert_return (invoke "min" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1p+0)) (f64.const -0x1.921fb54442d18p+2)) +(assert_return (invoke "min" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1p+0)) (f64.const -0x1.921fb54442d18p+2)) +(assert_return (invoke "min" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1p+0)) (f64.const -0x1p+0)) +(assert_return (invoke "min" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1p+0)) (f64.const 0x1p+0)) +(assert_return (invoke "min" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.921fb54442d18p+2)) +(assert_return (invoke "min" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1.921fb54442d18p+2)) (f64.const -0x1.921fb54442d18p+2)) +(assert_return (invoke "min" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.921fb54442d18p+2)) +(assert_return (invoke "min" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p+2)) +(assert_return (invoke "min" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023)) +(assert_return (invoke "min" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x1.921fb54442d18p+2)) +(assert_return (invoke "min" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023)) +(assert_return (invoke "min" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.921fb54442d18p+2)) +(assert_return (invoke "min" (f64.const -0x1.921fb54442d18p+2) (f64.const -inf)) (f64.const -inf)) +(assert_return (invoke "min" (f64.const -0x1.921fb54442d18p+2) (f64.const inf)) (f64.const -0x1.921fb54442d18p+2)) +(assert_return (invoke "min" (f64.const 0x1.921fb54442d18p+2) (f64.const -inf)) (f64.const -inf)) +(assert_return (invoke "min" (f64.const 0x1.921fb54442d18p+2) (f64.const inf)) (f64.const 0x1.921fb54442d18p+2)) +(assert_return (invoke "min" (f64.const -0x1.921fb54442d18p+2) (f64.const -nan)) (f64.const nan:canonical)) +(assert_return (invoke "min" (f64.const -0x1.921fb54442d18p+2) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "min" (f64.const -0x1.921fb54442d18p+2) (f64.const nan)) (f64.const nan:canonical)) +(assert_return (invoke "min" (f64.const -0x1.921fb54442d18p+2) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "min" (f64.const 0x1.921fb54442d18p+2) (f64.const -nan)) (f64.const nan:canonical)) +(assert_return (invoke "min" (f64.const 0x1.921fb54442d18p+2) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "min" (f64.const 0x1.921fb54442d18p+2) (f64.const nan)) (f64.const nan:canonical)) +(assert_return (invoke "min" (f64.const 0x1.921fb54442d18p+2) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "min" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x0p+0)) (f64.const -0x1.fffffffffffffp+1023)) +(assert_return (invoke "min" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x0p+0)) (f64.const -0x1.fffffffffffffp+1023)) +(assert_return (invoke "min" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x0p+0)) (f64.const -0x0p+0)) +(assert_return (invoke "min" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x0p+0)) (f64.const 0x0p+0)) +(assert_return (invoke "min" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x1.fffffffffffffp+1023)) +(assert_return (invoke "min" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x0.0000000000001p-1022)) (f64.const -0x1.fffffffffffffp+1023)) +(assert_return (invoke "min" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x0.0000000000001p-1022)) +(assert_return (invoke "min" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x0.0000000000001p-1022)) +(assert_return (invoke "min" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1p-1022)) (f64.const -0x1.fffffffffffffp+1023)) +(assert_return (invoke "min" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1p-1022)) (f64.const -0x1.fffffffffffffp+1023)) +(assert_return (invoke "min" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1p-1022)) (f64.const -0x1p-1022)) +(assert_return (invoke "min" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1p-1022)) (f64.const 0x1p-1022)) +(assert_return (invoke "min" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1p-1)) (f64.const -0x1.fffffffffffffp+1023)) +(assert_return (invoke "min" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1p-1)) (f64.const -0x1.fffffffffffffp+1023)) +(assert_return (invoke "min" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1p-1)) (f64.const -0x1p-1)) +(assert_return (invoke "min" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1p-1)) (f64.const 0x1p-1)) +(assert_return (invoke "min" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1p+0)) (f64.const -0x1.fffffffffffffp+1023)) +(assert_return (invoke "min" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1p+0)) (f64.const -0x1.fffffffffffffp+1023)) +(assert_return (invoke "min" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1p+0)) (f64.const -0x1p+0)) +(assert_return (invoke "min" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1p+0)) (f64.const 0x1p+0)) +(assert_return (invoke "min" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.fffffffffffffp+1023)) +(assert_return (invoke "min" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1.921fb54442d18p+2)) (f64.const -0x1.fffffffffffffp+1023)) +(assert_return (invoke "min" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.921fb54442d18p+2)) +(assert_return (invoke "min" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p+2)) +(assert_return (invoke "min" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023)) +(assert_return (invoke "min" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023)) +(assert_return (invoke "min" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023)) +(assert_return (invoke "min" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023)) +(assert_return (invoke "min" (f64.const -0x1.fffffffffffffp+1023) (f64.const -inf)) (f64.const -inf)) +(assert_return (invoke "min" (f64.const -0x1.fffffffffffffp+1023) (f64.const inf)) (f64.const -0x1.fffffffffffffp+1023)) +(assert_return (invoke "min" (f64.const 0x1.fffffffffffffp+1023) (f64.const -inf)) (f64.const -inf)) +(assert_return (invoke "min" (f64.const 0x1.fffffffffffffp+1023) (f64.const inf)) (f64.const 0x1.fffffffffffffp+1023)) +(assert_return (invoke "min" (f64.const -0x1.fffffffffffffp+1023) (f64.const -nan)) (f64.const nan:canonical)) +(assert_return (invoke "min" (f64.const -0x1.fffffffffffffp+1023) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "min" (f64.const -0x1.fffffffffffffp+1023) (f64.const nan)) (f64.const nan:canonical)) +(assert_return (invoke "min" (f64.const -0x1.fffffffffffffp+1023) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "min" (f64.const 0x1.fffffffffffffp+1023) (f64.const -nan)) (f64.const nan:canonical)) +(assert_return (invoke "min" (f64.const 0x1.fffffffffffffp+1023) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "min" (f64.const 0x1.fffffffffffffp+1023) (f64.const nan)) (f64.const nan:canonical)) +(assert_return (invoke "min" (f64.const 0x1.fffffffffffffp+1023) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "min" (f64.const -inf) (f64.const -0x0p+0)) (f64.const -inf)) +(assert_return (invoke "min" (f64.const -inf) (f64.const 0x0p+0)) (f64.const -inf)) +(assert_return (invoke "min" (f64.const inf) (f64.const -0x0p+0)) (f64.const -0x0p+0)) +(assert_return (invoke "min" (f64.const inf) (f64.const 0x0p+0)) (f64.const 0x0p+0)) +(assert_return (invoke "min" (f64.const -inf) (f64.const -0x0.0000000000001p-1022)) (f64.const -inf)) +(assert_return (invoke "min" (f64.const -inf) (f64.const 0x0.0000000000001p-1022)) (f64.const -inf)) +(assert_return (invoke "min" (f64.const inf) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x0.0000000000001p-1022)) +(assert_return (invoke "min" (f64.const inf) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x0.0000000000001p-1022)) +(assert_return (invoke "min" (f64.const -inf) (f64.const -0x1p-1022)) (f64.const -inf)) +(assert_return (invoke "min" (f64.const -inf) (f64.const 0x1p-1022)) (f64.const -inf)) +(assert_return (invoke "min" (f64.const inf) (f64.const -0x1p-1022)) (f64.const -0x1p-1022)) +(assert_return (invoke "min" (f64.const inf) (f64.const 0x1p-1022)) (f64.const 0x1p-1022)) +(assert_return (invoke "min" (f64.const -inf) (f64.const -0x1p-1)) (f64.const -inf)) +(assert_return (invoke "min" (f64.const -inf) (f64.const 0x1p-1)) (f64.const -inf)) +(assert_return (invoke "min" (f64.const inf) (f64.const -0x1p-1)) (f64.const -0x1p-1)) +(assert_return (invoke "min" (f64.const inf) (f64.const 0x1p-1)) (f64.const 0x1p-1)) +(assert_return (invoke "min" (f64.const -inf) (f64.const -0x1p+0)) (f64.const -inf)) +(assert_return (invoke "min" (f64.const -inf) (f64.const 0x1p+0)) (f64.const -inf)) +(assert_return (invoke "min" (f64.const inf) (f64.const -0x1p+0)) (f64.const -0x1p+0)) +(assert_return (invoke "min" (f64.const inf) (f64.const 0x1p+0)) (f64.const 0x1p+0)) +(assert_return (invoke "min" (f64.const -inf) (f64.const -0x1.921fb54442d18p+2)) (f64.const -inf)) +(assert_return (invoke "min" (f64.const -inf) (f64.const 0x1.921fb54442d18p+2)) (f64.const -inf)) +(assert_return (invoke "min" (f64.const inf) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.921fb54442d18p+2)) +(assert_return (invoke "min" (f64.const inf) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p+2)) +(assert_return (invoke "min" (f64.const -inf) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -inf)) +(assert_return (invoke "min" (f64.const -inf) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -inf)) +(assert_return (invoke "min" (f64.const inf) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023)) +(assert_return (invoke "min" (f64.const inf) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023)) +(assert_return (invoke "min" (f64.const -inf) (f64.const -inf)) (f64.const -inf)) +(assert_return (invoke "min" (f64.const -inf) (f64.const inf)) (f64.const -inf)) +(assert_return (invoke "min" (f64.const inf) (f64.const -inf)) (f64.const -inf)) +(assert_return (invoke "min" (f64.const inf) (f64.const inf)) (f64.const inf)) +(assert_return (invoke "min" (f64.const -inf) (f64.const -nan)) (f64.const nan:canonical)) +(assert_return (invoke "min" (f64.const -inf) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "min" (f64.const -inf) (f64.const nan)) (f64.const nan:canonical)) +(assert_return (invoke "min" (f64.const -inf) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "min" (f64.const inf) (f64.const -nan)) (f64.const nan:canonical)) +(assert_return (invoke "min" (f64.const inf) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "min" (f64.const inf) (f64.const nan)) (f64.const nan:canonical)) +(assert_return (invoke "min" (f64.const inf) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "min" (f64.const -nan) (f64.const -0x0p+0)) (f64.const nan:canonical)) +(assert_return (invoke "min" (f64.const -nan:0x4000000000000) (f64.const -0x0p+0)) (f64.const nan:arithmetic)) +(assert_return (invoke "min" (f64.const -nan) (f64.const 0x0p+0)) (f64.const nan:canonical)) +(assert_return (invoke "min" (f64.const -nan:0x4000000000000) (f64.const 0x0p+0)) (f64.const nan:arithmetic)) +(assert_return (invoke "min" (f64.const nan) (f64.const -0x0p+0)) (f64.const nan:canonical)) +(assert_return (invoke "min" (f64.const nan:0x4000000000000) (f64.const -0x0p+0)) (f64.const nan:arithmetic)) +(assert_return (invoke "min" (f64.const nan) (f64.const 0x0p+0)) (f64.const nan:canonical)) +(assert_return (invoke "min" (f64.const nan:0x4000000000000) (f64.const 0x0p+0)) (f64.const nan:arithmetic)) +(assert_return (invoke "min" (f64.const -nan) (f64.const -0x0.0000000000001p-1022)) (f64.const nan:canonical)) +(assert_return (invoke "min" (f64.const -nan:0x4000000000000) (f64.const -0x0.0000000000001p-1022)) (f64.const nan:arithmetic)) +(assert_return (invoke "min" (f64.const -nan) (f64.const 0x0.0000000000001p-1022)) (f64.const nan:canonical)) +(assert_return (invoke "min" (f64.const -nan:0x4000000000000) (f64.const 0x0.0000000000001p-1022)) (f64.const nan:arithmetic)) +(assert_return (invoke "min" (f64.const nan) (f64.const -0x0.0000000000001p-1022)) (f64.const nan:canonical)) +(assert_return (invoke "min" (f64.const nan:0x4000000000000) (f64.const -0x0.0000000000001p-1022)) (f64.const nan:arithmetic)) +(assert_return (invoke "min" (f64.const nan) (f64.const 0x0.0000000000001p-1022)) (f64.const nan:canonical)) +(assert_return (invoke "min" (f64.const nan:0x4000000000000) (f64.const 0x0.0000000000001p-1022)) (f64.const nan:arithmetic)) +(assert_return (invoke "min" (f64.const -nan) (f64.const -0x1p-1022)) (f64.const nan:canonical)) +(assert_return (invoke "min" (f64.const -nan:0x4000000000000) (f64.const -0x1p-1022)) (f64.const nan:arithmetic)) +(assert_return (invoke "min" (f64.const -nan) (f64.const 0x1p-1022)) (f64.const nan:canonical)) +(assert_return (invoke "min" (f64.const -nan:0x4000000000000) (f64.const 0x1p-1022)) (f64.const nan:arithmetic)) +(assert_return (invoke "min" (f64.const nan) (f64.const -0x1p-1022)) (f64.const nan:canonical)) +(assert_return (invoke "min" (f64.const nan:0x4000000000000) (f64.const -0x1p-1022)) (f64.const nan:arithmetic)) +(assert_return (invoke "min" (f64.const nan) (f64.const 0x1p-1022)) (f64.const nan:canonical)) +(assert_return (invoke "min" (f64.const nan:0x4000000000000) (f64.const 0x1p-1022)) (f64.const nan:arithmetic)) +(assert_return (invoke "min" (f64.const -nan) (f64.const -0x1p-1)) (f64.const nan:canonical)) +(assert_return (invoke "min" (f64.const -nan:0x4000000000000) (f64.const -0x1p-1)) (f64.const nan:arithmetic)) +(assert_return (invoke "min" (f64.const -nan) (f64.const 0x1p-1)) (f64.const nan:canonical)) +(assert_return (invoke "min" (f64.const -nan:0x4000000000000) (f64.const 0x1p-1)) (f64.const nan:arithmetic)) +(assert_return (invoke "min" (f64.const nan) (f64.const -0x1p-1)) (f64.const nan:canonical)) +(assert_return (invoke "min" (f64.const nan:0x4000000000000) (f64.const -0x1p-1)) (f64.const nan:arithmetic)) +(assert_return (invoke "min" (f64.const nan) (f64.const 0x1p-1)) (f64.const nan:canonical)) +(assert_return (invoke "min" (f64.const nan:0x4000000000000) (f64.const 0x1p-1)) (f64.const nan:arithmetic)) +(assert_return (invoke "min" (f64.const -nan) (f64.const -0x1p+0)) (f64.const nan:canonical)) +(assert_return (invoke "min" (f64.const -nan:0x4000000000000) (f64.const -0x1p+0)) (f64.const nan:arithmetic)) +(assert_return (invoke "min" (f64.const -nan) (f64.const 0x1p+0)) (f64.const nan:canonical)) +(assert_return (invoke "min" (f64.const -nan:0x4000000000000) (f64.const 0x1p+0)) (f64.const nan:arithmetic)) +(assert_return (invoke "min" (f64.const nan) (f64.const -0x1p+0)) (f64.const nan:canonical)) +(assert_return (invoke "min" (f64.const nan:0x4000000000000) (f64.const -0x1p+0)) (f64.const nan:arithmetic)) +(assert_return (invoke "min" (f64.const nan) (f64.const 0x1p+0)) (f64.const nan:canonical)) +(assert_return (invoke "min" (f64.const nan:0x4000000000000) (f64.const 0x1p+0)) (f64.const nan:arithmetic)) +(assert_return (invoke "min" (f64.const -nan) (f64.const -0x1.921fb54442d18p+2)) (f64.const nan:canonical)) +(assert_return (invoke "min" (f64.const -nan:0x4000000000000) (f64.const -0x1.921fb54442d18p+2)) (f64.const nan:arithmetic)) +(assert_return (invoke "min" (f64.const -nan) (f64.const 0x1.921fb54442d18p+2)) (f64.const nan:canonical)) +(assert_return (invoke "min" (f64.const -nan:0x4000000000000) (f64.const 0x1.921fb54442d18p+2)) (f64.const nan:arithmetic)) +(assert_return (invoke "min" (f64.const nan) (f64.const -0x1.921fb54442d18p+2)) (f64.const nan:canonical)) +(assert_return (invoke "min" (f64.const nan:0x4000000000000) (f64.const -0x1.921fb54442d18p+2)) (f64.const nan:arithmetic)) +(assert_return (invoke "min" (f64.const nan) (f64.const 0x1.921fb54442d18p+2)) (f64.const nan:canonical)) +(assert_return (invoke "min" (f64.const nan:0x4000000000000) (f64.const 0x1.921fb54442d18p+2)) (f64.const nan:arithmetic)) +(assert_return (invoke "min" (f64.const -nan) (f64.const -0x1.fffffffffffffp+1023)) (f64.const nan:canonical)) +(assert_return (invoke "min" (f64.const -nan:0x4000000000000) (f64.const -0x1.fffffffffffffp+1023)) (f64.const nan:arithmetic)) +(assert_return (invoke "min" (f64.const -nan) (f64.const 0x1.fffffffffffffp+1023)) (f64.const nan:canonical)) +(assert_return (invoke "min" (f64.const -nan:0x4000000000000) (f64.const 0x1.fffffffffffffp+1023)) (f64.const nan:arithmetic)) +(assert_return (invoke "min" (f64.const nan) (f64.const -0x1.fffffffffffffp+1023)) (f64.const nan:canonical)) +(assert_return (invoke "min" (f64.const nan:0x4000000000000) (f64.const -0x1.fffffffffffffp+1023)) (f64.const nan:arithmetic)) +(assert_return (invoke "min" (f64.const nan) (f64.const 0x1.fffffffffffffp+1023)) (f64.const nan:canonical)) +(assert_return (invoke "min" (f64.const nan:0x4000000000000) (f64.const 0x1.fffffffffffffp+1023)) (f64.const nan:arithmetic)) +(assert_return (invoke "min" (f64.const -nan) (f64.const -inf)) (f64.const nan:canonical)) +(assert_return (invoke "min" (f64.const -nan:0x4000000000000) (f64.const -inf)) (f64.const nan:arithmetic)) +(assert_return (invoke "min" (f64.const -nan) (f64.const inf)) (f64.const nan:canonical)) +(assert_return (invoke "min" (f64.const -nan:0x4000000000000) (f64.const inf)) (f64.const nan:arithmetic)) +(assert_return (invoke "min" (f64.const nan) (f64.const -inf)) (f64.const nan:canonical)) +(assert_return (invoke "min" (f64.const nan:0x4000000000000) (f64.const -inf)) (f64.const nan:arithmetic)) +(assert_return (invoke "min" (f64.const nan) (f64.const inf)) (f64.const nan:canonical)) +(assert_return (invoke "min" (f64.const nan:0x4000000000000) (f64.const inf)) (f64.const nan:arithmetic)) +(assert_return (invoke "min" (f64.const -nan) (f64.const -nan)) (f64.const nan:canonical)) +(assert_return (invoke "min" (f64.const -nan:0x4000000000000) (f64.const -nan)) (f64.const nan:arithmetic)) +(assert_return (invoke "min" (f64.const -nan) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "min" (f64.const -nan:0x4000000000000) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "min" (f64.const -nan) (f64.const nan)) (f64.const nan:canonical)) +(assert_return (invoke "min" (f64.const -nan:0x4000000000000) (f64.const nan)) (f64.const nan:arithmetic)) +(assert_return (invoke "min" (f64.const -nan) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "min" (f64.const -nan:0x4000000000000) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "min" (f64.const nan) (f64.const -nan)) (f64.const nan:canonical)) +(assert_return (invoke "min" (f64.const nan:0x4000000000000) (f64.const -nan)) (f64.const nan:arithmetic)) +(assert_return (invoke "min" (f64.const nan) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "min" (f64.const nan:0x4000000000000) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "min" (f64.const nan) (f64.const nan)) (f64.const nan:canonical)) +(assert_return (invoke "min" (f64.const nan:0x4000000000000) (f64.const nan)) (f64.const nan:arithmetic)) +(assert_return (invoke "min" (f64.const nan) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "min" (f64.const nan:0x4000000000000) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "max" (f64.const -0x0p+0) (f64.const -0x0p+0)) (f64.const -0x0p+0)) +(assert_return (invoke "max" (f64.const -0x0p+0) (f64.const 0x0p+0)) (f64.const 0x0p+0)) +(assert_return (invoke "max" (f64.const 0x0p+0) (f64.const -0x0p+0)) (f64.const 0x0p+0)) +(assert_return (invoke "max" (f64.const 0x0p+0) (f64.const 0x0p+0)) (f64.const 0x0p+0)) +(assert_return (invoke "max" (f64.const -0x0p+0) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x0p+0)) +(assert_return (invoke "max" (f64.const -0x0p+0) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x0.0000000000001p-1022)) +(assert_return (invoke "max" (f64.const 0x0p+0) (f64.const -0x0.0000000000001p-1022)) (f64.const 0x0p+0)) +(assert_return (invoke "max" (f64.const 0x0p+0) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x0.0000000000001p-1022)) +(assert_return (invoke "max" (f64.const -0x0p+0) (f64.const -0x1p-1022)) (f64.const -0x0p+0)) +(assert_return (invoke "max" (f64.const -0x0p+0) (f64.const 0x1p-1022)) (f64.const 0x1p-1022)) +(assert_return (invoke "max" (f64.const 0x0p+0) (f64.const -0x1p-1022)) (f64.const 0x0p+0)) +(assert_return (invoke "max" (f64.const 0x0p+0) (f64.const 0x1p-1022)) (f64.const 0x1p-1022)) +(assert_return (invoke "max" (f64.const -0x0p+0) (f64.const -0x1p-1)) (f64.const -0x0p+0)) +(assert_return (invoke "max" (f64.const -0x0p+0) (f64.const 0x1p-1)) (f64.const 0x1p-1)) +(assert_return (invoke "max" (f64.const 0x0p+0) (f64.const -0x1p-1)) (f64.const 0x0p+0)) +(assert_return (invoke "max" (f64.const 0x0p+0) (f64.const 0x1p-1)) (f64.const 0x1p-1)) +(assert_return (invoke "max" (f64.const -0x0p+0) (f64.const -0x1p+0)) (f64.const -0x0p+0)) +(assert_return (invoke "max" (f64.const -0x0p+0) (f64.const 0x1p+0)) (f64.const 0x1p+0)) +(assert_return (invoke "max" (f64.const 0x0p+0) (f64.const -0x1p+0)) (f64.const 0x0p+0)) +(assert_return (invoke "max" (f64.const 0x0p+0) (f64.const 0x1p+0)) (f64.const 0x1p+0)) +(assert_return (invoke "max" (f64.const -0x0p+0) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x0p+0)) +(assert_return (invoke "max" (f64.const -0x0p+0) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p+2)) +(assert_return (invoke "max" (f64.const 0x0p+0) (f64.const -0x1.921fb54442d18p+2)) (f64.const 0x0p+0)) +(assert_return (invoke "max" (f64.const 0x0p+0) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p+2)) +(assert_return (invoke "max" (f64.const -0x0p+0) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x0p+0)) +(assert_return (invoke "max" (f64.const -0x0p+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023)) +(assert_return (invoke "max" (f64.const 0x0p+0) (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x0p+0)) +(assert_return (invoke "max" (f64.const 0x0p+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023)) +(assert_return (invoke "max" (f64.const -0x0p+0) (f64.const -inf)) (f64.const -0x0p+0)) +(assert_return (invoke "max" (f64.const -0x0p+0) (f64.const inf)) (f64.const inf)) +(assert_return (invoke "max" (f64.const 0x0p+0) (f64.const -inf)) (f64.const 0x0p+0)) +(assert_return (invoke "max" (f64.const 0x0p+0) (f64.const inf)) (f64.const inf)) +(assert_return (invoke "max" (f64.const -0x0p+0) (f64.const -nan)) (f64.const nan:canonical)) +(assert_return (invoke "max" (f64.const -0x0p+0) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "max" (f64.const -0x0p+0) (f64.const nan)) (f64.const nan:canonical)) +(assert_return (invoke "max" (f64.const -0x0p+0) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "max" (f64.const 0x0p+0) (f64.const -nan)) (f64.const nan:canonical)) +(assert_return (invoke "max" (f64.const 0x0p+0) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "max" (f64.const 0x0p+0) (f64.const nan)) (f64.const nan:canonical)) +(assert_return (invoke "max" (f64.const 0x0p+0) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "max" (f64.const -0x0.0000000000001p-1022) (f64.const -0x0p+0)) (f64.const -0x0p+0)) +(assert_return (invoke "max" (f64.const -0x0.0000000000001p-1022) (f64.const 0x0p+0)) (f64.const 0x0p+0)) +(assert_return (invoke "max" (f64.const 0x0.0000000000001p-1022) (f64.const -0x0p+0)) (f64.const 0x0.0000000000001p-1022)) +(assert_return (invoke "max" (f64.const 0x0.0000000000001p-1022) (f64.const 0x0p+0)) (f64.const 0x0.0000000000001p-1022)) +(assert_return (invoke "max" (f64.const -0x0.0000000000001p-1022) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x0.0000000000001p-1022)) +(assert_return (invoke "max" (f64.const -0x0.0000000000001p-1022) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x0.0000000000001p-1022)) +(assert_return (invoke "max" (f64.const 0x0.0000000000001p-1022) (f64.const -0x0.0000000000001p-1022)) (f64.const 0x0.0000000000001p-1022)) +(assert_return (invoke "max" (f64.const 0x0.0000000000001p-1022) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x0.0000000000001p-1022)) +(assert_return (invoke "max" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1p-1022)) (f64.const -0x0.0000000000001p-1022)) +(assert_return (invoke "max" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1p-1022)) (f64.const 0x1p-1022)) +(assert_return (invoke "max" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1p-1022)) (f64.const 0x0.0000000000001p-1022)) +(assert_return (invoke "max" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1p-1022)) (f64.const 0x1p-1022)) +(assert_return (invoke "max" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1p-1)) (f64.const -0x0.0000000000001p-1022)) +(assert_return (invoke "max" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1p-1)) (f64.const 0x1p-1)) +(assert_return (invoke "max" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1p-1)) (f64.const 0x0.0000000000001p-1022)) +(assert_return (invoke "max" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1p-1)) (f64.const 0x1p-1)) +(assert_return (invoke "max" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1p+0)) (f64.const -0x0.0000000000001p-1022)) +(assert_return (invoke "max" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1p+0)) (f64.const 0x1p+0)) +(assert_return (invoke "max" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1p+0)) (f64.const 0x0.0000000000001p-1022)) +(assert_return (invoke "max" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1p+0)) (f64.const 0x1p+0)) +(assert_return (invoke "max" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x0.0000000000001p-1022)) +(assert_return (invoke "max" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p+2)) +(assert_return (invoke "max" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1.921fb54442d18p+2)) (f64.const 0x0.0000000000001p-1022)) +(assert_return (invoke "max" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p+2)) +(assert_return (invoke "max" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x0.0000000000001p-1022)) +(assert_return (invoke "max" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023)) +(assert_return (invoke "max" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x0.0000000000001p-1022)) +(assert_return (invoke "max" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023)) +(assert_return (invoke "max" (f64.const -0x0.0000000000001p-1022) (f64.const -inf)) (f64.const -0x0.0000000000001p-1022)) +(assert_return (invoke "max" (f64.const -0x0.0000000000001p-1022) (f64.const inf)) (f64.const inf)) +(assert_return (invoke "max" (f64.const 0x0.0000000000001p-1022) (f64.const -inf)) (f64.const 0x0.0000000000001p-1022)) +(assert_return (invoke "max" (f64.const 0x0.0000000000001p-1022) (f64.const inf)) (f64.const inf)) +(assert_return (invoke "max" (f64.const -0x0.0000000000001p-1022) (f64.const -nan)) (f64.const nan:canonical)) +(assert_return (invoke "max" (f64.const -0x0.0000000000001p-1022) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "max" (f64.const -0x0.0000000000001p-1022) (f64.const nan)) (f64.const nan:canonical)) +(assert_return (invoke "max" (f64.const -0x0.0000000000001p-1022) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "max" (f64.const 0x0.0000000000001p-1022) (f64.const -nan)) (f64.const nan:canonical)) +(assert_return (invoke "max" (f64.const 0x0.0000000000001p-1022) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "max" (f64.const 0x0.0000000000001p-1022) (f64.const nan)) (f64.const nan:canonical)) +(assert_return (invoke "max" (f64.const 0x0.0000000000001p-1022) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "max" (f64.const -0x1p-1022) (f64.const -0x0p+0)) (f64.const -0x0p+0)) +(assert_return (invoke "max" (f64.const -0x1p-1022) (f64.const 0x0p+0)) (f64.const 0x0p+0)) +(assert_return (invoke "max" (f64.const 0x1p-1022) (f64.const -0x0p+0)) (f64.const 0x1p-1022)) +(assert_return (invoke "max" (f64.const 0x1p-1022) (f64.const 0x0p+0)) (f64.const 0x1p-1022)) +(assert_return (invoke "max" (f64.const -0x1p-1022) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x0.0000000000001p-1022)) +(assert_return (invoke "max" (f64.const -0x1p-1022) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x0.0000000000001p-1022)) +(assert_return (invoke "max" (f64.const 0x1p-1022) (f64.const -0x0.0000000000001p-1022)) (f64.const 0x1p-1022)) +(assert_return (invoke "max" (f64.const 0x1p-1022) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x1p-1022)) +(assert_return (invoke "max" (f64.const -0x1p-1022) (f64.const -0x1p-1022)) (f64.const -0x1p-1022)) +(assert_return (invoke "max" (f64.const -0x1p-1022) (f64.const 0x1p-1022)) (f64.const 0x1p-1022)) +(assert_return (invoke "max" (f64.const 0x1p-1022) (f64.const -0x1p-1022)) (f64.const 0x1p-1022)) +(assert_return (invoke "max" (f64.const 0x1p-1022) (f64.const 0x1p-1022)) (f64.const 0x1p-1022)) +(assert_return (invoke "max" (f64.const -0x1p-1022) (f64.const -0x1p-1)) (f64.const -0x1p-1022)) +(assert_return (invoke "max" (f64.const -0x1p-1022) (f64.const 0x1p-1)) (f64.const 0x1p-1)) +(assert_return (invoke "max" (f64.const 0x1p-1022) (f64.const -0x1p-1)) (f64.const 0x1p-1022)) +(assert_return (invoke "max" (f64.const 0x1p-1022) (f64.const 0x1p-1)) (f64.const 0x1p-1)) +(assert_return (invoke "max" (f64.const -0x1p-1022) (f64.const -0x1p+0)) (f64.const -0x1p-1022)) +(assert_return (invoke "max" (f64.const -0x1p-1022) (f64.const 0x1p+0)) (f64.const 0x1p+0)) +(assert_return (invoke "max" (f64.const 0x1p-1022) (f64.const -0x1p+0)) (f64.const 0x1p-1022)) +(assert_return (invoke "max" (f64.const 0x1p-1022) (f64.const 0x1p+0)) (f64.const 0x1p+0)) +(assert_return (invoke "max" (f64.const -0x1p-1022) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1p-1022)) +(assert_return (invoke "max" (f64.const -0x1p-1022) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p+2)) +(assert_return (invoke "max" (f64.const 0x1p-1022) (f64.const -0x1.921fb54442d18p+2)) (f64.const 0x1p-1022)) +(assert_return (invoke "max" (f64.const 0x1p-1022) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p+2)) +(assert_return (invoke "max" (f64.const -0x1p-1022) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1p-1022)) +(assert_return (invoke "max" (f64.const -0x1p-1022) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023)) +(assert_return (invoke "max" (f64.const 0x1p-1022) (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x1p-1022)) +(assert_return (invoke "max" (f64.const 0x1p-1022) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023)) +(assert_return (invoke "max" (f64.const -0x1p-1022) (f64.const -inf)) (f64.const -0x1p-1022)) +(assert_return (invoke "max" (f64.const -0x1p-1022) (f64.const inf)) (f64.const inf)) +(assert_return (invoke "max" (f64.const 0x1p-1022) (f64.const -inf)) (f64.const 0x1p-1022)) +(assert_return (invoke "max" (f64.const 0x1p-1022) (f64.const inf)) (f64.const inf)) +(assert_return (invoke "max" (f64.const -0x1p-1022) (f64.const -nan)) (f64.const nan:canonical)) +(assert_return (invoke "max" (f64.const -0x1p-1022) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "max" (f64.const -0x1p-1022) (f64.const nan)) (f64.const nan:canonical)) +(assert_return (invoke "max" (f64.const -0x1p-1022) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "max" (f64.const 0x1p-1022) (f64.const -nan)) (f64.const nan:canonical)) +(assert_return (invoke "max" (f64.const 0x1p-1022) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "max" (f64.const 0x1p-1022) (f64.const nan)) (f64.const nan:canonical)) +(assert_return (invoke "max" (f64.const 0x1p-1022) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "max" (f64.const -0x1p-1) (f64.const -0x0p+0)) (f64.const -0x0p+0)) +(assert_return (invoke "max" (f64.const -0x1p-1) (f64.const 0x0p+0)) (f64.const 0x0p+0)) +(assert_return (invoke "max" (f64.const 0x1p-1) (f64.const -0x0p+0)) (f64.const 0x1p-1)) +(assert_return (invoke "max" (f64.const 0x1p-1) (f64.const 0x0p+0)) (f64.const 0x1p-1)) +(assert_return (invoke "max" (f64.const -0x1p-1) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x0.0000000000001p-1022)) +(assert_return (invoke "max" (f64.const -0x1p-1) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x0.0000000000001p-1022)) +(assert_return (invoke "max" (f64.const 0x1p-1) (f64.const -0x0.0000000000001p-1022)) (f64.const 0x1p-1)) +(assert_return (invoke "max" (f64.const 0x1p-1) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x1p-1)) +(assert_return (invoke "max" (f64.const -0x1p-1) (f64.const -0x1p-1022)) (f64.const -0x1p-1022)) +(assert_return (invoke "max" (f64.const -0x1p-1) (f64.const 0x1p-1022)) (f64.const 0x1p-1022)) +(assert_return (invoke "max" (f64.const 0x1p-1) (f64.const -0x1p-1022)) (f64.const 0x1p-1)) +(assert_return (invoke "max" (f64.const 0x1p-1) (f64.const 0x1p-1022)) (f64.const 0x1p-1)) +(assert_return (invoke "max" (f64.const -0x1p-1) (f64.const -0x1p-1)) (f64.const -0x1p-1)) +(assert_return (invoke "max" (f64.const -0x1p-1) (f64.const 0x1p-1)) (f64.const 0x1p-1)) +(assert_return (invoke "max" (f64.const 0x1p-1) (f64.const -0x1p-1)) (f64.const 0x1p-1)) +(assert_return (invoke "max" (f64.const 0x1p-1) (f64.const 0x1p-1)) (f64.const 0x1p-1)) +(assert_return (invoke "max" (f64.const -0x1p-1) (f64.const -0x1p+0)) (f64.const -0x1p-1)) +(assert_return (invoke "max" (f64.const -0x1p-1) (f64.const 0x1p+0)) (f64.const 0x1p+0)) +(assert_return (invoke "max" (f64.const 0x1p-1) (f64.const -0x1p+0)) (f64.const 0x1p-1)) +(assert_return (invoke "max" (f64.const 0x1p-1) (f64.const 0x1p+0)) (f64.const 0x1p+0)) +(assert_return (invoke "max" (f64.const -0x1p-1) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1p-1)) +(assert_return (invoke "max" (f64.const -0x1p-1) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p+2)) +(assert_return (invoke "max" (f64.const 0x1p-1) (f64.const -0x1.921fb54442d18p+2)) (f64.const 0x1p-1)) +(assert_return (invoke "max" (f64.const 0x1p-1) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p+2)) +(assert_return (invoke "max" (f64.const -0x1p-1) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1p-1)) +(assert_return (invoke "max" (f64.const -0x1p-1) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023)) +(assert_return (invoke "max" (f64.const 0x1p-1) (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x1p-1)) +(assert_return (invoke "max" (f64.const 0x1p-1) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023)) +(assert_return (invoke "max" (f64.const -0x1p-1) (f64.const -inf)) (f64.const -0x1p-1)) +(assert_return (invoke "max" (f64.const -0x1p-1) (f64.const inf)) (f64.const inf)) +(assert_return (invoke "max" (f64.const 0x1p-1) (f64.const -inf)) (f64.const 0x1p-1)) +(assert_return (invoke "max" (f64.const 0x1p-1) (f64.const inf)) (f64.const inf)) +(assert_return (invoke "max" (f64.const -0x1p-1) (f64.const -nan)) (f64.const nan:canonical)) +(assert_return (invoke "max" (f64.const -0x1p-1) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "max" (f64.const -0x1p-1) (f64.const nan)) (f64.const nan:canonical)) +(assert_return (invoke "max" (f64.const -0x1p-1) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "max" (f64.const 0x1p-1) (f64.const -nan)) (f64.const nan:canonical)) +(assert_return (invoke "max" (f64.const 0x1p-1) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "max" (f64.const 0x1p-1) (f64.const nan)) (f64.const nan:canonical)) +(assert_return (invoke "max" (f64.const 0x1p-1) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "max" (f64.const -0x1p+0) (f64.const -0x0p+0)) (f64.const -0x0p+0)) +(assert_return (invoke "max" (f64.const -0x1p+0) (f64.const 0x0p+0)) (f64.const 0x0p+0)) +(assert_return (invoke "max" (f64.const 0x1p+0) (f64.const -0x0p+0)) (f64.const 0x1p+0)) +(assert_return (invoke "max" (f64.const 0x1p+0) (f64.const 0x0p+0)) (f64.const 0x1p+0)) +(assert_return (invoke "max" (f64.const -0x1p+0) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x0.0000000000001p-1022)) +(assert_return (invoke "max" (f64.const -0x1p+0) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x0.0000000000001p-1022)) +(assert_return (invoke "max" (f64.const 0x1p+0) (f64.const -0x0.0000000000001p-1022)) (f64.const 0x1p+0)) +(assert_return (invoke "max" (f64.const 0x1p+0) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x1p+0)) +(assert_return (invoke "max" (f64.const -0x1p+0) (f64.const -0x1p-1022)) (f64.const -0x1p-1022)) +(assert_return (invoke "max" (f64.const -0x1p+0) (f64.const 0x1p-1022)) (f64.const 0x1p-1022)) +(assert_return (invoke "max" (f64.const 0x1p+0) (f64.const -0x1p-1022)) (f64.const 0x1p+0)) +(assert_return (invoke "max" (f64.const 0x1p+0) (f64.const 0x1p-1022)) (f64.const 0x1p+0)) +(assert_return (invoke "max" (f64.const -0x1p+0) (f64.const -0x1p-1)) (f64.const -0x1p-1)) +(assert_return (invoke "max" (f64.const -0x1p+0) (f64.const 0x1p-1)) (f64.const 0x1p-1)) +(assert_return (invoke "max" (f64.const 0x1p+0) (f64.const -0x1p-1)) (f64.const 0x1p+0)) +(assert_return (invoke "max" (f64.const 0x1p+0) (f64.const 0x1p-1)) (f64.const 0x1p+0)) +(assert_return (invoke "max" (f64.const -0x1p+0) (f64.const -0x1p+0)) (f64.const -0x1p+0)) +(assert_return (invoke "max" (f64.const -0x1p+0) (f64.const 0x1p+0)) (f64.const 0x1p+0)) +(assert_return (invoke "max" (f64.const 0x1p+0) (f64.const -0x1p+0)) (f64.const 0x1p+0)) +(assert_return (invoke "max" (f64.const 0x1p+0) (f64.const 0x1p+0)) (f64.const 0x1p+0)) +(assert_return (invoke "max" (f64.const -0x1p+0) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1p+0)) +(assert_return (invoke "max" (f64.const -0x1p+0) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p+2)) +(assert_return (invoke "max" (f64.const 0x1p+0) (f64.const -0x1.921fb54442d18p+2)) (f64.const 0x1p+0)) +(assert_return (invoke "max" (f64.const 0x1p+0) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p+2)) +(assert_return (invoke "max" (f64.const -0x1p+0) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1p+0)) +(assert_return (invoke "max" (f64.const -0x1p+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023)) +(assert_return (invoke "max" (f64.const 0x1p+0) (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x1p+0)) +(assert_return (invoke "max" (f64.const 0x1p+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023)) +(assert_return (invoke "max" (f64.const -0x1p+0) (f64.const -inf)) (f64.const -0x1p+0)) +(assert_return (invoke "max" (f64.const -0x1p+0) (f64.const inf)) (f64.const inf)) +(assert_return (invoke "max" (f64.const 0x1p+0) (f64.const -inf)) (f64.const 0x1p+0)) +(assert_return (invoke "max" (f64.const 0x1p+0) (f64.const inf)) (f64.const inf)) +(assert_return (invoke "max" (f64.const -0x1p+0) (f64.const -nan)) (f64.const nan:canonical)) +(assert_return (invoke "max" (f64.const -0x1p+0) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "max" (f64.const -0x1p+0) (f64.const nan)) (f64.const nan:canonical)) +(assert_return (invoke "max" (f64.const -0x1p+0) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "max" (f64.const 0x1p+0) (f64.const -nan)) (f64.const nan:canonical)) +(assert_return (invoke "max" (f64.const 0x1p+0) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "max" (f64.const 0x1p+0) (f64.const nan)) (f64.const nan:canonical)) +(assert_return (invoke "max" (f64.const 0x1p+0) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "max" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x0p+0)) (f64.const -0x0p+0)) +(assert_return (invoke "max" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x0p+0)) (f64.const 0x0p+0)) +(assert_return (invoke "max" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x0p+0)) (f64.const 0x1.921fb54442d18p+2)) +(assert_return (invoke "max" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x0p+0)) (f64.const 0x1.921fb54442d18p+2)) +(assert_return (invoke "max" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x0.0000000000001p-1022)) +(assert_return (invoke "max" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x0.0000000000001p-1022)) +(assert_return (invoke "max" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x0.0000000000001p-1022)) (f64.const 0x1.921fb54442d18p+2)) +(assert_return (invoke "max" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x1.921fb54442d18p+2)) +(assert_return (invoke "max" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1p-1022)) (f64.const -0x1p-1022)) +(assert_return (invoke "max" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1p-1022)) (f64.const 0x1p-1022)) +(assert_return (invoke "max" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1p-1022)) (f64.const 0x1.921fb54442d18p+2)) +(assert_return (invoke "max" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1p-1022)) (f64.const 0x1.921fb54442d18p+2)) +(assert_return (invoke "max" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1p-1)) (f64.const -0x1p-1)) +(assert_return (invoke "max" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1p-1)) (f64.const 0x1p-1)) +(assert_return (invoke "max" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1p-1)) (f64.const 0x1.921fb54442d18p+2)) +(assert_return (invoke "max" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1p-1)) (f64.const 0x1.921fb54442d18p+2)) +(assert_return (invoke "max" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1p+0)) (f64.const -0x1p+0)) +(assert_return (invoke "max" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1p+0)) (f64.const 0x1p+0)) +(assert_return (invoke "max" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1p+0)) (f64.const 0x1.921fb54442d18p+2)) +(assert_return (invoke "max" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1p+0)) (f64.const 0x1.921fb54442d18p+2)) +(assert_return (invoke "max" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.921fb54442d18p+2)) +(assert_return (invoke "max" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p+2)) +(assert_return (invoke "max" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p+2)) +(assert_return (invoke "max" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p+2)) +(assert_return (invoke "max" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.921fb54442d18p+2)) +(assert_return (invoke "max" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023)) +(assert_return (invoke "max" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x1.921fb54442d18p+2)) +(assert_return (invoke "max" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023)) +(assert_return (invoke "max" (f64.const -0x1.921fb54442d18p+2) (f64.const -inf)) (f64.const -0x1.921fb54442d18p+2)) +(assert_return (invoke "max" (f64.const -0x1.921fb54442d18p+2) (f64.const inf)) (f64.const inf)) +(assert_return (invoke "max" (f64.const 0x1.921fb54442d18p+2) (f64.const -inf)) (f64.const 0x1.921fb54442d18p+2)) +(assert_return (invoke "max" (f64.const 0x1.921fb54442d18p+2) (f64.const inf)) (f64.const inf)) +(assert_return (invoke "max" (f64.const -0x1.921fb54442d18p+2) (f64.const -nan)) (f64.const nan:canonical)) +(assert_return (invoke "max" (f64.const -0x1.921fb54442d18p+2) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "max" (f64.const -0x1.921fb54442d18p+2) (f64.const nan)) (f64.const nan:canonical)) +(assert_return (invoke "max" (f64.const -0x1.921fb54442d18p+2) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "max" (f64.const 0x1.921fb54442d18p+2) (f64.const -nan)) (f64.const nan:canonical)) +(assert_return (invoke "max" (f64.const 0x1.921fb54442d18p+2) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "max" (f64.const 0x1.921fb54442d18p+2) (f64.const nan)) (f64.const nan:canonical)) +(assert_return (invoke "max" (f64.const 0x1.921fb54442d18p+2) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "max" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x0p+0)) (f64.const -0x0p+0)) +(assert_return (invoke "max" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x0p+0)) (f64.const 0x0p+0)) +(assert_return (invoke "max" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x0p+0)) (f64.const 0x1.fffffffffffffp+1023)) +(assert_return (invoke "max" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x0p+0)) (f64.const 0x1.fffffffffffffp+1023)) +(assert_return (invoke "max" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x0.0000000000001p-1022)) +(assert_return (invoke "max" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x0.0000000000001p-1022)) +(assert_return (invoke "max" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x0.0000000000001p-1022)) (f64.const 0x1.fffffffffffffp+1023)) +(assert_return (invoke "max" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x1.fffffffffffffp+1023)) +(assert_return (invoke "max" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1p-1022)) (f64.const -0x1p-1022)) +(assert_return (invoke "max" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1p-1022)) (f64.const 0x1p-1022)) +(assert_return (invoke "max" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1p-1022)) (f64.const 0x1.fffffffffffffp+1023)) +(assert_return (invoke "max" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1p-1022)) (f64.const 0x1.fffffffffffffp+1023)) +(assert_return (invoke "max" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1p-1)) (f64.const -0x1p-1)) +(assert_return (invoke "max" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1p-1)) (f64.const 0x1p-1)) +(assert_return (invoke "max" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1p-1)) (f64.const 0x1.fffffffffffffp+1023)) +(assert_return (invoke "max" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1p-1)) (f64.const 0x1.fffffffffffffp+1023)) +(assert_return (invoke "max" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1p+0)) (f64.const -0x1p+0)) +(assert_return (invoke "max" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1p+0)) (f64.const 0x1p+0)) +(assert_return (invoke "max" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1p+0)) (f64.const 0x1.fffffffffffffp+1023)) +(assert_return (invoke "max" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1p+0)) (f64.const 0x1.fffffffffffffp+1023)) +(assert_return (invoke "max" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.921fb54442d18p+2)) +(assert_return (invoke "max" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p+2)) +(assert_return (invoke "max" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1.921fb54442d18p+2)) (f64.const 0x1.fffffffffffffp+1023)) +(assert_return (invoke "max" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.fffffffffffffp+1023)) +(assert_return (invoke "max" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023)) +(assert_return (invoke "max" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023)) +(assert_return (invoke "max" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023)) +(assert_return (invoke "max" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023)) +(assert_return (invoke "max" (f64.const -0x1.fffffffffffffp+1023) (f64.const -inf)) (f64.const -0x1.fffffffffffffp+1023)) +(assert_return (invoke "max" (f64.const -0x1.fffffffffffffp+1023) (f64.const inf)) (f64.const inf)) +(assert_return (invoke "max" (f64.const 0x1.fffffffffffffp+1023) (f64.const -inf)) (f64.const 0x1.fffffffffffffp+1023)) +(assert_return (invoke "max" (f64.const 0x1.fffffffffffffp+1023) (f64.const inf)) (f64.const inf)) +(assert_return (invoke "max" (f64.const -0x1.fffffffffffffp+1023) (f64.const -nan)) (f64.const nan:canonical)) +(assert_return (invoke "max" (f64.const -0x1.fffffffffffffp+1023) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "max" (f64.const -0x1.fffffffffffffp+1023) (f64.const nan)) (f64.const nan:canonical)) +(assert_return (invoke "max" (f64.const -0x1.fffffffffffffp+1023) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "max" (f64.const 0x1.fffffffffffffp+1023) (f64.const -nan)) (f64.const nan:canonical)) +(assert_return (invoke "max" (f64.const 0x1.fffffffffffffp+1023) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "max" (f64.const 0x1.fffffffffffffp+1023) (f64.const nan)) (f64.const nan:canonical)) +(assert_return (invoke "max" (f64.const 0x1.fffffffffffffp+1023) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "max" (f64.const -inf) (f64.const -0x0p+0)) (f64.const -0x0p+0)) +(assert_return (invoke "max" (f64.const -inf) (f64.const 0x0p+0)) (f64.const 0x0p+0)) +(assert_return (invoke "max" (f64.const inf) (f64.const -0x0p+0)) (f64.const inf)) +(assert_return (invoke "max" (f64.const inf) (f64.const 0x0p+0)) (f64.const inf)) +(assert_return (invoke "max" (f64.const -inf) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x0.0000000000001p-1022)) +(assert_return (invoke "max" (f64.const -inf) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x0.0000000000001p-1022)) +(assert_return (invoke "max" (f64.const inf) (f64.const -0x0.0000000000001p-1022)) (f64.const inf)) +(assert_return (invoke "max" (f64.const inf) (f64.const 0x0.0000000000001p-1022)) (f64.const inf)) +(assert_return (invoke "max" (f64.const -inf) (f64.const -0x1p-1022)) (f64.const -0x1p-1022)) +(assert_return (invoke "max" (f64.const -inf) (f64.const 0x1p-1022)) (f64.const 0x1p-1022)) +(assert_return (invoke "max" (f64.const inf) (f64.const -0x1p-1022)) (f64.const inf)) +(assert_return (invoke "max" (f64.const inf) (f64.const 0x1p-1022)) (f64.const inf)) +(assert_return (invoke "max" (f64.const -inf) (f64.const -0x1p-1)) (f64.const -0x1p-1)) +(assert_return (invoke "max" (f64.const -inf) (f64.const 0x1p-1)) (f64.const 0x1p-1)) +(assert_return (invoke "max" (f64.const inf) (f64.const -0x1p-1)) (f64.const inf)) +(assert_return (invoke "max" (f64.const inf) (f64.const 0x1p-1)) (f64.const inf)) +(assert_return (invoke "max" (f64.const -inf) (f64.const -0x1p+0)) (f64.const -0x1p+0)) +(assert_return (invoke "max" (f64.const -inf) (f64.const 0x1p+0)) (f64.const 0x1p+0)) +(assert_return (invoke "max" (f64.const inf) (f64.const -0x1p+0)) (f64.const inf)) +(assert_return (invoke "max" (f64.const inf) (f64.const 0x1p+0)) (f64.const inf)) +(assert_return (invoke "max" (f64.const -inf) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.921fb54442d18p+2)) +(assert_return (invoke "max" (f64.const -inf) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p+2)) +(assert_return (invoke "max" (f64.const inf) (f64.const -0x1.921fb54442d18p+2)) (f64.const inf)) +(assert_return (invoke "max" (f64.const inf) (f64.const 0x1.921fb54442d18p+2)) (f64.const inf)) +(assert_return (invoke "max" (f64.const -inf) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023)) +(assert_return (invoke "max" (f64.const -inf) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023)) +(assert_return (invoke "max" (f64.const inf) (f64.const -0x1.fffffffffffffp+1023)) (f64.const inf)) +(assert_return (invoke "max" (f64.const inf) (f64.const 0x1.fffffffffffffp+1023)) (f64.const inf)) +(assert_return (invoke "max" (f64.const -inf) (f64.const -inf)) (f64.const -inf)) +(assert_return (invoke "max" (f64.const -inf) (f64.const inf)) (f64.const inf)) +(assert_return (invoke "max" (f64.const inf) (f64.const -inf)) (f64.const inf)) +(assert_return (invoke "max" (f64.const inf) (f64.const inf)) (f64.const inf)) +(assert_return (invoke "max" (f64.const -inf) (f64.const -nan)) (f64.const nan:canonical)) +(assert_return (invoke "max" (f64.const -inf) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "max" (f64.const -inf) (f64.const nan)) (f64.const nan:canonical)) +(assert_return (invoke "max" (f64.const -inf) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "max" (f64.const inf) (f64.const -nan)) (f64.const nan:canonical)) +(assert_return (invoke "max" (f64.const inf) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "max" (f64.const inf) (f64.const nan)) (f64.const nan:canonical)) +(assert_return (invoke "max" (f64.const inf) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "max" (f64.const -nan) (f64.const -0x0p+0)) (f64.const nan:canonical)) +(assert_return (invoke "max" (f64.const -nan:0x4000000000000) (f64.const -0x0p+0)) (f64.const nan:arithmetic)) +(assert_return (invoke "max" (f64.const -nan) (f64.const 0x0p+0)) (f64.const nan:canonical)) +(assert_return (invoke "max" (f64.const -nan:0x4000000000000) (f64.const 0x0p+0)) (f64.const nan:arithmetic)) +(assert_return (invoke "max" (f64.const nan) (f64.const -0x0p+0)) (f64.const nan:canonical)) +(assert_return (invoke "max" (f64.const nan:0x4000000000000) (f64.const -0x0p+0)) (f64.const nan:arithmetic)) +(assert_return (invoke "max" (f64.const nan) (f64.const 0x0p+0)) (f64.const nan:canonical)) +(assert_return (invoke "max" (f64.const nan:0x4000000000000) (f64.const 0x0p+0)) (f64.const nan:arithmetic)) +(assert_return (invoke "max" (f64.const -nan) (f64.const -0x0.0000000000001p-1022)) (f64.const nan:canonical)) +(assert_return (invoke "max" (f64.const -nan:0x4000000000000) (f64.const -0x0.0000000000001p-1022)) (f64.const nan:arithmetic)) +(assert_return (invoke "max" (f64.const -nan) (f64.const 0x0.0000000000001p-1022)) (f64.const nan:canonical)) +(assert_return (invoke "max" (f64.const -nan:0x4000000000000) (f64.const 0x0.0000000000001p-1022)) (f64.const nan:arithmetic)) +(assert_return (invoke "max" (f64.const nan) (f64.const -0x0.0000000000001p-1022)) (f64.const nan:canonical)) +(assert_return (invoke "max" (f64.const nan:0x4000000000000) (f64.const -0x0.0000000000001p-1022)) (f64.const nan:arithmetic)) +(assert_return (invoke "max" (f64.const nan) (f64.const 0x0.0000000000001p-1022)) (f64.const nan:canonical)) +(assert_return (invoke "max" (f64.const nan:0x4000000000000) (f64.const 0x0.0000000000001p-1022)) (f64.const nan:arithmetic)) +(assert_return (invoke "max" (f64.const -nan) (f64.const -0x1p-1022)) (f64.const nan:canonical)) +(assert_return (invoke "max" (f64.const -nan:0x4000000000000) (f64.const -0x1p-1022)) (f64.const nan:arithmetic)) +(assert_return (invoke "max" (f64.const -nan) (f64.const 0x1p-1022)) (f64.const nan:canonical)) +(assert_return (invoke "max" (f64.const -nan:0x4000000000000) (f64.const 0x1p-1022)) (f64.const nan:arithmetic)) +(assert_return (invoke "max" (f64.const nan) (f64.const -0x1p-1022)) (f64.const nan:canonical)) +(assert_return (invoke "max" (f64.const nan:0x4000000000000) (f64.const -0x1p-1022)) (f64.const nan:arithmetic)) +(assert_return (invoke "max" (f64.const nan) (f64.const 0x1p-1022)) (f64.const nan:canonical)) +(assert_return (invoke "max" (f64.const nan:0x4000000000000) (f64.const 0x1p-1022)) (f64.const nan:arithmetic)) +(assert_return (invoke "max" (f64.const -nan) (f64.const -0x1p-1)) (f64.const nan:canonical)) +(assert_return (invoke "max" (f64.const -nan:0x4000000000000) (f64.const -0x1p-1)) (f64.const nan:arithmetic)) +(assert_return (invoke "max" (f64.const -nan) (f64.const 0x1p-1)) (f64.const nan:canonical)) +(assert_return (invoke "max" (f64.const -nan:0x4000000000000) (f64.const 0x1p-1)) (f64.const nan:arithmetic)) +(assert_return (invoke "max" (f64.const nan) (f64.const -0x1p-1)) (f64.const nan:canonical)) +(assert_return (invoke "max" (f64.const nan:0x4000000000000) (f64.const -0x1p-1)) (f64.const nan:arithmetic)) +(assert_return (invoke "max" (f64.const nan) (f64.const 0x1p-1)) (f64.const nan:canonical)) +(assert_return (invoke "max" (f64.const nan:0x4000000000000) (f64.const 0x1p-1)) (f64.const nan:arithmetic)) +(assert_return (invoke "max" (f64.const -nan) (f64.const -0x1p+0)) (f64.const nan:canonical)) +(assert_return (invoke "max" (f64.const -nan:0x4000000000000) (f64.const -0x1p+0)) (f64.const nan:arithmetic)) +(assert_return (invoke "max" (f64.const -nan) (f64.const 0x1p+0)) (f64.const nan:canonical)) +(assert_return (invoke "max" (f64.const -nan:0x4000000000000) (f64.const 0x1p+0)) (f64.const nan:arithmetic)) +(assert_return (invoke "max" (f64.const nan) (f64.const -0x1p+0)) (f64.const nan:canonical)) +(assert_return (invoke "max" (f64.const nan:0x4000000000000) (f64.const -0x1p+0)) (f64.const nan:arithmetic)) +(assert_return (invoke "max" (f64.const nan) (f64.const 0x1p+0)) (f64.const nan:canonical)) +(assert_return (invoke "max" (f64.const nan:0x4000000000000) (f64.const 0x1p+0)) (f64.const nan:arithmetic)) +(assert_return (invoke "max" (f64.const -nan) (f64.const -0x1.921fb54442d18p+2)) (f64.const nan:canonical)) +(assert_return (invoke "max" (f64.const -nan:0x4000000000000) (f64.const -0x1.921fb54442d18p+2)) (f64.const nan:arithmetic)) +(assert_return (invoke "max" (f64.const -nan) (f64.const 0x1.921fb54442d18p+2)) (f64.const nan:canonical)) +(assert_return (invoke "max" (f64.const -nan:0x4000000000000) (f64.const 0x1.921fb54442d18p+2)) (f64.const nan:arithmetic)) +(assert_return (invoke "max" (f64.const nan) (f64.const -0x1.921fb54442d18p+2)) (f64.const nan:canonical)) +(assert_return (invoke "max" (f64.const nan:0x4000000000000) (f64.const -0x1.921fb54442d18p+2)) (f64.const nan:arithmetic)) +(assert_return (invoke "max" (f64.const nan) (f64.const 0x1.921fb54442d18p+2)) (f64.const nan:canonical)) +(assert_return (invoke "max" (f64.const nan:0x4000000000000) (f64.const 0x1.921fb54442d18p+2)) (f64.const nan:arithmetic)) +(assert_return (invoke "max" (f64.const -nan) (f64.const -0x1.fffffffffffffp+1023)) (f64.const nan:canonical)) +(assert_return (invoke "max" (f64.const -nan:0x4000000000000) (f64.const -0x1.fffffffffffffp+1023)) (f64.const nan:arithmetic)) +(assert_return (invoke "max" (f64.const -nan) (f64.const 0x1.fffffffffffffp+1023)) (f64.const nan:canonical)) +(assert_return (invoke "max" (f64.const -nan:0x4000000000000) (f64.const 0x1.fffffffffffffp+1023)) (f64.const nan:arithmetic)) +(assert_return (invoke "max" (f64.const nan) (f64.const -0x1.fffffffffffffp+1023)) (f64.const nan:canonical)) +(assert_return (invoke "max" (f64.const nan:0x4000000000000) (f64.const -0x1.fffffffffffffp+1023)) (f64.const nan:arithmetic)) +(assert_return (invoke "max" (f64.const nan) (f64.const 0x1.fffffffffffffp+1023)) (f64.const nan:canonical)) +(assert_return (invoke "max" (f64.const nan:0x4000000000000) (f64.const 0x1.fffffffffffffp+1023)) (f64.const nan:arithmetic)) +(assert_return (invoke "max" (f64.const -nan) (f64.const -inf)) (f64.const nan:canonical)) +(assert_return (invoke "max" (f64.const -nan:0x4000000000000) (f64.const -inf)) (f64.const nan:arithmetic)) +(assert_return (invoke "max" (f64.const -nan) (f64.const inf)) (f64.const nan:canonical)) +(assert_return (invoke "max" (f64.const -nan:0x4000000000000) (f64.const inf)) (f64.const nan:arithmetic)) +(assert_return (invoke "max" (f64.const nan) (f64.const -inf)) (f64.const nan:canonical)) +(assert_return (invoke "max" (f64.const nan:0x4000000000000) (f64.const -inf)) (f64.const nan:arithmetic)) +(assert_return (invoke "max" (f64.const nan) (f64.const inf)) (f64.const nan:canonical)) +(assert_return (invoke "max" (f64.const nan:0x4000000000000) (f64.const inf)) (f64.const nan:arithmetic)) +(assert_return (invoke "max" (f64.const -nan) (f64.const -nan)) (f64.const nan:canonical)) +(assert_return (invoke "max" (f64.const -nan:0x4000000000000) (f64.const -nan)) (f64.const nan:arithmetic)) +(assert_return (invoke "max" (f64.const -nan) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "max" (f64.const -nan:0x4000000000000) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "max" (f64.const -nan) (f64.const nan)) (f64.const nan:canonical)) +(assert_return (invoke "max" (f64.const -nan:0x4000000000000) (f64.const nan)) (f64.const nan:arithmetic)) +(assert_return (invoke "max" (f64.const -nan) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "max" (f64.const -nan:0x4000000000000) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "max" (f64.const nan) (f64.const -nan)) (f64.const nan:canonical)) +(assert_return (invoke "max" (f64.const nan:0x4000000000000) (f64.const -nan)) (f64.const nan:arithmetic)) +(assert_return (invoke "max" (f64.const nan) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "max" (f64.const nan:0x4000000000000) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "max" (f64.const nan) (f64.const nan)) (f64.const nan:canonical)) +(assert_return (invoke "max" (f64.const nan:0x4000000000000) (f64.const nan)) (f64.const nan:arithmetic)) +(assert_return (invoke "max" (f64.const nan) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "max" (f64.const nan:0x4000000000000) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "sqrt" (f64.const -0x0p+0)) (f64.const -0x0p+0)) +(assert_return (invoke "sqrt" (f64.const 0x0p+0)) (f64.const 0x0p+0)) +(assert_return (invoke "sqrt" (f64.const -0x0.0000000000001p-1022)) (f64.const nan:canonical)) +(assert_return (invoke "sqrt" (f64.const 0x0.0000000000001p-1022)) (f64.const 0x1p-537)) +(assert_return (invoke "sqrt" (f64.const -0x1p-1022)) (f64.const nan:canonical)) +(assert_return (invoke "sqrt" (f64.const 0x1p-1022)) (f64.const 0x1p-511)) +(assert_return (invoke "sqrt" (f64.const -0x1p-1)) (f64.const nan:canonical)) +(assert_return (invoke "sqrt" (f64.const 0x1p-1)) (f64.const 0x1.6a09e667f3bcdp-1)) +(assert_return (invoke "sqrt" (f64.const -0x1p+0)) (f64.const nan:canonical)) +(assert_return (invoke "sqrt" (f64.const 0x1p+0)) (f64.const 0x1p+0)) +(assert_return (invoke "sqrt" (f64.const -0x1.921fb54442d18p+2)) (f64.const nan:canonical)) +(assert_return (invoke "sqrt" (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.40d931ff62705p+1)) +(assert_return (invoke "sqrt" (f64.const -0x1.fffffffffffffp+1023)) (f64.const nan:canonical)) +(assert_return (invoke "sqrt" (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+511)) +(assert_return (invoke "sqrt" (f64.const -inf)) (f64.const nan:canonical)) +(assert_return (invoke "sqrt" (f64.const inf)) (f64.const inf)) +(assert_return (invoke "sqrt" (f64.const -nan)) (f64.const nan:canonical)) +(assert_return (invoke "sqrt" (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "sqrt" (f64.const nan)) (f64.const nan:canonical)) +(assert_return (invoke "sqrt" (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "floor" (f64.const -0x0p+0)) (f64.const -0x0p+0)) +(assert_return (invoke "floor" (f64.const 0x0p+0)) (f64.const 0x0p+0)) +(assert_return (invoke "floor" (f64.const -0x0.0000000000001p-1022)) (f64.const -0x1p+0)) +(assert_return (invoke "floor" (f64.const 0x0.0000000000001p-1022)) (f64.const 0x0p+0)) +(assert_return (invoke "floor" (f64.const -0x1p-1022)) (f64.const -0x1p+0)) +(assert_return (invoke "floor" (f64.const 0x1p-1022)) (f64.const 0x0p+0)) +(assert_return (invoke "floor" (f64.const -0x1p-1)) (f64.const -0x1p+0)) +(assert_return (invoke "floor" (f64.const 0x1p-1)) (f64.const 0x0p+0)) +(assert_return (invoke "floor" (f64.const -0x1p+0)) (f64.const -0x1p+0)) +(assert_return (invoke "floor" (f64.const 0x1p+0)) (f64.const 0x1p+0)) +(assert_return (invoke "floor" (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.cp+2)) +(assert_return (invoke "floor" (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.8p+2)) +(assert_return (invoke "floor" (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023)) +(assert_return (invoke "floor" (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023)) +(assert_return (invoke "floor" (f64.const -inf)) (f64.const -inf)) +(assert_return (invoke "floor" (f64.const inf)) (f64.const inf)) +(assert_return (invoke "floor" (f64.const -nan)) (f64.const nan:canonical)) +(assert_return (invoke "floor" (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "floor" (f64.const nan)) (f64.const nan:canonical)) +(assert_return (invoke "floor" (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "ceil" (f64.const -0x0p+0)) (f64.const -0x0p+0)) +(assert_return (invoke "ceil" (f64.const 0x0p+0)) (f64.const 0x0p+0)) +(assert_return (invoke "ceil" (f64.const -0x0.0000000000001p-1022)) (f64.const -0x0p+0)) +(assert_return (invoke "ceil" (f64.const 0x0.0000000000001p-1022)) (f64.const 0x1p+0)) +(assert_return (invoke "ceil" (f64.const -0x1p-1022)) (f64.const -0x0p+0)) +(assert_return (invoke "ceil" (f64.const 0x1p-1022)) (f64.const 0x1p+0)) +(assert_return (invoke "ceil" (f64.const -0x1p-1)) (f64.const -0x0p+0)) +(assert_return (invoke "ceil" (f64.const 0x1p-1)) (f64.const 0x1p+0)) +(assert_return (invoke "ceil" (f64.const -0x1p+0)) (f64.const -0x1p+0)) +(assert_return (invoke "ceil" (f64.const 0x1p+0)) (f64.const 0x1p+0)) +(assert_return (invoke "ceil" (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.8p+2)) +(assert_return (invoke "ceil" (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.cp+2)) +(assert_return (invoke "ceil" (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023)) +(assert_return (invoke "ceil" (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023)) +(assert_return (invoke "ceil" (f64.const -inf)) (f64.const -inf)) +(assert_return (invoke "ceil" (f64.const inf)) (f64.const inf)) +(assert_return (invoke "ceil" (f64.const -nan)) (f64.const nan:canonical)) +(assert_return (invoke "ceil" (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "ceil" (f64.const nan)) (f64.const nan:canonical)) +(assert_return (invoke "ceil" (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "trunc" (f64.const -0x0p+0)) (f64.const -0x0p+0)) +(assert_return (invoke "trunc" (f64.const 0x0p+0)) (f64.const 0x0p+0)) +(assert_return (invoke "trunc" (f64.const -0x0.0000000000001p-1022)) (f64.const -0x0p+0)) +(assert_return (invoke "trunc" (f64.const 0x0.0000000000001p-1022)) (f64.const 0x0p+0)) +(assert_return (invoke "trunc" (f64.const -0x1p-1022)) (f64.const -0x0p+0)) +(assert_return (invoke "trunc" (f64.const 0x1p-1022)) (f64.const 0x0p+0)) +(assert_return (invoke "trunc" (f64.const -0x1p-1)) (f64.const -0x0p+0)) +(assert_return (invoke "trunc" (f64.const 0x1p-1)) (f64.const 0x0p+0)) +(assert_return (invoke "trunc" (f64.const -0x1p+0)) (f64.const -0x1p+0)) +(assert_return (invoke "trunc" (f64.const 0x1p+0)) (f64.const 0x1p+0)) +(assert_return (invoke "trunc" (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.8p+2)) +(assert_return (invoke "trunc" (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.8p+2)) +(assert_return (invoke "trunc" (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023)) +(assert_return (invoke "trunc" (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023)) +(assert_return (invoke "trunc" (f64.const -inf)) (f64.const -inf)) +(assert_return (invoke "trunc" (f64.const inf)) (f64.const inf)) +(assert_return (invoke "trunc" (f64.const -nan)) (f64.const nan:canonical)) +(assert_return (invoke "trunc" (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "trunc" (f64.const nan)) (f64.const nan:canonical)) +(assert_return (invoke "trunc" (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "nearest" (f64.const -0x0p+0)) (f64.const -0x0p+0)) +(assert_return (invoke "nearest" (f64.const 0x0p+0)) (f64.const 0x0p+0)) +(assert_return (invoke "nearest" (f64.const -0x0.0000000000001p-1022)) (f64.const -0x0p+0)) +(assert_return (invoke "nearest" (f64.const 0x0.0000000000001p-1022)) (f64.const 0x0p+0)) +(assert_return (invoke "nearest" (f64.const -0x1p-1022)) (f64.const -0x0p+0)) +(assert_return (invoke "nearest" (f64.const 0x1p-1022)) (f64.const 0x0p+0)) +(assert_return (invoke "nearest" (f64.const -0x1p-1)) (f64.const -0x0p+0)) +(assert_return (invoke "nearest" (f64.const 0x1p-1)) (f64.const 0x0p+0)) +(assert_return (invoke "nearest" (f64.const -0x1p+0)) (f64.const -0x1p+0)) +(assert_return (invoke "nearest" (f64.const 0x1p+0)) (f64.const 0x1p+0)) +(assert_return (invoke "nearest" (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.8p+2)) +(assert_return (invoke "nearest" (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.8p+2)) +(assert_return (invoke "nearest" (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023)) +(assert_return (invoke "nearest" (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023)) +(assert_return (invoke "nearest" (f64.const -inf)) (f64.const -inf)) +(assert_return (invoke "nearest" (f64.const inf)) (f64.const inf)) +(assert_return (invoke "nearest" (f64.const -nan)) (f64.const nan:canonical)) +(assert_return (invoke "nearest" (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic)) +(assert_return (invoke "nearest" (f64.const nan)) (f64.const nan:canonical)) +(assert_return (invoke "nearest" (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic)) + + +;; Type check + +(assert_invalid (module (func (result f64) (f64.add (i64.const 0) (f32.const 0)))) "type mismatch") +(assert_invalid (module (func (result f64) (f64.div (i64.const 0) (f32.const 0)))) "type mismatch") +(assert_invalid (module (func (result f64) (f64.max (i64.const 0) (f32.const 0)))) "type mismatch") +(assert_invalid (module (func (result f64) (f64.min (i64.const 0) (f32.const 0)))) "type mismatch") +(assert_invalid (module (func (result f64) (f64.mul (i64.const 0) (f32.const 0)))) "type mismatch") +(assert_invalid (module (func (result f64) (f64.sub (i64.const 0) (f32.const 0)))) "type mismatch") +(assert_invalid (module (func (result f64) (f64.ceil (i64.const 0)))) "type mismatch") +(assert_invalid (module (func (result f64) (f64.floor (i64.const 0)))) "type mismatch") +(assert_invalid (module (func (result f64) (f64.nearest (i64.const 0)))) "type mismatch") +(assert_invalid (module (func (result f64) (f64.sqrt (i64.const 0)))) "type mismatch") +(assert_invalid (module (func (result f64) (f64.trunc (i64.const 0)))) "type mismatch") diff --git a/runtime/near-vm/tests/wast/spec/f64_bitwise.wast b/runtime/near-vm/tests/wast/spec/f64_bitwise.wast new file mode 100644 index 00000000000..f268a3e18fa --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/f64_bitwise.wast @@ -0,0 +1,376 @@ +;; Test all the f64 bitwise operators on major boundary values and all special +;; values. + +(module + (func (export "abs") (param $x f64) (result f64) (f64.abs (local.get $x))) + (func (export "neg") (param $x f64) (result f64) (f64.neg (local.get $x))) + (func (export "copysign") (param $x f64) (param $y f64) (result f64) (f64.copysign (local.get $x) (local.get $y))) +) + +(assert_return (invoke "copysign" (f64.const -0x0p+0) (f64.const -0x0p+0)) (f64.const -0x0p+0)) +(assert_return (invoke "copysign" (f64.const -0x0p+0) (f64.const 0x0p+0)) (f64.const 0x0p+0)) +(assert_return (invoke "copysign" (f64.const 0x0p+0) (f64.const -0x0p+0)) (f64.const -0x0p+0)) +(assert_return (invoke "copysign" (f64.const 0x0p+0) (f64.const 0x0p+0)) (f64.const 0x0p+0)) +(assert_return (invoke "copysign" (f64.const -0x0p+0) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x0p+0)) +(assert_return (invoke "copysign" (f64.const -0x0p+0) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x0p+0)) +(assert_return (invoke "copysign" (f64.const 0x0p+0) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x0p+0)) +(assert_return (invoke "copysign" (f64.const 0x0p+0) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x0p+0)) +(assert_return (invoke "copysign" (f64.const -0x0p+0) (f64.const -0x1p-1022)) (f64.const -0x0p+0)) +(assert_return (invoke "copysign" (f64.const -0x0p+0) (f64.const 0x1p-1022)) (f64.const 0x0p+0)) +(assert_return (invoke "copysign" (f64.const 0x0p+0) (f64.const -0x1p-1022)) (f64.const -0x0p+0)) +(assert_return (invoke "copysign" (f64.const 0x0p+0) (f64.const 0x1p-1022)) (f64.const 0x0p+0)) +(assert_return (invoke "copysign" (f64.const -0x0p+0) (f64.const -0x1p-1)) (f64.const -0x0p+0)) +(assert_return (invoke "copysign" (f64.const -0x0p+0) (f64.const 0x1p-1)) (f64.const 0x0p+0)) +(assert_return (invoke "copysign" (f64.const 0x0p+0) (f64.const -0x1p-1)) (f64.const -0x0p+0)) +(assert_return (invoke "copysign" (f64.const 0x0p+0) (f64.const 0x1p-1)) (f64.const 0x0p+0)) +(assert_return (invoke "copysign" (f64.const -0x0p+0) (f64.const -0x1p+0)) (f64.const -0x0p+0)) +(assert_return (invoke "copysign" (f64.const -0x0p+0) (f64.const 0x1p+0)) (f64.const 0x0p+0)) +(assert_return (invoke "copysign" (f64.const 0x0p+0) (f64.const -0x1p+0)) (f64.const -0x0p+0)) +(assert_return (invoke "copysign" (f64.const 0x0p+0) (f64.const 0x1p+0)) (f64.const 0x0p+0)) +(assert_return (invoke "copysign" (f64.const -0x0p+0) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x0p+0)) +(assert_return (invoke "copysign" (f64.const -0x0p+0) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x0p+0)) +(assert_return (invoke "copysign" (f64.const 0x0p+0) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x0p+0)) +(assert_return (invoke "copysign" (f64.const 0x0p+0) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x0p+0)) +(assert_return (invoke "copysign" (f64.const -0x0p+0) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x0p+0)) +(assert_return (invoke "copysign" (f64.const -0x0p+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x0p+0)) +(assert_return (invoke "copysign" (f64.const 0x0p+0) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x0p+0)) +(assert_return (invoke "copysign" (f64.const 0x0p+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x0p+0)) +(assert_return (invoke "copysign" (f64.const -0x0p+0) (f64.const -inf)) (f64.const -0x0p+0)) +(assert_return (invoke "copysign" (f64.const -0x0p+0) (f64.const inf)) (f64.const 0x0p+0)) +(assert_return (invoke "copysign" (f64.const 0x0p+0) (f64.const -inf)) (f64.const -0x0p+0)) +(assert_return (invoke "copysign" (f64.const 0x0p+0) (f64.const inf)) (f64.const 0x0p+0)) +(assert_return (invoke "copysign" (f64.const -0x0p+0) (f64.const -nan)) (f64.const -0x0p+0)) +(assert_return (invoke "copysign" (f64.const -0x0p+0) (f64.const nan)) (f64.const 0x0p+0)) +(assert_return (invoke "copysign" (f64.const 0x0p+0) (f64.const -nan)) (f64.const -0x0p+0)) +(assert_return (invoke "copysign" (f64.const 0x0p+0) (f64.const nan)) (f64.const 0x0p+0)) +(assert_return (invoke "copysign" (f64.const -0x0.0000000000001p-1022) (f64.const -0x0p+0)) (f64.const -0x0.0000000000001p-1022)) +(assert_return (invoke "copysign" (f64.const -0x0.0000000000001p-1022) (f64.const 0x0p+0)) (f64.const 0x0.0000000000001p-1022)) +(assert_return (invoke "copysign" (f64.const 0x0.0000000000001p-1022) (f64.const -0x0p+0)) (f64.const -0x0.0000000000001p-1022)) +(assert_return (invoke "copysign" (f64.const 0x0.0000000000001p-1022) (f64.const 0x0p+0)) (f64.const 0x0.0000000000001p-1022)) +(assert_return (invoke "copysign" (f64.const -0x0.0000000000001p-1022) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x0.0000000000001p-1022)) +(assert_return (invoke "copysign" (f64.const -0x0.0000000000001p-1022) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x0.0000000000001p-1022)) +(assert_return (invoke "copysign" (f64.const 0x0.0000000000001p-1022) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x0.0000000000001p-1022)) +(assert_return (invoke "copysign" (f64.const 0x0.0000000000001p-1022) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x0.0000000000001p-1022)) +(assert_return (invoke "copysign" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1p-1022)) (f64.const -0x0.0000000000001p-1022)) +(assert_return (invoke "copysign" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1p-1022)) (f64.const 0x0.0000000000001p-1022)) +(assert_return (invoke "copysign" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1p-1022)) (f64.const -0x0.0000000000001p-1022)) +(assert_return (invoke "copysign" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1p-1022)) (f64.const 0x0.0000000000001p-1022)) +(assert_return (invoke "copysign" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1p-1)) (f64.const -0x0.0000000000001p-1022)) +(assert_return (invoke "copysign" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1p-1)) (f64.const 0x0.0000000000001p-1022)) +(assert_return (invoke "copysign" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1p-1)) (f64.const -0x0.0000000000001p-1022)) +(assert_return (invoke "copysign" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1p-1)) (f64.const 0x0.0000000000001p-1022)) +(assert_return (invoke "copysign" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1p+0)) (f64.const -0x0.0000000000001p-1022)) +(assert_return (invoke "copysign" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1p+0)) (f64.const 0x0.0000000000001p-1022)) +(assert_return (invoke "copysign" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1p+0)) (f64.const -0x0.0000000000001p-1022)) +(assert_return (invoke "copysign" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1p+0)) (f64.const 0x0.0000000000001p-1022)) +(assert_return (invoke "copysign" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x0.0000000000001p-1022)) +(assert_return (invoke "copysign" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x0.0000000000001p-1022)) +(assert_return (invoke "copysign" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x0.0000000000001p-1022)) +(assert_return (invoke "copysign" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x0.0000000000001p-1022)) +(assert_return (invoke "copysign" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x0.0000000000001p-1022)) +(assert_return (invoke "copysign" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x0.0000000000001p-1022)) +(assert_return (invoke "copysign" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x0.0000000000001p-1022)) +(assert_return (invoke "copysign" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x0.0000000000001p-1022)) +(assert_return (invoke "copysign" (f64.const -0x0.0000000000001p-1022) (f64.const -inf)) (f64.const -0x0.0000000000001p-1022)) +(assert_return (invoke "copysign" (f64.const -0x0.0000000000001p-1022) (f64.const inf)) (f64.const 0x0.0000000000001p-1022)) +(assert_return (invoke "copysign" (f64.const 0x0.0000000000001p-1022) (f64.const -inf)) (f64.const -0x0.0000000000001p-1022)) +(assert_return (invoke "copysign" (f64.const 0x0.0000000000001p-1022) (f64.const inf)) (f64.const 0x0.0000000000001p-1022)) +(assert_return (invoke "copysign" (f64.const -0x0.0000000000001p-1022) (f64.const -nan)) (f64.const -0x0.0000000000001p-1022)) +(assert_return (invoke "copysign" (f64.const -0x0.0000000000001p-1022) (f64.const nan)) (f64.const 0x0.0000000000001p-1022)) +(assert_return (invoke "copysign" (f64.const 0x0.0000000000001p-1022) (f64.const -nan)) (f64.const -0x0.0000000000001p-1022)) +(assert_return (invoke "copysign" (f64.const 0x0.0000000000001p-1022) (f64.const nan)) (f64.const 0x0.0000000000001p-1022)) +(assert_return (invoke "copysign" (f64.const -0x1p-1022) (f64.const -0x0p+0)) (f64.const -0x1p-1022)) +(assert_return (invoke "copysign" (f64.const -0x1p-1022) (f64.const 0x0p+0)) (f64.const 0x1p-1022)) +(assert_return (invoke "copysign" (f64.const 0x1p-1022) (f64.const -0x0p+0)) (f64.const -0x1p-1022)) +(assert_return (invoke "copysign" (f64.const 0x1p-1022) (f64.const 0x0p+0)) (f64.const 0x1p-1022)) +(assert_return (invoke "copysign" (f64.const -0x1p-1022) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x1p-1022)) +(assert_return (invoke "copysign" (f64.const -0x1p-1022) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x1p-1022)) +(assert_return (invoke "copysign" (f64.const 0x1p-1022) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x1p-1022)) +(assert_return (invoke "copysign" (f64.const 0x1p-1022) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x1p-1022)) +(assert_return (invoke "copysign" (f64.const -0x1p-1022) (f64.const -0x1p-1022)) (f64.const -0x1p-1022)) +(assert_return (invoke "copysign" (f64.const -0x1p-1022) (f64.const 0x1p-1022)) (f64.const 0x1p-1022)) +(assert_return (invoke "copysign" (f64.const 0x1p-1022) (f64.const -0x1p-1022)) (f64.const -0x1p-1022)) +(assert_return (invoke "copysign" (f64.const 0x1p-1022) (f64.const 0x1p-1022)) (f64.const 0x1p-1022)) +(assert_return (invoke "copysign" (f64.const -0x1p-1022) (f64.const -0x1p-1)) (f64.const -0x1p-1022)) +(assert_return (invoke "copysign" (f64.const -0x1p-1022) (f64.const 0x1p-1)) (f64.const 0x1p-1022)) +(assert_return (invoke "copysign" (f64.const 0x1p-1022) (f64.const -0x1p-1)) (f64.const -0x1p-1022)) +(assert_return (invoke "copysign" (f64.const 0x1p-1022) (f64.const 0x1p-1)) (f64.const 0x1p-1022)) +(assert_return (invoke "copysign" (f64.const -0x1p-1022) (f64.const -0x1p+0)) (f64.const -0x1p-1022)) +(assert_return (invoke "copysign" (f64.const -0x1p-1022) (f64.const 0x1p+0)) (f64.const 0x1p-1022)) +(assert_return (invoke "copysign" (f64.const 0x1p-1022) (f64.const -0x1p+0)) (f64.const -0x1p-1022)) +(assert_return (invoke "copysign" (f64.const 0x1p-1022) (f64.const 0x1p+0)) (f64.const 0x1p-1022)) +(assert_return (invoke "copysign" (f64.const -0x1p-1022) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1p-1022)) +(assert_return (invoke "copysign" (f64.const -0x1p-1022) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1p-1022)) +(assert_return (invoke "copysign" (f64.const 0x1p-1022) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1p-1022)) +(assert_return (invoke "copysign" (f64.const 0x1p-1022) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1p-1022)) +(assert_return (invoke "copysign" (f64.const -0x1p-1022) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1p-1022)) +(assert_return (invoke "copysign" (f64.const -0x1p-1022) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1p-1022)) +(assert_return (invoke "copysign" (f64.const 0x1p-1022) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1p-1022)) +(assert_return (invoke "copysign" (f64.const 0x1p-1022) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1p-1022)) +(assert_return (invoke "copysign" (f64.const -0x1p-1022) (f64.const -inf)) (f64.const -0x1p-1022)) +(assert_return (invoke "copysign" (f64.const -0x1p-1022) (f64.const inf)) (f64.const 0x1p-1022)) +(assert_return (invoke "copysign" (f64.const 0x1p-1022) (f64.const -inf)) (f64.const -0x1p-1022)) +(assert_return (invoke "copysign" (f64.const 0x1p-1022) (f64.const inf)) (f64.const 0x1p-1022)) +(assert_return (invoke "copysign" (f64.const -0x1p-1022) (f64.const -nan)) (f64.const -0x1p-1022)) +(assert_return (invoke "copysign" (f64.const -0x1p-1022) (f64.const nan)) (f64.const 0x1p-1022)) +(assert_return (invoke "copysign" (f64.const 0x1p-1022) (f64.const -nan)) (f64.const -0x1p-1022)) +(assert_return (invoke "copysign" (f64.const 0x1p-1022) (f64.const nan)) (f64.const 0x1p-1022)) +(assert_return (invoke "copysign" (f64.const -0x1p-1) (f64.const -0x0p+0)) (f64.const -0x1p-1)) +(assert_return (invoke "copysign" (f64.const -0x1p-1) (f64.const 0x0p+0)) (f64.const 0x1p-1)) +(assert_return (invoke "copysign" (f64.const 0x1p-1) (f64.const -0x0p+0)) (f64.const -0x1p-1)) +(assert_return (invoke "copysign" (f64.const 0x1p-1) (f64.const 0x0p+0)) (f64.const 0x1p-1)) +(assert_return (invoke "copysign" (f64.const -0x1p-1) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x1p-1)) +(assert_return (invoke "copysign" (f64.const -0x1p-1) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x1p-1)) +(assert_return (invoke "copysign" (f64.const 0x1p-1) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x1p-1)) +(assert_return (invoke "copysign" (f64.const 0x1p-1) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x1p-1)) +(assert_return (invoke "copysign" (f64.const -0x1p-1) (f64.const -0x1p-1022)) (f64.const -0x1p-1)) +(assert_return (invoke "copysign" (f64.const -0x1p-1) (f64.const 0x1p-1022)) (f64.const 0x1p-1)) +(assert_return (invoke "copysign" (f64.const 0x1p-1) (f64.const -0x1p-1022)) (f64.const -0x1p-1)) +(assert_return (invoke "copysign" (f64.const 0x1p-1) (f64.const 0x1p-1022)) (f64.const 0x1p-1)) +(assert_return (invoke "copysign" (f64.const -0x1p-1) (f64.const -0x1p-1)) (f64.const -0x1p-1)) +(assert_return (invoke "copysign" (f64.const -0x1p-1) (f64.const 0x1p-1)) (f64.const 0x1p-1)) +(assert_return (invoke "copysign" (f64.const 0x1p-1) (f64.const -0x1p-1)) (f64.const -0x1p-1)) +(assert_return (invoke "copysign" (f64.const 0x1p-1) (f64.const 0x1p-1)) (f64.const 0x1p-1)) +(assert_return (invoke "copysign" (f64.const -0x1p-1) (f64.const -0x1p+0)) (f64.const -0x1p-1)) +(assert_return (invoke "copysign" (f64.const -0x1p-1) (f64.const 0x1p+0)) (f64.const 0x1p-1)) +(assert_return (invoke "copysign" (f64.const 0x1p-1) (f64.const -0x1p+0)) (f64.const -0x1p-1)) +(assert_return (invoke "copysign" (f64.const 0x1p-1) (f64.const 0x1p+0)) (f64.const 0x1p-1)) +(assert_return (invoke "copysign" (f64.const -0x1p-1) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1p-1)) +(assert_return (invoke "copysign" (f64.const -0x1p-1) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1p-1)) +(assert_return (invoke "copysign" (f64.const 0x1p-1) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1p-1)) +(assert_return (invoke "copysign" (f64.const 0x1p-1) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1p-1)) +(assert_return (invoke "copysign" (f64.const -0x1p-1) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1p-1)) +(assert_return (invoke "copysign" (f64.const -0x1p-1) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1p-1)) +(assert_return (invoke "copysign" (f64.const 0x1p-1) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1p-1)) +(assert_return (invoke "copysign" (f64.const 0x1p-1) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1p-1)) +(assert_return (invoke "copysign" (f64.const -0x1p-1) (f64.const -inf)) (f64.const -0x1p-1)) +(assert_return (invoke "copysign" (f64.const -0x1p-1) (f64.const inf)) (f64.const 0x1p-1)) +(assert_return (invoke "copysign" (f64.const 0x1p-1) (f64.const -inf)) (f64.const -0x1p-1)) +(assert_return (invoke "copysign" (f64.const 0x1p-1) (f64.const inf)) (f64.const 0x1p-1)) +(assert_return (invoke "copysign" (f64.const -0x1p-1) (f64.const -nan)) (f64.const -0x1p-1)) +(assert_return (invoke "copysign" (f64.const -0x1p-1) (f64.const nan)) (f64.const 0x1p-1)) +(assert_return (invoke "copysign" (f64.const 0x1p-1) (f64.const -nan)) (f64.const -0x1p-1)) +(assert_return (invoke "copysign" (f64.const 0x1p-1) (f64.const nan)) (f64.const 0x1p-1)) +(assert_return (invoke "copysign" (f64.const -0x1p+0) (f64.const -0x0p+0)) (f64.const -0x1p+0)) +(assert_return (invoke "copysign" (f64.const -0x1p+0) (f64.const 0x0p+0)) (f64.const 0x1p+0)) +(assert_return (invoke "copysign" (f64.const 0x1p+0) (f64.const -0x0p+0)) (f64.const -0x1p+0)) +(assert_return (invoke "copysign" (f64.const 0x1p+0) (f64.const 0x0p+0)) (f64.const 0x1p+0)) +(assert_return (invoke "copysign" (f64.const -0x1p+0) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x1p+0)) +(assert_return (invoke "copysign" (f64.const -0x1p+0) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x1p+0)) +(assert_return (invoke "copysign" (f64.const 0x1p+0) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x1p+0)) +(assert_return (invoke "copysign" (f64.const 0x1p+0) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x1p+0)) +(assert_return (invoke "copysign" (f64.const -0x1p+0) (f64.const -0x1p-1022)) (f64.const -0x1p+0)) +(assert_return (invoke "copysign" (f64.const -0x1p+0) (f64.const 0x1p-1022)) (f64.const 0x1p+0)) +(assert_return (invoke "copysign" (f64.const 0x1p+0) (f64.const -0x1p-1022)) (f64.const -0x1p+0)) +(assert_return (invoke "copysign" (f64.const 0x1p+0) (f64.const 0x1p-1022)) (f64.const 0x1p+0)) +(assert_return (invoke "copysign" (f64.const -0x1p+0) (f64.const -0x1p-1)) (f64.const -0x1p+0)) +(assert_return (invoke "copysign" (f64.const -0x1p+0) (f64.const 0x1p-1)) (f64.const 0x1p+0)) +(assert_return (invoke "copysign" (f64.const 0x1p+0) (f64.const -0x1p-1)) (f64.const -0x1p+0)) +(assert_return (invoke "copysign" (f64.const 0x1p+0) (f64.const 0x1p-1)) (f64.const 0x1p+0)) +(assert_return (invoke "copysign" (f64.const -0x1p+0) (f64.const -0x1p+0)) (f64.const -0x1p+0)) +(assert_return (invoke "copysign" (f64.const -0x1p+0) (f64.const 0x1p+0)) (f64.const 0x1p+0)) +(assert_return (invoke "copysign" (f64.const 0x1p+0) (f64.const -0x1p+0)) (f64.const -0x1p+0)) +(assert_return (invoke "copysign" (f64.const 0x1p+0) (f64.const 0x1p+0)) (f64.const 0x1p+0)) +(assert_return (invoke "copysign" (f64.const -0x1p+0) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1p+0)) +(assert_return (invoke "copysign" (f64.const -0x1p+0) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1p+0)) +(assert_return (invoke "copysign" (f64.const 0x1p+0) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1p+0)) +(assert_return (invoke "copysign" (f64.const 0x1p+0) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1p+0)) +(assert_return (invoke "copysign" (f64.const -0x1p+0) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1p+0)) +(assert_return (invoke "copysign" (f64.const -0x1p+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1p+0)) +(assert_return (invoke "copysign" (f64.const 0x1p+0) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1p+0)) +(assert_return (invoke "copysign" (f64.const 0x1p+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1p+0)) +(assert_return (invoke "copysign" (f64.const -0x1p+0) (f64.const -inf)) (f64.const -0x1p+0)) +(assert_return (invoke "copysign" (f64.const -0x1p+0) (f64.const inf)) (f64.const 0x1p+0)) +(assert_return (invoke "copysign" (f64.const 0x1p+0) (f64.const -inf)) (f64.const -0x1p+0)) +(assert_return (invoke "copysign" (f64.const 0x1p+0) (f64.const inf)) (f64.const 0x1p+0)) +(assert_return (invoke "copysign" (f64.const -0x1p+0) (f64.const -nan)) (f64.const -0x1p+0)) +(assert_return (invoke "copysign" (f64.const -0x1p+0) (f64.const nan)) (f64.const 0x1p+0)) +(assert_return (invoke "copysign" (f64.const 0x1p+0) (f64.const -nan)) (f64.const -0x1p+0)) +(assert_return (invoke "copysign" (f64.const 0x1p+0) (f64.const nan)) (f64.const 0x1p+0)) +(assert_return (invoke "copysign" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x0p+0)) (f64.const -0x1.921fb54442d18p+2)) +(assert_return (invoke "copysign" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x0p+0)) (f64.const 0x1.921fb54442d18p+2)) +(assert_return (invoke "copysign" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x0p+0)) (f64.const -0x1.921fb54442d18p+2)) +(assert_return (invoke "copysign" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x0p+0)) (f64.const 0x1.921fb54442d18p+2)) +(assert_return (invoke "copysign" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x1.921fb54442d18p+2)) +(assert_return (invoke "copysign" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x1.921fb54442d18p+2)) +(assert_return (invoke "copysign" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x1.921fb54442d18p+2)) +(assert_return (invoke "copysign" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x1.921fb54442d18p+2)) +(assert_return (invoke "copysign" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1p-1022)) (f64.const -0x1.921fb54442d18p+2)) +(assert_return (invoke "copysign" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1p-1022)) (f64.const 0x1.921fb54442d18p+2)) +(assert_return (invoke "copysign" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1p-1022)) (f64.const -0x1.921fb54442d18p+2)) +(assert_return (invoke "copysign" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1p-1022)) (f64.const 0x1.921fb54442d18p+2)) +(assert_return (invoke "copysign" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1p-1)) (f64.const -0x1.921fb54442d18p+2)) +(assert_return (invoke "copysign" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1p-1)) (f64.const 0x1.921fb54442d18p+2)) +(assert_return (invoke "copysign" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1p-1)) (f64.const -0x1.921fb54442d18p+2)) +(assert_return (invoke "copysign" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1p-1)) (f64.const 0x1.921fb54442d18p+2)) +(assert_return (invoke "copysign" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1p+0)) (f64.const -0x1.921fb54442d18p+2)) +(assert_return (invoke "copysign" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1p+0)) (f64.const 0x1.921fb54442d18p+2)) +(assert_return (invoke "copysign" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1p+0)) (f64.const -0x1.921fb54442d18p+2)) +(assert_return (invoke "copysign" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1p+0)) (f64.const 0x1.921fb54442d18p+2)) +(assert_return (invoke "copysign" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.921fb54442d18p+2)) +(assert_return (invoke "copysign" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p+2)) +(assert_return (invoke "copysign" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.921fb54442d18p+2)) +(assert_return (invoke "copysign" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p+2)) +(assert_return (invoke "copysign" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.921fb54442d18p+2)) +(assert_return (invoke "copysign" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.921fb54442d18p+2)) +(assert_return (invoke "copysign" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.921fb54442d18p+2)) +(assert_return (invoke "copysign" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.921fb54442d18p+2)) +(assert_return (invoke "copysign" (f64.const -0x1.921fb54442d18p+2) (f64.const -inf)) (f64.const -0x1.921fb54442d18p+2)) +(assert_return (invoke "copysign" (f64.const -0x1.921fb54442d18p+2) (f64.const inf)) (f64.const 0x1.921fb54442d18p+2)) +(assert_return (invoke "copysign" (f64.const 0x1.921fb54442d18p+2) (f64.const -inf)) (f64.const -0x1.921fb54442d18p+2)) +(assert_return (invoke "copysign" (f64.const 0x1.921fb54442d18p+2) (f64.const inf)) (f64.const 0x1.921fb54442d18p+2)) +(assert_return (invoke "copysign" (f64.const -0x1.921fb54442d18p+2) (f64.const -nan)) (f64.const -0x1.921fb54442d18p+2)) +(assert_return (invoke "copysign" (f64.const -0x1.921fb54442d18p+2) (f64.const nan)) (f64.const 0x1.921fb54442d18p+2)) +(assert_return (invoke "copysign" (f64.const 0x1.921fb54442d18p+2) (f64.const -nan)) (f64.const -0x1.921fb54442d18p+2)) +(assert_return (invoke "copysign" (f64.const 0x1.921fb54442d18p+2) (f64.const nan)) (f64.const 0x1.921fb54442d18p+2)) +(assert_return (invoke "copysign" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x0p+0)) (f64.const -0x1.fffffffffffffp+1023)) +(assert_return (invoke "copysign" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x0p+0)) (f64.const 0x1.fffffffffffffp+1023)) +(assert_return (invoke "copysign" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x0p+0)) (f64.const -0x1.fffffffffffffp+1023)) +(assert_return (invoke "copysign" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x0p+0)) (f64.const 0x1.fffffffffffffp+1023)) +(assert_return (invoke "copysign" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x1.fffffffffffffp+1023)) +(assert_return (invoke "copysign" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x1.fffffffffffffp+1023)) +(assert_return (invoke "copysign" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x1.fffffffffffffp+1023)) +(assert_return (invoke "copysign" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x1.fffffffffffffp+1023)) +(assert_return (invoke "copysign" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1p-1022)) (f64.const -0x1.fffffffffffffp+1023)) +(assert_return (invoke "copysign" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1p-1022)) (f64.const 0x1.fffffffffffffp+1023)) +(assert_return (invoke "copysign" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1p-1022)) (f64.const -0x1.fffffffffffffp+1023)) +(assert_return (invoke "copysign" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1p-1022)) (f64.const 0x1.fffffffffffffp+1023)) +(assert_return (invoke "copysign" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1p-1)) (f64.const -0x1.fffffffffffffp+1023)) +(assert_return (invoke "copysign" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1p-1)) (f64.const 0x1.fffffffffffffp+1023)) +(assert_return (invoke "copysign" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1p-1)) (f64.const -0x1.fffffffffffffp+1023)) +(assert_return (invoke "copysign" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1p-1)) (f64.const 0x1.fffffffffffffp+1023)) +(assert_return (invoke "copysign" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1p+0)) (f64.const -0x1.fffffffffffffp+1023)) +(assert_return (invoke "copysign" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1p+0)) (f64.const 0x1.fffffffffffffp+1023)) +(assert_return (invoke "copysign" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1p+0)) (f64.const -0x1.fffffffffffffp+1023)) +(assert_return (invoke "copysign" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1p+0)) (f64.const 0x1.fffffffffffffp+1023)) +(assert_return (invoke "copysign" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.fffffffffffffp+1023)) +(assert_return (invoke "copysign" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.fffffffffffffp+1023)) +(assert_return (invoke "copysign" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.fffffffffffffp+1023)) +(assert_return (invoke "copysign" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.fffffffffffffp+1023)) +(assert_return (invoke "copysign" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023)) +(assert_return (invoke "copysign" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023)) +(assert_return (invoke "copysign" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023)) +(assert_return (invoke "copysign" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023)) +(assert_return (invoke "copysign" (f64.const -0x1.fffffffffffffp+1023) (f64.const -inf)) (f64.const -0x1.fffffffffffffp+1023)) +(assert_return (invoke "copysign" (f64.const -0x1.fffffffffffffp+1023) (f64.const inf)) (f64.const 0x1.fffffffffffffp+1023)) +(assert_return (invoke "copysign" (f64.const 0x1.fffffffffffffp+1023) (f64.const -inf)) (f64.const -0x1.fffffffffffffp+1023)) +(assert_return (invoke "copysign" (f64.const 0x1.fffffffffffffp+1023) (f64.const inf)) (f64.const 0x1.fffffffffffffp+1023)) +(assert_return (invoke "copysign" (f64.const -0x1.fffffffffffffp+1023) (f64.const -nan)) (f64.const -0x1.fffffffffffffp+1023)) +(assert_return (invoke "copysign" (f64.const -0x1.fffffffffffffp+1023) (f64.const nan)) (f64.const 0x1.fffffffffffffp+1023)) +(assert_return (invoke "copysign" (f64.const 0x1.fffffffffffffp+1023) (f64.const -nan)) (f64.const -0x1.fffffffffffffp+1023)) +(assert_return (invoke "copysign" (f64.const 0x1.fffffffffffffp+1023) (f64.const nan)) (f64.const 0x1.fffffffffffffp+1023)) +(assert_return (invoke "copysign" (f64.const -inf) (f64.const -0x0p+0)) (f64.const -inf)) +(assert_return (invoke "copysign" (f64.const -inf) (f64.const 0x0p+0)) (f64.const inf)) +(assert_return (invoke "copysign" (f64.const inf) (f64.const -0x0p+0)) (f64.const -inf)) +(assert_return (invoke "copysign" (f64.const inf) (f64.const 0x0p+0)) (f64.const inf)) +(assert_return (invoke "copysign" (f64.const -inf) (f64.const -0x0.0000000000001p-1022)) (f64.const -inf)) +(assert_return (invoke "copysign" (f64.const -inf) (f64.const 0x0.0000000000001p-1022)) (f64.const inf)) +(assert_return (invoke "copysign" (f64.const inf) (f64.const -0x0.0000000000001p-1022)) (f64.const -inf)) +(assert_return (invoke "copysign" (f64.const inf) (f64.const 0x0.0000000000001p-1022)) (f64.const inf)) +(assert_return (invoke "copysign" (f64.const -inf) (f64.const -0x1p-1022)) (f64.const -inf)) +(assert_return (invoke "copysign" (f64.const -inf) (f64.const 0x1p-1022)) (f64.const inf)) +(assert_return (invoke "copysign" (f64.const inf) (f64.const -0x1p-1022)) (f64.const -inf)) +(assert_return (invoke "copysign" (f64.const inf) (f64.const 0x1p-1022)) (f64.const inf)) +(assert_return (invoke "copysign" (f64.const -inf) (f64.const -0x1p-1)) (f64.const -inf)) +(assert_return (invoke "copysign" (f64.const -inf) (f64.const 0x1p-1)) (f64.const inf)) +(assert_return (invoke "copysign" (f64.const inf) (f64.const -0x1p-1)) (f64.const -inf)) +(assert_return (invoke "copysign" (f64.const inf) (f64.const 0x1p-1)) (f64.const inf)) +(assert_return (invoke "copysign" (f64.const -inf) (f64.const -0x1p+0)) (f64.const -inf)) +(assert_return (invoke "copysign" (f64.const -inf) (f64.const 0x1p+0)) (f64.const inf)) +(assert_return (invoke "copysign" (f64.const inf) (f64.const -0x1p+0)) (f64.const -inf)) +(assert_return (invoke "copysign" (f64.const inf) (f64.const 0x1p+0)) (f64.const inf)) +(assert_return (invoke "copysign" (f64.const -inf) (f64.const -0x1.921fb54442d18p+2)) (f64.const -inf)) +(assert_return (invoke "copysign" (f64.const -inf) (f64.const 0x1.921fb54442d18p+2)) (f64.const inf)) +(assert_return (invoke "copysign" (f64.const inf) (f64.const -0x1.921fb54442d18p+2)) (f64.const -inf)) +(assert_return (invoke "copysign" (f64.const inf) (f64.const 0x1.921fb54442d18p+2)) (f64.const inf)) +(assert_return (invoke "copysign" (f64.const -inf) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -inf)) +(assert_return (invoke "copysign" (f64.const -inf) (f64.const 0x1.fffffffffffffp+1023)) (f64.const inf)) +(assert_return (invoke "copysign" (f64.const inf) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -inf)) +(assert_return (invoke "copysign" (f64.const inf) (f64.const 0x1.fffffffffffffp+1023)) (f64.const inf)) +(assert_return (invoke "copysign" (f64.const -inf) (f64.const -inf)) (f64.const -inf)) +(assert_return (invoke "copysign" (f64.const -inf) (f64.const inf)) (f64.const inf)) +(assert_return (invoke "copysign" (f64.const inf) (f64.const -inf)) (f64.const -inf)) +(assert_return (invoke "copysign" (f64.const inf) (f64.const inf)) (f64.const inf)) +(assert_return (invoke "copysign" (f64.const -inf) (f64.const -nan)) (f64.const -inf)) +(assert_return (invoke "copysign" (f64.const -inf) (f64.const nan)) (f64.const inf)) +(assert_return (invoke "copysign" (f64.const inf) (f64.const -nan)) (f64.const -inf)) +(assert_return (invoke "copysign" (f64.const inf) (f64.const nan)) (f64.const inf)) +(assert_return (invoke "copysign" (f64.const -nan) (f64.const -0x0p+0)) (f64.const -nan)) +(assert_return (invoke "copysign" (f64.const -nan) (f64.const 0x0p+0)) (f64.const nan)) +(assert_return (invoke "copysign" (f64.const nan) (f64.const -0x0p+0)) (f64.const -nan)) +(assert_return (invoke "copysign" (f64.const nan) (f64.const 0x0p+0)) (f64.const nan)) +(assert_return (invoke "copysign" (f64.const -nan) (f64.const -0x0.0000000000001p-1022)) (f64.const -nan)) +(assert_return (invoke "copysign" (f64.const -nan) (f64.const 0x0.0000000000001p-1022)) (f64.const nan)) +(assert_return (invoke "copysign" (f64.const nan) (f64.const -0x0.0000000000001p-1022)) (f64.const -nan)) +(assert_return (invoke "copysign" (f64.const nan) (f64.const 0x0.0000000000001p-1022)) (f64.const nan)) +(assert_return (invoke "copysign" (f64.const -nan) (f64.const -0x1p-1022)) (f64.const -nan)) +(assert_return (invoke "copysign" (f64.const -nan) (f64.const 0x1p-1022)) (f64.const nan)) +(assert_return (invoke "copysign" (f64.const nan) (f64.const -0x1p-1022)) (f64.const -nan)) +(assert_return (invoke "copysign" (f64.const nan) (f64.const 0x1p-1022)) (f64.const nan)) +(assert_return (invoke "copysign" (f64.const -nan) (f64.const -0x1p-1)) (f64.const -nan)) +(assert_return (invoke "copysign" (f64.const -nan) (f64.const 0x1p-1)) (f64.const nan)) +(assert_return (invoke "copysign" (f64.const nan) (f64.const -0x1p-1)) (f64.const -nan)) +(assert_return (invoke "copysign" (f64.const nan) (f64.const 0x1p-1)) (f64.const nan)) +(assert_return (invoke "copysign" (f64.const -nan) (f64.const -0x1p+0)) (f64.const -nan)) +(assert_return (invoke "copysign" (f64.const -nan) (f64.const 0x1p+0)) (f64.const nan)) +(assert_return (invoke "copysign" (f64.const nan) (f64.const -0x1p+0)) (f64.const -nan)) +(assert_return (invoke "copysign" (f64.const nan) (f64.const 0x1p+0)) (f64.const nan)) +(assert_return (invoke "copysign" (f64.const -nan) (f64.const -0x1.921fb54442d18p+2)) (f64.const -nan)) +(assert_return (invoke "copysign" (f64.const -nan) (f64.const 0x1.921fb54442d18p+2)) (f64.const nan)) +(assert_return (invoke "copysign" (f64.const nan) (f64.const -0x1.921fb54442d18p+2)) (f64.const -nan)) +(assert_return (invoke "copysign" (f64.const nan) (f64.const 0x1.921fb54442d18p+2)) (f64.const nan)) +(assert_return (invoke "copysign" (f64.const -nan) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -nan)) +(assert_return (invoke "copysign" (f64.const -nan) (f64.const 0x1.fffffffffffffp+1023)) (f64.const nan)) +(assert_return (invoke "copysign" (f64.const nan) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -nan)) +(assert_return (invoke "copysign" (f64.const nan) (f64.const 0x1.fffffffffffffp+1023)) (f64.const nan)) +(assert_return (invoke "copysign" (f64.const -nan) (f64.const -inf)) (f64.const -nan)) +(assert_return (invoke "copysign" (f64.const -nan) (f64.const inf)) (f64.const nan)) +(assert_return (invoke "copysign" (f64.const nan) (f64.const -inf)) (f64.const -nan)) +(assert_return (invoke "copysign" (f64.const nan) (f64.const inf)) (f64.const nan)) +(assert_return (invoke "copysign" (f64.const -nan) (f64.const -nan)) (f64.const -nan)) +(assert_return (invoke "copysign" (f64.const -nan) (f64.const nan)) (f64.const nan)) +(assert_return (invoke "copysign" (f64.const nan) (f64.const -nan)) (f64.const -nan)) +(assert_return (invoke "copysign" (f64.const nan) (f64.const nan)) (f64.const nan)) +(assert_return (invoke "abs" (f64.const -0x0p+0)) (f64.const 0x0p+0)) +(assert_return (invoke "abs" (f64.const 0x0p+0)) (f64.const 0x0p+0)) +(assert_return (invoke "abs" (f64.const -0x0.0000000000001p-1022)) (f64.const 0x0.0000000000001p-1022)) +(assert_return (invoke "abs" (f64.const 0x0.0000000000001p-1022)) (f64.const 0x0.0000000000001p-1022)) +(assert_return (invoke "abs" (f64.const -0x1p-1022)) (f64.const 0x1p-1022)) +(assert_return (invoke "abs" (f64.const 0x1p-1022)) (f64.const 0x1p-1022)) +(assert_return (invoke "abs" (f64.const -0x1p-1)) (f64.const 0x1p-1)) +(assert_return (invoke "abs" (f64.const 0x1p-1)) (f64.const 0x1p-1)) +(assert_return (invoke "abs" (f64.const -0x1p+0)) (f64.const 0x1p+0)) +(assert_return (invoke "abs" (f64.const 0x1p+0)) (f64.const 0x1p+0)) +(assert_return (invoke "abs" (f64.const -0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p+2)) +(assert_return (invoke "abs" (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p+2)) +(assert_return (invoke "abs" (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023)) +(assert_return (invoke "abs" (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023)) +(assert_return (invoke "abs" (f64.const -inf)) (f64.const inf)) +(assert_return (invoke "abs" (f64.const inf)) (f64.const inf)) +(assert_return (invoke "abs" (f64.const -nan)) (f64.const nan)) +(assert_return (invoke "abs" (f64.const nan)) (f64.const nan)) +(assert_return (invoke "neg" (f64.const -0x0p+0)) (f64.const 0x0p+0)) +(assert_return (invoke "neg" (f64.const 0x0p+0)) (f64.const -0x0p+0)) +(assert_return (invoke "neg" (f64.const -0x0.0000000000001p-1022)) (f64.const 0x0.0000000000001p-1022)) +(assert_return (invoke "neg" (f64.const 0x0.0000000000001p-1022)) (f64.const -0x0.0000000000001p-1022)) +(assert_return (invoke "neg" (f64.const -0x1p-1022)) (f64.const 0x1p-1022)) +(assert_return (invoke "neg" (f64.const 0x1p-1022)) (f64.const -0x1p-1022)) +(assert_return (invoke "neg" (f64.const -0x1p-1)) (f64.const 0x1p-1)) +(assert_return (invoke "neg" (f64.const 0x1p-1)) (f64.const -0x1p-1)) +(assert_return (invoke "neg" (f64.const -0x1p+0)) (f64.const 0x1p+0)) +(assert_return (invoke "neg" (f64.const 0x1p+0)) (f64.const -0x1p+0)) +(assert_return (invoke "neg" (f64.const -0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p+2)) +(assert_return (invoke "neg" (f64.const 0x1.921fb54442d18p+2)) (f64.const -0x1.921fb54442d18p+2)) +(assert_return (invoke "neg" (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023)) +(assert_return (invoke "neg" (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023)) +(assert_return (invoke "neg" (f64.const -inf)) (f64.const inf)) +(assert_return (invoke "neg" (f64.const inf)) (f64.const -inf)) +(assert_return (invoke "neg" (f64.const -nan)) (f64.const nan)) +(assert_return (invoke "neg" (f64.const nan)) (f64.const -nan)) + + +;; Type check + +(assert_invalid (module (func (result f64) (f64.copysign (i64.const 0) (f32.const 0)))) "type mismatch") +(assert_invalid (module (func (result f64) (f64.abs (i64.const 0)))) "type mismatch") +(assert_invalid (module (func (result f64) (f64.neg (i64.const 0)))) "type mismatch") diff --git a/runtime/near-vm/tests/wast/spec/f64_cmp.wast b/runtime/near-vm/tests/wast/spec/f64_cmp.wast new file mode 100644 index 00000000000..dd79929d206 --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/f64_cmp.wast @@ -0,0 +1,2422 @@ +;; Test all the f64 comparison operators on major boundary values and all +;; special values. + +(module + (func (export "eq") (param $x f64) (param $y f64) (result i32) (f64.eq (local.get $x) (local.get $y))) + (func (export "ne") (param $x f64) (param $y f64) (result i32) (f64.ne (local.get $x) (local.get $y))) + (func (export "lt") (param $x f64) (param $y f64) (result i32) (f64.lt (local.get $x) (local.get $y))) + (func (export "le") (param $x f64) (param $y f64) (result i32) (f64.le (local.get $x) (local.get $y))) + (func (export "gt") (param $x f64) (param $y f64) (result i32) (f64.gt (local.get $x) (local.get $y))) + (func (export "ge") (param $x f64) (param $y f64) (result i32) (f64.ge (local.get $x) (local.get $y))) +) + +(assert_return (invoke "eq" (f64.const -0x0p+0) (f64.const -0x0p+0)) (i32.const 1)) +(assert_return (invoke "eq" (f64.const -0x0p+0) (f64.const 0x0p+0)) (i32.const 1)) +(assert_return (invoke "eq" (f64.const 0x0p+0) (f64.const -0x0p+0)) (i32.const 1)) +(assert_return (invoke "eq" (f64.const 0x0p+0) (f64.const 0x0p+0)) (i32.const 1)) +(assert_return (invoke "eq" (f64.const -0x0p+0) (f64.const -0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -0x0p+0) (f64.const 0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const 0x0p+0) (f64.const -0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const 0x0p+0) (f64.const 0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -0x0p+0) (f64.const -0x1p-1022)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -0x0p+0) (f64.const 0x1p-1022)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const 0x0p+0) (f64.const -0x1p-1022)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const 0x0p+0) (f64.const 0x1p-1022)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -0x0p+0) (f64.const -0x1p-1)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -0x0p+0) (f64.const 0x1p-1)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const 0x0p+0) (f64.const -0x1p-1)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const 0x0p+0) (f64.const 0x1p-1)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -0x0p+0) (f64.const -0x1p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -0x0p+0) (f64.const 0x1p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const 0x0p+0) (f64.const -0x1p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const 0x0p+0) (f64.const 0x1p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -0x0p+0) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -0x0p+0) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const 0x0p+0) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const 0x0p+0) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -0x0p+0) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -0x0p+0) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const 0x0p+0) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const 0x0p+0) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -0x0p+0) (f64.const -inf)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -0x0p+0) (f64.const inf)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const 0x0p+0) (f64.const -inf)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const 0x0p+0) (f64.const inf)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -0x0p+0) (f64.const -nan)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -0x0p+0) (f64.const -nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -0x0p+0) (f64.const nan)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -0x0p+0) (f64.const nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const 0x0p+0) (f64.const -nan)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const 0x0p+0) (f64.const -nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const 0x0p+0) (f64.const nan)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const 0x0p+0) (f64.const nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -0x0.0000000000001p-1022) (f64.const -0x0p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -0x0.0000000000001p-1022) (f64.const 0x0p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const 0x0.0000000000001p-1022) (f64.const -0x0p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const 0x0.0000000000001p-1022) (f64.const 0x0p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -0x0.0000000000001p-1022) (f64.const -0x0.0000000000001p-1022)) (i32.const 1)) +(assert_return (invoke "eq" (f64.const -0x0.0000000000001p-1022) (f64.const 0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const 0x0.0000000000001p-1022) (f64.const -0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const 0x0.0000000000001p-1022) (f64.const 0x0.0000000000001p-1022)) (i32.const 1)) +(assert_return (invoke "eq" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1p-1022)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1p-1022)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1p-1022)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1p-1022)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1p-1)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1p-1)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1p-1)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1p-1)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -0x0.0000000000001p-1022) (f64.const -inf)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -0x0.0000000000001p-1022) (f64.const inf)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const 0x0.0000000000001p-1022) (f64.const -inf)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const 0x0.0000000000001p-1022) (f64.const inf)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -0x0.0000000000001p-1022) (f64.const -nan)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -0x0.0000000000001p-1022) (f64.const -nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -0x0.0000000000001p-1022) (f64.const nan)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -0x0.0000000000001p-1022) (f64.const nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const 0x0.0000000000001p-1022) (f64.const -nan)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const 0x0.0000000000001p-1022) (f64.const -nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const 0x0.0000000000001p-1022) (f64.const nan)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const 0x0.0000000000001p-1022) (f64.const nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -0x1p-1022) (f64.const -0x0p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -0x1p-1022) (f64.const 0x0p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const 0x1p-1022) (f64.const -0x0p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const 0x1p-1022) (f64.const 0x0p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -0x1p-1022) (f64.const -0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -0x1p-1022) (f64.const 0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const 0x1p-1022) (f64.const -0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const 0x1p-1022) (f64.const 0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -0x1p-1022) (f64.const -0x1p-1022)) (i32.const 1)) +(assert_return (invoke "eq" (f64.const -0x1p-1022) (f64.const 0x1p-1022)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const 0x1p-1022) (f64.const -0x1p-1022)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const 0x1p-1022) (f64.const 0x1p-1022)) (i32.const 1)) +(assert_return (invoke "eq" (f64.const -0x1p-1022) (f64.const -0x1p-1)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -0x1p-1022) (f64.const 0x1p-1)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const 0x1p-1022) (f64.const -0x1p-1)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const 0x1p-1022) (f64.const 0x1p-1)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -0x1p-1022) (f64.const -0x1p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -0x1p-1022) (f64.const 0x1p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const 0x1p-1022) (f64.const -0x1p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const 0x1p-1022) (f64.const 0x1p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -0x1p-1022) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -0x1p-1022) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const 0x1p-1022) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const 0x1p-1022) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -0x1p-1022) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -0x1p-1022) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const 0x1p-1022) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const 0x1p-1022) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -0x1p-1022) (f64.const -inf)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -0x1p-1022) (f64.const inf)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const 0x1p-1022) (f64.const -inf)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const 0x1p-1022) (f64.const inf)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -0x1p-1022) (f64.const -nan)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -0x1p-1022) (f64.const -nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -0x1p-1022) (f64.const nan)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -0x1p-1022) (f64.const nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const 0x1p-1022) (f64.const -nan)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const 0x1p-1022) (f64.const -nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const 0x1p-1022) (f64.const nan)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const 0x1p-1022) (f64.const nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -0x1p-1) (f64.const -0x0p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -0x1p-1) (f64.const 0x0p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const 0x1p-1) (f64.const -0x0p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const 0x1p-1) (f64.const 0x0p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -0x1p-1) (f64.const -0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -0x1p-1) (f64.const 0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const 0x1p-1) (f64.const -0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const 0x1p-1) (f64.const 0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -0x1p-1) (f64.const -0x1p-1022)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -0x1p-1) (f64.const 0x1p-1022)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const 0x1p-1) (f64.const -0x1p-1022)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const 0x1p-1) (f64.const 0x1p-1022)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -0x1p-1) (f64.const -0x1p-1)) (i32.const 1)) +(assert_return (invoke "eq" (f64.const -0x1p-1) (f64.const 0x1p-1)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const 0x1p-1) (f64.const -0x1p-1)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const 0x1p-1) (f64.const 0x1p-1)) (i32.const 1)) +(assert_return (invoke "eq" (f64.const -0x1p-1) (f64.const -0x1p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -0x1p-1) (f64.const 0x1p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const 0x1p-1) (f64.const -0x1p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const 0x1p-1) (f64.const 0x1p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -0x1p-1) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -0x1p-1) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const 0x1p-1) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const 0x1p-1) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -0x1p-1) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -0x1p-1) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const 0x1p-1) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const 0x1p-1) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -0x1p-1) (f64.const -inf)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -0x1p-1) (f64.const inf)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const 0x1p-1) (f64.const -inf)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const 0x1p-1) (f64.const inf)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -0x1p-1) (f64.const -nan)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -0x1p-1) (f64.const -nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -0x1p-1) (f64.const nan)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -0x1p-1) (f64.const nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const 0x1p-1) (f64.const -nan)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const 0x1p-1) (f64.const -nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const 0x1p-1) (f64.const nan)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const 0x1p-1) (f64.const nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -0x1p+0) (f64.const -0x0p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -0x1p+0) (f64.const 0x0p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const 0x1p+0) (f64.const -0x0p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const 0x1p+0) (f64.const 0x0p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -0x1p+0) (f64.const -0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -0x1p+0) (f64.const 0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const 0x1p+0) (f64.const -0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const 0x1p+0) (f64.const 0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -0x1p+0) (f64.const -0x1p-1022)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -0x1p+0) (f64.const 0x1p-1022)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const 0x1p+0) (f64.const -0x1p-1022)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const 0x1p+0) (f64.const 0x1p-1022)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -0x1p+0) (f64.const -0x1p-1)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -0x1p+0) (f64.const 0x1p-1)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const 0x1p+0) (f64.const -0x1p-1)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const 0x1p+0) (f64.const 0x1p-1)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -0x1p+0) (f64.const -0x1p+0)) (i32.const 1)) +(assert_return (invoke "eq" (f64.const -0x1p+0) (f64.const 0x1p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const 0x1p+0) (f64.const -0x1p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const 0x1p+0) (f64.const 0x1p+0)) (i32.const 1)) +(assert_return (invoke "eq" (f64.const -0x1p+0) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -0x1p+0) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const 0x1p+0) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const 0x1p+0) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -0x1p+0) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -0x1p+0) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const 0x1p+0) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const 0x1p+0) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -0x1p+0) (f64.const -inf)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -0x1p+0) (f64.const inf)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const 0x1p+0) (f64.const -inf)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const 0x1p+0) (f64.const inf)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -0x1p+0) (f64.const -nan)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -0x1p+0) (f64.const -nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -0x1p+0) (f64.const nan)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -0x1p+0) (f64.const nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const 0x1p+0) (f64.const -nan)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const 0x1p+0) (f64.const -nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const 0x1p+0) (f64.const nan)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const 0x1p+0) (f64.const nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x0p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x0p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x0p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x0p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1p-1022)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1p-1022)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1p-1022)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1p-1022)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1p-1)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1p-1)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1p-1)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1p-1)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1.921fb54442d18p+2)) (i32.const 1)) +(assert_return (invoke "eq" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1.921fb54442d18p+2)) (i32.const 1)) +(assert_return (invoke "eq" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -0x1.921fb54442d18p+2) (f64.const -inf)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -0x1.921fb54442d18p+2) (f64.const inf)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const 0x1.921fb54442d18p+2) (f64.const -inf)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const 0x1.921fb54442d18p+2) (f64.const inf)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -0x1.921fb54442d18p+2) (f64.const -nan)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -0x1.921fb54442d18p+2) (f64.const -nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -0x1.921fb54442d18p+2) (f64.const nan)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -0x1.921fb54442d18p+2) (f64.const nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const 0x1.921fb54442d18p+2) (f64.const -nan)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const 0x1.921fb54442d18p+2) (f64.const -nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const 0x1.921fb54442d18p+2) (f64.const nan)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const 0x1.921fb54442d18p+2) (f64.const nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x0p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x0p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x0p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x0p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1p-1022)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1p-1022)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1p-1022)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1p-1022)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1p-1)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1p-1)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1p-1)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1p-1)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1)) +(assert_return (invoke "eq" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1)) +(assert_return (invoke "eq" (f64.const -0x1.fffffffffffffp+1023) (f64.const -inf)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -0x1.fffffffffffffp+1023) (f64.const inf)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const 0x1.fffffffffffffp+1023) (f64.const -inf)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const 0x1.fffffffffffffp+1023) (f64.const inf)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -0x1.fffffffffffffp+1023) (f64.const -nan)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -0x1.fffffffffffffp+1023) (f64.const -nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -0x1.fffffffffffffp+1023) (f64.const nan)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -0x1.fffffffffffffp+1023) (f64.const nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const 0x1.fffffffffffffp+1023) (f64.const -nan)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const 0x1.fffffffffffffp+1023) (f64.const -nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const 0x1.fffffffffffffp+1023) (f64.const nan)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const 0x1.fffffffffffffp+1023) (f64.const nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -inf) (f64.const -0x0p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -inf) (f64.const 0x0p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const inf) (f64.const -0x0p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const inf) (f64.const 0x0p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -inf) (f64.const -0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -inf) (f64.const 0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const inf) (f64.const -0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const inf) (f64.const 0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -inf) (f64.const -0x1p-1022)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -inf) (f64.const 0x1p-1022)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const inf) (f64.const -0x1p-1022)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const inf) (f64.const 0x1p-1022)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -inf) (f64.const -0x1p-1)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -inf) (f64.const 0x1p-1)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const inf) (f64.const -0x1p-1)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const inf) (f64.const 0x1p-1)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -inf) (f64.const -0x1p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -inf) (f64.const 0x1p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const inf) (f64.const -0x1p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const inf) (f64.const 0x1p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -inf) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -inf) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const inf) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const inf) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -inf) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -inf) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const inf) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const inf) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -inf) (f64.const -inf)) (i32.const 1)) +(assert_return (invoke "eq" (f64.const -inf) (f64.const inf)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const inf) (f64.const -inf)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const inf) (f64.const inf)) (i32.const 1)) +(assert_return (invoke "eq" (f64.const -inf) (f64.const -nan)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -inf) (f64.const -nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -inf) (f64.const nan)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -inf) (f64.const nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const inf) (f64.const -nan)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const inf) (f64.const -nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const inf) (f64.const nan)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const inf) (f64.const nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -nan) (f64.const -0x0p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -nan:0x4000000000000) (f64.const -0x0p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -nan) (f64.const 0x0p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -nan:0x4000000000000) (f64.const 0x0p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const nan) (f64.const -0x0p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const nan:0x4000000000000) (f64.const -0x0p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const nan) (f64.const 0x0p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const nan:0x4000000000000) (f64.const 0x0p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -nan) (f64.const -0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -nan:0x4000000000000) (f64.const -0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -nan) (f64.const 0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -nan:0x4000000000000) (f64.const 0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const nan) (f64.const -0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const nan:0x4000000000000) (f64.const -0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const nan) (f64.const 0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const nan:0x4000000000000) (f64.const 0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -nan) (f64.const -0x1p-1022)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -nan:0x4000000000000) (f64.const -0x1p-1022)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -nan) (f64.const 0x1p-1022)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -nan:0x4000000000000) (f64.const 0x1p-1022)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const nan) (f64.const -0x1p-1022)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const nan:0x4000000000000) (f64.const -0x1p-1022)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const nan) (f64.const 0x1p-1022)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const nan:0x4000000000000) (f64.const 0x1p-1022)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -nan) (f64.const -0x1p-1)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -nan:0x4000000000000) (f64.const -0x1p-1)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -nan) (f64.const 0x1p-1)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -nan:0x4000000000000) (f64.const 0x1p-1)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const nan) (f64.const -0x1p-1)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const nan:0x4000000000000) (f64.const -0x1p-1)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const nan) (f64.const 0x1p-1)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const nan:0x4000000000000) (f64.const 0x1p-1)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -nan) (f64.const -0x1p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -nan:0x4000000000000) (f64.const -0x1p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -nan) (f64.const 0x1p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -nan:0x4000000000000) (f64.const 0x1p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const nan) (f64.const -0x1p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const nan:0x4000000000000) (f64.const -0x1p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const nan) (f64.const 0x1p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const nan:0x4000000000000) (f64.const 0x1p+0)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -nan) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -nan:0x4000000000000) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -nan) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -nan:0x4000000000000) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const nan) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const nan:0x4000000000000) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const nan) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const nan:0x4000000000000) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -nan) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -nan:0x4000000000000) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -nan) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -nan:0x4000000000000) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const nan) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const nan:0x4000000000000) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const nan) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const nan:0x4000000000000) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -nan) (f64.const -inf)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -nan:0x4000000000000) (f64.const -inf)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -nan) (f64.const inf)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -nan:0x4000000000000) (f64.const inf)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const nan) (f64.const -inf)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const nan:0x4000000000000) (f64.const -inf)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const nan) (f64.const inf)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const nan:0x4000000000000) (f64.const inf)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -nan) (f64.const -nan)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -nan:0x4000000000000) (f64.const -nan)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -nan) (f64.const -nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -nan:0x4000000000000) (f64.const -nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -nan) (f64.const nan)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -nan:0x4000000000000) (f64.const nan)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -nan) (f64.const nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const -nan:0x4000000000000) (f64.const nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const nan) (f64.const -nan)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const nan:0x4000000000000) (f64.const -nan)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const nan) (f64.const -nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const nan:0x4000000000000) (f64.const -nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const nan) (f64.const nan)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const nan:0x4000000000000) (f64.const nan)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const nan) (f64.const nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "eq" (f64.const nan:0x4000000000000) (f64.const nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "ne" (f64.const -0x0p+0) (f64.const -0x0p+0)) (i32.const 0)) +(assert_return (invoke "ne" (f64.const -0x0p+0) (f64.const 0x0p+0)) (i32.const 0)) +(assert_return (invoke "ne" (f64.const 0x0p+0) (f64.const -0x0p+0)) (i32.const 0)) +(assert_return (invoke "ne" (f64.const 0x0p+0) (f64.const 0x0p+0)) (i32.const 0)) +(assert_return (invoke "ne" (f64.const -0x0p+0) (f64.const -0x0.0000000000001p-1022)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -0x0p+0) (f64.const 0x0.0000000000001p-1022)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const 0x0p+0) (f64.const -0x0.0000000000001p-1022)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const 0x0p+0) (f64.const 0x0.0000000000001p-1022)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -0x0p+0) (f64.const -0x1p-1022)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -0x0p+0) (f64.const 0x1p-1022)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const 0x0p+0) (f64.const -0x1p-1022)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const 0x0p+0) (f64.const 0x1p-1022)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -0x0p+0) (f64.const -0x1p-1)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -0x0p+0) (f64.const 0x1p-1)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const 0x0p+0) (f64.const -0x1p-1)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const 0x0p+0) (f64.const 0x1p-1)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -0x0p+0) (f64.const -0x1p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -0x0p+0) (f64.const 0x1p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const 0x0p+0) (f64.const -0x1p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const 0x0p+0) (f64.const 0x1p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -0x0p+0) (f64.const -0x1.921fb54442d18p+2)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -0x0p+0) (f64.const 0x1.921fb54442d18p+2)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const 0x0p+0) (f64.const -0x1.921fb54442d18p+2)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const 0x0p+0) (f64.const 0x1.921fb54442d18p+2)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -0x0p+0) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -0x0p+0) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const 0x0p+0) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const 0x0p+0) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -0x0p+0) (f64.const -inf)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -0x0p+0) (f64.const inf)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const 0x0p+0) (f64.const -inf)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const 0x0p+0) (f64.const inf)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -0x0p+0) (f64.const -nan)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -0x0p+0) (f64.const -nan:0x4000000000000)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -0x0p+0) (f64.const nan)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -0x0p+0) (f64.const nan:0x4000000000000)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const 0x0p+0) (f64.const -nan)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const 0x0p+0) (f64.const -nan:0x4000000000000)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const 0x0p+0) (f64.const nan)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const 0x0p+0) (f64.const nan:0x4000000000000)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -0x0.0000000000001p-1022) (f64.const -0x0p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -0x0.0000000000001p-1022) (f64.const 0x0p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const 0x0.0000000000001p-1022) (f64.const -0x0p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const 0x0.0000000000001p-1022) (f64.const 0x0p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -0x0.0000000000001p-1022) (f64.const -0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "ne" (f64.const -0x0.0000000000001p-1022) (f64.const 0x0.0000000000001p-1022)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const 0x0.0000000000001p-1022) (f64.const -0x0.0000000000001p-1022)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const 0x0.0000000000001p-1022) (f64.const 0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "ne" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1p-1022)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1p-1022)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1p-1022)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1p-1022)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1p-1)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1p-1)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1p-1)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1p-1)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1.921fb54442d18p+2)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1.921fb54442d18p+2)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1.921fb54442d18p+2)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1.921fb54442d18p+2)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -0x0.0000000000001p-1022) (f64.const -inf)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -0x0.0000000000001p-1022) (f64.const inf)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const 0x0.0000000000001p-1022) (f64.const -inf)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const 0x0.0000000000001p-1022) (f64.const inf)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -0x0.0000000000001p-1022) (f64.const -nan)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -0x0.0000000000001p-1022) (f64.const -nan:0x4000000000000)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -0x0.0000000000001p-1022) (f64.const nan)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -0x0.0000000000001p-1022) (f64.const nan:0x4000000000000)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const 0x0.0000000000001p-1022) (f64.const -nan)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const 0x0.0000000000001p-1022) (f64.const -nan:0x4000000000000)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const 0x0.0000000000001p-1022) (f64.const nan)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const 0x0.0000000000001p-1022) (f64.const nan:0x4000000000000)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -0x1p-1022) (f64.const -0x0p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -0x1p-1022) (f64.const 0x0p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const 0x1p-1022) (f64.const -0x0p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const 0x1p-1022) (f64.const 0x0p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -0x1p-1022) (f64.const -0x0.0000000000001p-1022)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -0x1p-1022) (f64.const 0x0.0000000000001p-1022)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const 0x1p-1022) (f64.const -0x0.0000000000001p-1022)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const 0x1p-1022) (f64.const 0x0.0000000000001p-1022)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -0x1p-1022) (f64.const -0x1p-1022)) (i32.const 0)) +(assert_return (invoke "ne" (f64.const -0x1p-1022) (f64.const 0x1p-1022)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const 0x1p-1022) (f64.const -0x1p-1022)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const 0x1p-1022) (f64.const 0x1p-1022)) (i32.const 0)) +(assert_return (invoke "ne" (f64.const -0x1p-1022) (f64.const -0x1p-1)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -0x1p-1022) (f64.const 0x1p-1)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const 0x1p-1022) (f64.const -0x1p-1)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const 0x1p-1022) (f64.const 0x1p-1)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -0x1p-1022) (f64.const -0x1p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -0x1p-1022) (f64.const 0x1p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const 0x1p-1022) (f64.const -0x1p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const 0x1p-1022) (f64.const 0x1p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -0x1p-1022) (f64.const -0x1.921fb54442d18p+2)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -0x1p-1022) (f64.const 0x1.921fb54442d18p+2)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const 0x1p-1022) (f64.const -0x1.921fb54442d18p+2)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const 0x1p-1022) (f64.const 0x1.921fb54442d18p+2)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -0x1p-1022) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -0x1p-1022) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const 0x1p-1022) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const 0x1p-1022) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -0x1p-1022) (f64.const -inf)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -0x1p-1022) (f64.const inf)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const 0x1p-1022) (f64.const -inf)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const 0x1p-1022) (f64.const inf)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -0x1p-1022) (f64.const -nan)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -0x1p-1022) (f64.const -nan:0x4000000000000)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -0x1p-1022) (f64.const nan)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -0x1p-1022) (f64.const nan:0x4000000000000)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const 0x1p-1022) (f64.const -nan)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const 0x1p-1022) (f64.const -nan:0x4000000000000)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const 0x1p-1022) (f64.const nan)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const 0x1p-1022) (f64.const nan:0x4000000000000)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -0x1p-1) (f64.const -0x0p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -0x1p-1) (f64.const 0x0p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const 0x1p-1) (f64.const -0x0p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const 0x1p-1) (f64.const 0x0p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -0x1p-1) (f64.const -0x0.0000000000001p-1022)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -0x1p-1) (f64.const 0x0.0000000000001p-1022)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const 0x1p-1) (f64.const -0x0.0000000000001p-1022)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const 0x1p-1) (f64.const 0x0.0000000000001p-1022)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -0x1p-1) (f64.const -0x1p-1022)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -0x1p-1) (f64.const 0x1p-1022)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const 0x1p-1) (f64.const -0x1p-1022)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const 0x1p-1) (f64.const 0x1p-1022)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -0x1p-1) (f64.const -0x1p-1)) (i32.const 0)) +(assert_return (invoke "ne" (f64.const -0x1p-1) (f64.const 0x1p-1)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const 0x1p-1) (f64.const -0x1p-1)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const 0x1p-1) (f64.const 0x1p-1)) (i32.const 0)) +(assert_return (invoke "ne" (f64.const -0x1p-1) (f64.const -0x1p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -0x1p-1) (f64.const 0x1p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const 0x1p-1) (f64.const -0x1p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const 0x1p-1) (f64.const 0x1p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -0x1p-1) (f64.const -0x1.921fb54442d18p+2)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -0x1p-1) (f64.const 0x1.921fb54442d18p+2)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const 0x1p-1) (f64.const -0x1.921fb54442d18p+2)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const 0x1p-1) (f64.const 0x1.921fb54442d18p+2)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -0x1p-1) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -0x1p-1) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const 0x1p-1) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const 0x1p-1) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -0x1p-1) (f64.const -inf)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -0x1p-1) (f64.const inf)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const 0x1p-1) (f64.const -inf)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const 0x1p-1) (f64.const inf)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -0x1p-1) (f64.const -nan)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -0x1p-1) (f64.const -nan:0x4000000000000)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -0x1p-1) (f64.const nan)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -0x1p-1) (f64.const nan:0x4000000000000)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const 0x1p-1) (f64.const -nan)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const 0x1p-1) (f64.const -nan:0x4000000000000)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const 0x1p-1) (f64.const nan)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const 0x1p-1) (f64.const nan:0x4000000000000)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -0x1p+0) (f64.const -0x0p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -0x1p+0) (f64.const 0x0p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const 0x1p+0) (f64.const -0x0p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const 0x1p+0) (f64.const 0x0p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -0x1p+0) (f64.const -0x0.0000000000001p-1022)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -0x1p+0) (f64.const 0x0.0000000000001p-1022)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const 0x1p+0) (f64.const -0x0.0000000000001p-1022)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const 0x1p+0) (f64.const 0x0.0000000000001p-1022)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -0x1p+0) (f64.const -0x1p-1022)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -0x1p+0) (f64.const 0x1p-1022)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const 0x1p+0) (f64.const -0x1p-1022)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const 0x1p+0) (f64.const 0x1p-1022)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -0x1p+0) (f64.const -0x1p-1)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -0x1p+0) (f64.const 0x1p-1)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const 0x1p+0) (f64.const -0x1p-1)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const 0x1p+0) (f64.const 0x1p-1)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -0x1p+0) (f64.const -0x1p+0)) (i32.const 0)) +(assert_return (invoke "ne" (f64.const -0x1p+0) (f64.const 0x1p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const 0x1p+0) (f64.const -0x1p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const 0x1p+0) (f64.const 0x1p+0)) (i32.const 0)) +(assert_return (invoke "ne" (f64.const -0x1p+0) (f64.const -0x1.921fb54442d18p+2)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -0x1p+0) (f64.const 0x1.921fb54442d18p+2)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const 0x1p+0) (f64.const -0x1.921fb54442d18p+2)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const 0x1p+0) (f64.const 0x1.921fb54442d18p+2)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -0x1p+0) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -0x1p+0) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const 0x1p+0) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const 0x1p+0) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -0x1p+0) (f64.const -inf)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -0x1p+0) (f64.const inf)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const 0x1p+0) (f64.const -inf)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const 0x1p+0) (f64.const inf)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -0x1p+0) (f64.const -nan)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -0x1p+0) (f64.const -nan:0x4000000000000)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -0x1p+0) (f64.const nan)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -0x1p+0) (f64.const nan:0x4000000000000)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const 0x1p+0) (f64.const -nan)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const 0x1p+0) (f64.const -nan:0x4000000000000)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const 0x1p+0) (f64.const nan)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const 0x1p+0) (f64.const nan:0x4000000000000)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x0p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x0p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x0p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x0p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x0.0000000000001p-1022)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x0.0000000000001p-1022)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x0.0000000000001p-1022)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x0.0000000000001p-1022)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1p-1022)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1p-1022)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1p-1022)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1p-1022)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1p-1)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1p-1)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1p-1)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1p-1)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0)) +(assert_return (invoke "ne" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1.921fb54442d18p+2)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1.921fb54442d18p+2)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0)) +(assert_return (invoke "ne" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -0x1.921fb54442d18p+2) (f64.const -inf)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -0x1.921fb54442d18p+2) (f64.const inf)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const 0x1.921fb54442d18p+2) (f64.const -inf)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const 0x1.921fb54442d18p+2) (f64.const inf)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -0x1.921fb54442d18p+2) (f64.const -nan)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -0x1.921fb54442d18p+2) (f64.const -nan:0x4000000000000)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -0x1.921fb54442d18p+2) (f64.const nan)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -0x1.921fb54442d18p+2) (f64.const nan:0x4000000000000)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const 0x1.921fb54442d18p+2) (f64.const -nan)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const 0x1.921fb54442d18p+2) (f64.const -nan:0x4000000000000)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const 0x1.921fb54442d18p+2) (f64.const nan)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const 0x1.921fb54442d18p+2) (f64.const nan:0x4000000000000)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x0p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x0p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x0p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x0p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x0.0000000000001p-1022)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x0.0000000000001p-1022)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x0.0000000000001p-1022)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x0.0000000000001p-1022)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1p-1022)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1p-1022)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1p-1022)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1p-1022)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1p-1)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1p-1)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1p-1)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1p-1)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1.921fb54442d18p+2)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1.921fb54442d18p+2)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1.921fb54442d18p+2)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1.921fb54442d18p+2)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0)) +(assert_return (invoke "ne" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0)) +(assert_return (invoke "ne" (f64.const -0x1.fffffffffffffp+1023) (f64.const -inf)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -0x1.fffffffffffffp+1023) (f64.const inf)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const 0x1.fffffffffffffp+1023) (f64.const -inf)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const 0x1.fffffffffffffp+1023) (f64.const inf)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -0x1.fffffffffffffp+1023) (f64.const -nan)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -0x1.fffffffffffffp+1023) (f64.const -nan:0x4000000000000)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -0x1.fffffffffffffp+1023) (f64.const nan)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -0x1.fffffffffffffp+1023) (f64.const nan:0x4000000000000)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const 0x1.fffffffffffffp+1023) (f64.const -nan)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const 0x1.fffffffffffffp+1023) (f64.const -nan:0x4000000000000)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const 0x1.fffffffffffffp+1023) (f64.const nan)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const 0x1.fffffffffffffp+1023) (f64.const nan:0x4000000000000)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -inf) (f64.const -0x0p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -inf) (f64.const 0x0p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const inf) (f64.const -0x0p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const inf) (f64.const 0x0p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -inf) (f64.const -0x0.0000000000001p-1022)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -inf) (f64.const 0x0.0000000000001p-1022)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const inf) (f64.const -0x0.0000000000001p-1022)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const inf) (f64.const 0x0.0000000000001p-1022)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -inf) (f64.const -0x1p-1022)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -inf) (f64.const 0x1p-1022)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const inf) (f64.const -0x1p-1022)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const inf) (f64.const 0x1p-1022)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -inf) (f64.const -0x1p-1)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -inf) (f64.const 0x1p-1)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const inf) (f64.const -0x1p-1)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const inf) (f64.const 0x1p-1)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -inf) (f64.const -0x1p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -inf) (f64.const 0x1p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const inf) (f64.const -0x1p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const inf) (f64.const 0x1p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -inf) (f64.const -0x1.921fb54442d18p+2)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -inf) (f64.const 0x1.921fb54442d18p+2)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const inf) (f64.const -0x1.921fb54442d18p+2)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const inf) (f64.const 0x1.921fb54442d18p+2)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -inf) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -inf) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const inf) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const inf) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -inf) (f64.const -inf)) (i32.const 0)) +(assert_return (invoke "ne" (f64.const -inf) (f64.const inf)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const inf) (f64.const -inf)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const inf) (f64.const inf)) (i32.const 0)) +(assert_return (invoke "ne" (f64.const -inf) (f64.const -nan)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -inf) (f64.const -nan:0x4000000000000)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -inf) (f64.const nan)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -inf) (f64.const nan:0x4000000000000)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const inf) (f64.const -nan)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const inf) (f64.const -nan:0x4000000000000)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const inf) (f64.const nan)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const inf) (f64.const nan:0x4000000000000)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -nan) (f64.const -0x0p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -nan:0x4000000000000) (f64.const -0x0p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -nan) (f64.const 0x0p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -nan:0x4000000000000) (f64.const 0x0p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const nan) (f64.const -0x0p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const nan:0x4000000000000) (f64.const -0x0p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const nan) (f64.const 0x0p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const nan:0x4000000000000) (f64.const 0x0p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -nan) (f64.const -0x0.0000000000001p-1022)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -nan:0x4000000000000) (f64.const -0x0.0000000000001p-1022)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -nan) (f64.const 0x0.0000000000001p-1022)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -nan:0x4000000000000) (f64.const 0x0.0000000000001p-1022)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const nan) (f64.const -0x0.0000000000001p-1022)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const nan:0x4000000000000) (f64.const -0x0.0000000000001p-1022)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const nan) (f64.const 0x0.0000000000001p-1022)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const nan:0x4000000000000) (f64.const 0x0.0000000000001p-1022)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -nan) (f64.const -0x1p-1022)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -nan:0x4000000000000) (f64.const -0x1p-1022)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -nan) (f64.const 0x1p-1022)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -nan:0x4000000000000) (f64.const 0x1p-1022)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const nan) (f64.const -0x1p-1022)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const nan:0x4000000000000) (f64.const -0x1p-1022)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const nan) (f64.const 0x1p-1022)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const nan:0x4000000000000) (f64.const 0x1p-1022)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -nan) (f64.const -0x1p-1)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -nan:0x4000000000000) (f64.const -0x1p-1)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -nan) (f64.const 0x1p-1)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -nan:0x4000000000000) (f64.const 0x1p-1)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const nan) (f64.const -0x1p-1)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const nan:0x4000000000000) (f64.const -0x1p-1)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const nan) (f64.const 0x1p-1)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const nan:0x4000000000000) (f64.const 0x1p-1)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -nan) (f64.const -0x1p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -nan:0x4000000000000) (f64.const -0x1p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -nan) (f64.const 0x1p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -nan:0x4000000000000) (f64.const 0x1p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const nan) (f64.const -0x1p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const nan:0x4000000000000) (f64.const -0x1p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const nan) (f64.const 0x1p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const nan:0x4000000000000) (f64.const 0x1p+0)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -nan) (f64.const -0x1.921fb54442d18p+2)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -nan:0x4000000000000) (f64.const -0x1.921fb54442d18p+2)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -nan) (f64.const 0x1.921fb54442d18p+2)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -nan:0x4000000000000) (f64.const 0x1.921fb54442d18p+2)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const nan) (f64.const -0x1.921fb54442d18p+2)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const nan:0x4000000000000) (f64.const -0x1.921fb54442d18p+2)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const nan) (f64.const 0x1.921fb54442d18p+2)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const nan:0x4000000000000) (f64.const 0x1.921fb54442d18p+2)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -nan) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -nan:0x4000000000000) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -nan) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -nan:0x4000000000000) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const nan) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const nan:0x4000000000000) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const nan) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const nan:0x4000000000000) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -nan) (f64.const -inf)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -nan:0x4000000000000) (f64.const -inf)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -nan) (f64.const inf)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -nan:0x4000000000000) (f64.const inf)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const nan) (f64.const -inf)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const nan:0x4000000000000) (f64.const -inf)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const nan) (f64.const inf)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const nan:0x4000000000000) (f64.const inf)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -nan) (f64.const -nan)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -nan:0x4000000000000) (f64.const -nan)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -nan) (f64.const -nan:0x4000000000000)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -nan:0x4000000000000) (f64.const -nan:0x4000000000000)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -nan) (f64.const nan)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -nan:0x4000000000000) (f64.const nan)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -nan) (f64.const nan:0x4000000000000)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const -nan:0x4000000000000) (f64.const nan:0x4000000000000)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const nan) (f64.const -nan)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const nan:0x4000000000000) (f64.const -nan)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const nan) (f64.const -nan:0x4000000000000)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const nan:0x4000000000000) (f64.const -nan:0x4000000000000)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const nan) (f64.const nan)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const nan:0x4000000000000) (f64.const nan)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const nan) (f64.const nan:0x4000000000000)) (i32.const 1)) +(assert_return (invoke "ne" (f64.const nan:0x4000000000000) (f64.const nan:0x4000000000000)) (i32.const 1)) +(assert_return (invoke "lt" (f64.const -0x0p+0) (f64.const -0x0p+0)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -0x0p+0) (f64.const 0x0p+0)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const 0x0p+0) (f64.const -0x0p+0)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const 0x0p+0) (f64.const 0x0p+0)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -0x0p+0) (f64.const -0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -0x0p+0) (f64.const 0x0.0000000000001p-1022)) (i32.const 1)) +(assert_return (invoke "lt" (f64.const 0x0p+0) (f64.const -0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const 0x0p+0) (f64.const 0x0.0000000000001p-1022)) (i32.const 1)) +(assert_return (invoke "lt" (f64.const -0x0p+0) (f64.const -0x1p-1022)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -0x0p+0) (f64.const 0x1p-1022)) (i32.const 1)) +(assert_return (invoke "lt" (f64.const 0x0p+0) (f64.const -0x1p-1022)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const 0x0p+0) (f64.const 0x1p-1022)) (i32.const 1)) +(assert_return (invoke "lt" (f64.const -0x0p+0) (f64.const -0x1p-1)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -0x0p+0) (f64.const 0x1p-1)) (i32.const 1)) +(assert_return (invoke "lt" (f64.const 0x0p+0) (f64.const -0x1p-1)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const 0x0p+0) (f64.const 0x1p-1)) (i32.const 1)) +(assert_return (invoke "lt" (f64.const -0x0p+0) (f64.const -0x1p+0)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -0x0p+0) (f64.const 0x1p+0)) (i32.const 1)) +(assert_return (invoke "lt" (f64.const 0x0p+0) (f64.const -0x1p+0)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const 0x0p+0) (f64.const 0x1p+0)) (i32.const 1)) +(assert_return (invoke "lt" (f64.const -0x0p+0) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -0x0p+0) (f64.const 0x1.921fb54442d18p+2)) (i32.const 1)) +(assert_return (invoke "lt" (f64.const 0x0p+0) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const 0x0p+0) (f64.const 0x1.921fb54442d18p+2)) (i32.const 1)) +(assert_return (invoke "lt" (f64.const -0x0p+0) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -0x0p+0) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1)) +(assert_return (invoke "lt" (f64.const 0x0p+0) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const 0x0p+0) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1)) +(assert_return (invoke "lt" (f64.const -0x0p+0) (f64.const -inf)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -0x0p+0) (f64.const inf)) (i32.const 1)) +(assert_return (invoke "lt" (f64.const 0x0p+0) (f64.const -inf)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const 0x0p+0) (f64.const inf)) (i32.const 1)) +(assert_return (invoke "lt" (f64.const -0x0p+0) (f64.const -nan)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -0x0p+0) (f64.const -nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -0x0p+0) (f64.const nan)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -0x0p+0) (f64.const nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const 0x0p+0) (f64.const -nan)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const 0x0p+0) (f64.const -nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const 0x0p+0) (f64.const nan)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const 0x0p+0) (f64.const nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -0x0.0000000000001p-1022) (f64.const -0x0p+0)) (i32.const 1)) +(assert_return (invoke "lt" (f64.const -0x0.0000000000001p-1022) (f64.const 0x0p+0)) (i32.const 1)) +(assert_return (invoke "lt" (f64.const 0x0.0000000000001p-1022) (f64.const -0x0p+0)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const 0x0.0000000000001p-1022) (f64.const 0x0p+0)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -0x0.0000000000001p-1022) (f64.const -0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -0x0.0000000000001p-1022) (f64.const 0x0.0000000000001p-1022)) (i32.const 1)) +(assert_return (invoke "lt" (f64.const 0x0.0000000000001p-1022) (f64.const -0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const 0x0.0000000000001p-1022) (f64.const 0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1p-1022)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1p-1022)) (i32.const 1)) +(assert_return (invoke "lt" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1p-1022)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1p-1022)) (i32.const 1)) +(assert_return (invoke "lt" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1p-1)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1p-1)) (i32.const 1)) +(assert_return (invoke "lt" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1p-1)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1p-1)) (i32.const 1)) +(assert_return (invoke "lt" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1p+0)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1p+0)) (i32.const 1)) +(assert_return (invoke "lt" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1p+0)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1p+0)) (i32.const 1)) +(assert_return (invoke "lt" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1.921fb54442d18p+2)) (i32.const 1)) +(assert_return (invoke "lt" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1.921fb54442d18p+2)) (i32.const 1)) +(assert_return (invoke "lt" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1)) +(assert_return (invoke "lt" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1)) +(assert_return (invoke "lt" (f64.const -0x0.0000000000001p-1022) (f64.const -inf)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -0x0.0000000000001p-1022) (f64.const inf)) (i32.const 1)) +(assert_return (invoke "lt" (f64.const 0x0.0000000000001p-1022) (f64.const -inf)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const 0x0.0000000000001p-1022) (f64.const inf)) (i32.const 1)) +(assert_return (invoke "lt" (f64.const -0x0.0000000000001p-1022) (f64.const -nan)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -0x0.0000000000001p-1022) (f64.const -nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -0x0.0000000000001p-1022) (f64.const nan)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -0x0.0000000000001p-1022) (f64.const nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const 0x0.0000000000001p-1022) (f64.const -nan)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const 0x0.0000000000001p-1022) (f64.const -nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const 0x0.0000000000001p-1022) (f64.const nan)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const 0x0.0000000000001p-1022) (f64.const nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -0x1p-1022) (f64.const -0x0p+0)) (i32.const 1)) +(assert_return (invoke "lt" (f64.const -0x1p-1022) (f64.const 0x0p+0)) (i32.const 1)) +(assert_return (invoke "lt" (f64.const 0x1p-1022) (f64.const -0x0p+0)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const 0x1p-1022) (f64.const 0x0p+0)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -0x1p-1022) (f64.const -0x0.0000000000001p-1022)) (i32.const 1)) +(assert_return (invoke "lt" (f64.const -0x1p-1022) (f64.const 0x0.0000000000001p-1022)) (i32.const 1)) +(assert_return (invoke "lt" (f64.const 0x1p-1022) (f64.const -0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const 0x1p-1022) (f64.const 0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -0x1p-1022) (f64.const -0x1p-1022)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -0x1p-1022) (f64.const 0x1p-1022)) (i32.const 1)) +(assert_return (invoke "lt" (f64.const 0x1p-1022) (f64.const -0x1p-1022)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const 0x1p-1022) (f64.const 0x1p-1022)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -0x1p-1022) (f64.const -0x1p-1)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -0x1p-1022) (f64.const 0x1p-1)) (i32.const 1)) +(assert_return (invoke "lt" (f64.const 0x1p-1022) (f64.const -0x1p-1)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const 0x1p-1022) (f64.const 0x1p-1)) (i32.const 1)) +(assert_return (invoke "lt" (f64.const -0x1p-1022) (f64.const -0x1p+0)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -0x1p-1022) (f64.const 0x1p+0)) (i32.const 1)) +(assert_return (invoke "lt" (f64.const 0x1p-1022) (f64.const -0x1p+0)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const 0x1p-1022) (f64.const 0x1p+0)) (i32.const 1)) +(assert_return (invoke "lt" (f64.const -0x1p-1022) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -0x1p-1022) (f64.const 0x1.921fb54442d18p+2)) (i32.const 1)) +(assert_return (invoke "lt" (f64.const 0x1p-1022) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const 0x1p-1022) (f64.const 0x1.921fb54442d18p+2)) (i32.const 1)) +(assert_return (invoke "lt" (f64.const -0x1p-1022) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -0x1p-1022) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1)) +(assert_return (invoke "lt" (f64.const 0x1p-1022) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const 0x1p-1022) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1)) +(assert_return (invoke "lt" (f64.const -0x1p-1022) (f64.const -inf)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -0x1p-1022) (f64.const inf)) (i32.const 1)) +(assert_return (invoke "lt" (f64.const 0x1p-1022) (f64.const -inf)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const 0x1p-1022) (f64.const inf)) (i32.const 1)) +(assert_return (invoke "lt" (f64.const -0x1p-1022) (f64.const -nan)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -0x1p-1022) (f64.const -nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -0x1p-1022) (f64.const nan)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -0x1p-1022) (f64.const nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const 0x1p-1022) (f64.const -nan)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const 0x1p-1022) (f64.const -nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const 0x1p-1022) (f64.const nan)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const 0x1p-1022) (f64.const nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -0x1p-1) (f64.const -0x0p+0)) (i32.const 1)) +(assert_return (invoke "lt" (f64.const -0x1p-1) (f64.const 0x0p+0)) (i32.const 1)) +(assert_return (invoke "lt" (f64.const 0x1p-1) (f64.const -0x0p+0)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const 0x1p-1) (f64.const 0x0p+0)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -0x1p-1) (f64.const -0x0.0000000000001p-1022)) (i32.const 1)) +(assert_return (invoke "lt" (f64.const -0x1p-1) (f64.const 0x0.0000000000001p-1022)) (i32.const 1)) +(assert_return (invoke "lt" (f64.const 0x1p-1) (f64.const -0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const 0x1p-1) (f64.const 0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -0x1p-1) (f64.const -0x1p-1022)) (i32.const 1)) +(assert_return (invoke "lt" (f64.const -0x1p-1) (f64.const 0x1p-1022)) (i32.const 1)) +(assert_return (invoke "lt" (f64.const 0x1p-1) (f64.const -0x1p-1022)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const 0x1p-1) (f64.const 0x1p-1022)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -0x1p-1) (f64.const -0x1p-1)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -0x1p-1) (f64.const 0x1p-1)) (i32.const 1)) +(assert_return (invoke "lt" (f64.const 0x1p-1) (f64.const -0x1p-1)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const 0x1p-1) (f64.const 0x1p-1)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -0x1p-1) (f64.const -0x1p+0)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -0x1p-1) (f64.const 0x1p+0)) (i32.const 1)) +(assert_return (invoke "lt" (f64.const 0x1p-1) (f64.const -0x1p+0)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const 0x1p-1) (f64.const 0x1p+0)) (i32.const 1)) +(assert_return (invoke "lt" (f64.const -0x1p-1) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -0x1p-1) (f64.const 0x1.921fb54442d18p+2)) (i32.const 1)) +(assert_return (invoke "lt" (f64.const 0x1p-1) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const 0x1p-1) (f64.const 0x1.921fb54442d18p+2)) (i32.const 1)) +(assert_return (invoke "lt" (f64.const -0x1p-1) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -0x1p-1) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1)) +(assert_return (invoke "lt" (f64.const 0x1p-1) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const 0x1p-1) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1)) +(assert_return (invoke "lt" (f64.const -0x1p-1) (f64.const -inf)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -0x1p-1) (f64.const inf)) (i32.const 1)) +(assert_return (invoke "lt" (f64.const 0x1p-1) (f64.const -inf)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const 0x1p-1) (f64.const inf)) (i32.const 1)) +(assert_return (invoke "lt" (f64.const -0x1p-1) (f64.const -nan)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -0x1p-1) (f64.const -nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -0x1p-1) (f64.const nan)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -0x1p-1) (f64.const nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const 0x1p-1) (f64.const -nan)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const 0x1p-1) (f64.const -nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const 0x1p-1) (f64.const nan)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const 0x1p-1) (f64.const nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -0x1p+0) (f64.const -0x0p+0)) (i32.const 1)) +(assert_return (invoke "lt" (f64.const -0x1p+0) (f64.const 0x0p+0)) (i32.const 1)) +(assert_return (invoke "lt" (f64.const 0x1p+0) (f64.const -0x0p+0)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const 0x1p+0) (f64.const 0x0p+0)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -0x1p+0) (f64.const -0x0.0000000000001p-1022)) (i32.const 1)) +(assert_return (invoke "lt" (f64.const -0x1p+0) (f64.const 0x0.0000000000001p-1022)) (i32.const 1)) +(assert_return (invoke "lt" (f64.const 0x1p+0) (f64.const -0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const 0x1p+0) (f64.const 0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -0x1p+0) (f64.const -0x1p-1022)) (i32.const 1)) +(assert_return (invoke "lt" (f64.const -0x1p+0) (f64.const 0x1p-1022)) (i32.const 1)) +(assert_return (invoke "lt" (f64.const 0x1p+0) (f64.const -0x1p-1022)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const 0x1p+0) (f64.const 0x1p-1022)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -0x1p+0) (f64.const -0x1p-1)) (i32.const 1)) +(assert_return (invoke "lt" (f64.const -0x1p+0) (f64.const 0x1p-1)) (i32.const 1)) +(assert_return (invoke "lt" (f64.const 0x1p+0) (f64.const -0x1p-1)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const 0x1p+0) (f64.const 0x1p-1)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -0x1p+0) (f64.const -0x1p+0)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -0x1p+0) (f64.const 0x1p+0)) (i32.const 1)) +(assert_return (invoke "lt" (f64.const 0x1p+0) (f64.const -0x1p+0)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const 0x1p+0) (f64.const 0x1p+0)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -0x1p+0) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -0x1p+0) (f64.const 0x1.921fb54442d18p+2)) (i32.const 1)) +(assert_return (invoke "lt" (f64.const 0x1p+0) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const 0x1p+0) (f64.const 0x1.921fb54442d18p+2)) (i32.const 1)) +(assert_return (invoke "lt" (f64.const -0x1p+0) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -0x1p+0) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1)) +(assert_return (invoke "lt" (f64.const 0x1p+0) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const 0x1p+0) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1)) +(assert_return (invoke "lt" (f64.const -0x1p+0) (f64.const -inf)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -0x1p+0) (f64.const inf)) (i32.const 1)) +(assert_return (invoke "lt" (f64.const 0x1p+0) (f64.const -inf)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const 0x1p+0) (f64.const inf)) (i32.const 1)) +(assert_return (invoke "lt" (f64.const -0x1p+0) (f64.const -nan)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -0x1p+0) (f64.const -nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -0x1p+0) (f64.const nan)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -0x1p+0) (f64.const nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const 0x1p+0) (f64.const -nan)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const 0x1p+0) (f64.const -nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const 0x1p+0) (f64.const nan)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const 0x1p+0) (f64.const nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x0p+0)) (i32.const 1)) +(assert_return (invoke "lt" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x0p+0)) (i32.const 1)) +(assert_return (invoke "lt" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x0p+0)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x0p+0)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x0.0000000000001p-1022)) (i32.const 1)) +(assert_return (invoke "lt" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x0.0000000000001p-1022)) (i32.const 1)) +(assert_return (invoke "lt" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1p-1022)) (i32.const 1)) +(assert_return (invoke "lt" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1p-1022)) (i32.const 1)) +(assert_return (invoke "lt" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1p-1022)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1p-1022)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1p-1)) (i32.const 1)) +(assert_return (invoke "lt" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1p-1)) (i32.const 1)) +(assert_return (invoke "lt" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1p-1)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1p-1)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1p+0)) (i32.const 1)) +(assert_return (invoke "lt" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1p+0)) (i32.const 1)) +(assert_return (invoke "lt" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1p+0)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1p+0)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1.921fb54442d18p+2)) (i32.const 1)) +(assert_return (invoke "lt" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1)) +(assert_return (invoke "lt" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1)) +(assert_return (invoke "lt" (f64.const -0x1.921fb54442d18p+2) (f64.const -inf)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -0x1.921fb54442d18p+2) (f64.const inf)) (i32.const 1)) +(assert_return (invoke "lt" (f64.const 0x1.921fb54442d18p+2) (f64.const -inf)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const 0x1.921fb54442d18p+2) (f64.const inf)) (i32.const 1)) +(assert_return (invoke "lt" (f64.const -0x1.921fb54442d18p+2) (f64.const -nan)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -0x1.921fb54442d18p+2) (f64.const -nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -0x1.921fb54442d18p+2) (f64.const nan)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -0x1.921fb54442d18p+2) (f64.const nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const 0x1.921fb54442d18p+2) (f64.const -nan)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const 0x1.921fb54442d18p+2) (f64.const -nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const 0x1.921fb54442d18p+2) (f64.const nan)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const 0x1.921fb54442d18p+2) (f64.const nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x0p+0)) (i32.const 1)) +(assert_return (invoke "lt" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x0p+0)) (i32.const 1)) +(assert_return (invoke "lt" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x0p+0)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x0p+0)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x0.0000000000001p-1022)) (i32.const 1)) +(assert_return (invoke "lt" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x0.0000000000001p-1022)) (i32.const 1)) +(assert_return (invoke "lt" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1p-1022)) (i32.const 1)) +(assert_return (invoke "lt" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1p-1022)) (i32.const 1)) +(assert_return (invoke "lt" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1p-1022)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1p-1022)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1p-1)) (i32.const 1)) +(assert_return (invoke "lt" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1p-1)) (i32.const 1)) +(assert_return (invoke "lt" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1p-1)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1p-1)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1p+0)) (i32.const 1)) +(assert_return (invoke "lt" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1p+0)) (i32.const 1)) +(assert_return (invoke "lt" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1p+0)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1p+0)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1.921fb54442d18p+2)) (i32.const 1)) +(assert_return (invoke "lt" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1.921fb54442d18p+2)) (i32.const 1)) +(assert_return (invoke "lt" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1)) +(assert_return (invoke "lt" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -0x1.fffffffffffffp+1023) (f64.const -inf)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -0x1.fffffffffffffp+1023) (f64.const inf)) (i32.const 1)) +(assert_return (invoke "lt" (f64.const 0x1.fffffffffffffp+1023) (f64.const -inf)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const 0x1.fffffffffffffp+1023) (f64.const inf)) (i32.const 1)) +(assert_return (invoke "lt" (f64.const -0x1.fffffffffffffp+1023) (f64.const -nan)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -0x1.fffffffffffffp+1023) (f64.const -nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -0x1.fffffffffffffp+1023) (f64.const nan)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -0x1.fffffffffffffp+1023) (f64.const nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const 0x1.fffffffffffffp+1023) (f64.const -nan)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const 0x1.fffffffffffffp+1023) (f64.const -nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const 0x1.fffffffffffffp+1023) (f64.const nan)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const 0x1.fffffffffffffp+1023) (f64.const nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -inf) (f64.const -0x0p+0)) (i32.const 1)) +(assert_return (invoke "lt" (f64.const -inf) (f64.const 0x0p+0)) (i32.const 1)) +(assert_return (invoke "lt" (f64.const inf) (f64.const -0x0p+0)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const inf) (f64.const 0x0p+0)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -inf) (f64.const -0x0.0000000000001p-1022)) (i32.const 1)) +(assert_return (invoke "lt" (f64.const -inf) (f64.const 0x0.0000000000001p-1022)) (i32.const 1)) +(assert_return (invoke "lt" (f64.const inf) (f64.const -0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const inf) (f64.const 0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -inf) (f64.const -0x1p-1022)) (i32.const 1)) +(assert_return (invoke "lt" (f64.const -inf) (f64.const 0x1p-1022)) (i32.const 1)) +(assert_return (invoke "lt" (f64.const inf) (f64.const -0x1p-1022)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const inf) (f64.const 0x1p-1022)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -inf) (f64.const -0x1p-1)) (i32.const 1)) +(assert_return (invoke "lt" (f64.const -inf) (f64.const 0x1p-1)) (i32.const 1)) +(assert_return (invoke "lt" (f64.const inf) (f64.const -0x1p-1)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const inf) (f64.const 0x1p-1)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -inf) (f64.const -0x1p+0)) (i32.const 1)) +(assert_return (invoke "lt" (f64.const -inf) (f64.const 0x1p+0)) (i32.const 1)) +(assert_return (invoke "lt" (f64.const inf) (f64.const -0x1p+0)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const inf) (f64.const 0x1p+0)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -inf) (f64.const -0x1.921fb54442d18p+2)) (i32.const 1)) +(assert_return (invoke "lt" (f64.const -inf) (f64.const 0x1.921fb54442d18p+2)) (i32.const 1)) +(assert_return (invoke "lt" (f64.const inf) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const inf) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -inf) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1)) +(assert_return (invoke "lt" (f64.const -inf) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1)) +(assert_return (invoke "lt" (f64.const inf) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const inf) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -inf) (f64.const -inf)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -inf) (f64.const inf)) (i32.const 1)) +(assert_return (invoke "lt" (f64.const inf) (f64.const -inf)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const inf) (f64.const inf)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -inf) (f64.const -nan)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -inf) (f64.const -nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -inf) (f64.const nan)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -inf) (f64.const nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const inf) (f64.const -nan)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const inf) (f64.const -nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const inf) (f64.const nan)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const inf) (f64.const nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -nan) (f64.const -0x0p+0)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -nan:0x4000000000000) (f64.const -0x0p+0)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -nan) (f64.const 0x0p+0)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -nan:0x4000000000000) (f64.const 0x0p+0)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const nan) (f64.const -0x0p+0)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const nan:0x4000000000000) (f64.const -0x0p+0)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const nan) (f64.const 0x0p+0)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const nan:0x4000000000000) (f64.const 0x0p+0)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -nan) (f64.const -0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -nan:0x4000000000000) (f64.const -0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -nan) (f64.const 0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -nan:0x4000000000000) (f64.const 0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const nan) (f64.const -0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const nan:0x4000000000000) (f64.const -0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const nan) (f64.const 0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const nan:0x4000000000000) (f64.const 0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -nan) (f64.const -0x1p-1022)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -nan:0x4000000000000) (f64.const -0x1p-1022)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -nan) (f64.const 0x1p-1022)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -nan:0x4000000000000) (f64.const 0x1p-1022)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const nan) (f64.const -0x1p-1022)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const nan:0x4000000000000) (f64.const -0x1p-1022)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const nan) (f64.const 0x1p-1022)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const nan:0x4000000000000) (f64.const 0x1p-1022)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -nan) (f64.const -0x1p-1)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -nan:0x4000000000000) (f64.const -0x1p-1)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -nan) (f64.const 0x1p-1)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -nan:0x4000000000000) (f64.const 0x1p-1)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const nan) (f64.const -0x1p-1)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const nan:0x4000000000000) (f64.const -0x1p-1)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const nan) (f64.const 0x1p-1)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const nan:0x4000000000000) (f64.const 0x1p-1)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -nan) (f64.const -0x1p+0)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -nan:0x4000000000000) (f64.const -0x1p+0)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -nan) (f64.const 0x1p+0)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -nan:0x4000000000000) (f64.const 0x1p+0)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const nan) (f64.const -0x1p+0)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const nan:0x4000000000000) (f64.const -0x1p+0)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const nan) (f64.const 0x1p+0)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const nan:0x4000000000000) (f64.const 0x1p+0)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -nan) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -nan:0x4000000000000) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -nan) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -nan:0x4000000000000) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const nan) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const nan:0x4000000000000) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const nan) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const nan:0x4000000000000) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -nan) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -nan:0x4000000000000) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -nan) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -nan:0x4000000000000) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const nan) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const nan:0x4000000000000) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const nan) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const nan:0x4000000000000) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -nan) (f64.const -inf)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -nan:0x4000000000000) (f64.const -inf)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -nan) (f64.const inf)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -nan:0x4000000000000) (f64.const inf)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const nan) (f64.const -inf)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const nan:0x4000000000000) (f64.const -inf)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const nan) (f64.const inf)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const nan:0x4000000000000) (f64.const inf)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -nan) (f64.const -nan)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -nan:0x4000000000000) (f64.const -nan)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -nan) (f64.const -nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -nan:0x4000000000000) (f64.const -nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -nan) (f64.const nan)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -nan:0x4000000000000) (f64.const nan)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -nan) (f64.const nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const -nan:0x4000000000000) (f64.const nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const nan) (f64.const -nan)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const nan:0x4000000000000) (f64.const -nan)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const nan) (f64.const -nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const nan:0x4000000000000) (f64.const -nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const nan) (f64.const nan)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const nan:0x4000000000000) (f64.const nan)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const nan) (f64.const nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "lt" (f64.const nan:0x4000000000000) (f64.const nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "le" (f64.const -0x0p+0) (f64.const -0x0p+0)) (i32.const 1)) +(assert_return (invoke "le" (f64.const -0x0p+0) (f64.const 0x0p+0)) (i32.const 1)) +(assert_return (invoke "le" (f64.const 0x0p+0) (f64.const -0x0p+0)) (i32.const 1)) +(assert_return (invoke "le" (f64.const 0x0p+0) (f64.const 0x0p+0)) (i32.const 1)) +(assert_return (invoke "le" (f64.const -0x0p+0) (f64.const -0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "le" (f64.const -0x0p+0) (f64.const 0x0.0000000000001p-1022)) (i32.const 1)) +(assert_return (invoke "le" (f64.const 0x0p+0) (f64.const -0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "le" (f64.const 0x0p+0) (f64.const 0x0.0000000000001p-1022)) (i32.const 1)) +(assert_return (invoke "le" (f64.const -0x0p+0) (f64.const -0x1p-1022)) (i32.const 0)) +(assert_return (invoke "le" (f64.const -0x0p+0) (f64.const 0x1p-1022)) (i32.const 1)) +(assert_return (invoke "le" (f64.const 0x0p+0) (f64.const -0x1p-1022)) (i32.const 0)) +(assert_return (invoke "le" (f64.const 0x0p+0) (f64.const 0x1p-1022)) (i32.const 1)) +(assert_return (invoke "le" (f64.const -0x0p+0) (f64.const -0x1p-1)) (i32.const 0)) +(assert_return (invoke "le" (f64.const -0x0p+0) (f64.const 0x1p-1)) (i32.const 1)) +(assert_return (invoke "le" (f64.const 0x0p+0) (f64.const -0x1p-1)) (i32.const 0)) +(assert_return (invoke "le" (f64.const 0x0p+0) (f64.const 0x1p-1)) (i32.const 1)) +(assert_return (invoke "le" (f64.const -0x0p+0) (f64.const -0x1p+0)) (i32.const 0)) +(assert_return (invoke "le" (f64.const -0x0p+0) (f64.const 0x1p+0)) (i32.const 1)) +(assert_return (invoke "le" (f64.const 0x0p+0) (f64.const -0x1p+0)) (i32.const 0)) +(assert_return (invoke "le" (f64.const 0x0p+0) (f64.const 0x1p+0)) (i32.const 1)) +(assert_return (invoke "le" (f64.const -0x0p+0) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0)) +(assert_return (invoke "le" (f64.const -0x0p+0) (f64.const 0x1.921fb54442d18p+2)) (i32.const 1)) +(assert_return (invoke "le" (f64.const 0x0p+0) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0)) +(assert_return (invoke "le" (f64.const 0x0p+0) (f64.const 0x1.921fb54442d18p+2)) (i32.const 1)) +(assert_return (invoke "le" (f64.const -0x0p+0) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0)) +(assert_return (invoke "le" (f64.const -0x0p+0) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1)) +(assert_return (invoke "le" (f64.const 0x0p+0) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0)) +(assert_return (invoke "le" (f64.const 0x0p+0) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1)) +(assert_return (invoke "le" (f64.const -0x0p+0) (f64.const -inf)) (i32.const 0)) +(assert_return (invoke "le" (f64.const -0x0p+0) (f64.const inf)) (i32.const 1)) +(assert_return (invoke "le" (f64.const 0x0p+0) (f64.const -inf)) (i32.const 0)) +(assert_return (invoke "le" (f64.const 0x0p+0) (f64.const inf)) (i32.const 1)) +(assert_return (invoke "le" (f64.const -0x0p+0) (f64.const -nan)) (i32.const 0)) +(assert_return (invoke "le" (f64.const -0x0p+0) (f64.const -nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "le" (f64.const -0x0p+0) (f64.const nan)) (i32.const 0)) +(assert_return (invoke "le" (f64.const -0x0p+0) (f64.const nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "le" (f64.const 0x0p+0) (f64.const -nan)) (i32.const 0)) +(assert_return (invoke "le" (f64.const 0x0p+0) (f64.const -nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "le" (f64.const 0x0p+0) (f64.const nan)) (i32.const 0)) +(assert_return (invoke "le" (f64.const 0x0p+0) (f64.const nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "le" (f64.const -0x0.0000000000001p-1022) (f64.const -0x0p+0)) (i32.const 1)) +(assert_return (invoke "le" (f64.const -0x0.0000000000001p-1022) (f64.const 0x0p+0)) (i32.const 1)) +(assert_return (invoke "le" (f64.const 0x0.0000000000001p-1022) (f64.const -0x0p+0)) (i32.const 0)) +(assert_return (invoke "le" (f64.const 0x0.0000000000001p-1022) (f64.const 0x0p+0)) (i32.const 0)) +(assert_return (invoke "le" (f64.const -0x0.0000000000001p-1022) (f64.const -0x0.0000000000001p-1022)) (i32.const 1)) +(assert_return (invoke "le" (f64.const -0x0.0000000000001p-1022) (f64.const 0x0.0000000000001p-1022)) (i32.const 1)) +(assert_return (invoke "le" (f64.const 0x0.0000000000001p-1022) (f64.const -0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "le" (f64.const 0x0.0000000000001p-1022) (f64.const 0x0.0000000000001p-1022)) (i32.const 1)) +(assert_return (invoke "le" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1p-1022)) (i32.const 0)) +(assert_return (invoke "le" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1p-1022)) (i32.const 1)) +(assert_return (invoke "le" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1p-1022)) (i32.const 0)) +(assert_return (invoke "le" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1p-1022)) (i32.const 1)) +(assert_return (invoke "le" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1p-1)) (i32.const 0)) +(assert_return (invoke "le" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1p-1)) (i32.const 1)) +(assert_return (invoke "le" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1p-1)) (i32.const 0)) +(assert_return (invoke "le" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1p-1)) (i32.const 1)) +(assert_return (invoke "le" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1p+0)) (i32.const 0)) +(assert_return (invoke "le" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1p+0)) (i32.const 1)) +(assert_return (invoke "le" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1p+0)) (i32.const 0)) +(assert_return (invoke "le" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1p+0)) (i32.const 1)) +(assert_return (invoke "le" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0)) +(assert_return (invoke "le" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1.921fb54442d18p+2)) (i32.const 1)) +(assert_return (invoke "le" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0)) +(assert_return (invoke "le" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1.921fb54442d18p+2)) (i32.const 1)) +(assert_return (invoke "le" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0)) +(assert_return (invoke "le" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1)) +(assert_return (invoke "le" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0)) +(assert_return (invoke "le" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1)) +(assert_return (invoke "le" (f64.const -0x0.0000000000001p-1022) (f64.const -inf)) (i32.const 0)) +(assert_return (invoke "le" (f64.const -0x0.0000000000001p-1022) (f64.const inf)) (i32.const 1)) +(assert_return (invoke "le" (f64.const 0x0.0000000000001p-1022) (f64.const -inf)) (i32.const 0)) +(assert_return (invoke "le" (f64.const 0x0.0000000000001p-1022) (f64.const inf)) (i32.const 1)) +(assert_return (invoke "le" (f64.const -0x0.0000000000001p-1022) (f64.const -nan)) (i32.const 0)) +(assert_return (invoke "le" (f64.const -0x0.0000000000001p-1022) (f64.const -nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "le" (f64.const -0x0.0000000000001p-1022) (f64.const nan)) (i32.const 0)) +(assert_return (invoke "le" (f64.const -0x0.0000000000001p-1022) (f64.const nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "le" (f64.const 0x0.0000000000001p-1022) (f64.const -nan)) (i32.const 0)) +(assert_return (invoke "le" (f64.const 0x0.0000000000001p-1022) (f64.const -nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "le" (f64.const 0x0.0000000000001p-1022) (f64.const nan)) (i32.const 0)) +(assert_return (invoke "le" (f64.const 0x0.0000000000001p-1022) (f64.const nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "le" (f64.const -0x1p-1022) (f64.const -0x0p+0)) (i32.const 1)) +(assert_return (invoke "le" (f64.const -0x1p-1022) (f64.const 0x0p+0)) (i32.const 1)) +(assert_return (invoke "le" (f64.const 0x1p-1022) (f64.const -0x0p+0)) (i32.const 0)) +(assert_return (invoke "le" (f64.const 0x1p-1022) (f64.const 0x0p+0)) (i32.const 0)) +(assert_return (invoke "le" (f64.const -0x1p-1022) (f64.const -0x0.0000000000001p-1022)) (i32.const 1)) +(assert_return (invoke "le" (f64.const -0x1p-1022) (f64.const 0x0.0000000000001p-1022)) (i32.const 1)) +(assert_return (invoke "le" (f64.const 0x1p-1022) (f64.const -0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "le" (f64.const 0x1p-1022) (f64.const 0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "le" (f64.const -0x1p-1022) (f64.const -0x1p-1022)) (i32.const 1)) +(assert_return (invoke "le" (f64.const -0x1p-1022) (f64.const 0x1p-1022)) (i32.const 1)) +(assert_return (invoke "le" (f64.const 0x1p-1022) (f64.const -0x1p-1022)) (i32.const 0)) +(assert_return (invoke "le" (f64.const 0x1p-1022) (f64.const 0x1p-1022)) (i32.const 1)) +(assert_return (invoke "le" (f64.const -0x1p-1022) (f64.const -0x1p-1)) (i32.const 0)) +(assert_return (invoke "le" (f64.const -0x1p-1022) (f64.const 0x1p-1)) (i32.const 1)) +(assert_return (invoke "le" (f64.const 0x1p-1022) (f64.const -0x1p-1)) (i32.const 0)) +(assert_return (invoke "le" (f64.const 0x1p-1022) (f64.const 0x1p-1)) (i32.const 1)) +(assert_return (invoke "le" (f64.const -0x1p-1022) (f64.const -0x1p+0)) (i32.const 0)) +(assert_return (invoke "le" (f64.const -0x1p-1022) (f64.const 0x1p+0)) (i32.const 1)) +(assert_return (invoke "le" (f64.const 0x1p-1022) (f64.const -0x1p+0)) (i32.const 0)) +(assert_return (invoke "le" (f64.const 0x1p-1022) (f64.const 0x1p+0)) (i32.const 1)) +(assert_return (invoke "le" (f64.const -0x1p-1022) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0)) +(assert_return (invoke "le" (f64.const -0x1p-1022) (f64.const 0x1.921fb54442d18p+2)) (i32.const 1)) +(assert_return (invoke "le" (f64.const 0x1p-1022) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0)) +(assert_return (invoke "le" (f64.const 0x1p-1022) (f64.const 0x1.921fb54442d18p+2)) (i32.const 1)) +(assert_return (invoke "le" (f64.const -0x1p-1022) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0)) +(assert_return (invoke "le" (f64.const -0x1p-1022) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1)) +(assert_return (invoke "le" (f64.const 0x1p-1022) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0)) +(assert_return (invoke "le" (f64.const 0x1p-1022) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1)) +(assert_return (invoke "le" (f64.const -0x1p-1022) (f64.const -inf)) (i32.const 0)) +(assert_return (invoke "le" (f64.const -0x1p-1022) (f64.const inf)) (i32.const 1)) +(assert_return (invoke "le" (f64.const 0x1p-1022) (f64.const -inf)) (i32.const 0)) +(assert_return (invoke "le" (f64.const 0x1p-1022) (f64.const inf)) (i32.const 1)) +(assert_return (invoke "le" (f64.const -0x1p-1022) (f64.const -nan)) (i32.const 0)) +(assert_return (invoke "le" (f64.const -0x1p-1022) (f64.const -nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "le" (f64.const -0x1p-1022) (f64.const nan)) (i32.const 0)) +(assert_return (invoke "le" (f64.const -0x1p-1022) (f64.const nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "le" (f64.const 0x1p-1022) (f64.const -nan)) (i32.const 0)) +(assert_return (invoke "le" (f64.const 0x1p-1022) (f64.const -nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "le" (f64.const 0x1p-1022) (f64.const nan)) (i32.const 0)) +(assert_return (invoke "le" (f64.const 0x1p-1022) (f64.const nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "le" (f64.const -0x1p-1) (f64.const -0x0p+0)) (i32.const 1)) +(assert_return (invoke "le" (f64.const -0x1p-1) (f64.const 0x0p+0)) (i32.const 1)) +(assert_return (invoke "le" (f64.const 0x1p-1) (f64.const -0x0p+0)) (i32.const 0)) +(assert_return (invoke "le" (f64.const 0x1p-1) (f64.const 0x0p+0)) (i32.const 0)) +(assert_return (invoke "le" (f64.const -0x1p-1) (f64.const -0x0.0000000000001p-1022)) (i32.const 1)) +(assert_return (invoke "le" (f64.const -0x1p-1) (f64.const 0x0.0000000000001p-1022)) (i32.const 1)) +(assert_return (invoke "le" (f64.const 0x1p-1) (f64.const -0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "le" (f64.const 0x1p-1) (f64.const 0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "le" (f64.const -0x1p-1) (f64.const -0x1p-1022)) (i32.const 1)) +(assert_return (invoke "le" (f64.const -0x1p-1) (f64.const 0x1p-1022)) (i32.const 1)) +(assert_return (invoke "le" (f64.const 0x1p-1) (f64.const -0x1p-1022)) (i32.const 0)) +(assert_return (invoke "le" (f64.const 0x1p-1) (f64.const 0x1p-1022)) (i32.const 0)) +(assert_return (invoke "le" (f64.const -0x1p-1) (f64.const -0x1p-1)) (i32.const 1)) +(assert_return (invoke "le" (f64.const -0x1p-1) (f64.const 0x1p-1)) (i32.const 1)) +(assert_return (invoke "le" (f64.const 0x1p-1) (f64.const -0x1p-1)) (i32.const 0)) +(assert_return (invoke "le" (f64.const 0x1p-1) (f64.const 0x1p-1)) (i32.const 1)) +(assert_return (invoke "le" (f64.const -0x1p-1) (f64.const -0x1p+0)) (i32.const 0)) +(assert_return (invoke "le" (f64.const -0x1p-1) (f64.const 0x1p+0)) (i32.const 1)) +(assert_return (invoke "le" (f64.const 0x1p-1) (f64.const -0x1p+0)) (i32.const 0)) +(assert_return (invoke "le" (f64.const 0x1p-1) (f64.const 0x1p+0)) (i32.const 1)) +(assert_return (invoke "le" (f64.const -0x1p-1) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0)) +(assert_return (invoke "le" (f64.const -0x1p-1) (f64.const 0x1.921fb54442d18p+2)) (i32.const 1)) +(assert_return (invoke "le" (f64.const 0x1p-1) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0)) +(assert_return (invoke "le" (f64.const 0x1p-1) (f64.const 0x1.921fb54442d18p+2)) (i32.const 1)) +(assert_return (invoke "le" (f64.const -0x1p-1) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0)) +(assert_return (invoke "le" (f64.const -0x1p-1) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1)) +(assert_return (invoke "le" (f64.const 0x1p-1) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0)) +(assert_return (invoke "le" (f64.const 0x1p-1) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1)) +(assert_return (invoke "le" (f64.const -0x1p-1) (f64.const -inf)) (i32.const 0)) +(assert_return (invoke "le" (f64.const -0x1p-1) (f64.const inf)) (i32.const 1)) +(assert_return (invoke "le" (f64.const 0x1p-1) (f64.const -inf)) (i32.const 0)) +(assert_return (invoke "le" (f64.const 0x1p-1) (f64.const inf)) (i32.const 1)) +(assert_return (invoke "le" (f64.const -0x1p-1) (f64.const -nan)) (i32.const 0)) +(assert_return (invoke "le" (f64.const -0x1p-1) (f64.const -nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "le" (f64.const -0x1p-1) (f64.const nan)) (i32.const 0)) +(assert_return (invoke "le" (f64.const -0x1p-1) (f64.const nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "le" (f64.const 0x1p-1) (f64.const -nan)) (i32.const 0)) +(assert_return (invoke "le" (f64.const 0x1p-1) (f64.const -nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "le" (f64.const 0x1p-1) (f64.const nan)) (i32.const 0)) +(assert_return (invoke "le" (f64.const 0x1p-1) (f64.const nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "le" (f64.const -0x1p+0) (f64.const -0x0p+0)) (i32.const 1)) +(assert_return (invoke "le" (f64.const -0x1p+0) (f64.const 0x0p+0)) (i32.const 1)) +(assert_return (invoke "le" (f64.const 0x1p+0) (f64.const -0x0p+0)) (i32.const 0)) +(assert_return (invoke "le" (f64.const 0x1p+0) (f64.const 0x0p+0)) (i32.const 0)) +(assert_return (invoke "le" (f64.const -0x1p+0) (f64.const -0x0.0000000000001p-1022)) (i32.const 1)) +(assert_return (invoke "le" (f64.const -0x1p+0) (f64.const 0x0.0000000000001p-1022)) (i32.const 1)) +(assert_return (invoke "le" (f64.const 0x1p+0) (f64.const -0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "le" (f64.const 0x1p+0) (f64.const 0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "le" (f64.const -0x1p+0) (f64.const -0x1p-1022)) (i32.const 1)) +(assert_return (invoke "le" (f64.const -0x1p+0) (f64.const 0x1p-1022)) (i32.const 1)) +(assert_return (invoke "le" (f64.const 0x1p+0) (f64.const -0x1p-1022)) (i32.const 0)) +(assert_return (invoke "le" (f64.const 0x1p+0) (f64.const 0x1p-1022)) (i32.const 0)) +(assert_return (invoke "le" (f64.const -0x1p+0) (f64.const -0x1p-1)) (i32.const 1)) +(assert_return (invoke "le" (f64.const -0x1p+0) (f64.const 0x1p-1)) (i32.const 1)) +(assert_return (invoke "le" (f64.const 0x1p+0) (f64.const -0x1p-1)) (i32.const 0)) +(assert_return (invoke "le" (f64.const 0x1p+0) (f64.const 0x1p-1)) (i32.const 0)) +(assert_return (invoke "le" (f64.const -0x1p+0) (f64.const -0x1p+0)) (i32.const 1)) +(assert_return (invoke "le" (f64.const -0x1p+0) (f64.const 0x1p+0)) (i32.const 1)) +(assert_return (invoke "le" (f64.const 0x1p+0) (f64.const -0x1p+0)) (i32.const 0)) +(assert_return (invoke "le" (f64.const 0x1p+0) (f64.const 0x1p+0)) (i32.const 1)) +(assert_return (invoke "le" (f64.const -0x1p+0) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0)) +(assert_return (invoke "le" (f64.const -0x1p+0) (f64.const 0x1.921fb54442d18p+2)) (i32.const 1)) +(assert_return (invoke "le" (f64.const 0x1p+0) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0)) +(assert_return (invoke "le" (f64.const 0x1p+0) (f64.const 0x1.921fb54442d18p+2)) (i32.const 1)) +(assert_return (invoke "le" (f64.const -0x1p+0) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0)) +(assert_return (invoke "le" (f64.const -0x1p+0) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1)) +(assert_return (invoke "le" (f64.const 0x1p+0) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0)) +(assert_return (invoke "le" (f64.const 0x1p+0) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1)) +(assert_return (invoke "le" (f64.const -0x1p+0) (f64.const -inf)) (i32.const 0)) +(assert_return (invoke "le" (f64.const -0x1p+0) (f64.const inf)) (i32.const 1)) +(assert_return (invoke "le" (f64.const 0x1p+0) (f64.const -inf)) (i32.const 0)) +(assert_return (invoke "le" (f64.const 0x1p+0) (f64.const inf)) (i32.const 1)) +(assert_return (invoke "le" (f64.const -0x1p+0) (f64.const -nan)) (i32.const 0)) +(assert_return (invoke "le" (f64.const -0x1p+0) (f64.const -nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "le" (f64.const -0x1p+0) (f64.const nan)) (i32.const 0)) +(assert_return (invoke "le" (f64.const -0x1p+0) (f64.const nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "le" (f64.const 0x1p+0) (f64.const -nan)) (i32.const 0)) +(assert_return (invoke "le" (f64.const 0x1p+0) (f64.const -nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "le" (f64.const 0x1p+0) (f64.const nan)) (i32.const 0)) +(assert_return (invoke "le" (f64.const 0x1p+0) (f64.const nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "le" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x0p+0)) (i32.const 1)) +(assert_return (invoke "le" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x0p+0)) (i32.const 1)) +(assert_return (invoke "le" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x0p+0)) (i32.const 0)) +(assert_return (invoke "le" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x0p+0)) (i32.const 0)) +(assert_return (invoke "le" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x0.0000000000001p-1022)) (i32.const 1)) +(assert_return (invoke "le" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x0.0000000000001p-1022)) (i32.const 1)) +(assert_return (invoke "le" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "le" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "le" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1p-1022)) (i32.const 1)) +(assert_return (invoke "le" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1p-1022)) (i32.const 1)) +(assert_return (invoke "le" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1p-1022)) (i32.const 0)) +(assert_return (invoke "le" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1p-1022)) (i32.const 0)) +(assert_return (invoke "le" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1p-1)) (i32.const 1)) +(assert_return (invoke "le" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1p-1)) (i32.const 1)) +(assert_return (invoke "le" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1p-1)) (i32.const 0)) +(assert_return (invoke "le" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1p-1)) (i32.const 0)) +(assert_return (invoke "le" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1p+0)) (i32.const 1)) +(assert_return (invoke "le" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1p+0)) (i32.const 1)) +(assert_return (invoke "le" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1p+0)) (i32.const 0)) +(assert_return (invoke "le" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1p+0)) (i32.const 0)) +(assert_return (invoke "le" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1.921fb54442d18p+2)) (i32.const 1)) +(assert_return (invoke "le" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1.921fb54442d18p+2)) (i32.const 1)) +(assert_return (invoke "le" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0)) +(assert_return (invoke "le" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1.921fb54442d18p+2)) (i32.const 1)) +(assert_return (invoke "le" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0)) +(assert_return (invoke "le" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1)) +(assert_return (invoke "le" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0)) +(assert_return (invoke "le" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1)) +(assert_return (invoke "le" (f64.const -0x1.921fb54442d18p+2) (f64.const -inf)) (i32.const 0)) +(assert_return (invoke "le" (f64.const -0x1.921fb54442d18p+2) (f64.const inf)) (i32.const 1)) +(assert_return (invoke "le" (f64.const 0x1.921fb54442d18p+2) (f64.const -inf)) (i32.const 0)) +(assert_return (invoke "le" (f64.const 0x1.921fb54442d18p+2) (f64.const inf)) (i32.const 1)) +(assert_return (invoke "le" (f64.const -0x1.921fb54442d18p+2) (f64.const -nan)) (i32.const 0)) +(assert_return (invoke "le" (f64.const -0x1.921fb54442d18p+2) (f64.const -nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "le" (f64.const -0x1.921fb54442d18p+2) (f64.const nan)) (i32.const 0)) +(assert_return (invoke "le" (f64.const -0x1.921fb54442d18p+2) (f64.const nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "le" (f64.const 0x1.921fb54442d18p+2) (f64.const -nan)) (i32.const 0)) +(assert_return (invoke "le" (f64.const 0x1.921fb54442d18p+2) (f64.const -nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "le" (f64.const 0x1.921fb54442d18p+2) (f64.const nan)) (i32.const 0)) +(assert_return (invoke "le" (f64.const 0x1.921fb54442d18p+2) (f64.const nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "le" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x0p+0)) (i32.const 1)) +(assert_return (invoke "le" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x0p+0)) (i32.const 1)) +(assert_return (invoke "le" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x0p+0)) (i32.const 0)) +(assert_return (invoke "le" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x0p+0)) (i32.const 0)) +(assert_return (invoke "le" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x0.0000000000001p-1022)) (i32.const 1)) +(assert_return (invoke "le" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x0.0000000000001p-1022)) (i32.const 1)) +(assert_return (invoke "le" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "le" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "le" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1p-1022)) (i32.const 1)) +(assert_return (invoke "le" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1p-1022)) (i32.const 1)) +(assert_return (invoke "le" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1p-1022)) (i32.const 0)) +(assert_return (invoke "le" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1p-1022)) (i32.const 0)) +(assert_return (invoke "le" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1p-1)) (i32.const 1)) +(assert_return (invoke "le" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1p-1)) (i32.const 1)) +(assert_return (invoke "le" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1p-1)) (i32.const 0)) +(assert_return (invoke "le" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1p-1)) (i32.const 0)) +(assert_return (invoke "le" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1p+0)) (i32.const 1)) +(assert_return (invoke "le" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1p+0)) (i32.const 1)) +(assert_return (invoke "le" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1p+0)) (i32.const 0)) +(assert_return (invoke "le" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1p+0)) (i32.const 0)) +(assert_return (invoke "le" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1.921fb54442d18p+2)) (i32.const 1)) +(assert_return (invoke "le" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1.921fb54442d18p+2)) (i32.const 1)) +(assert_return (invoke "le" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0)) +(assert_return (invoke "le" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0)) +(assert_return (invoke "le" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1)) +(assert_return (invoke "le" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1)) +(assert_return (invoke "le" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0)) +(assert_return (invoke "le" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1)) +(assert_return (invoke "le" (f64.const -0x1.fffffffffffffp+1023) (f64.const -inf)) (i32.const 0)) +(assert_return (invoke "le" (f64.const -0x1.fffffffffffffp+1023) (f64.const inf)) (i32.const 1)) +(assert_return (invoke "le" (f64.const 0x1.fffffffffffffp+1023) (f64.const -inf)) (i32.const 0)) +(assert_return (invoke "le" (f64.const 0x1.fffffffffffffp+1023) (f64.const inf)) (i32.const 1)) +(assert_return (invoke "le" (f64.const -0x1.fffffffffffffp+1023) (f64.const -nan)) (i32.const 0)) +(assert_return (invoke "le" (f64.const -0x1.fffffffffffffp+1023) (f64.const -nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "le" (f64.const -0x1.fffffffffffffp+1023) (f64.const nan)) (i32.const 0)) +(assert_return (invoke "le" (f64.const -0x1.fffffffffffffp+1023) (f64.const nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "le" (f64.const 0x1.fffffffffffffp+1023) (f64.const -nan)) (i32.const 0)) +(assert_return (invoke "le" (f64.const 0x1.fffffffffffffp+1023) (f64.const -nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "le" (f64.const 0x1.fffffffffffffp+1023) (f64.const nan)) (i32.const 0)) +(assert_return (invoke "le" (f64.const 0x1.fffffffffffffp+1023) (f64.const nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "le" (f64.const -inf) (f64.const -0x0p+0)) (i32.const 1)) +(assert_return (invoke "le" (f64.const -inf) (f64.const 0x0p+0)) (i32.const 1)) +(assert_return (invoke "le" (f64.const inf) (f64.const -0x0p+0)) (i32.const 0)) +(assert_return (invoke "le" (f64.const inf) (f64.const 0x0p+0)) (i32.const 0)) +(assert_return (invoke "le" (f64.const -inf) (f64.const -0x0.0000000000001p-1022)) (i32.const 1)) +(assert_return (invoke "le" (f64.const -inf) (f64.const 0x0.0000000000001p-1022)) (i32.const 1)) +(assert_return (invoke "le" (f64.const inf) (f64.const -0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "le" (f64.const inf) (f64.const 0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "le" (f64.const -inf) (f64.const -0x1p-1022)) (i32.const 1)) +(assert_return (invoke "le" (f64.const -inf) (f64.const 0x1p-1022)) (i32.const 1)) +(assert_return (invoke "le" (f64.const inf) (f64.const -0x1p-1022)) (i32.const 0)) +(assert_return (invoke "le" (f64.const inf) (f64.const 0x1p-1022)) (i32.const 0)) +(assert_return (invoke "le" (f64.const -inf) (f64.const -0x1p-1)) (i32.const 1)) +(assert_return (invoke "le" (f64.const -inf) (f64.const 0x1p-1)) (i32.const 1)) +(assert_return (invoke "le" (f64.const inf) (f64.const -0x1p-1)) (i32.const 0)) +(assert_return (invoke "le" (f64.const inf) (f64.const 0x1p-1)) (i32.const 0)) +(assert_return (invoke "le" (f64.const -inf) (f64.const -0x1p+0)) (i32.const 1)) +(assert_return (invoke "le" (f64.const -inf) (f64.const 0x1p+0)) (i32.const 1)) +(assert_return (invoke "le" (f64.const inf) (f64.const -0x1p+0)) (i32.const 0)) +(assert_return (invoke "le" (f64.const inf) (f64.const 0x1p+0)) (i32.const 0)) +(assert_return (invoke "le" (f64.const -inf) (f64.const -0x1.921fb54442d18p+2)) (i32.const 1)) +(assert_return (invoke "le" (f64.const -inf) (f64.const 0x1.921fb54442d18p+2)) (i32.const 1)) +(assert_return (invoke "le" (f64.const inf) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0)) +(assert_return (invoke "le" (f64.const inf) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0)) +(assert_return (invoke "le" (f64.const -inf) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1)) +(assert_return (invoke "le" (f64.const -inf) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1)) +(assert_return (invoke "le" (f64.const inf) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0)) +(assert_return (invoke "le" (f64.const inf) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0)) +(assert_return (invoke "le" (f64.const -inf) (f64.const -inf)) (i32.const 1)) +(assert_return (invoke "le" (f64.const -inf) (f64.const inf)) (i32.const 1)) +(assert_return (invoke "le" (f64.const inf) (f64.const -inf)) (i32.const 0)) +(assert_return (invoke "le" (f64.const inf) (f64.const inf)) (i32.const 1)) +(assert_return (invoke "le" (f64.const -inf) (f64.const -nan)) (i32.const 0)) +(assert_return (invoke "le" (f64.const -inf) (f64.const -nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "le" (f64.const -inf) (f64.const nan)) (i32.const 0)) +(assert_return (invoke "le" (f64.const -inf) (f64.const nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "le" (f64.const inf) (f64.const -nan)) (i32.const 0)) +(assert_return (invoke "le" (f64.const inf) (f64.const -nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "le" (f64.const inf) (f64.const nan)) (i32.const 0)) +(assert_return (invoke "le" (f64.const inf) (f64.const nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "le" (f64.const -nan) (f64.const -0x0p+0)) (i32.const 0)) +(assert_return (invoke "le" (f64.const -nan:0x4000000000000) (f64.const -0x0p+0)) (i32.const 0)) +(assert_return (invoke "le" (f64.const -nan) (f64.const 0x0p+0)) (i32.const 0)) +(assert_return (invoke "le" (f64.const -nan:0x4000000000000) (f64.const 0x0p+0)) (i32.const 0)) +(assert_return (invoke "le" (f64.const nan) (f64.const -0x0p+0)) (i32.const 0)) +(assert_return (invoke "le" (f64.const nan:0x4000000000000) (f64.const -0x0p+0)) (i32.const 0)) +(assert_return (invoke "le" (f64.const nan) (f64.const 0x0p+0)) (i32.const 0)) +(assert_return (invoke "le" (f64.const nan:0x4000000000000) (f64.const 0x0p+0)) (i32.const 0)) +(assert_return (invoke "le" (f64.const -nan) (f64.const -0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "le" (f64.const -nan:0x4000000000000) (f64.const -0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "le" (f64.const -nan) (f64.const 0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "le" (f64.const -nan:0x4000000000000) (f64.const 0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "le" (f64.const nan) (f64.const -0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "le" (f64.const nan:0x4000000000000) (f64.const -0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "le" (f64.const nan) (f64.const 0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "le" (f64.const nan:0x4000000000000) (f64.const 0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "le" (f64.const -nan) (f64.const -0x1p-1022)) (i32.const 0)) +(assert_return (invoke "le" (f64.const -nan:0x4000000000000) (f64.const -0x1p-1022)) (i32.const 0)) +(assert_return (invoke "le" (f64.const -nan) (f64.const 0x1p-1022)) (i32.const 0)) +(assert_return (invoke "le" (f64.const -nan:0x4000000000000) (f64.const 0x1p-1022)) (i32.const 0)) +(assert_return (invoke "le" (f64.const nan) (f64.const -0x1p-1022)) (i32.const 0)) +(assert_return (invoke "le" (f64.const nan:0x4000000000000) (f64.const -0x1p-1022)) (i32.const 0)) +(assert_return (invoke "le" (f64.const nan) (f64.const 0x1p-1022)) (i32.const 0)) +(assert_return (invoke "le" (f64.const nan:0x4000000000000) (f64.const 0x1p-1022)) (i32.const 0)) +(assert_return (invoke "le" (f64.const -nan) (f64.const -0x1p-1)) (i32.const 0)) +(assert_return (invoke "le" (f64.const -nan:0x4000000000000) (f64.const -0x1p-1)) (i32.const 0)) +(assert_return (invoke "le" (f64.const -nan) (f64.const 0x1p-1)) (i32.const 0)) +(assert_return (invoke "le" (f64.const -nan:0x4000000000000) (f64.const 0x1p-1)) (i32.const 0)) +(assert_return (invoke "le" (f64.const nan) (f64.const -0x1p-1)) (i32.const 0)) +(assert_return (invoke "le" (f64.const nan:0x4000000000000) (f64.const -0x1p-1)) (i32.const 0)) +(assert_return (invoke "le" (f64.const nan) (f64.const 0x1p-1)) (i32.const 0)) +(assert_return (invoke "le" (f64.const nan:0x4000000000000) (f64.const 0x1p-1)) (i32.const 0)) +(assert_return (invoke "le" (f64.const -nan) (f64.const -0x1p+0)) (i32.const 0)) +(assert_return (invoke "le" (f64.const -nan:0x4000000000000) (f64.const -0x1p+0)) (i32.const 0)) +(assert_return (invoke "le" (f64.const -nan) (f64.const 0x1p+0)) (i32.const 0)) +(assert_return (invoke "le" (f64.const -nan:0x4000000000000) (f64.const 0x1p+0)) (i32.const 0)) +(assert_return (invoke "le" (f64.const nan) (f64.const -0x1p+0)) (i32.const 0)) +(assert_return (invoke "le" (f64.const nan:0x4000000000000) (f64.const -0x1p+0)) (i32.const 0)) +(assert_return (invoke "le" (f64.const nan) (f64.const 0x1p+0)) (i32.const 0)) +(assert_return (invoke "le" (f64.const nan:0x4000000000000) (f64.const 0x1p+0)) (i32.const 0)) +(assert_return (invoke "le" (f64.const -nan) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0)) +(assert_return (invoke "le" (f64.const -nan:0x4000000000000) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0)) +(assert_return (invoke "le" (f64.const -nan) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0)) +(assert_return (invoke "le" (f64.const -nan:0x4000000000000) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0)) +(assert_return (invoke "le" (f64.const nan) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0)) +(assert_return (invoke "le" (f64.const nan:0x4000000000000) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0)) +(assert_return (invoke "le" (f64.const nan) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0)) +(assert_return (invoke "le" (f64.const nan:0x4000000000000) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0)) +(assert_return (invoke "le" (f64.const -nan) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0)) +(assert_return (invoke "le" (f64.const -nan:0x4000000000000) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0)) +(assert_return (invoke "le" (f64.const -nan) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0)) +(assert_return (invoke "le" (f64.const -nan:0x4000000000000) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0)) +(assert_return (invoke "le" (f64.const nan) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0)) +(assert_return (invoke "le" (f64.const nan:0x4000000000000) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0)) +(assert_return (invoke "le" (f64.const nan) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0)) +(assert_return (invoke "le" (f64.const nan:0x4000000000000) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0)) +(assert_return (invoke "le" (f64.const -nan) (f64.const -inf)) (i32.const 0)) +(assert_return (invoke "le" (f64.const -nan:0x4000000000000) (f64.const -inf)) (i32.const 0)) +(assert_return (invoke "le" (f64.const -nan) (f64.const inf)) (i32.const 0)) +(assert_return (invoke "le" (f64.const -nan:0x4000000000000) (f64.const inf)) (i32.const 0)) +(assert_return (invoke "le" (f64.const nan) (f64.const -inf)) (i32.const 0)) +(assert_return (invoke "le" (f64.const nan:0x4000000000000) (f64.const -inf)) (i32.const 0)) +(assert_return (invoke "le" (f64.const nan) (f64.const inf)) (i32.const 0)) +(assert_return (invoke "le" (f64.const nan:0x4000000000000) (f64.const inf)) (i32.const 0)) +(assert_return (invoke "le" (f64.const -nan) (f64.const -nan)) (i32.const 0)) +(assert_return (invoke "le" (f64.const -nan:0x4000000000000) (f64.const -nan)) (i32.const 0)) +(assert_return (invoke "le" (f64.const -nan) (f64.const -nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "le" (f64.const -nan:0x4000000000000) (f64.const -nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "le" (f64.const -nan) (f64.const nan)) (i32.const 0)) +(assert_return (invoke "le" (f64.const -nan:0x4000000000000) (f64.const nan)) (i32.const 0)) +(assert_return (invoke "le" (f64.const -nan) (f64.const nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "le" (f64.const -nan:0x4000000000000) (f64.const nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "le" (f64.const nan) (f64.const -nan)) (i32.const 0)) +(assert_return (invoke "le" (f64.const nan:0x4000000000000) (f64.const -nan)) (i32.const 0)) +(assert_return (invoke "le" (f64.const nan) (f64.const -nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "le" (f64.const nan:0x4000000000000) (f64.const -nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "le" (f64.const nan) (f64.const nan)) (i32.const 0)) +(assert_return (invoke "le" (f64.const nan:0x4000000000000) (f64.const nan)) (i32.const 0)) +(assert_return (invoke "le" (f64.const nan) (f64.const nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "le" (f64.const nan:0x4000000000000) (f64.const nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -0x0p+0) (f64.const -0x0p+0)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -0x0p+0) (f64.const 0x0p+0)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const 0x0p+0) (f64.const -0x0p+0)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const 0x0p+0) (f64.const 0x0p+0)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -0x0p+0) (f64.const -0x0.0000000000001p-1022)) (i32.const 1)) +(assert_return (invoke "gt" (f64.const -0x0p+0) (f64.const 0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const 0x0p+0) (f64.const -0x0.0000000000001p-1022)) (i32.const 1)) +(assert_return (invoke "gt" (f64.const 0x0p+0) (f64.const 0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -0x0p+0) (f64.const -0x1p-1022)) (i32.const 1)) +(assert_return (invoke "gt" (f64.const -0x0p+0) (f64.const 0x1p-1022)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const 0x0p+0) (f64.const -0x1p-1022)) (i32.const 1)) +(assert_return (invoke "gt" (f64.const 0x0p+0) (f64.const 0x1p-1022)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -0x0p+0) (f64.const -0x1p-1)) (i32.const 1)) +(assert_return (invoke "gt" (f64.const -0x0p+0) (f64.const 0x1p-1)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const 0x0p+0) (f64.const -0x1p-1)) (i32.const 1)) +(assert_return (invoke "gt" (f64.const 0x0p+0) (f64.const 0x1p-1)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -0x0p+0) (f64.const -0x1p+0)) (i32.const 1)) +(assert_return (invoke "gt" (f64.const -0x0p+0) (f64.const 0x1p+0)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const 0x0p+0) (f64.const -0x1p+0)) (i32.const 1)) +(assert_return (invoke "gt" (f64.const 0x0p+0) (f64.const 0x1p+0)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -0x0p+0) (f64.const -0x1.921fb54442d18p+2)) (i32.const 1)) +(assert_return (invoke "gt" (f64.const -0x0p+0) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const 0x0p+0) (f64.const -0x1.921fb54442d18p+2)) (i32.const 1)) +(assert_return (invoke "gt" (f64.const 0x0p+0) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -0x0p+0) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1)) +(assert_return (invoke "gt" (f64.const -0x0p+0) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const 0x0p+0) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1)) +(assert_return (invoke "gt" (f64.const 0x0p+0) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -0x0p+0) (f64.const -inf)) (i32.const 1)) +(assert_return (invoke "gt" (f64.const -0x0p+0) (f64.const inf)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const 0x0p+0) (f64.const -inf)) (i32.const 1)) +(assert_return (invoke "gt" (f64.const 0x0p+0) (f64.const inf)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -0x0p+0) (f64.const -nan)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -0x0p+0) (f64.const -nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -0x0p+0) (f64.const nan)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -0x0p+0) (f64.const nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const 0x0p+0) (f64.const -nan)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const 0x0p+0) (f64.const -nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const 0x0p+0) (f64.const nan)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const 0x0p+0) (f64.const nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -0x0.0000000000001p-1022) (f64.const -0x0p+0)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -0x0.0000000000001p-1022) (f64.const 0x0p+0)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const 0x0.0000000000001p-1022) (f64.const -0x0p+0)) (i32.const 1)) +(assert_return (invoke "gt" (f64.const 0x0.0000000000001p-1022) (f64.const 0x0p+0)) (i32.const 1)) +(assert_return (invoke "gt" (f64.const -0x0.0000000000001p-1022) (f64.const -0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -0x0.0000000000001p-1022) (f64.const 0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const 0x0.0000000000001p-1022) (f64.const -0x0.0000000000001p-1022)) (i32.const 1)) +(assert_return (invoke "gt" (f64.const 0x0.0000000000001p-1022) (f64.const 0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1p-1022)) (i32.const 1)) +(assert_return (invoke "gt" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1p-1022)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1p-1022)) (i32.const 1)) +(assert_return (invoke "gt" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1p-1022)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1p-1)) (i32.const 1)) +(assert_return (invoke "gt" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1p-1)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1p-1)) (i32.const 1)) +(assert_return (invoke "gt" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1p-1)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1p+0)) (i32.const 1)) +(assert_return (invoke "gt" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1p+0)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1p+0)) (i32.const 1)) +(assert_return (invoke "gt" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1p+0)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1.921fb54442d18p+2)) (i32.const 1)) +(assert_return (invoke "gt" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1.921fb54442d18p+2)) (i32.const 1)) +(assert_return (invoke "gt" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1)) +(assert_return (invoke "gt" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1)) +(assert_return (invoke "gt" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -0x0.0000000000001p-1022) (f64.const -inf)) (i32.const 1)) +(assert_return (invoke "gt" (f64.const -0x0.0000000000001p-1022) (f64.const inf)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const 0x0.0000000000001p-1022) (f64.const -inf)) (i32.const 1)) +(assert_return (invoke "gt" (f64.const 0x0.0000000000001p-1022) (f64.const inf)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -0x0.0000000000001p-1022) (f64.const -nan)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -0x0.0000000000001p-1022) (f64.const -nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -0x0.0000000000001p-1022) (f64.const nan)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -0x0.0000000000001p-1022) (f64.const nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const 0x0.0000000000001p-1022) (f64.const -nan)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const 0x0.0000000000001p-1022) (f64.const -nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const 0x0.0000000000001p-1022) (f64.const nan)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const 0x0.0000000000001p-1022) (f64.const nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -0x1p-1022) (f64.const -0x0p+0)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -0x1p-1022) (f64.const 0x0p+0)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const 0x1p-1022) (f64.const -0x0p+0)) (i32.const 1)) +(assert_return (invoke "gt" (f64.const 0x1p-1022) (f64.const 0x0p+0)) (i32.const 1)) +(assert_return (invoke "gt" (f64.const -0x1p-1022) (f64.const -0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -0x1p-1022) (f64.const 0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const 0x1p-1022) (f64.const -0x0.0000000000001p-1022)) (i32.const 1)) +(assert_return (invoke "gt" (f64.const 0x1p-1022) (f64.const 0x0.0000000000001p-1022)) (i32.const 1)) +(assert_return (invoke "gt" (f64.const -0x1p-1022) (f64.const -0x1p-1022)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -0x1p-1022) (f64.const 0x1p-1022)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const 0x1p-1022) (f64.const -0x1p-1022)) (i32.const 1)) +(assert_return (invoke "gt" (f64.const 0x1p-1022) (f64.const 0x1p-1022)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -0x1p-1022) (f64.const -0x1p-1)) (i32.const 1)) +(assert_return (invoke "gt" (f64.const -0x1p-1022) (f64.const 0x1p-1)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const 0x1p-1022) (f64.const -0x1p-1)) (i32.const 1)) +(assert_return (invoke "gt" (f64.const 0x1p-1022) (f64.const 0x1p-1)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -0x1p-1022) (f64.const -0x1p+0)) (i32.const 1)) +(assert_return (invoke "gt" (f64.const -0x1p-1022) (f64.const 0x1p+0)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const 0x1p-1022) (f64.const -0x1p+0)) (i32.const 1)) +(assert_return (invoke "gt" (f64.const 0x1p-1022) (f64.const 0x1p+0)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -0x1p-1022) (f64.const -0x1.921fb54442d18p+2)) (i32.const 1)) +(assert_return (invoke "gt" (f64.const -0x1p-1022) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const 0x1p-1022) (f64.const -0x1.921fb54442d18p+2)) (i32.const 1)) +(assert_return (invoke "gt" (f64.const 0x1p-1022) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -0x1p-1022) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1)) +(assert_return (invoke "gt" (f64.const -0x1p-1022) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const 0x1p-1022) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1)) +(assert_return (invoke "gt" (f64.const 0x1p-1022) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -0x1p-1022) (f64.const -inf)) (i32.const 1)) +(assert_return (invoke "gt" (f64.const -0x1p-1022) (f64.const inf)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const 0x1p-1022) (f64.const -inf)) (i32.const 1)) +(assert_return (invoke "gt" (f64.const 0x1p-1022) (f64.const inf)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -0x1p-1022) (f64.const -nan)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -0x1p-1022) (f64.const -nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -0x1p-1022) (f64.const nan)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -0x1p-1022) (f64.const nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const 0x1p-1022) (f64.const -nan)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const 0x1p-1022) (f64.const -nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const 0x1p-1022) (f64.const nan)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const 0x1p-1022) (f64.const nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -0x1p-1) (f64.const -0x0p+0)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -0x1p-1) (f64.const 0x0p+0)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const 0x1p-1) (f64.const -0x0p+0)) (i32.const 1)) +(assert_return (invoke "gt" (f64.const 0x1p-1) (f64.const 0x0p+0)) (i32.const 1)) +(assert_return (invoke "gt" (f64.const -0x1p-1) (f64.const -0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -0x1p-1) (f64.const 0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const 0x1p-1) (f64.const -0x0.0000000000001p-1022)) (i32.const 1)) +(assert_return (invoke "gt" (f64.const 0x1p-1) (f64.const 0x0.0000000000001p-1022)) (i32.const 1)) +(assert_return (invoke "gt" (f64.const -0x1p-1) (f64.const -0x1p-1022)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -0x1p-1) (f64.const 0x1p-1022)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const 0x1p-1) (f64.const -0x1p-1022)) (i32.const 1)) +(assert_return (invoke "gt" (f64.const 0x1p-1) (f64.const 0x1p-1022)) (i32.const 1)) +(assert_return (invoke "gt" (f64.const -0x1p-1) (f64.const -0x1p-1)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -0x1p-1) (f64.const 0x1p-1)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const 0x1p-1) (f64.const -0x1p-1)) (i32.const 1)) +(assert_return (invoke "gt" (f64.const 0x1p-1) (f64.const 0x1p-1)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -0x1p-1) (f64.const -0x1p+0)) (i32.const 1)) +(assert_return (invoke "gt" (f64.const -0x1p-1) (f64.const 0x1p+0)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const 0x1p-1) (f64.const -0x1p+0)) (i32.const 1)) +(assert_return (invoke "gt" (f64.const 0x1p-1) (f64.const 0x1p+0)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -0x1p-1) (f64.const -0x1.921fb54442d18p+2)) (i32.const 1)) +(assert_return (invoke "gt" (f64.const -0x1p-1) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const 0x1p-1) (f64.const -0x1.921fb54442d18p+2)) (i32.const 1)) +(assert_return (invoke "gt" (f64.const 0x1p-1) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -0x1p-1) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1)) +(assert_return (invoke "gt" (f64.const -0x1p-1) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const 0x1p-1) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1)) +(assert_return (invoke "gt" (f64.const 0x1p-1) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -0x1p-1) (f64.const -inf)) (i32.const 1)) +(assert_return (invoke "gt" (f64.const -0x1p-1) (f64.const inf)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const 0x1p-1) (f64.const -inf)) (i32.const 1)) +(assert_return (invoke "gt" (f64.const 0x1p-1) (f64.const inf)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -0x1p-1) (f64.const -nan)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -0x1p-1) (f64.const -nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -0x1p-1) (f64.const nan)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -0x1p-1) (f64.const nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const 0x1p-1) (f64.const -nan)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const 0x1p-1) (f64.const -nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const 0x1p-1) (f64.const nan)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const 0x1p-1) (f64.const nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -0x1p+0) (f64.const -0x0p+0)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -0x1p+0) (f64.const 0x0p+0)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const 0x1p+0) (f64.const -0x0p+0)) (i32.const 1)) +(assert_return (invoke "gt" (f64.const 0x1p+0) (f64.const 0x0p+0)) (i32.const 1)) +(assert_return (invoke "gt" (f64.const -0x1p+0) (f64.const -0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -0x1p+0) (f64.const 0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const 0x1p+0) (f64.const -0x0.0000000000001p-1022)) (i32.const 1)) +(assert_return (invoke "gt" (f64.const 0x1p+0) (f64.const 0x0.0000000000001p-1022)) (i32.const 1)) +(assert_return (invoke "gt" (f64.const -0x1p+0) (f64.const -0x1p-1022)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -0x1p+0) (f64.const 0x1p-1022)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const 0x1p+0) (f64.const -0x1p-1022)) (i32.const 1)) +(assert_return (invoke "gt" (f64.const 0x1p+0) (f64.const 0x1p-1022)) (i32.const 1)) +(assert_return (invoke "gt" (f64.const -0x1p+0) (f64.const -0x1p-1)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -0x1p+0) (f64.const 0x1p-1)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const 0x1p+0) (f64.const -0x1p-1)) (i32.const 1)) +(assert_return (invoke "gt" (f64.const 0x1p+0) (f64.const 0x1p-1)) (i32.const 1)) +(assert_return (invoke "gt" (f64.const -0x1p+0) (f64.const -0x1p+0)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -0x1p+0) (f64.const 0x1p+0)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const 0x1p+0) (f64.const -0x1p+0)) (i32.const 1)) +(assert_return (invoke "gt" (f64.const 0x1p+0) (f64.const 0x1p+0)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -0x1p+0) (f64.const -0x1.921fb54442d18p+2)) (i32.const 1)) +(assert_return (invoke "gt" (f64.const -0x1p+0) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const 0x1p+0) (f64.const -0x1.921fb54442d18p+2)) (i32.const 1)) +(assert_return (invoke "gt" (f64.const 0x1p+0) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -0x1p+0) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1)) +(assert_return (invoke "gt" (f64.const -0x1p+0) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const 0x1p+0) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1)) +(assert_return (invoke "gt" (f64.const 0x1p+0) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -0x1p+0) (f64.const -inf)) (i32.const 1)) +(assert_return (invoke "gt" (f64.const -0x1p+0) (f64.const inf)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const 0x1p+0) (f64.const -inf)) (i32.const 1)) +(assert_return (invoke "gt" (f64.const 0x1p+0) (f64.const inf)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -0x1p+0) (f64.const -nan)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -0x1p+0) (f64.const -nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -0x1p+0) (f64.const nan)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -0x1p+0) (f64.const nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const 0x1p+0) (f64.const -nan)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const 0x1p+0) (f64.const -nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const 0x1p+0) (f64.const nan)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const 0x1p+0) (f64.const nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x0p+0)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x0p+0)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x0p+0)) (i32.const 1)) +(assert_return (invoke "gt" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x0p+0)) (i32.const 1)) +(assert_return (invoke "gt" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x0.0000000000001p-1022)) (i32.const 1)) +(assert_return (invoke "gt" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x0.0000000000001p-1022)) (i32.const 1)) +(assert_return (invoke "gt" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1p-1022)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1p-1022)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1p-1022)) (i32.const 1)) +(assert_return (invoke "gt" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1p-1022)) (i32.const 1)) +(assert_return (invoke "gt" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1p-1)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1p-1)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1p-1)) (i32.const 1)) +(assert_return (invoke "gt" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1p-1)) (i32.const 1)) +(assert_return (invoke "gt" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1p+0)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1p+0)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1p+0)) (i32.const 1)) +(assert_return (invoke "gt" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1p+0)) (i32.const 1)) +(assert_return (invoke "gt" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1.921fb54442d18p+2)) (i32.const 1)) +(assert_return (invoke "gt" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1)) +(assert_return (invoke "gt" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1)) +(assert_return (invoke "gt" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -0x1.921fb54442d18p+2) (f64.const -inf)) (i32.const 1)) +(assert_return (invoke "gt" (f64.const -0x1.921fb54442d18p+2) (f64.const inf)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const 0x1.921fb54442d18p+2) (f64.const -inf)) (i32.const 1)) +(assert_return (invoke "gt" (f64.const 0x1.921fb54442d18p+2) (f64.const inf)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -0x1.921fb54442d18p+2) (f64.const -nan)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -0x1.921fb54442d18p+2) (f64.const -nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -0x1.921fb54442d18p+2) (f64.const nan)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -0x1.921fb54442d18p+2) (f64.const nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const 0x1.921fb54442d18p+2) (f64.const -nan)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const 0x1.921fb54442d18p+2) (f64.const -nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const 0x1.921fb54442d18p+2) (f64.const nan)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const 0x1.921fb54442d18p+2) (f64.const nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x0p+0)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x0p+0)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x0p+0)) (i32.const 1)) +(assert_return (invoke "gt" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x0p+0)) (i32.const 1)) +(assert_return (invoke "gt" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x0.0000000000001p-1022)) (i32.const 1)) +(assert_return (invoke "gt" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x0.0000000000001p-1022)) (i32.const 1)) +(assert_return (invoke "gt" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1p-1022)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1p-1022)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1p-1022)) (i32.const 1)) +(assert_return (invoke "gt" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1p-1022)) (i32.const 1)) +(assert_return (invoke "gt" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1p-1)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1p-1)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1p-1)) (i32.const 1)) +(assert_return (invoke "gt" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1p-1)) (i32.const 1)) +(assert_return (invoke "gt" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1p+0)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1p+0)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1p+0)) (i32.const 1)) +(assert_return (invoke "gt" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1p+0)) (i32.const 1)) +(assert_return (invoke "gt" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1.921fb54442d18p+2)) (i32.const 1)) +(assert_return (invoke "gt" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1.921fb54442d18p+2)) (i32.const 1)) +(assert_return (invoke "gt" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1)) +(assert_return (invoke "gt" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -0x1.fffffffffffffp+1023) (f64.const -inf)) (i32.const 1)) +(assert_return (invoke "gt" (f64.const -0x1.fffffffffffffp+1023) (f64.const inf)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const 0x1.fffffffffffffp+1023) (f64.const -inf)) (i32.const 1)) +(assert_return (invoke "gt" (f64.const 0x1.fffffffffffffp+1023) (f64.const inf)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -0x1.fffffffffffffp+1023) (f64.const -nan)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -0x1.fffffffffffffp+1023) (f64.const -nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -0x1.fffffffffffffp+1023) (f64.const nan)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -0x1.fffffffffffffp+1023) (f64.const nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const 0x1.fffffffffffffp+1023) (f64.const -nan)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const 0x1.fffffffffffffp+1023) (f64.const -nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const 0x1.fffffffffffffp+1023) (f64.const nan)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const 0x1.fffffffffffffp+1023) (f64.const nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -inf) (f64.const -0x0p+0)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -inf) (f64.const 0x0p+0)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const inf) (f64.const -0x0p+0)) (i32.const 1)) +(assert_return (invoke "gt" (f64.const inf) (f64.const 0x0p+0)) (i32.const 1)) +(assert_return (invoke "gt" (f64.const -inf) (f64.const -0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -inf) (f64.const 0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const inf) (f64.const -0x0.0000000000001p-1022)) (i32.const 1)) +(assert_return (invoke "gt" (f64.const inf) (f64.const 0x0.0000000000001p-1022)) (i32.const 1)) +(assert_return (invoke "gt" (f64.const -inf) (f64.const -0x1p-1022)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -inf) (f64.const 0x1p-1022)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const inf) (f64.const -0x1p-1022)) (i32.const 1)) +(assert_return (invoke "gt" (f64.const inf) (f64.const 0x1p-1022)) (i32.const 1)) +(assert_return (invoke "gt" (f64.const -inf) (f64.const -0x1p-1)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -inf) (f64.const 0x1p-1)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const inf) (f64.const -0x1p-1)) (i32.const 1)) +(assert_return (invoke "gt" (f64.const inf) (f64.const 0x1p-1)) (i32.const 1)) +(assert_return (invoke "gt" (f64.const -inf) (f64.const -0x1p+0)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -inf) (f64.const 0x1p+0)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const inf) (f64.const -0x1p+0)) (i32.const 1)) +(assert_return (invoke "gt" (f64.const inf) (f64.const 0x1p+0)) (i32.const 1)) +(assert_return (invoke "gt" (f64.const -inf) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -inf) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const inf) (f64.const -0x1.921fb54442d18p+2)) (i32.const 1)) +(assert_return (invoke "gt" (f64.const inf) (f64.const 0x1.921fb54442d18p+2)) (i32.const 1)) +(assert_return (invoke "gt" (f64.const -inf) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -inf) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const inf) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1)) +(assert_return (invoke "gt" (f64.const inf) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1)) +(assert_return (invoke "gt" (f64.const -inf) (f64.const -inf)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -inf) (f64.const inf)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const inf) (f64.const -inf)) (i32.const 1)) +(assert_return (invoke "gt" (f64.const inf) (f64.const inf)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -inf) (f64.const -nan)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -inf) (f64.const -nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -inf) (f64.const nan)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -inf) (f64.const nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const inf) (f64.const -nan)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const inf) (f64.const -nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const inf) (f64.const nan)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const inf) (f64.const nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -nan) (f64.const -0x0p+0)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -nan:0x4000000000000) (f64.const -0x0p+0)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -nan) (f64.const 0x0p+0)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -nan:0x4000000000000) (f64.const 0x0p+0)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const nan) (f64.const -0x0p+0)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const nan:0x4000000000000) (f64.const -0x0p+0)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const nan) (f64.const 0x0p+0)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const nan:0x4000000000000) (f64.const 0x0p+0)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -nan) (f64.const -0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -nan:0x4000000000000) (f64.const -0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -nan) (f64.const 0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -nan:0x4000000000000) (f64.const 0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const nan) (f64.const -0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const nan:0x4000000000000) (f64.const -0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const nan) (f64.const 0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const nan:0x4000000000000) (f64.const 0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -nan) (f64.const -0x1p-1022)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -nan:0x4000000000000) (f64.const -0x1p-1022)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -nan) (f64.const 0x1p-1022)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -nan:0x4000000000000) (f64.const 0x1p-1022)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const nan) (f64.const -0x1p-1022)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const nan:0x4000000000000) (f64.const -0x1p-1022)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const nan) (f64.const 0x1p-1022)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const nan:0x4000000000000) (f64.const 0x1p-1022)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -nan) (f64.const -0x1p-1)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -nan:0x4000000000000) (f64.const -0x1p-1)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -nan) (f64.const 0x1p-1)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -nan:0x4000000000000) (f64.const 0x1p-1)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const nan) (f64.const -0x1p-1)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const nan:0x4000000000000) (f64.const -0x1p-1)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const nan) (f64.const 0x1p-1)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const nan:0x4000000000000) (f64.const 0x1p-1)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -nan) (f64.const -0x1p+0)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -nan:0x4000000000000) (f64.const -0x1p+0)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -nan) (f64.const 0x1p+0)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -nan:0x4000000000000) (f64.const 0x1p+0)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const nan) (f64.const -0x1p+0)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const nan:0x4000000000000) (f64.const -0x1p+0)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const nan) (f64.const 0x1p+0)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const nan:0x4000000000000) (f64.const 0x1p+0)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -nan) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -nan:0x4000000000000) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -nan) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -nan:0x4000000000000) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const nan) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const nan:0x4000000000000) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const nan) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const nan:0x4000000000000) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -nan) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -nan:0x4000000000000) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -nan) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -nan:0x4000000000000) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const nan) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const nan:0x4000000000000) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const nan) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const nan:0x4000000000000) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -nan) (f64.const -inf)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -nan:0x4000000000000) (f64.const -inf)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -nan) (f64.const inf)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -nan:0x4000000000000) (f64.const inf)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const nan) (f64.const -inf)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const nan:0x4000000000000) (f64.const -inf)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const nan) (f64.const inf)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const nan:0x4000000000000) (f64.const inf)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -nan) (f64.const -nan)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -nan:0x4000000000000) (f64.const -nan)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -nan) (f64.const -nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -nan:0x4000000000000) (f64.const -nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -nan) (f64.const nan)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -nan:0x4000000000000) (f64.const nan)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -nan) (f64.const nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const -nan:0x4000000000000) (f64.const nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const nan) (f64.const -nan)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const nan:0x4000000000000) (f64.const -nan)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const nan) (f64.const -nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const nan:0x4000000000000) (f64.const -nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const nan) (f64.const nan)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const nan:0x4000000000000) (f64.const nan)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const nan) (f64.const nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "gt" (f64.const nan:0x4000000000000) (f64.const nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const -0x0p+0) (f64.const -0x0p+0)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const -0x0p+0) (f64.const 0x0p+0)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const 0x0p+0) (f64.const -0x0p+0)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const 0x0p+0) (f64.const 0x0p+0)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const -0x0p+0) (f64.const -0x0.0000000000001p-1022)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const -0x0p+0) (f64.const 0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const 0x0p+0) (f64.const -0x0.0000000000001p-1022)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const 0x0p+0) (f64.const 0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const -0x0p+0) (f64.const -0x1p-1022)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const -0x0p+0) (f64.const 0x1p-1022)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const 0x0p+0) (f64.const -0x1p-1022)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const 0x0p+0) (f64.const 0x1p-1022)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const -0x0p+0) (f64.const -0x1p-1)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const -0x0p+0) (f64.const 0x1p-1)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const 0x0p+0) (f64.const -0x1p-1)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const 0x0p+0) (f64.const 0x1p-1)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const -0x0p+0) (f64.const -0x1p+0)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const -0x0p+0) (f64.const 0x1p+0)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const 0x0p+0) (f64.const -0x1p+0)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const 0x0p+0) (f64.const 0x1p+0)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const -0x0p+0) (f64.const -0x1.921fb54442d18p+2)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const -0x0p+0) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const 0x0p+0) (f64.const -0x1.921fb54442d18p+2)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const 0x0p+0) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const -0x0p+0) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const -0x0p+0) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const 0x0p+0) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const 0x0p+0) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const -0x0p+0) (f64.const -inf)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const -0x0p+0) (f64.const inf)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const 0x0p+0) (f64.const -inf)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const 0x0p+0) (f64.const inf)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const -0x0p+0) (f64.const -nan)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const -0x0p+0) (f64.const -nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const -0x0p+0) (f64.const nan)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const -0x0p+0) (f64.const nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const 0x0p+0) (f64.const -nan)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const 0x0p+0) (f64.const -nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const 0x0p+0) (f64.const nan)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const 0x0p+0) (f64.const nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const -0x0.0000000000001p-1022) (f64.const -0x0p+0)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const -0x0.0000000000001p-1022) (f64.const 0x0p+0)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const 0x0.0000000000001p-1022) (f64.const -0x0p+0)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const 0x0.0000000000001p-1022) (f64.const 0x0p+0)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const -0x0.0000000000001p-1022) (f64.const -0x0.0000000000001p-1022)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const -0x0.0000000000001p-1022) (f64.const 0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const 0x0.0000000000001p-1022) (f64.const -0x0.0000000000001p-1022)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const 0x0.0000000000001p-1022) (f64.const 0x0.0000000000001p-1022)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1p-1022)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1p-1022)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1p-1022)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1p-1022)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1p-1)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1p-1)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1p-1)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1p-1)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1p+0)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1p+0)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1p+0)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1p+0)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1.921fb54442d18p+2)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1.921fb54442d18p+2)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const -0x0.0000000000001p-1022) (f64.const -inf)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const -0x0.0000000000001p-1022) (f64.const inf)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const 0x0.0000000000001p-1022) (f64.const -inf)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const 0x0.0000000000001p-1022) (f64.const inf)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const -0x0.0000000000001p-1022) (f64.const -nan)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const -0x0.0000000000001p-1022) (f64.const -nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const -0x0.0000000000001p-1022) (f64.const nan)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const -0x0.0000000000001p-1022) (f64.const nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const 0x0.0000000000001p-1022) (f64.const -nan)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const 0x0.0000000000001p-1022) (f64.const -nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const 0x0.0000000000001p-1022) (f64.const nan)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const 0x0.0000000000001p-1022) (f64.const nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const -0x1p-1022) (f64.const -0x0p+0)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const -0x1p-1022) (f64.const 0x0p+0)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const 0x1p-1022) (f64.const -0x0p+0)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const 0x1p-1022) (f64.const 0x0p+0)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const -0x1p-1022) (f64.const -0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const -0x1p-1022) (f64.const 0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const 0x1p-1022) (f64.const -0x0.0000000000001p-1022)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const 0x1p-1022) (f64.const 0x0.0000000000001p-1022)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const -0x1p-1022) (f64.const -0x1p-1022)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const -0x1p-1022) (f64.const 0x1p-1022)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const 0x1p-1022) (f64.const -0x1p-1022)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const 0x1p-1022) (f64.const 0x1p-1022)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const -0x1p-1022) (f64.const -0x1p-1)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const -0x1p-1022) (f64.const 0x1p-1)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const 0x1p-1022) (f64.const -0x1p-1)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const 0x1p-1022) (f64.const 0x1p-1)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const -0x1p-1022) (f64.const -0x1p+0)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const -0x1p-1022) (f64.const 0x1p+0)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const 0x1p-1022) (f64.const -0x1p+0)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const 0x1p-1022) (f64.const 0x1p+0)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const -0x1p-1022) (f64.const -0x1.921fb54442d18p+2)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const -0x1p-1022) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const 0x1p-1022) (f64.const -0x1.921fb54442d18p+2)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const 0x1p-1022) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const -0x1p-1022) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const -0x1p-1022) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const 0x1p-1022) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const 0x1p-1022) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const -0x1p-1022) (f64.const -inf)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const -0x1p-1022) (f64.const inf)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const 0x1p-1022) (f64.const -inf)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const 0x1p-1022) (f64.const inf)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const -0x1p-1022) (f64.const -nan)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const -0x1p-1022) (f64.const -nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const -0x1p-1022) (f64.const nan)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const -0x1p-1022) (f64.const nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const 0x1p-1022) (f64.const -nan)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const 0x1p-1022) (f64.const -nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const 0x1p-1022) (f64.const nan)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const 0x1p-1022) (f64.const nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const -0x1p-1) (f64.const -0x0p+0)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const -0x1p-1) (f64.const 0x0p+0)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const 0x1p-1) (f64.const -0x0p+0)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const 0x1p-1) (f64.const 0x0p+0)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const -0x1p-1) (f64.const -0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const -0x1p-1) (f64.const 0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const 0x1p-1) (f64.const -0x0.0000000000001p-1022)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const 0x1p-1) (f64.const 0x0.0000000000001p-1022)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const -0x1p-1) (f64.const -0x1p-1022)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const -0x1p-1) (f64.const 0x1p-1022)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const 0x1p-1) (f64.const -0x1p-1022)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const 0x1p-1) (f64.const 0x1p-1022)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const -0x1p-1) (f64.const -0x1p-1)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const -0x1p-1) (f64.const 0x1p-1)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const 0x1p-1) (f64.const -0x1p-1)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const 0x1p-1) (f64.const 0x1p-1)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const -0x1p-1) (f64.const -0x1p+0)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const -0x1p-1) (f64.const 0x1p+0)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const 0x1p-1) (f64.const -0x1p+0)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const 0x1p-1) (f64.const 0x1p+0)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const -0x1p-1) (f64.const -0x1.921fb54442d18p+2)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const -0x1p-1) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const 0x1p-1) (f64.const -0x1.921fb54442d18p+2)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const 0x1p-1) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const -0x1p-1) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const -0x1p-1) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const 0x1p-1) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const 0x1p-1) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const -0x1p-1) (f64.const -inf)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const -0x1p-1) (f64.const inf)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const 0x1p-1) (f64.const -inf)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const 0x1p-1) (f64.const inf)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const -0x1p-1) (f64.const -nan)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const -0x1p-1) (f64.const -nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const -0x1p-1) (f64.const nan)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const -0x1p-1) (f64.const nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const 0x1p-1) (f64.const -nan)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const 0x1p-1) (f64.const -nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const 0x1p-1) (f64.const nan)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const 0x1p-1) (f64.const nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const -0x1p+0) (f64.const -0x0p+0)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const -0x1p+0) (f64.const 0x0p+0)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const 0x1p+0) (f64.const -0x0p+0)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const 0x1p+0) (f64.const 0x0p+0)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const -0x1p+0) (f64.const -0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const -0x1p+0) (f64.const 0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const 0x1p+0) (f64.const -0x0.0000000000001p-1022)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const 0x1p+0) (f64.const 0x0.0000000000001p-1022)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const -0x1p+0) (f64.const -0x1p-1022)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const -0x1p+0) (f64.const 0x1p-1022)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const 0x1p+0) (f64.const -0x1p-1022)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const 0x1p+0) (f64.const 0x1p-1022)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const -0x1p+0) (f64.const -0x1p-1)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const -0x1p+0) (f64.const 0x1p-1)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const 0x1p+0) (f64.const -0x1p-1)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const 0x1p+0) (f64.const 0x1p-1)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const -0x1p+0) (f64.const -0x1p+0)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const -0x1p+0) (f64.const 0x1p+0)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const 0x1p+0) (f64.const -0x1p+0)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const 0x1p+0) (f64.const 0x1p+0)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const -0x1p+0) (f64.const -0x1.921fb54442d18p+2)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const -0x1p+0) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const 0x1p+0) (f64.const -0x1.921fb54442d18p+2)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const 0x1p+0) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const -0x1p+0) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const -0x1p+0) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const 0x1p+0) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const 0x1p+0) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const -0x1p+0) (f64.const -inf)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const -0x1p+0) (f64.const inf)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const 0x1p+0) (f64.const -inf)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const 0x1p+0) (f64.const inf)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const -0x1p+0) (f64.const -nan)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const -0x1p+0) (f64.const -nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const -0x1p+0) (f64.const nan)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const -0x1p+0) (f64.const nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const 0x1p+0) (f64.const -nan)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const 0x1p+0) (f64.const -nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const 0x1p+0) (f64.const nan)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const 0x1p+0) (f64.const nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x0p+0)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x0p+0)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x0p+0)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x0p+0)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x0.0000000000001p-1022)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x0.0000000000001p-1022)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1p-1022)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1p-1022)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1p-1022)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1p-1022)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1p-1)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1p-1)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1p-1)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1p-1)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1p+0)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1p+0)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1p+0)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1p+0)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1.921fb54442d18p+2)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1.921fb54442d18p+2)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1.921fb54442d18p+2)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const -0x1.921fb54442d18p+2) (f64.const -inf)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const -0x1.921fb54442d18p+2) (f64.const inf)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const 0x1.921fb54442d18p+2) (f64.const -inf)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const 0x1.921fb54442d18p+2) (f64.const inf)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const -0x1.921fb54442d18p+2) (f64.const -nan)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const -0x1.921fb54442d18p+2) (f64.const -nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const -0x1.921fb54442d18p+2) (f64.const nan)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const -0x1.921fb54442d18p+2) (f64.const nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const 0x1.921fb54442d18p+2) (f64.const -nan)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const 0x1.921fb54442d18p+2) (f64.const -nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const 0x1.921fb54442d18p+2) (f64.const nan)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const 0x1.921fb54442d18p+2) (f64.const nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x0p+0)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x0p+0)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x0p+0)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x0p+0)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x0.0000000000001p-1022)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x0.0000000000001p-1022)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1p-1022)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1p-1022)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1p-1022)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1p-1022)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1p-1)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1p-1)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1p-1)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1p-1)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1p+0)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1p+0)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1p+0)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1p+0)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1.921fb54442d18p+2)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1.921fb54442d18p+2)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const -0x1.fffffffffffffp+1023) (f64.const -inf)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const -0x1.fffffffffffffp+1023) (f64.const inf)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const 0x1.fffffffffffffp+1023) (f64.const -inf)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const 0x1.fffffffffffffp+1023) (f64.const inf)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const -0x1.fffffffffffffp+1023) (f64.const -nan)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const -0x1.fffffffffffffp+1023) (f64.const -nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const -0x1.fffffffffffffp+1023) (f64.const nan)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const -0x1.fffffffffffffp+1023) (f64.const nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const 0x1.fffffffffffffp+1023) (f64.const -nan)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const 0x1.fffffffffffffp+1023) (f64.const -nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const 0x1.fffffffffffffp+1023) (f64.const nan)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const 0x1.fffffffffffffp+1023) (f64.const nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const -inf) (f64.const -0x0p+0)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const -inf) (f64.const 0x0p+0)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const inf) (f64.const -0x0p+0)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const inf) (f64.const 0x0p+0)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const -inf) (f64.const -0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const -inf) (f64.const 0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const inf) (f64.const -0x0.0000000000001p-1022)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const inf) (f64.const 0x0.0000000000001p-1022)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const -inf) (f64.const -0x1p-1022)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const -inf) (f64.const 0x1p-1022)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const inf) (f64.const -0x1p-1022)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const inf) (f64.const 0x1p-1022)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const -inf) (f64.const -0x1p-1)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const -inf) (f64.const 0x1p-1)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const inf) (f64.const -0x1p-1)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const inf) (f64.const 0x1p-1)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const -inf) (f64.const -0x1p+0)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const -inf) (f64.const 0x1p+0)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const inf) (f64.const -0x1p+0)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const inf) (f64.const 0x1p+0)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const -inf) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const -inf) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const inf) (f64.const -0x1.921fb54442d18p+2)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const inf) (f64.const 0x1.921fb54442d18p+2)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const -inf) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const -inf) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const inf) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const inf) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const -inf) (f64.const -inf)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const -inf) (f64.const inf)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const inf) (f64.const -inf)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const inf) (f64.const inf)) (i32.const 1)) +(assert_return (invoke "ge" (f64.const -inf) (f64.const -nan)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const -inf) (f64.const -nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const -inf) (f64.const nan)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const -inf) (f64.const nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const inf) (f64.const -nan)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const inf) (f64.const -nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const inf) (f64.const nan)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const inf) (f64.const nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const -nan) (f64.const -0x0p+0)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const -nan:0x4000000000000) (f64.const -0x0p+0)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const -nan) (f64.const 0x0p+0)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const -nan:0x4000000000000) (f64.const 0x0p+0)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const nan) (f64.const -0x0p+0)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const nan:0x4000000000000) (f64.const -0x0p+0)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const nan) (f64.const 0x0p+0)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const nan:0x4000000000000) (f64.const 0x0p+0)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const -nan) (f64.const -0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const -nan:0x4000000000000) (f64.const -0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const -nan) (f64.const 0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const -nan:0x4000000000000) (f64.const 0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const nan) (f64.const -0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const nan:0x4000000000000) (f64.const -0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const nan) (f64.const 0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const nan:0x4000000000000) (f64.const 0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const -nan) (f64.const -0x1p-1022)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const -nan:0x4000000000000) (f64.const -0x1p-1022)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const -nan) (f64.const 0x1p-1022)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const -nan:0x4000000000000) (f64.const 0x1p-1022)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const nan) (f64.const -0x1p-1022)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const nan:0x4000000000000) (f64.const -0x1p-1022)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const nan) (f64.const 0x1p-1022)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const nan:0x4000000000000) (f64.const 0x1p-1022)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const -nan) (f64.const -0x1p-1)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const -nan:0x4000000000000) (f64.const -0x1p-1)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const -nan) (f64.const 0x1p-1)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const -nan:0x4000000000000) (f64.const 0x1p-1)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const nan) (f64.const -0x1p-1)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const nan:0x4000000000000) (f64.const -0x1p-1)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const nan) (f64.const 0x1p-1)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const nan:0x4000000000000) (f64.const 0x1p-1)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const -nan) (f64.const -0x1p+0)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const -nan:0x4000000000000) (f64.const -0x1p+0)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const -nan) (f64.const 0x1p+0)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const -nan:0x4000000000000) (f64.const 0x1p+0)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const nan) (f64.const -0x1p+0)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const nan:0x4000000000000) (f64.const -0x1p+0)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const nan) (f64.const 0x1p+0)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const nan:0x4000000000000) (f64.const 0x1p+0)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const -nan) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const -nan:0x4000000000000) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const -nan) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const -nan:0x4000000000000) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const nan) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const nan:0x4000000000000) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const nan) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const nan:0x4000000000000) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const -nan) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const -nan:0x4000000000000) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const -nan) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const -nan:0x4000000000000) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const nan) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const nan:0x4000000000000) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const nan) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const nan:0x4000000000000) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const -nan) (f64.const -inf)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const -nan:0x4000000000000) (f64.const -inf)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const -nan) (f64.const inf)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const -nan:0x4000000000000) (f64.const inf)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const nan) (f64.const -inf)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const nan:0x4000000000000) (f64.const -inf)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const nan) (f64.const inf)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const nan:0x4000000000000) (f64.const inf)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const -nan) (f64.const -nan)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const -nan:0x4000000000000) (f64.const -nan)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const -nan) (f64.const -nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const -nan:0x4000000000000) (f64.const -nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const -nan) (f64.const nan)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const -nan:0x4000000000000) (f64.const nan)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const -nan) (f64.const nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const -nan:0x4000000000000) (f64.const nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const nan) (f64.const -nan)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const nan:0x4000000000000) (f64.const -nan)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const nan) (f64.const -nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const nan:0x4000000000000) (f64.const -nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const nan) (f64.const nan)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const nan:0x4000000000000) (f64.const nan)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const nan) (f64.const nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "ge" (f64.const nan:0x4000000000000) (f64.const nan:0x4000000000000)) (i32.const 0)) + + +;; Type check + +(assert_invalid (module (func (result f64) (f64.eq (i64.const 0) (f32.const 0)))) "type mismatch") +(assert_invalid (module (func (result f64) (f64.ge (i64.const 0) (f32.const 0)))) "type mismatch") +(assert_invalid (module (func (result f64) (f64.gt (i64.const 0) (f32.const 0)))) "type mismatch") +(assert_invalid (module (func (result f64) (f64.le (i64.const 0) (f32.const 0)))) "type mismatch") +(assert_invalid (module (func (result f64) (f64.lt (i64.const 0) (f32.const 0)))) "type mismatch") +(assert_invalid (module (func (result f64) (f64.ne (i64.const 0) (f32.const 0)))) "type mismatch") diff --git a/runtime/near-vm/tests/wast/spec/fac.wast b/runtime/near-vm/tests/wast/spec/fac.wast new file mode 100644 index 00000000000..0e61c1f9eee --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/fac.wast @@ -0,0 +1,109 @@ +(module + ;; Recursive factorial + (func (export "fac-rec") (param i64) (result i64) + (if (result i64) (i64.eq (local.get 0) (i64.const 0)) + (then (i64.const 1)) + (else + (i64.mul (local.get 0) (call 0 (i64.sub (local.get 0) (i64.const 1)))) + ) + ) + ) + + ;; Recursive factorial named + (func $fac-rec-named (export "fac-rec-named") (param $n i64) (result i64) + (if (result i64) (i64.eq (local.get $n) (i64.const 0)) + (then (i64.const 1)) + (else + (i64.mul + (local.get $n) + (call $fac-rec-named (i64.sub (local.get $n) (i64.const 1))) + ) + ) + ) + ) + + ;; Iterative factorial + (func (export "fac-iter") (param i64) (result i64) + (local i64 i64) + (local.set 1 (local.get 0)) + (local.set 2 (i64.const 1)) + (block + (loop + (if + (i64.eq (local.get 1) (i64.const 0)) + (then (br 2)) + (else + (local.set 2 (i64.mul (local.get 1) (local.get 2))) + (local.set 1 (i64.sub (local.get 1) (i64.const 1))) + ) + ) + (br 0) + ) + ) + (local.get 2) + ) + + ;; Iterative factorial named + (func (export "fac-iter-named") (param $n i64) (result i64) + (local $i i64) + (local $res i64) + (local.set $i (local.get $n)) + (local.set $res (i64.const 1)) + (block $done + (loop $loop + (if + (i64.eq (local.get $i) (i64.const 0)) + (then (br $done)) + (else + (local.set $res (i64.mul (local.get $i) (local.get $res))) + (local.set $i (i64.sub (local.get $i) (i64.const 1))) + ) + ) + (br $loop) + ) + ) + (local.get $res) + ) + + ;; Optimized factorial. + (func (export "fac-opt") (param i64) (result i64) + (local i64) + (local.set 1 (i64.const 1)) + (block + (br_if 0 (i64.lt_s (local.get 0) (i64.const 2))) + (loop + (local.set 1 (i64.mul (local.get 1) (local.get 0))) + (local.set 0 (i64.add (local.get 0) (i64.const -1))) + (br_if 0 (i64.gt_s (local.get 0) (i64.const 1))) + ) + ) + (local.get 1) + ) + + ;; Iterative factorial without locals. + (func $pick0 (param i64) (result i64 i64) + (local.get 0) (local.get 0) + ) + (func $pick1 (param i64 i64) (result i64 i64 i64) + (local.get 0) (local.get 1) (local.get 0) + ) + (func (export "fac-ssa") (param i64) (result i64) + (i64.const 1) (local.get 0) + (loop $l (param i64 i64) (result i64) + (call $pick1) (call $pick1) (i64.mul) + (call $pick1) (i64.const 1) (i64.sub) + (call $pick0) (i64.const 0) (i64.gt_u) + (br_if $l) + (drop) (return) + ) + ) +) + +(assert_return (invoke "fac-rec" (i64.const 25)) (i64.const 7034535277573963776)) +(assert_return (invoke "fac-iter" (i64.const 25)) (i64.const 7034535277573963776)) +(assert_return (invoke "fac-rec-named" (i64.const 25)) (i64.const 7034535277573963776)) +(assert_return (invoke "fac-iter-named" (i64.const 25)) (i64.const 7034535277573963776)) +(assert_return (invoke "fac-opt" (i64.const 25)) (i64.const 7034535277573963776)) +(assert_return (invoke "fac-ssa" (i64.const 25)) (i64.const 7034535277573963776)) + +(assert_exhaustion (invoke "fac-rec" (i64.const 1073741824)) "call stack exhausted") diff --git a/runtime/near-vm/tests/wast/spec/float_exprs.wast b/runtime/near-vm/tests/wast/spec/float_exprs.wast new file mode 100644 index 00000000000..1f882992122 --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/float_exprs.wast @@ -0,0 +1,2570 @@ +;; Test interesting floating-point "expressions". These tests contain code +;; patterns which tempt common value-changing optimizations. + +;; Test that x*y+z is not done with x87-style intermediate precision. + +(module + (func (export "f64.no_contraction") (param $x f64) (param $y f64) (param $z f64) (result f64) + (f64.add (f64.mul (local.get $x) (local.get $y)) (local.get $z))) +) + +(assert_return (invoke "f64.no_contraction" (f64.const -0x1.9e87ce14273afp-103) (f64.const 0x1.2515ad31db63ep+664) (f64.const 0x1.868c6685e6185p+533)) (f64.const -0x1.da94885b11493p+561)) +(assert_return (invoke "f64.no_contraction" (f64.const 0x1.da21c460a6f44p+52) (f64.const 0x1.60859d2e7714ap-321) (f64.const 0x1.e63f1b7b660e1p-302)) (f64.const 0x1.4672f256d1794p-268)) +(assert_return (invoke "f64.no_contraction" (f64.const -0x1.f3eaf43f327cp-594) (f64.const 0x1.dfcc009906b57p+533) (f64.const 0x1.5984e03c520a1p-104)) (f64.const -0x1.d4797fb3db166p-60)) +(assert_return (invoke "f64.no_contraction" (f64.const 0x1.dab6c772cb2e2p-69) (f64.const -0x1.d761663679a84p-101) (f64.const 0x1.f22f92c843226p-218)) (f64.const -0x1.b50d72dfcef68p-169)) +(assert_return (invoke "f64.no_contraction" (f64.const -0x1.87c5def1e4d3dp-950) (f64.const -0x1.50cd5dab2207fp+935) (f64.const 0x1.e629bd0da8c5dp-54)) (f64.const 0x1.01b6feb4e78a7p-14)) + +;; Test that x*y+z is not folded to fma. + +(module + (func (export "f32.no_fma") (param $x f32) (param $y f32) (param $z f32) (result f32) + (f32.add (f32.mul (local.get $x) (local.get $y)) (local.get $z))) + (func (export "f64.no_fma") (param $x f64) (param $y f64) (param $z f64) (result f64) + (f64.add (f64.mul (local.get $x) (local.get $y)) (local.get $z))) +) + +(assert_return (invoke "f32.no_fma" (f32.const 0x1.a78402p+124) (f32.const 0x1.cf8548p-23) (f32.const 0x1.992adap+107)) (f32.const 0x1.a5262cp+107)) +(assert_return (invoke "f32.no_fma" (f32.const 0x1.ed15a4p-28) (f32.const -0x1.613c72p-50) (f32.const 0x1.4757bp-88)) (f32.const -0x1.5406b8p-77)) +(assert_return (invoke "f32.no_fma" (f32.const 0x1.ae63a2p+37) (f32.const 0x1.b3a59ap-13) (f32.const 0x1.c16918p+10)) (f32.const 0x1.6e385cp+25)) +(assert_return (invoke "f32.no_fma" (f32.const 0x1.2a77fap-8) (f32.const -0x1.bb7356p+22) (f32.const -0x1.32be2ap+1)) (f32.const -0x1.0286d4p+15)) +(assert_return (invoke "f32.no_fma" (f32.const 0x1.298fb6p+126) (f32.const -0x1.03080cp-70) (f32.const -0x1.418de6p+34)) (f32.const -0x1.2d15c6p+56)) +(assert_return (invoke "f64.no_fma" (f64.const 0x1.ac357ff46eed4p+557) (f64.const 0x1.852c01a5e7297p+430) (f64.const -0x1.05995704eda8ap+987)) (f64.const 0x1.855d905d338ep+987)) +(assert_return (invoke "f64.no_fma" (f64.const 0x1.e2fd6bf32010cp+749) (f64.const 0x1.01c2238d405e4p-130) (f64.const 0x1.2ecc0db4b9f94p+573)) (f64.const 0x1.e64eb07e063bcp+619)) +(assert_return (invoke "f64.no_fma" (f64.const 0x1.92b7c7439ede3p-721) (f64.const -0x1.6aa97586d3de6p+1011) (f64.const 0x1.8de4823f6358ap+237)) (f64.const -0x1.1d4139fd20ecdp+291)) +(assert_return (invoke "f64.no_fma" (f64.const -0x1.466d30bddb453p-386) (f64.const -0x1.185a4d739c7aap+443) (f64.const 0x1.5f9c436fbfc7bp+55)) (f64.const 0x1.bd61a350fcc1ap+57)) +(assert_return (invoke "f64.no_fma" (f64.const 0x1.7e2c44058a799p+52) (f64.const 0x1.c73b71765b8b2p+685) (f64.const -0x1.16c641df0b108p+690)) (f64.const 0x1.53ccb53de0bd1p+738)) + +;; Test that x+0.0 is not folded to x. +;; See IEEE 754-2008 10.4 "Literal meaning and value-changing optimizations". + +(module + (func (export "f32.no_fold_add_zero") (param $x f32) (result f32) + (f32.add (local.get $x) (f32.const 0.0))) + (func (export "f64.no_fold_add_zero") (param $x f64) (result f64) + (f64.add (local.get $x) (f64.const 0.0))) +) + +(assert_return (invoke "f32.no_fold_add_zero" (f32.const -0.0)) (f32.const 0.0)) +(assert_return (invoke "f64.no_fold_add_zero" (f64.const -0.0)) (f64.const 0.0)) +(assert_return (invoke "f32.no_fold_add_zero" (f32.const nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "f64.no_fold_add_zero" (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic)) + +;; Test that 0.0 - x is not folded to -x. + +(module + (func (export "f32.no_fold_zero_sub") (param $x f32) (result f32) + (f32.sub (f32.const 0.0) (local.get $x))) + (func (export "f64.no_fold_zero_sub") (param $x f64) (result f64) + (f64.sub (f64.const 0.0) (local.get $x))) +) + +(assert_return (invoke "f32.no_fold_zero_sub" (f32.const 0.0)) (f32.const 0.0)) +(assert_return (invoke "f64.no_fold_zero_sub" (f64.const 0.0)) (f64.const 0.0)) +(assert_return (invoke "f32.no_fold_zero_sub" (f32.const nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "f64.no_fold_zero_sub" (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic)) + +;; Test that x - 0.0 is not folded to x. + +(module + (func (export "f32.no_fold_sub_zero") (param $x f32) (result f32) + (f32.sub (local.get $x) (f32.const 0.0))) + (func (export "f64.no_fold_sub_zero") (param $x f64) (result f64) + (f64.sub (local.get $x) (f64.const 0.0))) +) + +(assert_return (invoke "f32.no_fold_sub_zero" (f32.const nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "f64.no_fold_sub_zero" (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic)) + +;; Test that x*0.0 is not folded to 0.0. + +(module + (func (export "f32.no_fold_mul_zero") (param $x f32) (result f32) + (f32.mul (local.get $x) (f32.const 0.0))) + (func (export "f64.no_fold_mul_zero") (param $x f64) (result f64) + (f64.mul (local.get $x) (f64.const 0.0))) +) + +(assert_return (invoke "f32.no_fold_mul_zero" (f32.const -0.0)) (f32.const -0.0)) +(assert_return (invoke "f32.no_fold_mul_zero" (f32.const -1.0)) (f32.const -0.0)) +(assert_return (invoke "f32.no_fold_mul_zero" (f32.const -2.0)) (f32.const -0.0)) +(assert_return (invoke "f32.no_fold_mul_zero" (f32.const nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "f64.no_fold_mul_zero" (f64.const -0.0)) (f64.const -0.0)) +(assert_return (invoke "f64.no_fold_mul_zero" (f64.const -1.0)) (f64.const -0.0)) +(assert_return (invoke "f64.no_fold_mul_zero" (f64.const -2.0)) (f64.const -0.0)) +(assert_return (invoke "f64.no_fold_mul_zero" (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic)) + +;; Test that x*1.0 is not folded to x. +;; See IEEE 754-2008 10.4 "Literal meaning and value-changing optimizations". + +(module + (func (export "f32.no_fold_mul_one") (param $x f32) (result f32) + (f32.mul (local.get $x) (f32.const 1.0))) + (func (export "f64.no_fold_mul_one") (param $x f64) (result f64) + (f64.mul (local.get $x) (f64.const 1.0))) +) + +(assert_return (invoke "f32.no_fold_mul_one" (f32.const nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "f64.no_fold_mul_one" (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic)) + +;; Test that 0.0/x is not folded to 0.0. + +(module + (func (export "f32.no_fold_zero_div") (param $x f32) (result f32) + (f32.div (f32.const 0.0) (local.get $x))) + (func (export "f64.no_fold_zero_div") (param $x f64) (result f64) + (f64.div (f64.const 0.0) (local.get $x))) +) + +(assert_return (invoke "f32.no_fold_zero_div" (f32.const 0.0)) (f32.const nan:canonical)) +(assert_return (invoke "f32.no_fold_zero_div" (f32.const -0.0)) (f32.const nan:canonical)) +(assert_return (invoke "f32.no_fold_zero_div" (f32.const nan)) (f32.const nan:canonical)) +(assert_return (invoke "f32.no_fold_zero_div" (f32.const nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "f64.no_fold_zero_div" (f64.const 0.0)) (f64.const nan:canonical)) +(assert_return (invoke "f64.no_fold_zero_div" (f64.const -0.0)) (f64.const nan:canonical)) +(assert_return (invoke "f64.no_fold_zero_div" (f64.const nan)) (f64.const nan:canonical)) +(assert_return (invoke "f64.no_fold_zero_div" (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic)) + +;; Test that x/1.0 is not folded to x. + +(module + (func (export "f32.no_fold_div_one") (param $x f32) (result f32) + (f32.div (local.get $x) (f32.const 1.0))) + (func (export "f64.no_fold_div_one") (param $x f64) (result f64) + (f64.div (local.get $x) (f64.const 1.0))) +) + +(assert_return (invoke "f32.no_fold_div_one" (f32.const nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "f64.no_fold_div_one" (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic)) + +;; Test that x/-1.0 is not folded to -x. + +(module + (func (export "f32.no_fold_div_neg1") (param $x f32) (result f32) + (f32.div (local.get $x) (f32.const -1.0))) + (func (export "f64.no_fold_div_neg1") (param $x f64) (result f64) + (f64.div (local.get $x) (f64.const -1.0))) +) + +(assert_return (invoke "f32.no_fold_div_neg1" (f32.const nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "f64.no_fold_div_neg1" (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic)) + +;; Test that -0.0 - x is not folded to -x. + +(module + (func (export "f32.no_fold_neg0_sub") (param $x f32) (result f32) + (f32.sub (f32.const -0.0) (local.get $x))) + (func (export "f64.no_fold_neg0_sub") (param $x f64) (result f64) + (f64.sub (f64.const -0.0) (local.get $x))) +) + +(assert_return (invoke "f32.no_fold_neg0_sub" (f32.const nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "f64.no_fold_neg0_sub" (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic)) + +;; Test that -1.0 * x is not folded to -x. + +(module + (func (export "f32.no_fold_neg1_mul") (param $x f32) (result f32) + (f32.mul (f32.const -1.0) (local.get $x))) + (func (export "f64.no_fold_neg1_mul") (param $x f64) (result f64) + (f64.mul (f64.const -1.0) (local.get $x))) +) + +(assert_return (invoke "f32.no_fold_neg1_mul" (f32.const nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "f64.no_fold_neg1_mul" (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic)) + +;; Test that x == x is not folded to true. + +(module + (func (export "f32.no_fold_eq_self") (param $x f32) (result i32) + (f32.eq (local.get $x) (local.get $x))) + (func (export "f64.no_fold_eq_self") (param $x f64) (result i32) + (f64.eq (local.get $x) (local.get $x))) +) + +(assert_return (invoke "f32.no_fold_eq_self" (f32.const nan)) (i32.const 0)) +(assert_return (invoke "f64.no_fold_eq_self" (f64.const nan)) (i32.const 0)) + +;; Test that x != x is not folded to false. + +(module + (func (export "f32.no_fold_ne_self") (param $x f32) (result i32) + (f32.ne (local.get $x) (local.get $x))) + (func (export "f64.no_fold_ne_self") (param $x f64) (result i32) + (f64.ne (local.get $x) (local.get $x))) +) + +(assert_return (invoke "f32.no_fold_ne_self" (f32.const nan)) (i32.const 1)) +(assert_return (invoke "f64.no_fold_ne_self" (f64.const nan)) (i32.const 1)) + +;; Test that x - x is not folded to 0.0. + +(module + (func (export "f32.no_fold_sub_self") (param $x f32) (result f32) + (f32.sub (local.get $x) (local.get $x))) + (func (export "f64.no_fold_sub_self") (param $x f64) (result f64) + (f64.sub (local.get $x) (local.get $x))) +) + +(assert_return (invoke "f32.no_fold_sub_self" (f32.const inf)) (f32.const nan:canonical)) +(assert_return (invoke "f32.no_fold_sub_self" (f32.const nan)) (f32.const nan:canonical)) +(assert_return (invoke "f64.no_fold_sub_self" (f64.const inf)) (f64.const nan:canonical)) +(assert_return (invoke "f64.no_fold_sub_self" (f64.const nan)) (f64.const nan:canonical)) + +;; Test that x / x is not folded to 1.0. + +(module + (func (export "f32.no_fold_div_self") (param $x f32) (result f32) + (f32.div (local.get $x) (local.get $x))) + (func (export "f64.no_fold_div_self") (param $x f64) (result f64) + (f64.div (local.get $x) (local.get $x))) +) + +(assert_return (invoke "f32.no_fold_div_self" (f32.const inf)) (f32.const nan:canonical)) +(assert_return (invoke "f32.no_fold_div_self" (f32.const nan)) (f32.const nan:canonical)) +(assert_return (invoke "f32.no_fold_div_self" (f32.const 0.0)) (f32.const nan:canonical)) +(assert_return (invoke "f32.no_fold_div_self" (f32.const -0.0)) (f32.const nan:canonical)) +(assert_return (invoke "f64.no_fold_div_self" (f64.const inf)) (f64.const nan:canonical)) +(assert_return (invoke "f64.no_fold_div_self" (f64.const nan)) (f64.const nan:canonical)) +(assert_return (invoke "f64.no_fold_div_self" (f64.const 0.0)) (f64.const nan:canonical)) +(assert_return (invoke "f64.no_fold_div_self" (f64.const -0.0)) (f64.const nan:canonical)) + +;; Test that x/3 is not folded to x*(1/3). + +(module + (func (export "f32.no_fold_div_3") (param $x f32) (result f32) + (f32.div (local.get $x) (f32.const 3.0))) + (func (export "f64.no_fold_div_3") (param $x f64) (result f64) + (f64.div (local.get $x) (f64.const 3.0))) +) + +(assert_return (invoke "f32.no_fold_div_3" (f32.const -0x1.359c26p+50)) (f32.const -0x1.9cd032p+48)) +(assert_return (invoke "f32.no_fold_div_3" (f32.const -0x1.e45646p+93)) (f32.const -0x1.42e42ep+92)) +(assert_return (invoke "f32.no_fold_div_3" (f32.const -0x1.2a3916p-83)) (f32.const -0x1.8da172p-85)) +(assert_return (invoke "f32.no_fold_div_3" (f32.const -0x1.1f8b38p-124)) (f32.const -0x1.7f644ap-126)) +(assert_return (invoke "f32.no_fold_div_3" (f32.const -0x1.d64f64p-56)) (f32.const -0x1.398a42p-57)) +(assert_return (invoke "f64.no_fold_div_3" (f64.const -0x1.a8a88d29e2cc3p+632)) (f64.const -0x1.1b1b08c69732dp+631)) +(assert_return (invoke "f64.no_fold_div_3" (f64.const -0x1.bcf52dc950972p-167)) (f64.const -0x1.28a373db8b0f7p-168)) +(assert_return (invoke "f64.no_fold_div_3" (f64.const 0x1.bd3c0d989f7a4p-874)) (f64.const 0x1.28d2b3bb14fc3p-875)) +(assert_return (invoke "f64.no_fold_div_3" (f64.const -0x1.0138bf530a53cp+1007)) (f64.const -0x1.56f6546eb86fbp+1005)) +(assert_return (invoke "f64.no_fold_div_3" (f64.const 0x1.052b87f9d794dp+415)) (f64.const 0x1.5c3a0aa274c67p+413)) + +;; Test that (x*z)+(y*z) is not folded to (x+y)*z. + +(module + (func (export "f32.no_factor") (param $x f32) (param $y f32) (param $z f32) (result f32) + (f32.add (f32.mul (local.get $x) (local.get $z)) (f32.mul (local.get $y) (local.get $z)))) + (func (export "f64.no_factor") (param $x f64) (param $y f64) (param $z f64) (result f64) + (f64.add (f64.mul (local.get $x) (local.get $z)) (f64.mul (local.get $y) (local.get $z)))) +) + +(assert_return (invoke "f32.no_factor" (f32.const -0x1.4e2352p+40) (f32.const -0x1.842e2cp+49) (f32.const 0x1.eea602p+59)) (f32.const -0x1.77a7dp+109)) +(assert_return (invoke "f32.no_factor" (f32.const -0x1.b4e7f6p-6) (f32.const 0x1.8c990cp-5) (f32.const -0x1.70cc02p-9)) (f32.const -0x1.00a342p-14)) +(assert_return (invoke "f32.no_factor" (f32.const -0x1.06722ep-41) (f32.const 0x1.eed3cep-64) (f32.const 0x1.5c5558p+123)) (f32.const -0x1.651aaep+82)) +(assert_return (invoke "f32.no_factor" (f32.const -0x1.f8c6a4p-64) (f32.const 0x1.08c806p-83) (f32.const 0x1.b5ceccp+118)) (f32.const -0x1.afa15p+55)) +(assert_return (invoke "f32.no_factor" (f32.const -0x1.3aaa1ep-84) (f32.const 0x1.c6d5eep-71) (f32.const 0x1.8d2924p+20)) (f32.const 0x1.60c9cep-50)) +(assert_return (invoke "f64.no_factor" (f64.const 0x1.3adeda9144977p-424) (f64.const 0x1.c15af887049e1p-462) (f64.const -0x1.905179c4c4778p-225)) (f64.const -0x1.ec606bcb87b1ap-649)) +(assert_return (invoke "f64.no_factor" (f64.const 0x1.3c84821c1d348p-662) (f64.const -0x1.4ffd4c77ad037p-1009) (f64.const -0x1.dd275335c6f4p-957)) (f64.const 0x0p+0)) +(assert_return (invoke "f64.no_factor" (f64.const -0x1.074f372347051p-334) (f64.const -0x1.aaeef661f4c96p-282) (f64.const -0x1.9bd34abe8696dp+479)) (f64.const 0x1.5767029593e2p+198)) +(assert_return (invoke "f64.no_factor" (f64.const -0x1.c4ded58a6f389p-289) (f64.const 0x1.ba6fdef5d59c9p-260) (f64.const -0x1.c1201c0470205p-253)) (f64.const -0x1.841ada2e0f184p-512)) +(assert_return (invoke "f64.no_factor" (f64.const 0x1.9d3688f8e375ap-608) (f64.const 0x1.bf91311588256p-579) (f64.const -0x1.1605a6b5d5ff8p+489)) (f64.const -0x1.e6118ca76af53p-90)) + +;; Test that (x+y)*z is not folded to (x*z)+(y*z). + +(module + (func (export "f32.no_distribute") (param $x f32) (param $y f32) (param $z f32) (result f32) + (f32.mul (f32.add (local.get $x) (local.get $y)) (local.get $z))) + (func (export "f64.no_distribute") (param $x f64) (param $y f64) (param $z f64) (result f64) + (f64.mul (f64.add (local.get $x) (local.get $y)) (local.get $z))) +) + +(assert_return (invoke "f32.no_distribute" (f32.const -0x1.4e2352p+40) (f32.const -0x1.842e2cp+49) (f32.const 0x1.eea602p+59)) (f32.const -0x1.77a7d2p+109)) +(assert_return (invoke "f32.no_distribute" (f32.const -0x1.b4e7f6p-6) (f32.const 0x1.8c990cp-5) (f32.const -0x1.70cc02p-9)) (f32.const -0x1.00a34p-14)) +(assert_return (invoke "f32.no_distribute" (f32.const -0x1.06722ep-41) (f32.const 0x1.eed3cep-64) (f32.const 0x1.5c5558p+123)) (f32.const -0x1.651abp+82)) +(assert_return (invoke "f32.no_distribute" (f32.const -0x1.f8c6a4p-64) (f32.const 0x1.08c806p-83) (f32.const 0x1.b5ceccp+118)) (f32.const -0x1.afa14ep+55)) +(assert_return (invoke "f32.no_distribute" (f32.const -0x1.3aaa1ep-84) (f32.const 0x1.c6d5eep-71) (f32.const 0x1.8d2924p+20)) (f32.const 0x1.60c9ccp-50)) +(assert_return (invoke "f64.no_distribute" (f64.const 0x1.3adeda9144977p-424) (f64.const 0x1.c15af887049e1p-462) (f64.const -0x1.905179c4c4778p-225)) (f64.const -0x1.ec606bcb87b1bp-649)) +(assert_return (invoke "f64.no_distribute" (f64.const 0x1.3c84821c1d348p-662) (f64.const -0x1.4ffd4c77ad037p-1009) (f64.const -0x1.dd275335c6f4p-957)) (f64.const -0x0p+0)) +(assert_return (invoke "f64.no_distribute" (f64.const -0x1.074f372347051p-334) (f64.const -0x1.aaeef661f4c96p-282) (f64.const -0x1.9bd34abe8696dp+479)) (f64.const 0x1.5767029593e1fp+198)) +(assert_return (invoke "f64.no_distribute" (f64.const -0x1.c4ded58a6f389p-289) (f64.const 0x1.ba6fdef5d59c9p-260) (f64.const -0x1.c1201c0470205p-253)) (f64.const -0x1.841ada2e0f183p-512)) +(assert_return (invoke "f64.no_distribute" (f64.const 0x1.9d3688f8e375ap-608) (f64.const 0x1.bf91311588256p-579) (f64.const -0x1.1605a6b5d5ff8p+489)) (f64.const -0x1.e6118ca76af52p-90)) + +;; Test that x*(y/z) is not folded to (x*y)/z. + +(module + (func (export "f32.no_regroup_div_mul") (param $x f32) (param $y f32) (param $z f32) (result f32) + (f32.mul (local.get $x) (f32.div (local.get $y) (local.get $z)))) + (func (export "f64.no_regroup_div_mul") (param $x f64) (param $y f64) (param $z f64) (result f64) + (f64.mul (local.get $x) (f64.div (local.get $y) (local.get $z)))) +) + +(assert_return (invoke "f32.no_regroup_div_mul" (f32.const -0x1.2d14a6p-115) (f32.const -0x1.575a6cp-64) (f32.const 0x1.5cee0ep-116)) (f32.const 0x1.2844cap-63)) +(assert_return (invoke "f32.no_regroup_div_mul" (f32.const -0x1.454738p+91) (f32.const -0x1.b28a66p-115) (f32.const -0x1.f53908p+72)) (f32.const -0x0p+0)) +(assert_return (invoke "f32.no_regroup_div_mul" (f32.const -0x1.6be56ep+16) (f32.const -0x1.b46fc6p-21) (f32.const -0x1.a51df6p-123)) (f32.const -0x1.792258p+118)) +(assert_return (invoke "f32.no_regroup_div_mul" (f32.const -0x1.c343f8p-94) (f32.const 0x1.e4d906p+73) (f32.const 0x1.be69f8p+68)) (f32.const -0x1.ea1df2p-89)) +(assert_return (invoke "f32.no_regroup_div_mul" (f32.const 0x1.c6ae76p+112) (f32.const 0x1.fc953cp+24) (f32.const -0x1.60b3e8p+71)) (f32.const -0x1.47d0eap+66)) +(assert_return (invoke "f64.no_regroup_div_mul" (f64.const 0x1.3c04b815e30bp-423) (f64.const -0x1.379646fd98127p-119) (f64.const 0x1.bddb158506031p-642)) (f64.const -0x1.b9b3301f2dd2dp+99)) +(assert_return (invoke "f64.no_regroup_div_mul" (f64.const 0x1.46b3a402f86d5p+337) (f64.const 0x1.6fbf1b9e1798dp-447) (f64.const -0x1.bd9704a5a6a06p+797)) (f64.const -0x0p+0)) +(assert_return (invoke "f64.no_regroup_div_mul" (f64.const 0x1.6c9765bb4347fp-479) (f64.const 0x1.a4af42e34a141p+902) (f64.const 0x1.d2dde70eb68f9p-448)) (f64.const inf)) +(assert_return (invoke "f64.no_regroup_div_mul" (f64.const -0x1.706023645be72p+480) (f64.const -0x1.6c229f7d9101dp+611) (f64.const -0x1.4d50fa68d3d9ep+836)) (f64.const -0x1.926fa3cacc651p+255)) +(assert_return (invoke "f64.no_regroup_div_mul" (f64.const 0x1.8cc63d8caf4c7p-599) (f64.const 0x1.8671ac4c35753p-878) (f64.const -0x1.ef35b1695e659p-838)) (f64.const -0x1.38d55f56406dp-639)) + +;; Test that (x*y)/z is not folded to x*(y/z). + +(module + (func (export "f32.no_regroup_mul_div") (param $x f32) (param $y f32) (param $z f32) (result f32) + (f32.div (f32.mul (local.get $x) (local.get $y)) (local.get $z))) + (func (export "f64.no_regroup_mul_div") (param $x f64) (param $y f64) (param $z f64) (result f64) + (f64.div (f64.mul (local.get $x) (local.get $y)) (local.get $z))) +) + +(assert_return (invoke "f32.no_regroup_mul_div" (f32.const -0x1.2d14a6p-115) (f32.const -0x1.575a6cp-64) (f32.const 0x1.5cee0ep-116)) (f32.const 0x0p+0)) +(assert_return (invoke "f32.no_regroup_mul_div" (f32.const -0x1.454738p+91) (f32.const -0x1.b28a66p-115) (f32.const -0x1.f53908p+72)) (f32.const -0x1.1a00e8p-96)) +(assert_return (invoke "f32.no_regroup_mul_div" (f32.const -0x1.6be56ep+16) (f32.const -0x1.b46fc6p-21) (f32.const -0x1.a51df6p-123)) (f32.const -0x1.79225ap+118)) +(assert_return (invoke "f32.no_regroup_mul_div" (f32.const -0x1.c343f8p-94) (f32.const 0x1.e4d906p+73) (f32.const 0x1.be69f8p+68)) (f32.const -0x1.ea1df4p-89)) +(assert_return (invoke "f32.no_regroup_mul_div" (f32.const 0x1.c6ae76p+112) (f32.const 0x1.fc953cp+24) (f32.const -0x1.60b3e8p+71)) (f32.const -inf)) +(assert_return (invoke "f64.no_regroup_mul_div" (f64.const 0x1.3c04b815e30bp-423) (f64.const -0x1.379646fd98127p-119) (f64.const 0x1.bddb158506031p-642)) (f64.const -0x1.b9b3301f2dd2ep+99)) +(assert_return (invoke "f64.no_regroup_mul_div" (f64.const 0x1.46b3a402f86d5p+337) (f64.const 0x1.6fbf1b9e1798dp-447) (f64.const -0x1.bd9704a5a6a06p+797)) (f64.const -0x1.0da0b6328e09p-907)) +(assert_return (invoke "f64.no_regroup_mul_div" (f64.const 0x1.6c9765bb4347fp-479) (f64.const 0x1.a4af42e34a141p+902) (f64.const 0x1.d2dde70eb68f9p-448)) (f64.const 0x1.4886b6d9a9a79p+871)) +(assert_return (invoke "f64.no_regroup_mul_div" (f64.const -0x1.706023645be72p+480) (f64.const -0x1.6c229f7d9101dp+611) (f64.const -0x1.4d50fa68d3d9ep+836)) (f64.const -inf)) +(assert_return (invoke "f64.no_regroup_mul_div" (f64.const 0x1.8cc63d8caf4c7p-599) (f64.const 0x1.8671ac4c35753p-878) (f64.const -0x1.ef35b1695e659p-838)) (f64.const -0x0p+0)) + +;; Test that x+y+z+w is not reassociated. + +(module + (func (export "f32.no_reassociate_add") (param $x f32) (param $y f32) (param $z f32) (param $w f32) (result f32) + (f32.add (f32.add (f32.add (local.get $x) (local.get $y)) (local.get $z)) (local.get $w))) + (func (export "f64.no_reassociate_add") (param $x f64) (param $y f64) (param $z f64) (param $w f64) (result f64) + (f64.add (f64.add (f64.add (local.get $x) (local.get $y)) (local.get $z)) (local.get $w))) +) + +(assert_return (invoke "f32.no_reassociate_add" (f32.const -0x1.5f7ddcp+44) (f32.const 0x1.854e1p+34) (f32.const -0x1.b2068cp+47) (f32.const -0x1.209692p+41)) (f32.const -0x1.e26c76p+47)) +(assert_return (invoke "f32.no_reassociate_add" (f32.const 0x1.da3b78p-9) (f32.const -0x1.4312fap-7) (f32.const 0x1.0395e6p-4) (f32.const -0x1.6d5ea6p-7)) (f32.const 0x1.78b31ap-5)) +(assert_return (invoke "f32.no_reassociate_add" (f32.const -0x1.fdb93ap+34) (f32.const -0x1.b6fce6p+41) (f32.const 0x1.c131d8p+44) (f32.const 0x1.8835b6p+38)) (f32.const 0x1.8ff3a2p+44)) +(assert_return (invoke "f32.no_reassociate_add" (f32.const 0x1.1739fcp+47) (f32.const 0x1.a4b186p+49) (f32.const -0x1.0c623cp+35) (f32.const 0x1.16a102p+51)) (f32.const 0x1.913ff6p+51)) +(assert_return (invoke "f32.no_reassociate_add" (f32.const 0x1.733cfap+108) (f32.const -0x1.38d30cp+108) (f32.const 0x1.2f5854p+105) (f32.const -0x1.ccb058p+94)) (f32.const 0x1.813716p+106)) +(assert_return (invoke "f64.no_reassociate_add" (f64.const -0x1.697a4d9ff19a6p+841) (f64.const 0x1.b305466238397p+847) (f64.const 0x1.e0b2d9bfb4e72p+855) (f64.const -0x1.6e1f3ae2b06bbp+857)) (f64.const -0x1.eb0e5936f087ap+856)) +(assert_return (invoke "f64.no_reassociate_add" (f64.const 0x1.00ef6746b30e1p-543) (f64.const 0x1.cc1cfafdf3fe1p-544) (f64.const -0x1.f7726df3ecba6p-543) (f64.const -0x1.b26695f99d307p-594)) (f64.const -0x1.074892e3fad76p-547)) +(assert_return (invoke "f64.no_reassociate_add" (f64.const -0x1.e807b3bd6d854p+440) (f64.const 0x1.cedae26c2c5fp+407) (f64.const -0x1.00ab6e1442541p+437) (f64.const 0x1.28538a55997bdp+397)) (f64.const -0x1.040e90bf871ebp+441)) +(assert_return (invoke "f64.no_reassociate_add" (f64.const -0x1.ba2b6f35a2402p-317) (f64.const 0x1.ad1c3fea7cd9ep-307) (f64.const -0x1.93aace2bf1261p-262) (f64.const 0x1.9fddbe472847ep-260)) (f64.const 0x1.3af30abc2c01bp-260)) +(assert_return (invoke "f64.no_reassociate_add" (f64.const -0x1.ccb9c6092fb1dp+641) (f64.const -0x1.4b7c28c108244p+614) (f64.const 0x1.8a7cefef4bde1p+646) (f64.const -0x1.901b28b08b482p+644)) (f64.const 0x1.1810579194126p+646)) + +;; Test that x*y*z*w is not reassociated. + +(module + (func (export "f32.no_reassociate_mul") (param $x f32) (param $y f32) (param $z f32) (param $w f32) (result f32) + (f32.mul (f32.mul (f32.mul (local.get $x) (local.get $y)) (local.get $z)) (local.get $w))) + (func (export "f64.no_reassociate_mul") (param $x f64) (param $y f64) (param $z f64) (param $w f64) (result f64) + (f64.mul (f64.mul (f64.mul (local.get $x) (local.get $y)) (local.get $z)) (local.get $w))) +) + +(assert_return (invoke "f32.no_reassociate_mul" (f32.const 0x1.950ba8p-116) (f32.const 0x1.efdacep-33) (f32.const -0x1.5f9bcp+102) (f32.const 0x1.f04508p-56)) (f32.const -0x1.ff356ep-101)) +(assert_return (invoke "f32.no_reassociate_mul" (f32.const 0x1.5990aep-56) (f32.const -0x1.7dfb04p+102) (f32.const -0x1.4f774ap-125) (f32.const -0x1.595fe6p+70)) (f32.const -0x1.c7c8fcp-8)) +(assert_return (invoke "f32.no_reassociate_mul" (f32.const 0x1.6ad9a4p-48) (f32.const -0x1.9138aap+55) (f32.const -0x1.4a774ep-40) (f32.const 0x1.1ff08p+76)) (f32.const 0x1.9cd8ecp+44)) +(assert_return (invoke "f32.no_reassociate_mul" (f32.const 0x1.e1caecp-105) (f32.const 0x1.af0dd2p+77) (f32.const -0x1.016eep+56) (f32.const -0x1.ab70d6p+59)) (f32.const 0x1.54870ep+89)) +(assert_return (invoke "f32.no_reassociate_mul" (f32.const -0x1.3b1dcp-99) (f32.const 0x1.4e5a34p-49) (f32.const -0x1.38ba5ap+3) (f32.const 0x1.7fb8eep+59)) (f32.const 0x1.5bbf98p-85)) +(assert_return (invoke "f64.no_reassociate_mul" (f64.const -0x1.e7842ab7181p-667) (f64.const -0x1.fabf40ceeceafp+990) (f64.const -0x1.1a38a825ab01ap-376) (f64.const -0x1.27e8ea469b14fp+664)) (f64.const 0x1.336eb428af4f3p+613)) +(assert_return (invoke "f64.no_reassociate_mul" (f64.const 0x1.4ca2292a6acbcp+454) (f64.const 0x1.6ffbab850089ap-516) (f64.const -0x1.547c32e1f5b93p-899) (f64.const -0x1.c7571d9388375p+540)) (f64.const 0x1.1ac796954fc1p-419)) +(assert_return (invoke "f64.no_reassociate_mul" (f64.const 0x1.73881a52e0401p-501) (f64.const -0x1.1b68dd9efb1a7p+788) (f64.const 0x1.d1c5e6a3eb27cp-762) (f64.const -0x1.56cb2fcc7546fp+88)) (f64.const 0x1.f508db92c34efp-386)) +(assert_return (invoke "f64.no_reassociate_mul" (f64.const 0x1.2efa87859987cp+692) (f64.const 0x1.68e4373e241p-423) (f64.const 0x1.4e2d0fb383a57p+223) (f64.const -0x1.301d3265c737bp-23)) (f64.const -0x1.4b2b6c393f30cp+470)) +(assert_return (invoke "f64.no_reassociate_mul" (f64.const 0x1.1013f7498b95fp-234) (f64.const 0x1.d2d1c36fff138p-792) (f64.const -0x1.cbf1824ea7bfdp+728) (f64.const -0x1.440da9c8b836dp-599)) (f64.const 0x1.1a16512881c91p-895)) + +;; Test that x/0 is not folded away. + +(module + (func (export "f32.no_fold_div_0") (param $x f32) (result f32) + (f32.div (local.get $x) (f32.const 0.0))) + (func (export "f64.no_fold_div_0") (param $x f64) (result f64) + (f64.div (local.get $x) (f64.const 0.0))) +) + +(assert_return (invoke "f32.no_fold_div_0" (f32.const 1.0)) (f32.const inf)) +(assert_return (invoke "f32.no_fold_div_0" (f32.const -1.0)) (f32.const -inf)) +(assert_return (invoke "f32.no_fold_div_0" (f32.const inf)) (f32.const inf)) +(assert_return (invoke "f32.no_fold_div_0" (f32.const -inf)) (f32.const -inf)) +(assert_return (invoke "f32.no_fold_div_0" (f32.const 0)) (f32.const nan:canonical)) +(assert_return (invoke "f32.no_fold_div_0" (f32.const -0)) (f32.const nan:canonical)) +(assert_return (invoke "f32.no_fold_div_0" (f32.const nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "f32.no_fold_div_0" (f32.const nan)) (f32.const nan:canonical)) +(assert_return (invoke "f64.no_fold_div_0" (f64.const 1.0)) (f64.const inf)) +(assert_return (invoke "f64.no_fold_div_0" (f64.const -1.0)) (f64.const -inf)) +(assert_return (invoke "f64.no_fold_div_0" (f64.const inf)) (f64.const inf)) +(assert_return (invoke "f64.no_fold_div_0" (f64.const -inf)) (f64.const -inf)) +(assert_return (invoke "f64.no_fold_div_0" (f64.const 0)) (f64.const nan:canonical)) +(assert_return (invoke "f64.no_fold_div_0" (f64.const -0)) (f64.const nan:canonical)) +(assert_return (invoke "f64.no_fold_div_0" (f64.const nan)) (f64.const nan:canonical)) +(assert_return (invoke "f64.no_fold_div_0" (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic)) + +;; Test that x/-0 is not folded away. + +(module + (func (export "f32.no_fold_div_neg0") (param $x f32) (result f32) + (f32.div (local.get $x) (f32.const -0.0))) + (func (export "f64.no_fold_div_neg0") (param $x f64) (result f64) + (f64.div (local.get $x) (f64.const -0.0))) +) + +(assert_return (invoke "f32.no_fold_div_neg0" (f32.const 1.0)) (f32.const -inf)) +(assert_return (invoke "f32.no_fold_div_neg0" (f32.const -1.0)) (f32.const inf)) +(assert_return (invoke "f32.no_fold_div_neg0" (f32.const inf)) (f32.const -inf)) +(assert_return (invoke "f32.no_fold_div_neg0" (f32.const -inf)) (f32.const inf)) +(assert_return (invoke "f32.no_fold_div_neg0" (f32.const 0)) (f32.const nan:canonical)) +(assert_return (invoke "f32.no_fold_div_neg0" (f32.const -0)) (f32.const nan:canonical)) +(assert_return (invoke "f32.no_fold_div_neg0" (f32.const nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "f32.no_fold_div_neg0" (f32.const nan)) (f32.const nan:canonical)) +(assert_return (invoke "f64.no_fold_div_neg0" (f64.const 1.0)) (f64.const -inf)) +(assert_return (invoke "f64.no_fold_div_neg0" (f64.const -1.0)) (f64.const inf)) +(assert_return (invoke "f64.no_fold_div_neg0" (f64.const inf)) (f64.const -inf)) +(assert_return (invoke "f64.no_fold_div_neg0" (f64.const -inf)) (f64.const inf)) +(assert_return (invoke "f64.no_fold_div_neg0" (f64.const 0)) (f64.const nan:canonical)) +(assert_return (invoke "f64.no_fold_div_neg0" (f64.const -0)) (f64.const nan:canonical)) +(assert_return (invoke "f64.no_fold_div_neg0" (f64.const nan)) (f64.const nan:canonical)) +(assert_return (invoke "f64.no_fold_div_neg0" (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic)) + +;; Test that sqrt(x*x+y*y) is not folded to hypot. + +(module + (func (export "f32.no_fold_to_hypot") (param $x f32) (param $y f32) (result f32) + (f32.sqrt (f32.add (f32.mul (local.get $x) (local.get $x)) + (f32.mul (local.get $y) (local.get $y))))) + (func (export "f64.no_fold_to_hypot") (param $x f64) (param $y f64) (result f64) + (f64.sqrt (f64.add (f64.mul (local.get $x) (local.get $x)) + (f64.mul (local.get $y) (local.get $y))))) +) + +(assert_return (invoke "f32.no_fold_to_hypot" (f32.const 0x1.c2f338p-81) (f32.const 0x1.401b5ep-68)) (f32.const 0x1.401cccp-68)) +(assert_return (invoke "f32.no_fold_to_hypot" (f32.const -0x1.c38d1p-71) (f32.const -0x1.359ddp-107)) (f32.const 0x1.c36a62p-71)) +(assert_return (invoke "f32.no_fold_to_hypot" (f32.const -0x1.99e0cap-114) (f32.const -0x1.ed0c6cp-69)) (f32.const 0x1.ed0e48p-69)) +(assert_return (invoke "f32.no_fold_to_hypot" (f32.const -0x1.1b6ceap+5) (f32.const 0x1.5440bep+17)) (f32.const 0x1.5440cp+17)) +(assert_return (invoke "f32.no_fold_to_hypot" (f32.const 0x1.8f019ep-76) (f32.const -0x1.182308p-71)) (f32.const 0x1.17e2bcp-71)) +(assert_return (invoke "f64.no_fold_to_hypot" (f64.const 0x1.1a0ac4f7c8711p-636) (f64.const 0x1.1372ebafff551p-534)) (f64.const 0x1.13463fa37014ep-534)) +(assert_return (invoke "f64.no_fold_to_hypot" (f64.const 0x1.b793512167499p+395) (f64.const -0x1.11cbc52af4c36p+410)) (f64.const 0x1.11cbc530783a2p+410)) +(assert_return (invoke "f64.no_fold_to_hypot" (f64.const 0x1.76777f44ff40bp-536) (f64.const -0x1.c3896e4dc1fbp-766)) (f64.const 0x1.8p-536)) +(assert_return (invoke "f64.no_fold_to_hypot" (f64.const -0x1.889ac72cc6b5dp-521) (f64.const 0x1.8d7084e659f3bp-733)) (f64.const 0x1.889ac72ca843ap-521)) +(assert_return (invoke "f64.no_fold_to_hypot" (f64.const 0x1.5ee588c02cb08p-670) (f64.const -0x1.05ce25788d9ecp-514)) (f64.const 0x1.05ce25788d9dfp-514)) + +;; Test that 1.0/x isn't approximated. + +(module + (func (export "f32.no_approximate_reciprocal") (param $x f32) (result f32) + (f32.div (f32.const 1.0) (local.get $x))) +) + +(assert_return (invoke "f32.no_approximate_reciprocal" (f32.const -0x1.2900b6p-10)) (f32.const -0x1.b950d4p+9)) +(assert_return (invoke "f32.no_approximate_reciprocal" (f32.const 0x1.e7212p+127)) (f32.const 0x1.0d11f8p-128)) +(assert_return (invoke "f32.no_approximate_reciprocal" (f32.const -0x1.42a466p-93)) (f32.const -0x1.963ee6p+92)) +(assert_return (invoke "f32.no_approximate_reciprocal" (f32.const 0x1.5d0c32p+76)) (f32.const 0x1.778362p-77)) +(assert_return (invoke "f32.no_approximate_reciprocal" (f32.const -0x1.601de2p-82)) (f32.const -0x1.743d7ep+81)) + +;; Test that 1.0/sqrt(x) isn't approximated or fused. + +(module + (func (export "f32.no_approximate_reciprocal_sqrt") (param $x f32) (result f32) + (f32.div (f32.const 1.0) (f32.sqrt (local.get $x)))) + (func (export "f64.no_fuse_reciprocal_sqrt") (param $x f64) (result f64) + (f64.div (f64.const 1.0) (f64.sqrt (local.get $x)))) +) + +(assert_return (invoke "f32.no_approximate_reciprocal_sqrt" (f32.const 0x1.6af12ap-43)) (f32.const 0x1.300ed4p+21)) +(assert_return (invoke "f32.no_approximate_reciprocal_sqrt" (f32.const 0x1.e82fc6p-8)) (f32.const 0x1.72c376p+3)) +(assert_return (invoke "f32.no_approximate_reciprocal_sqrt" (f32.const 0x1.b9fa9cp-66)) (f32.const 0x1.85a9bap+32)) +(assert_return (invoke "f32.no_approximate_reciprocal_sqrt" (f32.const 0x1.f4f546p-44)) (f32.const 0x1.6e01c2p+21)) +(assert_return (invoke "f32.no_approximate_reciprocal_sqrt" (f32.const 0x1.5da7aap-86)) (f32.const 0x1.b618cap+42)) + +(assert_return (invoke "f64.no_fuse_reciprocal_sqrt" (f64.const 0x1.1568a63b55fa3p+889)) (f64.const 0x1.5bc9c74c9952p-445)) +(assert_return (invoke "f64.no_fuse_reciprocal_sqrt" (f64.const 0x1.239fcd0939cafp+311)) (f64.const 0x1.5334a922b4818p-156)) +(assert_return (invoke "f64.no_fuse_reciprocal_sqrt" (f64.const 0x1.6e36a24e11054p+104)) (f64.const 0x1.ac13f20977f29p-53)) +(assert_return (invoke "f64.no_fuse_reciprocal_sqrt" (f64.const 0x1.23ee173219f83p+668)) (f64.const 0x1.df753e055862dp-335)) +(assert_return (invoke "f64.no_fuse_reciprocal_sqrt" (f64.const 0x1.b30f74caf9babp+146)) (f64.const 0x1.88bfc3d1764a9p-74)) + +;; Test that sqrt(1.0/x) isn't approximated. + +(module + (func (export "f32.no_approximate_sqrt_reciprocal") (param $x f32) (result f32) + (f32.sqrt (f32.div (f32.const 1.0) (local.get $x)))) +) + +(assert_return (invoke "f32.no_approximate_sqrt_reciprocal" (f32.const 0x1.a4c986p+60)) (f32.const 0x1.8f5ac6p-31)) +(assert_return (invoke "f32.no_approximate_sqrt_reciprocal" (f32.const 0x1.50511ep-9)) (f32.const 0x1.3bdd46p+4)) +(assert_return (invoke "f32.no_approximate_sqrt_reciprocal" (f32.const 0x1.125ec2p+69)) (f32.const 0x1.5db572p-35)) +(assert_return (invoke "f32.no_approximate_sqrt_reciprocal" (f32.const 0x1.ba4c5p+13)) (f32.const 0x1.136f16p-7)) +(assert_return (invoke "f32.no_approximate_sqrt_reciprocal" (f32.const 0x1.4a5be2p+104)) (f32.const 0x1.c2b5bp-53)) + +;; Test that converting i32/i64 to f32/f64 and back isn't folded away. + +(module + (func (export "i32.no_fold_f32_s") (param i32) (result i32) + (i32.trunc_f32_s (f32.convert_i32_s (local.get 0)))) + (func (export "i32.no_fold_f32_u") (param i32) (result i32) + (i32.trunc_f32_u (f32.convert_i32_u (local.get 0)))) + (func (export "i64.no_fold_f64_s") (param i64) (result i64) + (i64.trunc_f64_s (f64.convert_i64_s (local.get 0)))) + (func (export "i64.no_fold_f64_u") (param i64) (result i64) + (i64.trunc_f64_u (f64.convert_i64_u (local.get 0)))) +) + +(assert_return (invoke "i32.no_fold_f32_s" (i32.const 0x1000000)) (i32.const 0x1000000)) +(assert_return (invoke "i32.no_fold_f32_s" (i32.const 0x1000001)) (i32.const 0x1000000)) +(assert_return (invoke "i32.no_fold_f32_s" (i32.const 0xf0000010)) (i32.const 0xf0000010)) + +(assert_return (invoke "i32.no_fold_f32_u" (i32.const 0x1000000)) (i32.const 0x1000000)) +(assert_return (invoke "i32.no_fold_f32_u" (i32.const 0x1000001)) (i32.const 0x1000000)) +(assert_return (invoke "i32.no_fold_f32_u" (i32.const 0xf0000010)) (i32.const 0xf0000000)) + +(assert_return (invoke "i64.no_fold_f64_s" (i64.const 0x20000000000000)) (i64.const 0x20000000000000)) +(assert_return (invoke "i64.no_fold_f64_s" (i64.const 0x20000000000001)) (i64.const 0x20000000000000)) +(assert_return (invoke "i64.no_fold_f64_s" (i64.const 0xf000000000000400)) (i64.const 0xf000000000000400)) + +(assert_return (invoke "i64.no_fold_f64_u" (i64.const 0x20000000000000)) (i64.const 0x20000000000000)) +(assert_return (invoke "i64.no_fold_f64_u" (i64.const 0x20000000000001)) (i64.const 0x20000000000000)) +(assert_return (invoke "i64.no_fold_f64_u" (i64.const 0xf000000000000400)) (i64.const 0xf000000000000000)) + +;; Test that x+y-y is not folded to x. + +(module + (func (export "f32.no_fold_add_sub") (param $x f32) (param $y f32) (result f32) + (f32.sub (f32.add (local.get $x) (local.get $y)) (local.get $y))) + (func (export "f64.no_fold_add_sub") (param $x f64) (param $y f64) (result f64) + (f64.sub (f64.add (local.get $x) (local.get $y)) (local.get $y))) +) + +(assert_return (invoke "f32.no_fold_add_sub" (f32.const 0x1.b553e4p-47) (f32.const -0x1.67db2cp-26)) (f32.const 0x1.cp-47)) +(assert_return (invoke "f32.no_fold_add_sub" (f32.const -0x1.a884dp-23) (f32.const 0x1.f2ae1ep-19)) (f32.const -0x1.a884ep-23)) +(assert_return (invoke "f32.no_fold_add_sub" (f32.const -0x1.fc04fp+82) (f32.const -0x1.65403ap+101)) (f32.const -0x1p+83)) +(assert_return (invoke "f32.no_fold_add_sub" (f32.const 0x1.870fa2p-78) (f32.const 0x1.c54916p-56)) (f32.const 0x1.8p-78)) +(assert_return (invoke "f32.no_fold_add_sub" (f32.const -0x1.17e966p-108) (f32.const -0x1.5fa61ap-84)) (f32.const -0x1p-107)) + +(assert_return (invoke "f64.no_fold_add_sub" (f64.const -0x1.1053ea172dba8p-874) (f64.const 0x1.113c413408ac8p-857)) (f64.const -0x1.1053ea172p-874)) +(assert_return (invoke "f64.no_fold_add_sub" (f64.const 0x1.e377d54807972p-546) (f64.const 0x1.040a0a4d1ff7p-526)) (f64.const 0x1.e377d548p-546)) +(assert_return (invoke "f64.no_fold_add_sub" (f64.const -0x1.75f53cd926b62p-30) (f64.const -0x1.66b176e602bb5p-3)) (f64.const -0x1.75f53dp-30)) +(assert_return (invoke "f64.no_fold_add_sub" (f64.const -0x1.c450ff28332ap-341) (f64.const 0x1.15a5855023baep-305)) (f64.const -0x1.c451p-341)) +(assert_return (invoke "f64.no_fold_add_sub" (f64.const -0x1.1ad4a596d3ea8p-619) (f64.const -0x1.17d81a41c0ea8p-588)) (f64.const -0x1.1ad4a8p-619)) + +;; Test that x-y+y is not folded to x. + +(module + (func (export "f32.no_fold_sub_add") (param $x f32) (param $y f32) (result f32) + (f32.add (f32.sub (local.get $x) (local.get $y)) (local.get $y))) + (func (export "f64.no_fold_sub_add") (param $x f64) (param $y f64) (result f64) + (f64.add (f64.sub (local.get $x) (local.get $y)) (local.get $y))) +) + +(assert_return (invoke "f32.no_fold_sub_add" (f32.const -0x1.523cb8p+9) (f32.const 0x1.93096cp+8)) (f32.const -0x1.523cbap+9)) +(assert_return (invoke "f32.no_fold_sub_add" (f32.const -0x1.a31a1p-111) (f32.const 0x1.745efp-95)) (f32.const -0x1.a4p-111)) +(assert_return (invoke "f32.no_fold_sub_add" (f32.const 0x1.3d5328p+26) (f32.const 0x1.58567p+35)) (f32.const 0x1.3d54p+26)) +(assert_return (invoke "f32.no_fold_sub_add" (f32.const 0x1.374e26p-39) (f32.const -0x1.66a5p-27)) (f32.const 0x1.374p-39)) +(assert_return (invoke "f32.no_fold_sub_add" (f32.const 0x1.320facp-3) (f32.const -0x1.ac069ap+14)) (f32.const 0x1.34p-3)) + +(assert_return (invoke "f64.no_fold_sub_add" (f64.const 0x1.8f92aad2c9b8dp+255) (f64.const -0x1.08cd4992266cbp+259)) (f64.const 0x1.8f92aad2c9b9p+255)) +(assert_return (invoke "f64.no_fold_sub_add" (f64.const 0x1.5aaff55742c8bp-666) (f64.const 0x1.8f5f47181f46dp-647)) (f64.const 0x1.5aaff5578p-666)) +(assert_return (invoke "f64.no_fold_sub_add" (f64.const 0x1.21bc52967a98dp+251) (f64.const -0x1.fcffaa32d0884p+300)) (f64.const 0x1.2p+251)) +(assert_return (invoke "f64.no_fold_sub_add" (f64.const 0x1.9c78361f47374p-26) (f64.const -0x1.69d69f4edc61cp-13)) (f64.const 0x1.9c78361f48p-26)) +(assert_return (invoke "f64.no_fold_sub_add" (f64.const 0x1.4dbe68e4afab2p-367) (f64.const -0x1.dc24e5b39cd02p-361)) (f64.const 0x1.4dbe68e4afacp-367)) + +;; Test that x*y/y is not folded to x. + +(module + (func (export "f32.no_fold_mul_div") (param $x f32) (param $y f32) (result f32) + (f32.div (f32.mul (local.get $x) (local.get $y)) (local.get $y))) + (func (export "f64.no_fold_mul_div") (param $x f64) (param $y f64) (result f64) + (f64.div (f64.mul (local.get $x) (local.get $y)) (local.get $y))) +) + +(assert_return (invoke "f32.no_fold_mul_div" (f32.const -0x1.cd859ap+54) (f32.const 0x1.6ca936p-47)) (f32.const -0x1.cd8598p+54)) +(assert_return (invoke "f32.no_fold_mul_div" (f32.const -0x1.0b56b8p-26) (f32.const 0x1.48264cp-106)) (f32.const -0x1.0b56a4p-26)) +(assert_return (invoke "f32.no_fold_mul_div" (f32.const -0x1.e7555cp-48) (f32.const -0x1.9161cp+48)) (f32.const -0x1.e7555ap-48)) +(assert_return (invoke "f32.no_fold_mul_div" (f32.const 0x1.aaa50ep+52) (f32.const -0x1.dfb39ep+60)) (f32.const 0x1.aaa50cp+52)) +(assert_return (invoke "f32.no_fold_mul_div" (f32.const -0x1.2b7dfap-92) (f32.const -0x1.7c4ca6p-37)) (f32.const -0x1.2b7dfep-92)) + +(assert_return (invoke "f64.no_fold_mul_div" (f64.const -0x1.3d79ff4118a1ap-837) (f64.const -0x1.b8b5dda31808cp-205)) (f64.const -0x1.3d79ff412263ep-837)) +(assert_return (invoke "f64.no_fold_mul_div" (f64.const 0x1.f894d1ee6b3a4p+384) (f64.const 0x1.8c2606d03d58ap+585)) (f64.const 0x1.f894d1ee6b3a5p+384)) +(assert_return (invoke "f64.no_fold_mul_div" (f64.const -0x1.a022260acc993p+238) (f64.const -0x1.5fbc128fc8e3cp-552)) (f64.const -0x1.a022260acc992p+238)) +(assert_return (invoke "f64.no_fold_mul_div" (f64.const 0x1.9d4b8ed174f54p-166) (f64.const 0x1.ee3d467aeeac6p-906)) (f64.const 0x1.8dcc95a053b2bp-166)) +(assert_return (invoke "f64.no_fold_mul_div" (f64.const -0x1.e95ea897cdcd4p+660) (f64.const -0x1.854d5df085f2ep-327)) (f64.const -0x1.e95ea897cdcd5p+660)) + +;; Test that x/y*y is not folded to x. + +(module + (func (export "f32.no_fold_div_mul") (param $x f32) (param $y f32) (result f32) + (f32.mul (f32.div (local.get $x) (local.get $y)) (local.get $y))) + (func (export "f64.no_fold_div_mul") (param $x f64) (param $y f64) (result f64) + (f64.mul (f64.div (local.get $x) (local.get $y)) (local.get $y))) +) + +(assert_return (invoke "f32.no_fold_div_mul" (f32.const -0x1.dc6364p+38) (f32.const 0x1.d630ecp+29)) (f32.const -0x1.dc6362p+38)) +(assert_return (invoke "f32.no_fold_div_mul" (f32.const -0x1.1f9836p-52) (f32.const -0x1.16c4e4p-18)) (f32.const -0x1.1f9838p-52)) +(assert_return (invoke "f32.no_fold_div_mul" (f32.const 0x1.c5972cp-126) (f32.const -0x1.d6659ep+7)) (f32.const 0x1.c5980ep-126)) +(assert_return (invoke "f32.no_fold_div_mul" (f32.const -0x1.2e3a9ep-74) (f32.const -0x1.353994p+59)) (f32.const -0x1.2e3a4p-74)) +(assert_return (invoke "f32.no_fold_div_mul" (f32.const 0x1.d96b82p-98) (f32.const 0x1.95d908p+27)) (f32.const 0x1.d96b84p-98)) + +(assert_return (invoke "f64.no_fold_div_mul" (f64.const 0x1.d01f913a52481p-876) (f64.const -0x1.2cd0668b28344p+184)) (f64.const 0x1.d020daf71cdcp-876)) +(assert_return (invoke "f64.no_fold_div_mul" (f64.const -0x1.81cb7d400918dp-714) (f64.const 0x1.7caa643586d6ep-53)) (f64.const -0x1.81cb7d400918ep-714)) +(assert_return (invoke "f64.no_fold_div_mul" (f64.const -0x1.66904c97b5c8ep-145) (f64.const 0x1.5c3481592ad4cp+428)) (f64.const -0x1.66904c97b5c8dp-145)) +(assert_return (invoke "f64.no_fold_div_mul" (f64.const -0x1.e75859d2f0765p-278) (f64.const -0x1.5f19b6ab497f9p+283)) (f64.const -0x1.e75859d2f0764p-278)) +(assert_return (invoke "f64.no_fold_div_mul" (f64.const -0x1.515fe9c3b5f5p+620) (f64.const 0x1.36be869c99f7ap+989)) (f64.const -0x1.515fe9c3b5f4fp+620)) + +;; Test that x/2*2 is not folded to x. + +(module + (func (export "f32.no_fold_div2_mul2") (param $x f32) (result f32) + (f32.mul (f32.div (local.get $x) (f32.const 2.0)) (f32.const 2.0))) + (func (export "f64.no_fold_div2_mul2") (param $x f64) (result f64) + (f64.mul (f64.div (local.get $x) (f64.const 2.0)) (f64.const 2.0))) +) + +(assert_return (invoke "f32.no_fold_div2_mul2" (f32.const 0x1.fffffep-126)) (f32.const 0x1p-125)) +(assert_return (invoke "f64.no_fold_div2_mul2" (f64.const 0x1.fffffffffffffp-1022)) (f64.const 0x1p-1021)) + +;; Test that promote(demote(x)) is not folded to x. + +(module + (func (export "no_fold_demote_promote") (param $x f64) (result f64) + (f64.promote_f32 (f32.demote_f64 (local.get $x)))) +) + +(assert_return (invoke "no_fold_demote_promote" (f64.const -0x1.dece272390f5dp-133)) (f64.const -0x1.decep-133)) +(assert_return (invoke "no_fold_demote_promote" (f64.const -0x1.19e6c79938a6fp-85)) (f64.const -0x1.19e6c8p-85)) +(assert_return (invoke "no_fold_demote_promote" (f64.const 0x1.49b297ec44dc1p+107)) (f64.const 0x1.49b298p+107)) +(assert_return (invoke "no_fold_demote_promote" (f64.const -0x1.74f5bd865163p-88)) (f64.const -0x1.74f5bep-88)) +(assert_return (invoke "no_fold_demote_promote" (f64.const 0x1.26d675662367ep+104)) (f64.const 0x1.26d676p+104)) + +;; Test that demote(promote(x)) is not folded to x, and aside from NaN is +;; bit-preserving. + +(module + (func (export "no_fold_promote_demote") (param $x f32) (result f32) + (f32.demote_f64 (f64.promote_f32 (local.get $x)))) +) + +(assert_return (invoke "no_fold_promote_demote" (f32.const nan:0x200000)) (f32.const nan:arithmetic)) +(assert_return (invoke "no_fold_promote_demote" (f32.const 0x0p+0)) (f32.const 0x0p+0)) +(assert_return (invoke "no_fold_promote_demote" (f32.const -0x0p+0)) (f32.const -0x0p+0)) +(assert_return (invoke "no_fold_promote_demote" (f32.const 0x1p-149)) (f32.const 0x1p-149)) +(assert_return (invoke "no_fold_promote_demote" (f32.const -0x1p-149)) (f32.const -0x1p-149)) +(assert_return (invoke "no_fold_promote_demote" (f32.const 0x1.fffffcp-127)) (f32.const 0x1.fffffcp-127)) +(assert_return (invoke "no_fold_promote_demote" (f32.const -0x1.fffffcp-127)) (f32.const -0x1.fffffcp-127)) +(assert_return (invoke "no_fold_promote_demote" (f32.const 0x1p-126)) (f32.const 0x1p-126)) +(assert_return (invoke "no_fold_promote_demote" (f32.const -0x1p-126)) (f32.const -0x1p-126)) +(assert_return (invoke "no_fold_promote_demote" (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127)) +(assert_return (invoke "no_fold_promote_demote" (f32.const -0x1.fffffep+127)) (f32.const -0x1.fffffep+127)) +(assert_return (invoke "no_fold_promote_demote" (f32.const inf)) (f32.const inf)) +(assert_return (invoke "no_fold_promote_demote" (f32.const -inf)) (f32.const -inf)) + +;; Test that demote(x+promote(y)) is not folded to demote(x)+y. + +(module + (func (export "no_demote_mixed_add") (param $x f64) (param $y f32) (result f32) + (f32.demote_f64 (f64.add (local.get $x) (f64.promote_f32 (local.get $y))))) + (func (export "no_demote_mixed_add_commuted") (param $y f32) (param $x f64) (result f32) + (f32.demote_f64 (f64.add (f64.promote_f32 (local.get $y)) (local.get $x)))) +) + +(assert_return (invoke "no_demote_mixed_add" (f64.const 0x1.f51a9d04854f9p-95) (f32.const 0x1.3f4e9cp-119)) (f32.const 0x1.f51a9ep-95)) +(assert_return (invoke "no_demote_mixed_add" (f64.const 0x1.065b3d81ad8dp+37) (f32.const 0x1.758cd8p+38)) (f32.const 0x1.f8ba76p+38)) +(assert_return (invoke "no_demote_mixed_add" (f64.const 0x1.626c80963bd17p-119) (f32.const -0x1.9bbf86p-121)) (f32.const 0x1.f6f93ep-120)) +(assert_return (invoke "no_demote_mixed_add" (f64.const -0x1.0d5110e3385bbp-20) (f32.const 0x1.096f4ap-29)) (f32.const -0x1.0ccc5ap-20)) +(assert_return (invoke "no_demote_mixed_add" (f64.const -0x1.73852db4e5075p-20) (f32.const -0x1.24e474p-41)) (f32.const -0x1.738536p-20)) + +(assert_return (invoke "no_demote_mixed_add_commuted" (f32.const 0x1.3f4e9cp-119) (f64.const 0x1.f51a9d04854f9p-95)) (f32.const 0x1.f51a9ep-95)) +(assert_return (invoke "no_demote_mixed_add_commuted" (f32.const 0x1.758cd8p+38) (f64.const 0x1.065b3d81ad8dp+37)) (f32.const 0x1.f8ba76p+38)) +(assert_return (invoke "no_demote_mixed_add_commuted" (f32.const -0x1.9bbf86p-121) (f64.const 0x1.626c80963bd17p-119)) (f32.const 0x1.f6f93ep-120)) +(assert_return (invoke "no_demote_mixed_add_commuted" (f32.const 0x1.096f4ap-29) (f64.const -0x1.0d5110e3385bbp-20)) (f32.const -0x1.0ccc5ap-20)) +(assert_return (invoke "no_demote_mixed_add_commuted" (f32.const -0x1.24e474p-41) (f64.const -0x1.73852db4e5075p-20)) (f32.const -0x1.738536p-20)) + +;; Test that demote(x-promote(y)) is not folded to demote(x)-y. + +(module + (func (export "no_demote_mixed_sub") (param $x f64) (param $y f32) (result f32) + (f32.demote_f64 (f64.sub (local.get $x) (f64.promote_f32 (local.get $y))))) +) + +(assert_return (invoke "no_demote_mixed_sub" (f64.const 0x1.a0a183220e9b1p+82) (f32.const 0x1.c5acf8p+61)) (f32.const 0x1.a0a174p+82)) +(assert_return (invoke "no_demote_mixed_sub" (f64.const -0x1.6e2c5ac39f63ep+30) (f32.const 0x1.d48ca4p+17)) (f32.const -0x1.6e3bp+30)) +(assert_return (invoke "no_demote_mixed_sub" (f64.const -0x1.98c74350dde6ap+6) (f32.const 0x1.9d69bcp-12)) (f32.const -0x1.98c7aap+6)) +(assert_return (invoke "no_demote_mixed_sub" (f64.const 0x1.0459f34091dbfp-54) (f32.const 0x1.61ad08p-71)) (f32.const 0x1.045942p-54)) +(assert_return (invoke "no_demote_mixed_sub" (f64.const 0x1.a7498dca3fdb7p+14) (f32.const 0x1.ed21c8p+15)) (f32.const -0x1.197d02p+15)) + +;; Test that converting between integer and float and back isn't folded away. + +(module + (func (export "f32.i32.no_fold_trunc_s_convert_s") (param $x f32) (result f32) + (f32.convert_i32_s (i32.trunc_f32_s (local.get $x)))) + (func (export "f32.i32.no_fold_trunc_u_convert_s") (param $x f32) (result f32) + (f32.convert_i32_s (i32.trunc_f32_u (local.get $x)))) + (func (export "f32.i32.no_fold_trunc_s_convert_u") (param $x f32) (result f32) + (f32.convert_i32_u (i32.trunc_f32_s (local.get $x)))) + (func (export "f32.i32.no_fold_trunc_u_convert_u") (param $x f32) (result f32) + (f32.convert_i32_u (i32.trunc_f32_u (local.get $x)))) + (func (export "f64.i32.no_fold_trunc_s_convert_s") (param $x f64) (result f64) + (f64.convert_i32_s (i32.trunc_f64_s (local.get $x)))) + (func (export "f64.i32.no_fold_trunc_u_convert_s") (param $x f64) (result f64) + (f64.convert_i32_s (i32.trunc_f64_u (local.get $x)))) + (func (export "f64.i32.no_fold_trunc_s_convert_u") (param $x f64) (result f64) + (f64.convert_i32_u (i32.trunc_f64_s (local.get $x)))) + (func (export "f64.i32.no_fold_trunc_u_convert_u") (param $x f64) (result f64) + (f64.convert_i32_u (i32.trunc_f64_u (local.get $x)))) + (func (export "f32.i64.no_fold_trunc_s_convert_s") (param $x f32) (result f32) + (f32.convert_i64_s (i64.trunc_f32_s (local.get $x)))) + (func (export "f32.i64.no_fold_trunc_u_convert_s") (param $x f32) (result f32) + (f32.convert_i64_s (i64.trunc_f32_u (local.get $x)))) + (func (export "f32.i64.no_fold_trunc_s_convert_u") (param $x f32) (result f32) + (f32.convert_i64_u (i64.trunc_f32_s (local.get $x)))) + (func (export "f32.i64.no_fold_trunc_u_convert_u") (param $x f32) (result f32) + (f32.convert_i64_u (i64.trunc_f32_u (local.get $x)))) + (func (export "f64.i64.no_fold_trunc_s_convert_s") (param $x f64) (result f64) + (f64.convert_i64_s (i64.trunc_f64_s (local.get $x)))) + (func (export "f64.i64.no_fold_trunc_u_convert_s") (param $x f64) (result f64) + (f64.convert_i64_s (i64.trunc_f64_u (local.get $x)))) + (func (export "f64.i64.no_fold_trunc_s_convert_u") (param $x f64) (result f64) + (f64.convert_i64_u (i64.trunc_f64_s (local.get $x)))) + (func (export "f64.i64.no_fold_trunc_u_convert_u") (param $x f64) (result f64) + (f64.convert_i64_u (i64.trunc_f64_u (local.get $x)))) +) + +(assert_return (invoke "f32.i32.no_fold_trunc_s_convert_s" (f32.const 1.5)) (f32.const 1.0)) +(assert_return (invoke "f32.i32.no_fold_trunc_s_convert_s" (f32.const -1.5)) (f32.const -1.0)) +(assert_return (invoke "f32.i32.no_fold_trunc_u_convert_s" (f32.const 1.5)) (f32.const 1.0)) +(assert_return (invoke "f32.i32.no_fold_trunc_u_convert_s" (f32.const -0.5)) (f32.const 0.0)) +(assert_return (invoke "f32.i32.no_fold_trunc_s_convert_u" (f32.const 1.5)) (f32.const 1.0)) +(assert_return (invoke "f32.i32.no_fold_trunc_s_convert_u" (f32.const -1.5)) (f32.const 0x1p+32)) +(assert_return (invoke "f32.i32.no_fold_trunc_u_convert_u" (f32.const 1.5)) (f32.const 1.0)) +(assert_return (invoke "f32.i32.no_fold_trunc_u_convert_u" (f32.const -0.5)) (f32.const 0.0)) + +(assert_return (invoke "f64.i32.no_fold_trunc_s_convert_s" (f64.const 1.5)) (f64.const 1.0)) +(assert_return (invoke "f64.i32.no_fold_trunc_s_convert_s" (f64.const -1.5)) (f64.const -1.0)) +(assert_return (invoke "f64.i32.no_fold_trunc_u_convert_s" (f64.const 1.5)) (f64.const 1.0)) +(assert_return (invoke "f64.i32.no_fold_trunc_u_convert_s" (f64.const -0.5)) (f64.const 0.0)) +(assert_return (invoke "f64.i32.no_fold_trunc_s_convert_u" (f64.const 1.5)) (f64.const 1.0)) +(assert_return (invoke "f64.i32.no_fold_trunc_s_convert_u" (f64.const -1.5)) (f64.const 0x1.fffffffep+31)) +(assert_return (invoke "f64.i32.no_fold_trunc_u_convert_u" (f64.const 1.5)) (f64.const 1.0)) +(assert_return (invoke "f64.i32.no_fold_trunc_u_convert_u" (f64.const -0.5)) (f64.const 0.0)) + +(assert_return (invoke "f32.i64.no_fold_trunc_s_convert_s" (f32.const 1.5)) (f32.const 1.0)) +(assert_return (invoke "f32.i64.no_fold_trunc_s_convert_s" (f32.const -1.5)) (f32.const -1.0)) +(assert_return (invoke "f32.i64.no_fold_trunc_u_convert_s" (f32.const 1.5)) (f32.const 1.0)) +(assert_return (invoke "f32.i64.no_fold_trunc_u_convert_s" (f32.const -0.5)) (f32.const 0.0)) +(assert_return (invoke "f32.i64.no_fold_trunc_s_convert_u" (f32.const 1.5)) (f32.const 1.0)) +(assert_return (invoke "f32.i64.no_fold_trunc_s_convert_u" (f32.const -1.5)) (f32.const 0x1p+64)) +(assert_return (invoke "f32.i64.no_fold_trunc_u_convert_u" (f32.const 1.5)) (f32.const 1.0)) +(assert_return (invoke "f32.i64.no_fold_trunc_u_convert_u" (f32.const -0.5)) (f32.const 0.0)) + +(assert_return (invoke "f64.i64.no_fold_trunc_s_convert_s" (f64.const 1.5)) (f64.const 1.0)) +(assert_return (invoke "f64.i64.no_fold_trunc_s_convert_s" (f64.const -1.5)) (f64.const -1.0)) +(assert_return (invoke "f64.i64.no_fold_trunc_u_convert_s" (f64.const 1.5)) (f64.const 1.0)) +(assert_return (invoke "f64.i64.no_fold_trunc_u_convert_s" (f64.const -0.5)) (f64.const 0.0)) +(assert_return (invoke "f64.i64.no_fold_trunc_s_convert_u" (f64.const 1.5)) (f64.const 1.0)) +(assert_return (invoke "f64.i64.no_fold_trunc_s_convert_u" (f64.const -1.5)) (f64.const 0x1p+64)) +(assert_return (invoke "f64.i64.no_fold_trunc_u_convert_u" (f64.const 1.5)) (f64.const 1.0)) +(assert_return (invoke "f64.i64.no_fold_trunc_u_convert_u" (f64.const -0.5)) (f64.const 0.0)) + +;; Test that dividing by a loop-invariant constant isn't optimized to be a +;; multiplication by a reciprocal, which would be particularly tempting since +;; the reciprocal computation could be hoisted. + +(module + (memory 1 1) + (func (export "init") (param $i i32) (param $x f32) (f32.store (local.get $i) (local.get $x))) + + (func (export "run") (param $n i32) (param $z f32) + (local $i i32) + (block $exit + (loop $cont + (f32.store + (local.get $i) + (f32.div (f32.load (local.get $i)) (local.get $z)) + ) + (local.set $i (i32.add (local.get $i) (i32.const 4))) + (br_if $cont (i32.lt_u (local.get $i) (local.get $n))) + ) + ) + ) + + (func (export "check") (param $i i32) (result f32) (f32.load (local.get $i))) +) + +(invoke "init" (i32.const 0) (f32.const 15.1)) +(invoke "init" (i32.const 4) (f32.const 15.2)) +(invoke "init" (i32.const 8) (f32.const 15.3)) +(invoke "init" (i32.const 12) (f32.const 15.4)) +(assert_return (invoke "check" (i32.const 0)) (f32.const 15.1)) +(assert_return (invoke "check" (i32.const 4)) (f32.const 15.2)) +(assert_return (invoke "check" (i32.const 8)) (f32.const 15.3)) +(assert_return (invoke "check" (i32.const 12)) (f32.const 15.4)) +(invoke "run" (i32.const 16) (f32.const 3.0)) +(assert_return (invoke "check" (i32.const 0)) (f32.const 0x1.422222p+2)) +(assert_return (invoke "check" (i32.const 4)) (f32.const 0x1.444444p+2)) +(assert_return (invoke "check" (i32.const 8)) (f32.const 0x1.466666p+2)) +(assert_return (invoke "check" (i32.const 12)) (f32.const 0x1.488888p+2)) + +(module + (memory 1 1) + (func (export "init") (param $i i32) (param $x f64) (f64.store (local.get $i) (local.get $x))) + + (func (export "run") (param $n i32) (param $z f64) + (local $i i32) + (block $exit + (loop $cont + (f64.store + (local.get $i) + (f64.div (f64.load (local.get $i)) (local.get $z)) + ) + (local.set $i (i32.add (local.get $i) (i32.const 8))) + (br_if $cont (i32.lt_u (local.get $i) (local.get $n))) + ) + ) + ) + + (func (export "check") (param $i i32) (result f64) (f64.load (local.get $i))) +) + +(invoke "init" (i32.const 0) (f64.const 15.1)) +(invoke "init" (i32.const 8) (f64.const 15.2)) +(invoke "init" (i32.const 16) (f64.const 15.3)) +(invoke "init" (i32.const 24) (f64.const 15.4)) +(assert_return (invoke "check" (i32.const 0)) (f64.const 15.1)) +(assert_return (invoke "check" (i32.const 8)) (f64.const 15.2)) +(assert_return (invoke "check" (i32.const 16)) (f64.const 15.3)) +(assert_return (invoke "check" (i32.const 24)) (f64.const 15.4)) +(invoke "run" (i32.const 32) (f64.const 3.0)) +(assert_return (invoke "check" (i32.const 0)) (f64.const 0x1.4222222222222p+2)) +(assert_return (invoke "check" (i32.const 8)) (f64.const 0x1.4444444444444p+2)) +(assert_return (invoke "check" (i32.const 16)) (f64.const 0x1.4666666666667p+2)) +(assert_return (invoke "check" (i32.const 24)) (f64.const 0x1.4888888888889p+2)) + +;; Test that ult/ugt/etc. aren't folded to olt/ogt/etc. + +(module + (func (export "f32.ult") (param $x f32) (param $y f32) (result i32) (i32.eqz (f32.ge (local.get $x) (local.get $y)))) + (func (export "f32.ule") (param $x f32) (param $y f32) (result i32) (i32.eqz (f32.gt (local.get $x) (local.get $y)))) + (func (export "f32.ugt") (param $x f32) (param $y f32) (result i32) (i32.eqz (f32.le (local.get $x) (local.get $y)))) + (func (export "f32.uge") (param $x f32) (param $y f32) (result i32) (i32.eqz (f32.lt (local.get $x) (local.get $y)))) + + (func (export "f64.ult") (param $x f64) (param $y f64) (result i32) (i32.eqz (f64.ge (local.get $x) (local.get $y)))) + (func (export "f64.ule") (param $x f64) (param $y f64) (result i32) (i32.eqz (f64.gt (local.get $x) (local.get $y)))) + (func (export "f64.ugt") (param $x f64) (param $y f64) (result i32) (i32.eqz (f64.le (local.get $x) (local.get $y)))) + (func (export "f64.uge") (param $x f64) (param $y f64) (result i32) (i32.eqz (f64.lt (local.get $x) (local.get $y)))) +) + +(assert_return (invoke "f32.ult" (f32.const 3.0) (f32.const 2.0)) (i32.const 0)) +(assert_return (invoke "f32.ult" (f32.const 2.0) (f32.const 2.0)) (i32.const 0)) +(assert_return (invoke "f32.ult" (f32.const 2.0) (f32.const 3.0)) (i32.const 1)) +(assert_return (invoke "f32.ult" (f32.const 2.0) (f32.const nan)) (i32.const 1)) +(assert_return (invoke "f32.ule" (f32.const 3.0) (f32.const 2.0)) (i32.const 0)) +(assert_return (invoke "f32.ule" (f32.const 2.0) (f32.const 2.0)) (i32.const 1)) +(assert_return (invoke "f32.ule" (f32.const 2.0) (f32.const 3.0)) (i32.const 1)) +(assert_return (invoke "f32.ule" (f32.const 2.0) (f32.const nan)) (i32.const 1)) +(assert_return (invoke "f32.ugt" (f32.const 3.0) (f32.const 2.0)) (i32.const 1)) +(assert_return (invoke "f32.ugt" (f32.const 2.0) (f32.const 2.0)) (i32.const 0)) +(assert_return (invoke "f32.ugt" (f32.const 2.0) (f32.const 3.0)) (i32.const 0)) +(assert_return (invoke "f32.ugt" (f32.const 2.0) (f32.const nan)) (i32.const 1)) +(assert_return (invoke "f32.uge" (f32.const 3.0) (f32.const 2.0)) (i32.const 1)) +(assert_return (invoke "f32.uge" (f32.const 2.0) (f32.const 2.0)) (i32.const 1)) +(assert_return (invoke "f32.uge" (f32.const 2.0) (f32.const 3.0)) (i32.const 0)) +(assert_return (invoke "f32.uge" (f32.const 2.0) (f32.const nan)) (i32.const 1)) +(assert_return (invoke "f64.ult" (f64.const 3.0) (f64.const 2.0)) (i32.const 0)) +(assert_return (invoke "f64.ult" (f64.const 2.0) (f64.const 2.0)) (i32.const 0)) +(assert_return (invoke "f64.ult" (f64.const 2.0) (f64.const 3.0)) (i32.const 1)) +(assert_return (invoke "f64.ult" (f64.const 2.0) (f64.const nan)) (i32.const 1)) +(assert_return (invoke "f64.ule" (f64.const 3.0) (f64.const 2.0)) (i32.const 0)) +(assert_return (invoke "f64.ule" (f64.const 2.0) (f64.const 2.0)) (i32.const 1)) +(assert_return (invoke "f64.ule" (f64.const 2.0) (f64.const 3.0)) (i32.const 1)) +(assert_return (invoke "f64.ule" (f64.const 2.0) (f64.const nan)) (i32.const 1)) +(assert_return (invoke "f64.ugt" (f64.const 3.0) (f64.const 2.0)) (i32.const 1)) +(assert_return (invoke "f64.ugt" (f64.const 2.0) (f64.const 2.0)) (i32.const 0)) +(assert_return (invoke "f64.ugt" (f64.const 2.0) (f64.const 3.0)) (i32.const 0)) +(assert_return (invoke "f64.ugt" (f64.const 2.0) (f64.const nan)) (i32.const 1)) +(assert_return (invoke "f64.uge" (f64.const 3.0) (f64.const 2.0)) (i32.const 1)) +(assert_return (invoke "f64.uge" (f64.const 2.0) (f64.const 2.0)) (i32.const 1)) +(assert_return (invoke "f64.uge" (f64.const 2.0) (f64.const 3.0)) (i32.const 0)) +(assert_return (invoke "f64.uge" (f64.const 2.0) (f64.const nan)) (i32.const 1)) + +;; Test that x= y+z is not optimized to x >= y (monotonicity). +;; http://cs.nyu.edu/courses/spring13/CSCI-UA.0201-003/lecture6.pdf + +(module + (func (export "f32.no_fold_add_le_monotonicity") (param $x f32) (param $y f32) (param $z f32) (result i32) + (f32.le (f32.add (local.get $x) (local.get $z)) (f32.add (local.get $y) (local.get $z)))) + + (func (export "f32.no_fold_add_ge_monotonicity") (param $x f32) (param $y f32) (param $z f32) (result i32) + (f32.ge (f32.add (local.get $x) (local.get $z)) (f32.add (local.get $y) (local.get $z)))) + + (func (export "f64.no_fold_add_le_monotonicity") (param $x f64) (param $y f64) (param $z f64) (result i32) + (f64.le (f64.add (local.get $x) (local.get $z)) (f64.add (local.get $y) (local.get $z)))) + + (func (export "f64.no_fold_add_ge_monotonicity") (param $x f64) (param $y f64) (param $z f64) (result i32) + (f64.ge (f64.add (local.get $x) (local.get $z)) (f64.add (local.get $y) (local.get $z)))) +) + +(assert_return (invoke "f32.no_fold_add_le_monotonicity" (f32.const 0.0) (f32.const 0.0) (f32.const nan)) (i32.const 0)) +(assert_return (invoke "f32.no_fold_add_le_monotonicity" (f32.const inf) (f32.const -inf) (f32.const inf)) (i32.const 0)) +(assert_return (invoke "f64.no_fold_add_le_monotonicity" (f64.const 0.0) (f64.const 0.0) (f64.const nan)) (i32.const 0)) +(assert_return (invoke "f64.no_fold_add_le_monotonicity" (f64.const inf) (f64.const -inf) (f64.const inf)) (i32.const 0)) + +;; Test that !(x < y) and friends are not optimized to x >= y and friends. + +(module + (func (export "f32.not_lt") (param $x f32) (param $y f32) (result i32) + (i32.eqz (f32.lt (local.get $x) (local.get $y)))) + + (func (export "f32.not_le") (param $x f32) (param $y f32) (result i32) + (i32.eqz (f32.le (local.get $x) (local.get $y)))) + + (func (export "f32.not_gt") (param $x f32) (param $y f32) (result i32) + (i32.eqz (f32.gt (local.get $x) (local.get $y)))) + + (func (export "f32.not_ge") (param $x f32) (param $y f32) (result i32) + (i32.eqz (f32.ge (local.get $x) (local.get $y)))) + + (func (export "f64.not_lt") (param $x f64) (param $y f64) (result i32) + (i32.eqz (f64.lt (local.get $x) (local.get $y)))) + + (func (export "f64.not_le") (param $x f64) (param $y f64) (result i32) + (i32.eqz (f64.le (local.get $x) (local.get $y)))) + + (func (export "f64.not_gt") (param $x f64) (param $y f64) (result i32) + (i32.eqz (f64.gt (local.get $x) (local.get $y)))) + + (func (export "f64.not_ge") (param $x f64) (param $y f64) (result i32) + (i32.eqz (f64.ge (local.get $x) (local.get $y)))) +) + +(assert_return (invoke "f32.not_lt" (f32.const nan) (f32.const 0.0)) (i32.const 1)) +(assert_return (invoke "f32.not_le" (f32.const nan) (f32.const 0.0)) (i32.const 1)) +(assert_return (invoke "f32.not_gt" (f32.const nan) (f32.const 0.0)) (i32.const 1)) +(assert_return (invoke "f32.not_ge" (f32.const nan) (f32.const 0.0)) (i32.const 1)) +(assert_return (invoke "f64.not_lt" (f64.const nan) (f64.const 0.0)) (i32.const 1)) +(assert_return (invoke "f64.not_le" (f64.const nan) (f64.const 0.0)) (i32.const 1)) +(assert_return (invoke "f64.not_gt" (f64.const nan) (f64.const 0.0)) (i32.const 1)) +(assert_return (invoke "f64.not_ge" (f64.const nan) (f64.const 0.0)) (i32.const 1)) + +;; Test that a method for approximating a "machine epsilon" produces the expected +;; approximation. +;; http://blogs.mathworks.com/cleve/2014/07/07/floating-point-numbers/#24cb4f4d-b8a9-4c19-b22b-9d2a9f7f3812 + +(module + (func (export "f32.epsilon") (result f32) + (f32.sub (f32.const 1.0) (f32.mul (f32.const 3.0) (f32.sub (f32.div (f32.const 4.0) (f32.const 3.0)) (f32.const 1.0))))) + + (func (export "f64.epsilon") (result f64) + (f64.sub (f64.const 1.0) (f64.mul (f64.const 3.0) (f64.sub (f64.div (f64.const 4.0) (f64.const 3.0)) (f64.const 1.0))))) +) + +(assert_return (invoke "f32.epsilon") (f32.const -0x1p-23)) +(assert_return (invoke "f64.epsilon") (f64.const 0x1p-52)) + +;; Test that a method for computing a "machine epsilon" produces the expected +;; result. +;; https://www.math.utah.edu/~beebe/software/ieee/ + +(module + (func (export "f32.epsilon") (result f32) + (local $x f32) + (local $result f32) + (local.set $x (f32.const 1)) + (loop $loop + (br_if $loop + (f32.gt + (f32.add + (local.tee $x + (f32.mul + (local.tee $result (local.get $x)) + (f32.const 0.5) + ) + ) + (f32.const 1) + ) + (f32.const 1) + ) + ) + ) + (local.get $result) + ) + + (func (export "f64.epsilon") (result f64) + (local $x f64) + (local $result f64) + (local.set $x (f64.const 1)) + (loop $loop + (br_if $loop + (f64.gt + (f64.add + (local.tee $x + (f64.mul + (local.tee $result (local.get $x)) + (f64.const 0.5) + ) + ) + (f64.const 1) + ) + (f64.const 1) + ) + ) + ) + (local.get $result) + ) +) + +(assert_return (invoke "f32.epsilon") (f32.const 0x1p-23)) +(assert_return (invoke "f64.epsilon") (f64.const 0x1p-52)) + +;; Test that floating-point numbers are not optimized as if they form a +;; trichotomy. + +(module + (func (export "f32.no_trichotomy_lt") (param $x f32) (param $y f32) (result i32) + (i32.or (f32.lt (local.get $x) (local.get $y)) (f32.ge (local.get $x) (local.get $y)))) + (func (export "f32.no_trichotomy_le") (param $x f32) (param $y f32) (result i32) + (i32.or (f32.le (local.get $x) (local.get $y)) (f32.gt (local.get $x) (local.get $y)))) + (func (export "f32.no_trichotomy_gt") (param $x f32) (param $y f32) (result i32) + (i32.or (f32.gt (local.get $x) (local.get $y)) (f32.le (local.get $x) (local.get $y)))) + (func (export "f32.no_trichotomy_ge") (param $x f32) (param $y f32) (result i32) + (i32.or (f32.ge (local.get $x) (local.get $y)) (f32.lt (local.get $x) (local.get $y)))) + + (func (export "f64.no_trichotomy_lt") (param $x f64) (param $y f64) (result i32) + (i32.or (f64.lt (local.get $x) (local.get $y)) (f64.ge (local.get $x) (local.get $y)))) + (func (export "f64.no_trichotomy_le") (param $x f64) (param $y f64) (result i32) + (i32.or (f64.le (local.get $x) (local.get $y)) (f64.gt (local.get $x) (local.get $y)))) + (func (export "f64.no_trichotomy_gt") (param $x f64) (param $y f64) (result i32) + (i32.or (f64.gt (local.get $x) (local.get $y)) (f64.le (local.get $x) (local.get $y)))) + (func (export "f64.no_trichotomy_ge") (param $x f64) (param $y f64) (result i32) + (i32.or (f64.ge (local.get $x) (local.get $y)) (f64.lt (local.get $x) (local.get $y)))) +) + +(assert_return (invoke "f32.no_trichotomy_lt" (f32.const 0.0) (f32.const nan)) (i32.const 0)) +(assert_return (invoke "f32.no_trichotomy_le" (f32.const 0.0) (f32.const nan)) (i32.const 0)) +(assert_return (invoke "f32.no_trichotomy_gt" (f32.const 0.0) (f32.const nan)) (i32.const 0)) +(assert_return (invoke "f32.no_trichotomy_ge" (f32.const 0.0) (f32.const nan)) (i32.const 0)) +(assert_return (invoke "f64.no_trichotomy_lt" (f64.const 0.0) (f64.const nan)) (i32.const 0)) +(assert_return (invoke "f64.no_trichotomy_le" (f64.const 0.0) (f64.const nan)) (i32.const 0)) +(assert_return (invoke "f64.no_trichotomy_gt" (f64.const 0.0) (f64.const nan)) (i32.const 0)) +(assert_return (invoke "f64.no_trichotomy_ge" (f64.const 0.0) (f64.const nan)) (i32.const 0)) + +;; Some test harnesses which can run this testsuite are unable to perform tests +;; of NaN bitpatterns. The following tests whether the underlying platform is +;; generally producing the kinds of NaNs expected. +(module + (func (export "f32.arithmetic_nan_bitpattern") + (param $x i32) (param $y i32) (result i32) + (i32.and (i32.reinterpret_f32 + (f32.div + (f32.reinterpret_i32 (local.get $x)) + (f32.reinterpret_i32 (local.get $y)))) + (i32.const 0x7fc00000))) + (func (export "f32.canonical_nan_bitpattern") + (param $x i32) (param $y i32) (result i32) + (i32.and (i32.reinterpret_f32 + (f32.div + (f32.reinterpret_i32 (local.get $x)) + (f32.reinterpret_i32 (local.get $y)))) + (i32.const 0x7fffffff))) + (func (export "f32.nonarithmetic_nan_bitpattern") + (param $x i32) (result i32) + (i32.reinterpret_f32 (f32.neg (f32.reinterpret_i32 (local.get $x))))) + + (func (export "f64.arithmetic_nan_bitpattern") + (param $x i64) (param $y i64) (result i64) + (i64.and (i64.reinterpret_f64 + (f64.div + (f64.reinterpret_i64 (local.get $x)) + (f64.reinterpret_i64 (local.get $y)))) + (i64.const 0x7ff8000000000000))) + (func (export "f64.canonical_nan_bitpattern") + (param $x i64) (param $y i64) (result i64) + (i64.and (i64.reinterpret_f64 + (f64.div + (f64.reinterpret_i64 (local.get $x)) + (f64.reinterpret_i64 (local.get $y)))) + (i64.const 0x7fffffffffffffff))) + (func (export "f64.nonarithmetic_nan_bitpattern") + (param $x i64) (result i64) + (i64.reinterpret_f64 (f64.neg (f64.reinterpret_i64 (local.get $x))))) + + ;; Versions of no_fold testcases that only care about NaN bitpatterns. + (func (export "f32.no_fold_sub_zero") (param $x i32) (result i32) + (i32.and (i32.reinterpret_f32 (f32.sub (f32.reinterpret_i32 (local.get $x)) (f32.const 0.0))) + (i32.const 0x7fc00000))) + (func (export "f32.no_fold_neg0_sub") (param $x i32) (result i32) + (i32.and (i32.reinterpret_f32 (f32.sub (f32.const -0.0) (f32.reinterpret_i32 (local.get $x)))) + (i32.const 0x7fc00000))) + (func (export "f32.no_fold_mul_one") (param $x i32) (result i32) + (i32.and (i32.reinterpret_f32 (f32.mul (f32.reinterpret_i32 (local.get $x)) (f32.const 1.0))) + (i32.const 0x7fc00000))) + (func (export "f32.no_fold_neg1_mul") (param $x i32) (result i32) + (i32.and (i32.reinterpret_f32 (f32.mul (f32.const -1.0) (f32.reinterpret_i32 (local.get $x)))) + (i32.const 0x7fc00000))) + (func (export "f32.no_fold_div_one") (param $x i32) (result i32) + (i32.and (i32.reinterpret_f32 (f32.div (f32.reinterpret_i32 (local.get $x)) (f32.const 1.0))) + (i32.const 0x7fc00000))) + (func (export "f32.no_fold_div_neg1") (param $x i32) (result i32) + (i32.and (i32.reinterpret_f32 (f32.div (f32.reinterpret_i32 (local.get $x)) (f32.const -1.0))) + (i32.const 0x7fc00000))) + (func (export "f64.no_fold_sub_zero") (param $x i64) (result i64) + (i64.and (i64.reinterpret_f64 (f64.sub (f64.reinterpret_i64 (local.get $x)) (f64.const 0.0))) + (i64.const 0x7ff8000000000000))) + (func (export "f64.no_fold_neg0_sub") (param $x i64) (result i64) + (i64.and (i64.reinterpret_f64 (f64.sub (f64.const -0.0) (f64.reinterpret_i64 (local.get $x)))) + (i64.const 0x7ff8000000000000))) + (func (export "f64.no_fold_mul_one") (param $x i64) (result i64) + (i64.and (i64.reinterpret_f64 (f64.mul (f64.reinterpret_i64 (local.get $x)) (f64.const 1.0))) + (i64.const 0x7ff8000000000000))) + (func (export "f64.no_fold_neg1_mul") (param $x i64) (result i64) + (i64.and (i64.reinterpret_f64 (f64.mul (f64.const -1.0) (f64.reinterpret_i64 (local.get $x)))) + (i64.const 0x7ff8000000000000))) + (func (export "f64.no_fold_div_one") (param $x i64) (result i64) + (i64.and (i64.reinterpret_f64 (f64.div (f64.reinterpret_i64 (local.get $x)) (f64.const 1.0))) + (i64.const 0x7ff8000000000000))) + (func (export "f64.no_fold_div_neg1") (param $x i64) (result i64) + (i64.and (i64.reinterpret_f64 (f64.div (f64.reinterpret_i64 (local.get $x)) (f64.const -1.0))) + (i64.const 0x7ff8000000000000))) + (func (export "no_fold_promote_demote") (param $x i32) (result i32) + (i32.and (i32.reinterpret_f32 (f32.demote_f64 (f64.promote_f32 (f32.reinterpret_i32 (local.get $x))))) + (i32.const 0x7fc00000))) +) + +(assert_return (invoke "f32.arithmetic_nan_bitpattern" (i32.const 0x7f803210) (i32.const 0x7f803210)) (i32.const 0x7fc00000)) +(assert_return (invoke "f32.canonical_nan_bitpattern" (i32.const 0) (i32.const 0)) (i32.const 0x7fc00000)) +(assert_return (invoke "f32.canonical_nan_bitpattern" (i32.const 0x7fc00000) (i32.const 0x7fc00000)) (i32.const 0x7fc00000)) +(assert_return (invoke "f32.canonical_nan_bitpattern" (i32.const 0xffc00000) (i32.const 0x7fc00000)) (i32.const 0x7fc00000)) +(assert_return (invoke "f32.canonical_nan_bitpattern" (i32.const 0x7fc00000) (i32.const 0xffc00000)) (i32.const 0x7fc00000)) +(assert_return (invoke "f32.canonical_nan_bitpattern" (i32.const 0xffc00000) (i32.const 0xffc00000)) (i32.const 0x7fc00000)) +(assert_return (invoke "f32.nonarithmetic_nan_bitpattern" (i32.const 0x7fc03210)) (i32.const 0xffc03210)) +(assert_return (invoke "f32.nonarithmetic_nan_bitpattern" (i32.const 0xffc03210)) (i32.const 0x7fc03210)) +(assert_return (invoke "f32.nonarithmetic_nan_bitpattern" (i32.const 0x7f803210)) (i32.const 0xff803210)) +(assert_return (invoke "f32.nonarithmetic_nan_bitpattern" (i32.const 0xff803210)) (i32.const 0x7f803210)) +(assert_return (invoke "f64.arithmetic_nan_bitpattern" (i64.const 0x7ff0000000003210) (i64.const 0x7ff0000000003210)) (i64.const 0x7ff8000000000000)) +(assert_return (invoke "f64.canonical_nan_bitpattern" (i64.const 0) (i64.const 0)) (i64.const 0x7ff8000000000000)) +(assert_return (invoke "f64.canonical_nan_bitpattern" (i64.const 0x7ff8000000000000) (i64.const 0x7ff8000000000000)) (i64.const 0x7ff8000000000000)) +(assert_return (invoke "f64.canonical_nan_bitpattern" (i64.const 0xfff8000000000000) (i64.const 0x7ff8000000000000)) (i64.const 0x7ff8000000000000)) +(assert_return (invoke "f64.canonical_nan_bitpattern" (i64.const 0x7ff8000000000000) (i64.const 0xfff8000000000000)) (i64.const 0x7ff8000000000000)) +(assert_return (invoke "f64.canonical_nan_bitpattern" (i64.const 0xfff8000000000000) (i64.const 0xfff8000000000000)) (i64.const 0x7ff8000000000000)) +(assert_return (invoke "f64.nonarithmetic_nan_bitpattern" (i64.const 0x7ff8000000003210)) (i64.const 0xfff8000000003210)) +(assert_return (invoke "f64.nonarithmetic_nan_bitpattern" (i64.const 0xfff8000000003210)) (i64.const 0x7ff8000000003210)) +(assert_return (invoke "f64.nonarithmetic_nan_bitpattern" (i64.const 0x7ff0000000003210)) (i64.const 0xfff0000000003210)) +(assert_return (invoke "f64.nonarithmetic_nan_bitpattern" (i64.const 0xfff0000000003210)) (i64.const 0x7ff0000000003210)) +(assert_return (invoke "f32.no_fold_sub_zero" (i32.const 0x7fa00000)) (i32.const 0x7fc00000)) +(assert_return (invoke "f32.no_fold_neg0_sub" (i32.const 0x7fa00000)) (i32.const 0x7fc00000)) +(assert_return (invoke "f32.no_fold_mul_one" (i32.const 0x7fa00000)) (i32.const 0x7fc00000)) +(assert_return (invoke "f32.no_fold_neg1_mul" (i32.const 0x7fa00000)) (i32.const 0x7fc00000)) +(assert_return (invoke "f32.no_fold_div_one" (i32.const 0x7fa00000)) (i32.const 0x7fc00000)) +(assert_return (invoke "f32.no_fold_div_neg1" (i32.const 0x7fa00000)) (i32.const 0x7fc00000)) +(assert_return (invoke "f64.no_fold_sub_zero" (i64.const 0x7ff4000000000000)) (i64.const 0x7ff8000000000000)) +(assert_return (invoke "f64.no_fold_neg0_sub" (i64.const 0x7ff4000000000000)) (i64.const 0x7ff8000000000000)) +(assert_return (invoke "f64.no_fold_mul_one" (i64.const 0x7ff4000000000000)) (i64.const 0x7ff8000000000000)) +(assert_return (invoke "f64.no_fold_neg1_mul" (i64.const 0x7ff4000000000000)) (i64.const 0x7ff8000000000000)) +(assert_return (invoke "f64.no_fold_div_one" (i64.const 0x7ff4000000000000)) (i64.const 0x7ff8000000000000)) +(assert_return (invoke "f64.no_fold_div_neg1" (i64.const 0x7ff4000000000000)) (i64.const 0x7ff8000000000000)) +(assert_return (invoke "no_fold_promote_demote" (i32.const 0x7fa00000)) (i32.const 0x7fc00000)) + +;; Test that IEEE 754 double precision does, in fact, compute a certain dot +;; product correctly. + +(module + (func (export "dot_product_example") + (param $x0 f64) (param $x1 f64) (param $x2 f64) (param $x3 f64) + (param $y0 f64) (param $y1 f64) (param $y2 f64) (param $y3 f64) + (result f64) + (f64.add (f64.add (f64.add + (f64.mul (local.get $x0) (local.get $y0)) + (f64.mul (local.get $x1) (local.get $y1))) + (f64.mul (local.get $x2) (local.get $y2))) + (f64.mul (local.get $x3) (local.get $y3))) + ) + + (func (export "with_binary_sum_collapse") + (param $x0 f64) (param $x1 f64) (param $x2 f64) (param $x3 f64) + (param $y0 f64) (param $y1 f64) (param $y2 f64) (param $y3 f64) + (result f64) + (f64.add (f64.add (f64.mul (local.get $x0) (local.get $y0)) + (f64.mul (local.get $x1) (local.get $y1))) + (f64.add (f64.mul (local.get $x2) (local.get $y2)) + (f64.mul (local.get $x3) (local.get $y3)))) + ) +) + +(assert_return (invoke "dot_product_example" + (f64.const 3.2e7) (f64.const 1.0) (f64.const -1.0) (f64.const 8.0e7) + (f64.const 4.0e7) (f64.const 1.0) (f64.const -1.0) (f64.const -1.6e7)) + (f64.const 2.0)) +(assert_return (invoke "with_binary_sum_collapse" + (f64.const 3.2e7) (f64.const 1.0) (f64.const -1.0) (f64.const 8.0e7) + (f64.const 4.0e7) (f64.const 1.0) (f64.const -1.0) (f64.const -1.6e7)) + (f64.const 2.0)) + +;; http://www.vinc17.org/research/fptest.en.html#contract2fma + +(module + (func (export "f32.contract2fma") + (param $x f32) (param $y f32) (result f32) + (f32.sqrt (f32.sub (f32.mul (local.get $x) (local.get $x)) + (f32.mul (local.get $y) (local.get $y))))) + (func (export "f64.contract2fma") + (param $x f64) (param $y f64) (result f64) + (f64.sqrt (f64.sub (f64.mul (local.get $x) (local.get $x)) + (f64.mul (local.get $y) (local.get $y))))) +) + +(assert_return (invoke "f32.contract2fma" (f32.const 1.0) (f32.const 1.0)) (f32.const 0.0)) +(assert_return (invoke "f32.contract2fma" (f32.const 0x1.19999ap+0) (f32.const 0x1.19999ap+0)) (f32.const 0.0)) +(assert_return (invoke "f32.contract2fma" (f32.const 0x1.333332p+0) (f32.const 0x1.333332p+0)) (f32.const 0.0)) +(assert_return (invoke "f64.contract2fma" (f64.const 1.0) (f64.const 1.0)) (f64.const 0.0)) +(assert_return (invoke "f64.contract2fma" (f64.const 0x1.199999999999ap+0) (f64.const 0x1.199999999999ap+0)) (f64.const 0.0)) +(assert_return (invoke "f64.contract2fma" (f64.const 0x1.3333333333333p+0) (f64.const 0x1.3333333333333p+0)) (f64.const 0.0)) + +;; Test that floating-point isn't implemented with QuickBasic for MS-DOS. +;; https://support.microsoft.com/en-us/help/42980/-complete-tutorial-to-understand-ieee-floating-point-errors + +(module + (func (export "f32.division_by_small_number") + (param $a f32) (param $b f32) (param $c f32) (result f32) + (f32.sub (local.get $a) (f32.div (local.get $b) (local.get $c)))) + (func (export "f64.division_by_small_number") + (param $a f64) (param $b f64) (param $c f64) (result f64) + (f64.sub (local.get $a) (f64.div (local.get $b) (local.get $c)))) +) + +(assert_return (invoke "f32.division_by_small_number" (f32.const 112000000) (f32.const 100000) (f32.const 0.0009)) (f32.const 888888)) +(assert_return (invoke "f64.division_by_small_number" (f64.const 112000000) (f64.const 100000) (f64.const 0.0009)) (f64.const 888888.8888888806)) + +;; Test a simple golden ratio computation. +;; http://mathworld.wolfram.com/GoldenRatio.html + +(module + (func (export "f32.golden_ratio") (param $a f32) (param $b f32) (param $c f32) (result f32) + (f32.mul (local.get 0) (f32.add (local.get 1) (f32.sqrt (local.get 2))))) + (func (export "f64.golden_ratio") (param $a f64) (param $b f64) (param $c f64) (result f64) + (f64.mul (local.get 0) (f64.add (local.get 1) (f64.sqrt (local.get 2))))) +) + +(assert_return (invoke "f32.golden_ratio" (f32.const 0.5) (f32.const 1.0) (f32.const 5.0)) (f32.const 1.618034)) +(assert_return (invoke "f64.golden_ratio" (f64.const 0.5) (f64.const 1.0) (f64.const 5.0)) (f64.const 1.618033988749895)) + +;; Test some silver means computations. +;; http://mathworld.wolfram.com/SilverRatio.html + +(module + (func (export "f32.silver_means") (param $n f32) (result f32) + (f32.mul (f32.const 0.5) + (f32.add (local.get $n) + (f32.sqrt (f32.add (f32.mul (local.get $n) (local.get $n)) + (f32.const 4.0)))))) + (func (export "f64.silver_means") (param $n f64) (result f64) + (f64.mul (f64.const 0.5) + (f64.add (local.get $n) + (f64.sqrt (f64.add (f64.mul (local.get $n) (local.get $n)) + (f64.const 4.0)))))) +) + +(assert_return (invoke "f32.silver_means" (f32.const 0.0)) (f32.const 1.0)) +(assert_return (invoke "f32.silver_means" (f32.const 1.0)) (f32.const 1.6180340)) +(assert_return (invoke "f32.silver_means" (f32.const 2.0)) (f32.const 2.4142136)) +(assert_return (invoke "f32.silver_means" (f32.const 3.0)) (f32.const 3.3027756)) +(assert_return (invoke "f32.silver_means" (f32.const 4.0)) (f32.const 4.2360680)) +(assert_return (invoke "f32.silver_means" (f32.const 5.0)) (f32.const 5.1925821)) +(assert_return (invoke "f64.silver_means" (f64.const 0.0)) (f64.const 1.0)) +(assert_return (invoke "f64.silver_means" (f64.const 1.0)) (f64.const 1.618033988749895)) +(assert_return (invoke "f64.silver_means" (f64.const 2.0)) (f64.const 2.414213562373095)) +(assert_return (invoke "f64.silver_means" (f64.const 3.0)) (f64.const 3.302775637731995)) +(assert_return (invoke "f64.silver_means" (f64.const 4.0)) (f64.const 4.236067977499790)) +(assert_return (invoke "f64.silver_means" (f64.const 5.0)) (f64.const 5.192582403567252)) + +;; Test that an f64 0.4 isn't double-rounded as via extended precision. +;; https://bugs.llvm.org/show_bug.cgi?id=11200 + +(module + (func (export "point_four") (param $four f64) (param $ten f64) (result i32) + (f64.lt (f64.div (local.get $four) (local.get $ten)) (f64.const 0.4))) +) + +(assert_return (invoke "point_four" (f64.const 4.0) (f64.const 10.0)) (i32.const 0)) + +;; Test an approximation function for tau; it should produces the correctly +;; rounded result after (and only after) the expected number of iterations. + +(module + (func (export "tau") (param i32) (result f64) + (local f64 f64 f64 f64) + f64.const 0x0p+0 + local.set 1 + block + local.get 0 + i32.const 1 + i32.lt_s + br_if 0 + f64.const 0x1p+0 + local.set 2 + f64.const 0x0p+0 + local.set 3 + loop + local.get 1 + local.get 2 + f64.const 0x1p+3 + local.get 3 + f64.const 0x1p+3 + f64.mul + local.tee 4 + f64.const 0x1p+0 + f64.add + f64.div + f64.const 0x1p+2 + local.get 4 + f64.const 0x1p+2 + f64.add + f64.div + f64.sub + f64.const 0x1p+1 + local.get 4 + f64.const 0x1.4p+2 + f64.add + f64.div + f64.sub + f64.const 0x1p+1 + local.get 4 + f64.const 0x1.8p+2 + f64.add + f64.div + f64.sub + f64.mul + f64.add + local.set 1 + local.get 3 + f64.const 0x1p+0 + f64.add + local.set 3 + local.get 2 + f64.const 0x1p-4 + f64.mul + local.set 2 + local.get 0 + i32.const -1 + i32.add + local.tee 0 + br_if 0 + end + end + local.get 1 + ) +) + +(assert_return (invoke "tau" (i32.const 10)) (f64.const 0x1.921fb54442d14p+2)) +(assert_return (invoke "tau" (i32.const 11)) (f64.const 0x1.921fb54442d18p+2)) + +;; Test that y < 0 ? x : (x + 1) is not folded to x + (y < 0). + +(module + (func (export "f32.no_fold_conditional_inc") (param $x f32) (param $y f32) (result f32) + (select (local.get $x) + (f32.add (local.get $x) (f32.const 1.0)) + (f32.lt (local.get $y) (f32.const 0.0)))) + (func (export "f64.no_fold_conditional_inc") (param $x f64) (param $y f64) (result f64) + (select (local.get $x) + (f64.add (local.get $x) (f64.const 1.0)) + (f64.lt (local.get $y) (f64.const 0.0)))) +) + +(assert_return (invoke "f32.no_fold_conditional_inc" (f32.const -0.0) (f32.const -1.0)) (f32.const -0.0)) +(assert_return (invoke "f64.no_fold_conditional_inc" (f64.const -0.0) (f64.const -1.0)) (f64.const -0.0)) diff --git a/runtime/near-vm/tests/wast/spec/float_literals.wast b/runtime/near-vm/tests/wast/spec/float_literals.wast new file mode 100644 index 00000000000..fefb91fbb76 --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/float_literals.wast @@ -0,0 +1,507 @@ +;; Test floating-point literal parsing. + +(module + ;; f32 special values + (func (export "f32.nan") (result i32) (i32.reinterpret_f32 (f32.const nan))) + (func (export "f32.positive_nan") (result i32) (i32.reinterpret_f32 (f32.const +nan))) + (func (export "f32.negative_nan") (result i32) (i32.reinterpret_f32 (f32.const -nan))) + (func (export "f32.plain_nan") (result i32) (i32.reinterpret_f32 (f32.const nan:0x400000))) + (func (export "f32.informally_known_as_plain_snan") (result i32) (i32.reinterpret_f32 (f32.const nan:0x200000))) + (func (export "f32.all_ones_nan") (result i32) (i32.reinterpret_f32 (f32.const -nan:0x7fffff))) + (func (export "f32.misc_nan") (result i32) (i32.reinterpret_f32 (f32.const nan:0x012345))) + (func (export "f32.misc_positive_nan") (result i32) (i32.reinterpret_f32 (f32.const +nan:0x304050))) + (func (export "f32.misc_negative_nan") (result i32) (i32.reinterpret_f32 (f32.const -nan:0x2abcde))) + (func (export "f32.infinity") (result i32) (i32.reinterpret_f32 (f32.const inf))) + (func (export "f32.positive_infinity") (result i32) (i32.reinterpret_f32 (f32.const +inf))) + (func (export "f32.negative_infinity") (result i32) (i32.reinterpret_f32 (f32.const -inf))) + + ;; f32 numbers + (func (export "f32.zero") (result i32) (i32.reinterpret_f32 (f32.const 0x0.0p0))) + (func (export "f32.positive_zero") (result i32) (i32.reinterpret_f32 (f32.const +0x0.0p0))) + (func (export "f32.negative_zero") (result i32) (i32.reinterpret_f32 (f32.const -0x0.0p0))) + (func (export "f32.misc") (result i32) (i32.reinterpret_f32 (f32.const 0x1.921fb6p+2))) + (func (export "f32.min_positive") (result i32) (i32.reinterpret_f32 (f32.const 0x1p-149))) + (func (export "f32.min_normal") (result i32) (i32.reinterpret_f32 (f32.const 0x1p-126))) + (func (export "f32.max_finite") (result i32) (i32.reinterpret_f32 (f32.const 0x1.fffffep+127))) + (func (export "f32.max_subnormal") (result i32) (i32.reinterpret_f32 (f32.const 0x1.fffffcp-127))) + (func (export "f32.trailing_dot") (result i32) (i32.reinterpret_f32 (f32.const 0x1.p10))) + + ;; f32 in decimal format + (func (export "f32_dec.zero") (result i32) (i32.reinterpret_f32 (f32.const 0.0e0))) + (func (export "f32_dec.positive_zero") (result i32) (i32.reinterpret_f32 (f32.const +0.0e0))) + (func (export "f32_dec.negative_zero") (result i32) (i32.reinterpret_f32 (f32.const -0.0e0))) + (func (export "f32_dec.misc") (result i32) (i32.reinterpret_f32 (f32.const 6.28318548202514648))) + (func (export "f32_dec.min_positive") (result i32) (i32.reinterpret_f32 (f32.const 1.4013e-45))) + (func (export "f32_dec.min_normal") (result i32) (i32.reinterpret_f32 (f32.const 1.1754944e-38))) + (func (export "f32_dec.max_subnormal") (result i32) (i32.reinterpret_f32 (f32.const 1.1754942e-38))) + (func (export "f32_dec.max_finite") (result i32) (i32.reinterpret_f32 (f32.const 3.4028234e+38))) + (func (export "f32_dec.trailing_dot") (result i32) (i32.reinterpret_f32 (f32.const 1.e10))) + + ;; https://twitter.com/Archivd/status/994637336506912768 + (func (export "f32_dec.root_beer_float") (result i32) (i32.reinterpret_f32 (f32.const 1.000000119))) + + ;; f64 special values + (func (export "f64.nan") (result i64) (i64.reinterpret_f64 (f64.const nan))) + (func (export "f64.positive_nan") (result i64) (i64.reinterpret_f64 (f64.const +nan))) + (func (export "f64.negative_nan") (result i64) (i64.reinterpret_f64 (f64.const -nan))) + (func (export "f64.plain_nan") (result i64) (i64.reinterpret_f64 (f64.const nan:0x8000000000000))) + (func (export "f64.informally_known_as_plain_snan") (result i64) (i64.reinterpret_f64 (f64.const nan:0x4000000000000))) + (func (export "f64.all_ones_nan") (result i64) (i64.reinterpret_f64 (f64.const -nan:0xfffffffffffff))) + (func (export "f64.misc_nan") (result i64) (i64.reinterpret_f64 (f64.const nan:0x0123456789abc))) + (func (export "f64.misc_positive_nan") (result i64) (i64.reinterpret_f64 (f64.const +nan:0x3040506070809))) + (func (export "f64.misc_negative_nan") (result i64) (i64.reinterpret_f64 (f64.const -nan:0x2abcdef012345))) + (func (export "f64.infinity") (result i64) (i64.reinterpret_f64 (f64.const inf))) + (func (export "f64.positive_infinity") (result i64) (i64.reinterpret_f64 (f64.const +inf))) + (func (export "f64.negative_infinity") (result i64) (i64.reinterpret_f64 (f64.const -inf))) + + ;; f64 numbers + (func (export "f64.zero") (result i64) (i64.reinterpret_f64 (f64.const 0x0.0p0))) + (func (export "f64.positive_zero") (result i64) (i64.reinterpret_f64 (f64.const +0x0.0p0))) + (func (export "f64.negative_zero") (result i64) (i64.reinterpret_f64 (f64.const -0x0.0p0))) + (func (export "f64.misc") (result i64) (i64.reinterpret_f64 (f64.const 0x1.921fb54442d18p+2))) + (func (export "f64.min_positive") (result i64) (i64.reinterpret_f64 (f64.const 0x0.0000000000001p-1022))) + (func (export "f64.min_normal") (result i64) (i64.reinterpret_f64 (f64.const 0x1p-1022))) + (func (export "f64.max_subnormal") (result i64) (i64.reinterpret_f64 (f64.const 0x0.fffffffffffffp-1022))) + (func (export "f64.max_finite") (result i64) (i64.reinterpret_f64 (f64.const 0x1.fffffffffffffp+1023))) + (func (export "f64.trailing_dot") (result i64) (i64.reinterpret_f64 (f64.const 0x1.p100))) + + ;; f64 numbers in decimal format + (func (export "f64_dec.zero") (result i64) (i64.reinterpret_f64 (f64.const 0.0e0))) + (func (export "f64_dec.positive_zero") (result i64) (i64.reinterpret_f64 (f64.const +0.0e0))) + (func (export "f64_dec.negative_zero") (result i64) (i64.reinterpret_f64 (f64.const -0.0e0))) + (func (export "f64_dec.misc") (result i64) (i64.reinterpret_f64 (f64.const 6.28318530717958623))) + (func (export "f64_dec.min_positive") (result i64) (i64.reinterpret_f64 (f64.const 4.94066e-324))) + (func (export "f64_dec.min_normal") (result i64) (i64.reinterpret_f64 (f64.const 2.2250738585072012e-308))) + (func (export "f64_dec.max_subnormal") (result i64) (i64.reinterpret_f64 (f64.const 2.2250738585072011e-308))) + (func (export "f64_dec.max_finite") (result i64) (i64.reinterpret_f64 (f64.const 1.7976931348623157e+308))) + (func (export "f64_dec.trailing_dot") (result i64) (i64.reinterpret_f64 (f64.const 1.e100))) + + ;; https://twitter.com/Archivd/status/994637336506912768 + (func (export "f64_dec.root_beer_float") (result i64) (i64.reinterpret_f64 (f64.const 1.000000119))) + + (func (export "f32-dec-sep1") (result f32) (f32.const 1_000_000)) + (func (export "f32-dec-sep2") (result f32) (f32.const 1_0_0_0)) + (func (export "f32-dec-sep3") (result f32) (f32.const 100_3.141_592)) + (func (export "f32-dec-sep4") (result f32) (f32.const 99e+1_3)) + (func (export "f32-dec-sep5") (result f32) (f32.const 122_000.11_3_54E0_2_3)) + (func (export "f32-hex-sep1") (result f32) (f32.const 0xa_0f_00_99)) + (func (export "f32-hex-sep2") (result f32) (f32.const 0x1_a_A_0_f)) + (func (export "f32-hex-sep3") (result f32) (f32.const 0xa0_ff.f141_a59a)) + (func (export "f32-hex-sep4") (result f32) (f32.const 0xf0P+1_3)) + (func (export "f32-hex-sep5") (result f32) (f32.const 0x2a_f00a.1f_3_eep2_3)) + + (func (export "f64-dec-sep1") (result f64) (f64.const 1_000_000)) + (func (export "f64-dec-sep2") (result f64) (f64.const 1_0_0_0)) + (func (export "f64-dec-sep3") (result f64) (f64.const 100_3.141_592)) + (func (export "f64-dec-sep4") (result f64) (f64.const 99e-1_23)) + (func (export "f64-dec-sep5") (result f64) (f64.const 122_000.11_3_54e0_2_3)) + (func (export "f64-hex-sep1") (result f64) (f64.const 0xa_f00f_0000_9999)) + (func (export "f64-hex-sep2") (result f64) (f64.const 0x1_a_A_0_f)) + (func (export "f64-hex-sep3") (result f64) (f64.const 0xa0_ff.f141_a59a)) + (func (export "f64-hex-sep4") (result f64) (f64.const 0xf0P+1_3)) + (func (export "f64-hex-sep5") (result f64) (f64.const 0x2a_f00a.1f_3_eep2_3)) +) + +(assert_return (invoke "f32.nan") (i32.const 0x7fc00000)) +(assert_return (invoke "f32.positive_nan") (i32.const 0x7fc00000)) +(assert_return (invoke "f32.negative_nan") (i32.const 0xffc00000)) +(assert_return (invoke "f32.plain_nan") (i32.const 0x7fc00000)) +(assert_return (invoke "f32.informally_known_as_plain_snan") (i32.const 0x7fa00000)) +(assert_return (invoke "f32.all_ones_nan") (i32.const 0xffffffff)) +(assert_return (invoke "f32.misc_nan") (i32.const 0x7f812345)) +(assert_return (invoke "f32.misc_positive_nan") (i32.const 0x7fb04050)) +(assert_return (invoke "f32.misc_negative_nan") (i32.const 0xffaabcde)) +(assert_return (invoke "f32.infinity") (i32.const 0x7f800000)) +(assert_return (invoke "f32.positive_infinity") (i32.const 0x7f800000)) +(assert_return (invoke "f32.negative_infinity") (i32.const 0xff800000)) +(assert_return (invoke "f32.zero") (i32.const 0)) +(assert_return (invoke "f32.positive_zero") (i32.const 0)) +(assert_return (invoke "f32.negative_zero") (i32.const 0x80000000)) +(assert_return (invoke "f32.misc") (i32.const 0x40c90fdb)) +(assert_return (invoke "f32.min_positive") (i32.const 1)) +(assert_return (invoke "f32.min_normal") (i32.const 0x800000)) +(assert_return (invoke "f32.max_subnormal") (i32.const 0x7fffff)) +(assert_return (invoke "f32.max_finite") (i32.const 0x7f7fffff)) +(assert_return (invoke "f32.trailing_dot") (i32.const 0x44800000)) +(assert_return (invoke "f32_dec.zero") (i32.const 0)) +(assert_return (invoke "f32_dec.positive_zero") (i32.const 0)) +(assert_return (invoke "f32_dec.negative_zero") (i32.const 0x80000000)) +(assert_return (invoke "f32_dec.misc") (i32.const 0x40c90fdb)) +(assert_return (invoke "f32_dec.min_positive") (i32.const 1)) +(assert_return (invoke "f32_dec.min_normal") (i32.const 0x800000)) +(assert_return (invoke "f32_dec.max_subnormal") (i32.const 0x7fffff)) +(assert_return (invoke "f32_dec.max_finite") (i32.const 0x7f7fffff)) +(assert_return (invoke "f32_dec.trailing_dot") (i32.const 0x501502f9)) +(assert_return (invoke "f32_dec.root_beer_float") (i32.const 0x3f800001)) + +(assert_return (invoke "f64.nan") (i64.const 0x7ff8000000000000)) +(assert_return (invoke "f64.positive_nan") (i64.const 0x7ff8000000000000)) +(assert_return (invoke "f64.negative_nan") (i64.const 0xfff8000000000000)) +(assert_return (invoke "f64.plain_nan") (i64.const 0x7ff8000000000000)) +(assert_return (invoke "f64.informally_known_as_plain_snan") (i64.const 0x7ff4000000000000)) +(assert_return (invoke "f64.all_ones_nan") (i64.const 0xffffffffffffffff)) +(assert_return (invoke "f64.misc_nan") (i64.const 0x7ff0123456789abc)) +(assert_return (invoke "f64.misc_positive_nan") (i64.const 0x7ff3040506070809)) +(assert_return (invoke "f64.misc_negative_nan") (i64.const 0xfff2abcdef012345)) +(assert_return (invoke "f64.infinity") (i64.const 0x7ff0000000000000)) +(assert_return (invoke "f64.positive_infinity") (i64.const 0x7ff0000000000000)) +(assert_return (invoke "f64.negative_infinity") (i64.const 0xfff0000000000000)) +(assert_return (invoke "f64.zero") (i64.const 0)) +(assert_return (invoke "f64.positive_zero") (i64.const 0)) +(assert_return (invoke "f64.negative_zero") (i64.const 0x8000000000000000)) +(assert_return (invoke "f64.misc") (i64.const 0x401921fb54442d18)) +(assert_return (invoke "f64.min_positive") (i64.const 1)) +(assert_return (invoke "f64.min_normal") (i64.const 0x10000000000000)) +(assert_return (invoke "f64.max_subnormal") (i64.const 0xfffffffffffff)) +(assert_return (invoke "f64.max_finite") (i64.const 0x7fefffffffffffff)) +(assert_return (invoke "f64.trailing_dot") (i64.const 0x4630000000000000)) +(assert_return (invoke "f64_dec.zero") (i64.const 0)) +(assert_return (invoke "f64_dec.positive_zero") (i64.const 0)) +(assert_return (invoke "f64_dec.negative_zero") (i64.const 0x8000000000000000)) +(assert_return (invoke "f64_dec.misc") (i64.const 0x401921fb54442d18)) +(assert_return (invoke "f64_dec.min_positive") (i64.const 1)) +(assert_return (invoke "f64_dec.min_normal") (i64.const 0x10000000000000)) +(assert_return (invoke "f64_dec.max_subnormal") (i64.const 0xfffffffffffff)) +(assert_return (invoke "f64_dec.max_finite") (i64.const 0x7fefffffffffffff)) +(assert_return (invoke "f64_dec.trailing_dot") (i64.const 0x54b249ad2594c37d)) +(assert_return (invoke "f64_dec.root_beer_float") (i64.const 0x3ff000001ff19e24)) + +(assert_return (invoke "f32-dec-sep1") (f32.const 1000000)) +(assert_return (invoke "f32-dec-sep2") (f32.const 1000)) +(assert_return (invoke "f32-dec-sep3") (f32.const 1003.141592)) +(assert_return (invoke "f32-dec-sep4") (f32.const 99e+13)) +(assert_return (invoke "f32-dec-sep5") (f32.const 122000.11354e23)) +(assert_return (invoke "f32-hex-sep1") (f32.const 0xa0f0099)) +(assert_return (invoke "f32-hex-sep2") (f32.const 0x1aa0f)) +(assert_return (invoke "f32-hex-sep3") (f32.const 0xa0ff.f141a59a)) +(assert_return (invoke "f32-hex-sep4") (f32.const 0xf0P+13)) +(assert_return (invoke "f32-hex-sep5") (f32.const 0x2af00a.1f3eep23)) + +(assert_return (invoke "f64-dec-sep1") (f64.const 1000000)) +(assert_return (invoke "f64-dec-sep2") (f64.const 1000)) +(assert_return (invoke "f64-dec-sep3") (f64.const 1003.141592)) +(assert_return (invoke "f64-dec-sep4") (f64.const 99e-123)) +(assert_return (invoke "f64-dec-sep5") (f64.const 122000.11354e23)) +(assert_return (invoke "f64-hex-sep1") (f64.const 0xaf00f00009999)) +(assert_return (invoke "f64-hex-sep2") (f64.const 0x1aa0f)) +(assert_return (invoke "f64-hex-sep3") (f64.const 0xa0ff.f141a59a)) +(assert_return (invoke "f64-hex-sep4") (f64.const 0xf0P+13)) +(assert_return (invoke "f64-hex-sep5") (f64.const 0x2af00a.1f3eep23)) + +;; Test parsing a float from binary +(module binary + ;; (func (export "4294967249") (result f64) (f64.const 4294967249)) + "\00\61\73\6d\01\00\00\00\01\85\80\80\80\00\01\60" + "\00\01\7c\03\82\80\80\80\00\01\00\07\8e\80\80\80" + "\00\01\0a\34\32\39\34\39\36\37\32\34\39\00\00\0a" + "\91\80\80\80\00\01\8b\80\80\80\00\00\44\00\00\20" + "\fa\ff\ff\ef\41\0b" +) + +(assert_return (invoke "4294967249") (f64.const 4294967249)) + +(assert_malformed + (module quote "(global f32 (f32.const _100))") + "unknown operator" +) +(assert_malformed + (module quote "(global f32 (f32.const +_100))") + "unknown operator" +) +(assert_malformed + (module quote "(global f32 (f32.const -_100))") + "unknown operator" +) +(assert_malformed + (module quote "(global f32 (f32.const 99_))") + "unknown operator" +) +(assert_malformed + (module quote "(global f32 (f32.const 1__000))") + "unknown operator" +) +(assert_malformed + (module quote "(global f32 (f32.const _1.0))") + "unknown operator" +) +(assert_malformed + (module quote "(global f32 (f32.const 1.0_))") + "unknown operator" +) +(assert_malformed + (module quote "(global f32 (f32.const 1_.0))") + "unknown operator" +) +(assert_malformed + (module quote "(global f32 (f32.const 1._0))") + "unknown operator" +) +(assert_malformed + (module quote "(global f32 (f32.const _1e1))") + "unknown operator" +) +(assert_malformed + (module quote "(global f32 (f32.const 1e1_))") + "unknown operator" +) +(assert_malformed + (module quote "(global f32 (f32.const 1_e1))") + "unknown operator" +) +(assert_malformed + (module quote "(global f32 (f32.const 1e_1))") + "unknown operator" +) +(assert_malformed + (module quote "(global f32 (f32.const _1.0e1))") + "unknown operator" +) +(assert_malformed + (module quote "(global f32 (f32.const 1.0e1_))") + "unknown operator" +) +(assert_malformed + (module quote "(global f32 (f32.const 1.0_e1))") + "unknown operator" +) +(assert_malformed + (module quote "(global f32 (f32.const 1.0e_1))") + "unknown operator" +) +(assert_malformed + (module quote "(global f32 (f32.const 1.0e+_1))") + "unknown operator" +) +(assert_malformed + (module quote "(global f32 (f32.const 1.0e_+1))") + "unknown operator" +) +(assert_malformed + (module quote "(global f32 (f32.const _0x100))") + "unknown operator" +) +(assert_malformed + (module quote "(global f32 (f32.const 0_x100))") + "unknown operator" +) +(assert_malformed + (module quote "(global f32 (f32.const 0x_100))") + "unknown operator" +) +(assert_malformed + (module quote "(global f32 (f32.const 0x00_))") + "unknown operator" +) +(assert_malformed + (module quote "(global f32 (f32.const 0xff__ffff))") + "unknown operator" +) +(assert_malformed + (module quote "(global f32 (f32.const 0x_1.0))") + "unknown operator" +) +(assert_malformed + (module quote "(global f32 (f32.const 0x1.0_))") + "unknown operator" +) +(assert_malformed + (module quote "(global f32 (f32.const 0x1_.0))") + "unknown operator" +) +(assert_malformed + (module quote "(global f32 (f32.const 0x1._0))") + "unknown operator" +) +(assert_malformed + (module quote "(global f32 (f32.const 0x_1p1))") + "unknown operator" +) +(assert_malformed + (module quote "(global f32 (f32.const 0x1p1_))") + "unknown operator" +) +(assert_malformed + (module quote "(global f32 (f32.const 0x1_p1))") + "unknown operator" +) +(assert_malformed + (module quote "(global f32 (f32.const 0x1p_1))") + "unknown operator" +) +(assert_malformed + (module quote "(global f32 (f32.const 0x_1.0p1))") + "unknown operator" +) +(assert_malformed + (module quote "(global f32 (f32.const 0x1.0p1_))") + "unknown operator" +) +(assert_malformed + (module quote "(global f32 (f32.const 0x1.0_p1))") + "unknown operator" +) +(assert_malformed + (module quote "(global f32 (f32.const 0x1.0p_1))") + "unknown operator" +) +(assert_malformed + (module quote "(global f32 (f32.const 0x1.0p+_1))") + "unknown operator" +) +(assert_malformed + (module quote "(global f32 (f32.const 0x1.0p_+1))") + "unknown operator" +) + +(assert_malformed + (module quote "(global f64 (f64.const _100))") + "unknown operator" +) +(assert_malformed + (module quote "(global f64 (f64.const +_100))") + "unknown operator" +) +(assert_malformed + (module quote "(global f64 (f64.const -_100))") + "unknown operator" +) +(assert_malformed + (module quote "(global f64 (f64.const 99_))") + "unknown operator" +) +(assert_malformed + (module quote "(global f64 (f64.const 1__000))") + "unknown operator" +) +(assert_malformed + (module quote "(global f64 (f64.const _1.0))") + "unknown operator" +) +(assert_malformed + (module quote "(global f64 (f64.const 1.0_))") + "unknown operator" +) +(assert_malformed + (module quote "(global f64 (f64.const 1_.0))") + "unknown operator" +) +(assert_malformed + (module quote "(global f64 (f64.const 1._0))") + "unknown operator" +) +(assert_malformed + (module quote "(global f64 (f64.const _1e1))") + "unknown operator" +) +(assert_malformed + (module quote "(global f64 (f64.const 1e1_))") + "unknown operator" +) +(assert_malformed + (module quote "(global f64 (f64.const 1_e1))") + "unknown operator" +) +(assert_malformed + (module quote "(global f64 (f64.const 1e_1))") + "unknown operator" +) +(assert_malformed + (module quote "(global f64 (f64.const _1.0e1))") + "unknown operator" +) +(assert_malformed + (module quote "(global f64 (f64.const 1.0e1_))") + "unknown operator" +) +(assert_malformed + (module quote "(global f64 (f64.const 1.0_e1))") + "unknown operator" +) +(assert_malformed + (module quote "(global f64 (f64.const 1.0e_1))") + "unknown operator" +) +(assert_malformed + (module quote "(global f64 (f64.const 1.0e+_1))") + "unknown operator" +) +(assert_malformed + (module quote "(global f64 (f64.const 1.0e_+1))") + "unknown operator" +) +(assert_malformed + (module quote "(global f64 (f64.const _0x100))") + "unknown operator" +) +(assert_malformed + (module quote "(global f64 (f64.const 0_x100))") + "unknown operator" +) +(assert_malformed + (module quote "(global f64 (f64.const 0x_100))") + "unknown operator" +) +(assert_malformed + (module quote "(global f64 (f64.const 0x00_))") + "unknown operator" +) +(assert_malformed + (module quote "(global f64 (f64.const 0xff__ffff))") + "unknown operator" +) +(assert_malformed + (module quote "(global f64 (f64.const 0x_1.0))") + "unknown operator" +) +(assert_malformed + (module quote "(global f64 (f64.const 0x1.0_))") + "unknown operator" +) +(assert_malformed + (module quote "(global f64 (f64.const 0x1_.0))") + "unknown operator" +) +(assert_malformed + (module quote "(global f64 (f64.const 0x1._0))") + "unknown operator" +) +(assert_malformed + (module quote "(global f64 (f64.const 0x_1p1))") + "unknown operator" +) +(assert_malformed + (module quote "(global f64 (f64.const 0x1p1_))") + "unknown operator" +) +(assert_malformed + (module quote "(global f64 (f64.const 0x1_p1))") + "unknown operator" +) +(assert_malformed + (module quote "(global f64 (f64.const 0x1p_1))") + "unknown operator" +) +(assert_malformed + (module quote "(global f64 (f64.const 0x_1.0p1))") + "unknown operator" +) +(assert_malformed + (module quote "(global f64 (f64.const 0x1.0p1_))") + "unknown operator" +) +(assert_malformed + (module quote "(global f64 (f64.const 0x1.0_p1))") + "unknown operator" +) +(assert_malformed + (module quote "(global f64 (f64.const 0x1.0p_1))") + "unknown operator" +) +(assert_malformed + (module quote "(global f64 (f64.const 0x1.0p+_1))") + "unknown operator" +) +(assert_malformed + (module quote "(global f64 (f64.const 0x1.0p_+1))") + "unknown operator" +) diff --git a/runtime/near-vm/tests/wast/spec/float_memory.wast b/runtime/near-vm/tests/wast/spec/float_memory.wast new file mode 100644 index 00000000000..3801158f92b --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/float_memory.wast @@ -0,0 +1,157 @@ +;; Test that floating-point load and store are bit-preserving. + +;; Test that load and store do not canonicalize NaNs as x87 does. + +(module + (memory (data "\00\00\a0\7f")) + + (func (export "f32.load") (result f32) (f32.load (i32.const 0))) + (func (export "i32.load") (result i32) (i32.load (i32.const 0))) + (func (export "f32.store") (f32.store (i32.const 0) (f32.const nan:0x200000))) + (func (export "i32.store") (i32.store (i32.const 0) (i32.const 0x7fa00000))) + (func (export "reset") (i32.store (i32.const 0) (i32.const 0))) +) + +(assert_return (invoke "i32.load") (i32.const 0x7fa00000)) +(assert_return (invoke "f32.load") (f32.const nan:0x200000)) +(invoke "reset") +(assert_return (invoke "i32.load") (i32.const 0x0)) +(assert_return (invoke "f32.load") (f32.const 0.0)) +(invoke "f32.store") +(assert_return (invoke "i32.load") (i32.const 0x7fa00000)) +(assert_return (invoke "f32.load") (f32.const nan:0x200000)) +(invoke "reset") +(assert_return (invoke "i32.load") (i32.const 0x0)) +(assert_return (invoke "f32.load") (f32.const 0.0)) +(invoke "i32.store") +(assert_return (invoke "i32.load") (i32.const 0x7fa00000)) +(assert_return (invoke "f32.load") (f32.const nan:0x200000)) + +(module + (memory (data "\00\00\00\00\00\00\f4\7f")) + + (func (export "f64.load") (result f64) (f64.load (i32.const 0))) + (func (export "i64.load") (result i64) (i64.load (i32.const 0))) + (func (export "f64.store") (f64.store (i32.const 0) (f64.const nan:0x4000000000000))) + (func (export "i64.store") (i64.store (i32.const 0) (i64.const 0x7ff4000000000000))) + (func (export "reset") (i64.store (i32.const 0) (i64.const 0))) +) + +(assert_return (invoke "i64.load") (i64.const 0x7ff4000000000000)) +(assert_return (invoke "f64.load") (f64.const nan:0x4000000000000)) +(invoke "reset") +(assert_return (invoke "i64.load") (i64.const 0x0)) +(assert_return (invoke "f64.load") (f64.const 0.0)) +(invoke "f64.store") +(assert_return (invoke "i64.load") (i64.const 0x7ff4000000000000)) +(assert_return (invoke "f64.load") (f64.const nan:0x4000000000000)) +(invoke "reset") +(assert_return (invoke "i64.load") (i64.const 0x0)) +(assert_return (invoke "f64.load") (f64.const 0.0)) +(invoke "i64.store") +(assert_return (invoke "i64.load") (i64.const 0x7ff4000000000000)) +(assert_return (invoke "f64.load") (f64.const nan:0x4000000000000)) + +;; Test that unaligned load and store do not canonicalize NaNs. + +(module + (memory (data "\00\00\00\a0\7f")) + + (func (export "f32.load") (result f32) (f32.load (i32.const 1))) + (func (export "i32.load") (result i32) (i32.load (i32.const 1))) + (func (export "f32.store") (f32.store (i32.const 1) (f32.const nan:0x200000))) + (func (export "i32.store") (i32.store (i32.const 1) (i32.const 0x7fa00000))) + (func (export "reset") (i32.store (i32.const 1) (i32.const 0))) +) + +(assert_return (invoke "i32.load") (i32.const 0x7fa00000)) +(assert_return (invoke "f32.load") (f32.const nan:0x200000)) +(invoke "reset") +(assert_return (invoke "i32.load") (i32.const 0x0)) +(assert_return (invoke "f32.load") (f32.const 0.0)) +(invoke "f32.store") +(assert_return (invoke "i32.load") (i32.const 0x7fa00000)) +(assert_return (invoke "f32.load") (f32.const nan:0x200000)) +(invoke "reset") +(assert_return (invoke "i32.load") (i32.const 0x0)) +(assert_return (invoke "f32.load") (f32.const 0.0)) +(invoke "i32.store") +(assert_return (invoke "i32.load") (i32.const 0x7fa00000)) +(assert_return (invoke "f32.load") (f32.const nan:0x200000)) + +(module + (memory (data "\00\00\00\00\00\00\00\f4\7f")) + + (func (export "f64.load") (result f64) (f64.load (i32.const 1))) + (func (export "i64.load") (result i64) (i64.load (i32.const 1))) + (func (export "f64.store") (f64.store (i32.const 1) (f64.const nan:0x4000000000000))) + (func (export "i64.store") (i64.store (i32.const 1) (i64.const 0x7ff4000000000000))) + (func (export "reset") (i64.store (i32.const 1) (i64.const 0))) +) + +(assert_return (invoke "i64.load") (i64.const 0x7ff4000000000000)) +(assert_return (invoke "f64.load") (f64.const nan:0x4000000000000)) +(invoke "reset") +(assert_return (invoke "i64.load") (i64.const 0x0)) +(assert_return (invoke "f64.load") (f64.const 0.0)) +(invoke "f64.store") +(assert_return (invoke "i64.load") (i64.const 0x7ff4000000000000)) +(assert_return (invoke "f64.load") (f64.const nan:0x4000000000000)) +(invoke "reset") +(assert_return (invoke "i64.load") (i64.const 0x0)) +(assert_return (invoke "f64.load") (f64.const 0.0)) +(invoke "i64.store") +(assert_return (invoke "i64.load") (i64.const 0x7ff4000000000000)) +(assert_return (invoke "f64.load") (f64.const nan:0x4000000000000)) + +;; Test that load and store do not canonicalize NaNs as some JS engines do. + +(module + (memory (data "\01\00\d0\7f")) + + (func (export "f32.load") (result f32) (f32.load (i32.const 0))) + (func (export "i32.load") (result i32) (i32.load (i32.const 0))) + (func (export "f32.store") (f32.store (i32.const 0) (f32.const nan:0x500001))) + (func (export "i32.store") (i32.store (i32.const 0) (i32.const 0x7fd00001))) + (func (export "reset") (i32.store (i32.const 0) (i32.const 0))) +) + +(assert_return (invoke "i32.load") (i32.const 0x7fd00001)) +(assert_return (invoke "f32.load") (f32.const nan:0x500001)) +(invoke "reset") +(assert_return (invoke "i32.load") (i32.const 0x0)) +(assert_return (invoke "f32.load") (f32.const 0.0)) +(invoke "f32.store") +(assert_return (invoke "i32.load") (i32.const 0x7fd00001)) +(assert_return (invoke "f32.load") (f32.const nan:0x500001)) +(invoke "reset") +(assert_return (invoke "i32.load") (i32.const 0x0)) +(assert_return (invoke "f32.load") (f32.const 0.0)) +(invoke "i32.store") +(assert_return (invoke "i32.load") (i32.const 0x7fd00001)) +(assert_return (invoke "f32.load") (f32.const nan:0x500001)) + +(module + (memory (data "\01\00\00\00\00\00\fc\7f")) + + (func (export "f64.load") (result f64) (f64.load (i32.const 0))) + (func (export "i64.load") (result i64) (i64.load (i32.const 0))) + (func (export "f64.store") (f64.store (i32.const 0) (f64.const nan:0xc000000000001))) + (func (export "i64.store") (i64.store (i32.const 0) (i64.const 0x7ffc000000000001))) + (func (export "reset") (i64.store (i32.const 0) (i64.const 0))) +) + +(assert_return (invoke "i64.load") (i64.const 0x7ffc000000000001)) +(assert_return (invoke "f64.load") (f64.const nan:0xc000000000001)) +(invoke "reset") +(assert_return (invoke "i64.load") (i64.const 0x0)) +(assert_return (invoke "f64.load") (f64.const 0.0)) +(invoke "f64.store") +(assert_return (invoke "i64.load") (i64.const 0x7ffc000000000001)) +(assert_return (invoke "f64.load") (f64.const nan:0xc000000000001)) +(invoke "reset") +(assert_return (invoke "i64.load") (i64.const 0x0)) +(assert_return (invoke "f64.load") (f64.const 0.0)) +(invoke "i64.store") +(assert_return (invoke "i64.load") (i64.const 0x7ffc000000000001)) +(assert_return (invoke "f64.load") (f64.const nan:0xc000000000001)) diff --git a/runtime/near-vm/tests/wast/spec/float_misc.wast b/runtime/near-vm/tests/wast/spec/float_misc.wast new file mode 100644 index 00000000000..3d83281d77a --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/float_misc.wast @@ -0,0 +1,678 @@ +;; Platforms intended to run WebAssembly must support IEEE 754 arithmetic. +;; This testsuite is not currently sufficient for full IEEE 754 conformance +;; testing; platforms are currently expected to meet these requirements in +;; their own way (widely-used hardware platforms already do this). +;; +;; What this testsuite does test is that (a) the platform is basically IEEE 754 +;; rather than something else entirely, (b) it's configured correctly for +;; WebAssembly (rounding direction, exception masks, precision level, subnormal +;; mode, etc.), (c) the WebAssembly implementation doesn't perform any common +;; value-changing optimizations, and (d) that the WebAssembly implementation +;; doesn't exhibit any known implementation bugs. +;; +;; This file supplements f32.wast, f64.wast, f32_bitwise.wast, f64_bitwise.wast, +;; f32_cmp.wast, and f64_cmp.wast with additional single-instruction tests +;; covering additional miscellaneous interesting cases. + +(module + (func (export "f32.add") (param $x f32) (param $y f32) (result f32) (f32.add (local.get $x) (local.get $y))) + (func (export "f32.sub") (param $x f32) (param $y f32) (result f32) (f32.sub (local.get $x) (local.get $y))) + (func (export "f32.mul") (param $x f32) (param $y f32) (result f32) (f32.mul (local.get $x) (local.get $y))) + (func (export "f32.div") (param $x f32) (param $y f32) (result f32) (f32.div (local.get $x) (local.get $y))) + (func (export "f32.sqrt") (param $x f32) (result f32) (f32.sqrt (local.get $x))) + (func (export "f32.abs") (param $x f32) (result f32) (f32.abs (local.get $x))) + (func (export "f32.neg") (param $x f32) (result f32) (f32.neg (local.get $x))) + (func (export "f32.copysign") (param $x f32) (param $y f32) (result f32) (f32.copysign (local.get $x) (local.get $y))) + (func (export "f32.ceil") (param $x f32) (result f32) (f32.ceil (local.get $x))) + (func (export "f32.floor") (param $x f32) (result f32) (f32.floor (local.get $x))) + (func (export "f32.trunc") (param $x f32) (result f32) (f32.trunc (local.get $x))) + (func (export "f32.nearest") (param $x f32) (result f32) (f32.nearest (local.get $x))) + (func (export "f32.min") (param $x f32) (param $y f32) (result f32) (f32.min (local.get $x) (local.get $y))) + (func (export "f32.max") (param $x f32) (param $y f32) (result f32) (f32.max (local.get $x) (local.get $y))) + + (func (export "f64.add") (param $x f64) (param $y f64) (result f64) (f64.add (local.get $x) (local.get $y))) + (func (export "f64.sub") (param $x f64) (param $y f64) (result f64) (f64.sub (local.get $x) (local.get $y))) + (func (export "f64.mul") (param $x f64) (param $y f64) (result f64) (f64.mul (local.get $x) (local.get $y))) + (func (export "f64.div") (param $x f64) (param $y f64) (result f64) (f64.div (local.get $x) (local.get $y))) + (func (export "f64.sqrt") (param $x f64) (result f64) (f64.sqrt (local.get $x))) + (func (export "f64.abs") (param $x f64) (result f64) (f64.abs (local.get $x))) + (func (export "f64.neg") (param $x f64) (result f64) (f64.neg (local.get $x))) + (func (export "f64.copysign") (param $x f64) (param $y f64) (result f64) (f64.copysign (local.get $x) (local.get $y))) + (func (export "f64.ceil") (param $x f64) (result f64) (f64.ceil (local.get $x))) + (func (export "f64.floor") (param $x f64) (result f64) (f64.floor (local.get $x))) + (func (export "f64.trunc") (param $x f64) (result f64) (f64.trunc (local.get $x))) + (func (export "f64.nearest") (param $x f64) (result f64) (f64.nearest (local.get $x))) + (func (export "f64.min") (param $x f64) (param $y f64) (result f64) (f64.min (local.get $x) (local.get $y))) + (func (export "f64.max") (param $x f64) (param $y f64) (result f64) (f64.max (local.get $x) (local.get $y))) +) + +;; Miscellaneous values. +(assert_return (invoke "f32.add" (f32.const 1.1234567890) (f32.const 1.2345e-10)) (f32.const 1.123456789)) +(assert_return (invoke "f64.add" (f64.const 1.1234567890) (f64.const 1.2345e-10)) (f64.const 0x1.1f9add37c11f7p+0)) + +;; Test adding the greatest value to 1.0 that rounds back to 1.0, and the +;; least that rounds to something greater. +(assert_return (invoke "f32.add" (f32.const 1.0) (f32.const 0x1p-24)) (f32.const 0x1.0p+0)) +(assert_return (invoke "f32.add" (f32.const 1.0) (f32.const 0x1.000002p-24)) (f32.const 0x1.000002p+0)) +(assert_return (invoke "f64.add" (f64.const 1.0) (f64.const 0x1p-53)) (f64.const 0x1.0p+0)) +(assert_return (invoke "f64.add" (f64.const 1.0) (f64.const 0x1.0000000000001p-53)) (f64.const 0x1.0000000000001p+0)) + +;; Max subnormal + min subnormal = min normal. +(assert_return (invoke "f32.add" (f32.const 0x1p-149) (f32.const 0x1.fffffcp-127)) (f32.const 0x1p-126)) +(assert_return (invoke "f64.add" (f64.const 0x0.0000000000001p-1022) (f64.const 0x0.fffffffffffffp-1022)) (f64.const 0x1p-1022)) + +;; Test for a case of double rounding, example from: +;; http://perso.ens-lyon.fr/jean-michel.muller/Handbook.html +;; section 3.3.1: A typical problem: "double rounding" +(assert_return (invoke "f32.add" (f32.const 0x1p+31) (f32.const 1024.25)) (f32.const 0x1.000008p+31)) +(assert_return (invoke "f64.add" (f64.const 0x1p+63) (f64.const 1024.25)) (f64.const 0x1.0000000000001p+63)) + +;; Test a case that was "tricky" on MMIX. +;; http://mmix.cs.hm.edu/bugs/bug_rounding.html +(assert_return (invoke "f64.add" (f64.const -0x1p-1008) (f64.const 0x0.0000000001716p-1022)) (f64.const -0x1.fffffffffffffp-1009)) + +;; http://www.vinc17.org/software/tst-ieee754.xsl +(assert_return (invoke "f64.add" (f64.const 9007199254740992) (f64.const 1.00001)) (f64.const 9007199254740994)) + +;; http://www.vinc17.org/software/test.java +(assert_return (invoke "f64.add" (f64.const 9007199254740994) (f64.const 0x1.fffep-1)) (f64.const 9007199254740994)) + +;; Computations that round differently in ties-to-odd mode. +(assert_return (invoke "f32.add" (f32.const 0x1p23) (f32.const 0x1p-1)) (f32.const 0x1p23)) +(assert_return (invoke "f32.add" (f32.const 0x1.000002p+23) (f32.const 0x1p-1)) (f32.const 0x1.000004p+23)) +(assert_return (invoke "f64.add" (f64.const 0x1p52) (f64.const 0x1p-1)) (f64.const 0x1p52)) +(assert_return (invoke "f64.add" (f64.const 0x1.0000000000001p+52) (f64.const 0x1p-1)) (f64.const 0x1.0000000000002p+52)) + +;; Computations that round differently in round-upward mode. +(assert_return (invoke "f32.add" (f32.const -0x1.39675ap+102) (f32.const 0x1.76c94cp-99)) (f32.const -0x1.39675ap+102)) +(assert_return (invoke "f32.add" (f32.const 0x1.6c0f24p+67) (f32.const -0x1.2b92dp+52)) (f32.const 0x1.6c0cccp+67)) +(assert_return (invoke "f32.add" (f32.const 0x1.e62318p-83) (f32.const 0x1.f74abep-125)) (f32.const 0x1.e62318p-83)) +(assert_return (invoke "f32.add" (f32.const 0x1.2a71d4p+39) (f32.const -0x1.c9f10cp+55)) (f32.const -0x1.c9efe2p+55)) +(assert_return (invoke "f32.add" (f32.const 0x1.f8f736p-15) (f32.const 0x1.7bd45ep+106)) (f32.const 0x1.7bd45ep+106)) +(assert_return (invoke "f64.add" (f64.const 0x1.f33e1fbca27aap-413) (f64.const -0x1.6b192891ed61p+249)) (f64.const -0x1.6b192891ed61p+249)) +(assert_return (invoke "f64.add" (f64.const -0x1.46f75d130eeb1p+76) (f64.const 0x1.25275d6f7a4acp-184)) (f64.const -0x1.46f75d130eeb1p+76)) +(assert_return (invoke "f64.add" (f64.const 0x1.04dec9265a731p-148) (f64.const -0x1.11eed4e8c127cp-12)) (f64.const -0x1.11eed4e8c127cp-12)) +(assert_return (invoke "f64.add" (f64.const 0x1.05773b7166b0ap+497) (f64.const 0x1.134022f2da37bp+66)) (f64.const 0x1.05773b7166b0ap+497)) +(assert_return (invoke "f64.add" (f64.const 0x1.ef4f794282a82p+321) (f64.const 0x1.14a82266badep+394)) (f64.const 0x1.14a82266badep+394)) + +;; Computations that round differently in round-downward mode. +(assert_return (invoke "f32.add" (f32.const 0x1.1bf976p+72) (f32.const -0x1.7f5868p+20)) (f32.const 0x1.1bf976p+72)) +(assert_return (invoke "f32.add" (f32.const 0x1.7f9c6cp-45) (f32.const -0x1.b9bb0ep-78)) (f32.const 0x1.7f9c6cp-45)) +(assert_return (invoke "f32.add" (f32.const -0x1.32d1bcp-42) (f32.const 0x1.f7d214p+125)) (f32.const 0x1.f7d214p+125)) +(assert_return (invoke "f32.add" (f32.const -0x1.8e5c0ep-44) (f32.const -0x1.3afa4cp-106)) (f32.const -0x1.8e5c0ep-44)) +(assert_return (invoke "f32.add" (f32.const 0x1.13cd78p-10) (f32.const -0x1.3af316p-107)) (f32.const 0x1.13cd78p-10)) +(assert_return (invoke "f64.add" (f64.const 0x1.f8dd15ca97d4ap+179) (f64.const -0x1.367317d1fe8bfp-527)) (f64.const 0x1.f8dd15ca97d4ap+179)) +(assert_return (invoke "f64.add" (f64.const 0x1.5db08d739228cp+155) (f64.const -0x1.fb316fa147dcbp-61)) (f64.const 0x1.5db08d739228cp+155)) +(assert_return (invoke "f64.add" (f64.const 0x1.bbb403cb85c07p-404) (f64.const -0x1.7e44046b8bbf3p-979)) (f64.const 0x1.bbb403cb85c07p-404)) +(assert_return (invoke "f64.add" (f64.const -0x1.34d38af291831p+147) (f64.const -0x1.9890b47439953p+139)) (f64.const -0x1.366c1ba705bcap+147)) +(assert_return (invoke "f64.add" (f64.const -0x1.b61dedf4e0306p+3) (f64.const 0x1.09e2f31773c4ap+290)) (f64.const 0x1.09e2f31773c4ap+290)) + +;; Computations that round differently in round-toward-zero mode. +(assert_return (invoke "f32.add" (f32.const -0x1.129bd8p-117) (f32.const 0x1.c75012p-43)) (f32.const 0x1.c75012p-43)) +(assert_return (invoke "f32.add" (f32.const -0x1.c204a2p-16) (f32.const 0x1.80b132p-27)) (f32.const -0x1.c1d48cp-16)) +(assert_return (invoke "f32.add" (f32.const -0x1.decc1cp+36) (f32.const 0x1.c688dap-109)) (f32.const -0x1.decc1cp+36)) +(assert_return (invoke "f32.add" (f32.const 0x1.61ce6ap-118) (f32.const -0x1.772892p+30)) (f32.const -0x1.772892p+30)) +(assert_return (invoke "f32.add" (f32.const -0x1.3dc826p-120) (f32.const 0x1.fc3f66p+95)) (f32.const 0x1.fc3f66p+95)) +(assert_return (invoke "f64.add" (f64.const 0x1.bf68acc263a0fp-777) (f64.const -0x1.5f9352965e5a6p+1004)) (f64.const -0x1.5f9352965e5a6p+1004)) +(assert_return (invoke "f64.add" (f64.const -0x1.76eaa70911f51p+516) (f64.const -0x1.2d746324ce47ap+493)) (f64.const -0x1.76eaa963fabb6p+516)) +(assert_return (invoke "f64.add" (f64.const -0x1.b637d82c15a7ap-967) (f64.const 0x1.cc654ccab4152p-283)) (f64.const 0x1.cc654ccab4152p-283)) +(assert_return (invoke "f64.add" (f64.const -0x1.a5b1fb66e846ep-509) (f64.const 0x1.4bdd36f0bb5ccp-860)) (f64.const -0x1.a5b1fb66e846ep-509)) +(assert_return (invoke "f64.add" (f64.const -0x1.14108da880f9ep+966) (f64.const 0x1.417f35701e89fp+800)) (f64.const -0x1.14108da880f9ep+966)) + +;; Computations that round differently on x87. +(assert_return (invoke "f64.add" (f64.const -0x1.fa0caf21ffebcp+804) (f64.const 0x1.4ca8fdcff89f9p+826)) (f64.const 0x1.4ca8f5e7c5e31p+826)) +(assert_return (invoke "f64.add" (f64.const 0x1.016f1fcbdfd38p+784) (f64.const 0x1.375dffcbc9a2cp+746)) (f64.const 0x1.016f1fcbe4b0fp+784)) +(assert_return (invoke "f64.add" (f64.const -0x1.dffda6d5bff3ap+624) (f64.const 0x1.f9e8cc2dff782p+674)) (f64.const 0x1.f9e8cc2dff77bp+674)) +(assert_return (invoke "f64.add" (f64.const 0x1.fff4b43687dfbp+463) (f64.const 0x1.0fd5617c4a809p+517)) (f64.const 0x1.0fd5617c4a809p+517)) +(assert_return (invoke "f64.add" (f64.const 0x1.535d380035da2p-995) (f64.const 0x1.cce37dddbb73bp-963)) (f64.const 0x1.cce37ddf0ed0fp-963)) + +;; Computations that round differently when computed via f32. +(assert_return (invoke "f64.add" (f64.const -0x1.d91cd3fc0c66fp+752) (f64.const -0x1.4e18c80229734p+952)) (f64.const -0x1.4e18c80229734p+952)) +(assert_return (invoke "f64.add" (f64.const 0x1.afc70fd36e372p+193) (f64.const -0x1.bd10a9b377b46p+273)) (f64.const -0x1.bd10a9b377b46p+273)) +(assert_return (invoke "f64.add" (f64.const -0x1.2abd570b078b2p+302) (f64.const 0x1.b3c1ad759cb5bp-423)) (f64.const -0x1.2abd570b078b2p+302)) +(assert_return (invoke "f64.add" (f64.const -0x1.5b2ae84c0686cp-317) (f64.const -0x1.dba7a1c022823p+466)) (f64.const -0x1.dba7a1c022823p+466)) +(assert_return (invoke "f64.add" (f64.const -0x1.ac627bd7cbf38p-198) (f64.const 0x1.2312e265b8d59p-990)) (f64.const -0x1.ac627bd7cbf38p-198)) + +;; Computations that utilize the maximum exponent value to avoid overflow. +(assert_return (invoke "f32.add" (f32.const 0x1.2b91ap+116) (f32.const 0x1.cbcd52p+127)) (f32.const 0x1.cbf2c4p+127)) +(assert_return (invoke "f32.add" (f32.const 0x1.96f392p+127) (f32.const -0x1.6b3fecp+107)) (f32.const 0x1.96f37cp+127)) +(assert_return (invoke "f32.add" (f32.const 0x1.132f1cp+118) (f32.const -0x1.63d632p+127)) (f32.const -0x1.634c9ap+127)) +(assert_return (invoke "f32.add" (f32.const -0x1.1dda64p+120) (f32.const -0x1.ef02ep+127)) (f32.const -0x1.f13e94p+127)) +(assert_return (invoke "f32.add" (f32.const -0x1.4ad8dap+127) (f32.const -0x1.eae082p+125)) (f32.const -0x1.c590fap+127)) +(assert_return (invoke "f64.add" (f64.const 0x1.017099f2a4b8bp+1023) (f64.const 0x1.1f63b28f05454p+981)) (f64.const 0x1.017099f2a5009p+1023)) +(assert_return (invoke "f64.add" (f64.const 0x1.d88b6c74984efp+1023) (f64.const 0x1.33b444775eabcp+990)) (f64.const 0x1.d88b6c7532291p+1023)) +(assert_return (invoke "f64.add" (f64.const -0x1.84576422fdf5p+1023) (f64.const 0x1.60ee6aa12fb9cp+1012)) (f64.const -0x1.842b4655a9cf1p+1023)) +(assert_return (invoke "f64.add" (f64.const -0x1.9aaace3e79f7dp+1001) (f64.const 0x1.e4068af295cb6p+1023)) (f64.const 0x1.e4068487ea926p+1023)) +(assert_return (invoke "f64.add" (f64.const 0x1.06cdae79f27b9p+1023) (f64.const -0x1.e05cb0c96f975p+991)) (f64.const 0x1.06cdae78121eep+1023)) + +;; Computations that utilize the minimum exponent value. +(assert_return (invoke "f32.add" (f32.const 0x1.6a1a2p-127) (f32.const 0x1.378p-140)) (f32.const 0x1.6a23dcp-127)) +(assert_return (invoke "f32.add" (f32.const 0x1.28p-144) (f32.const -0x1p-148)) (f32.const 0x1.18p-144)) +(assert_return (invoke "f32.add" (f32.const -0x1p-146) (f32.const 0x1.c3cap-128)) (f32.const 0x1.c3c9cp-128)) +(assert_return (invoke "f32.add" (f32.const -0x1.4p-145) (f32.const 0x1.424052p-122)) (f32.const 0x1.42405p-122)) +(assert_return (invoke "f32.add" (f32.const 0x1.c5p-141) (f32.const -0x1.72f8p-135)) (f32.const -0x1.6be4p-135)) +(assert_return (invoke "f64.add" (f64.const 0x1.4774c681d1e21p-1022) (f64.const -0x1.271e58e9f58cap-1021)) (f64.const -0x1.06c7eb5219373p-1022)) +(assert_return (invoke "f64.add" (f64.const 0x1.10b3a75e31916p-1021) (f64.const -0x1.ffb82b0e868a7p-1021)) (f64.const -0x1.de090760a9f22p-1022)) +(assert_return (invoke "f64.add" (f64.const -0x0.6b58448b8098ap-1022) (f64.const -0x1.579796ed04cbep-1022)) (f64.const -0x1.c2efdb7885648p-1022)) +(assert_return (invoke "f64.add" (f64.const 0x1.9eb9e7baae8d1p-1020) (f64.const -0x1.d58e136f8c6eep-1020)) (f64.const -0x0.db50aed377874p-1022)) +(assert_return (invoke "f64.add" (f64.const -0x1.f1115deeafa0bp-1022) (f64.const 0x1.221b1c87dca29p-1022)) (f64.const -0x0.cef64166d2fe2p-1022)) + +;; Test an add of the second-greatest finite value with the distance to greatest +;; finite value. +(assert_return (invoke "f32.add" (f32.const 0x1.fffffcp+127) (f32.const 0x1p+104)) (f32.const 0x1.fffffep+127)) +(assert_return (invoke "f64.add" (f64.const 0x1.ffffffffffffep+1023) (f64.const 0x1p+971)) (f64.const 0x1.fffffffffffffp+1023)) + +;; http://news.harvard.edu/gazette/story/2013/09/dawn-of-a-revolution/ +(assert_return (invoke "f32.add" (f32.const 2.0) (f32.const 2.0)) (f32.const 4.0)) +(assert_return (invoke "f64.add" (f64.const 2.0) (f64.const 2.0)) (f64.const 4.0)) + +;; Test rounding above the greatest finite value. +(assert_return (invoke "f32.add" (f32.const 0x1.fffffep+127) (f32.const 0x1.fffffep+102)) (f32.const 0x1.fffffep+127)) +(assert_return (invoke "f32.add" (f32.const 0x1.fffffep+127) (f32.const 0x1p+103)) (f32.const inf)) +(assert_return (invoke "f64.add" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1.fffffffffffffp+969)) (f64.const 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64.add" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1p+970)) (f64.const inf)) + +;; Test for a historic spreadsheet bug. +;; https://blogs.office.com/2007/09/25/calculation-issue-update/ +(assert_return (invoke "f32.sub" (f32.const 65536.0) (f32.const 0x1p-37)) (f32.const 65536.0)) +(assert_return (invoke "f64.sub" (f64.const 65536.0) (f64.const 0x1p-37)) (f64.const 0x1.fffffffffffffp+15)) + +;; Test subtracting the greatest value from 1.0 that rounds back to 1.0, and the +;; least that rounds to something less. +(assert_return (invoke "f32.sub" (f32.const 1.0) (f32.const 0x1p-25)) (f32.const 0x1.0p+0)) +(assert_return (invoke "f32.sub" (f32.const 1.0) (f32.const 0x1.000002p-25)) (f32.const 0x1.fffffep-1)) +(assert_return (invoke "f64.sub" (f64.const 1.0) (f64.const 0x1p-54)) (f64.const 0x1.0p+0)) +(assert_return (invoke "f64.sub" (f64.const 1.0) (f64.const 0x1.0000000000001p-54)) (f64.const 0x1.fffffffffffffp-1)) + +;; Computations that round differently in round-upward mode. +(assert_return (invoke "f32.sub" (f32.const 0x1.ee2466p-106) (f32.const -0x1.16277ep+119)) (f32.const 0x1.16277ep+119)) +(assert_return (invoke "f32.sub" (f32.const -0x1.446f9ep+119) (f32.const -0x1.4396a4p+43)) (f32.const -0x1.446f9ep+119)) +(assert_return (invoke "f32.sub" (f32.const 0x1.74773cp+0) (f32.const -0x1.a25512p-82)) (f32.const 0x1.74773cp+0)) +(assert_return (invoke "f32.sub" (f32.const 0x1.9345c4p-117) (f32.const 0x1.6792c2p-76)) (f32.const -0x1.6792c2p-76)) +(assert_return (invoke "f32.sub" (f32.const 0x1.9ecfa4p-18) (f32.const -0x1.864b44p-107)) (f32.const 0x1.9ecfa4p-18)) +(assert_return (invoke "f64.sub" (f64.const -0x1.5b798875e7845p-333) (f64.const -0x1.b5147117452fep-903)) (f64.const -0x1.5b798875e7845p-333)) +(assert_return (invoke "f64.sub" (f64.const -0x1.6c87baeb6d72dp+552) (f64.const -0x1.64fb35d4b5571p-158)) (f64.const -0x1.6c87baeb6d72dp+552)) +(assert_return (invoke "f64.sub" (f64.const 0x1.b3d369fcf74bp-461) (f64.const -0x1.ea1668c0dec93p-837)) (f64.const 0x1.b3d369fcf74bp-461)) +(assert_return (invoke "f64.sub" (f64.const 0x1.0abd449353eadp-1005) (f64.const -0x1.0422ea3e82ee9p+154)) (f64.const 0x1.0422ea3e82ee9p+154)) +(assert_return (invoke "f64.sub" (f64.const -0x1.aadbc6b43cc3dp-143) (f64.const -0x1.e7f922ef1ee58p-539)) (f64.const -0x1.aadbc6b43cc3dp-143)) + +;; Computations that round differently in round-downward mode. +(assert_return (invoke "f32.sub" (f32.const -0x1.61e262p+108) (f32.const -0x1.baf3e4p+112)) (f32.const 0x1.a4d5bep+112)) +(assert_return (invoke "f32.sub" (f32.const -0x1.62c2f6p+109) (f32.const 0x1.6e514ap+6)) (f32.const -0x1.62c2f6p+109)) +(assert_return (invoke "f32.sub" (f32.const -0x1.287c94p-83) (f32.const 0x1.0f2f9cp-24)) (f32.const -0x1.0f2f9cp-24)) +(assert_return (invoke "f32.sub" (f32.const -0x1.c8825cp-77) (f32.const -0x1.4aead6p-12)) (f32.const 0x1.4aead6p-12)) +(assert_return (invoke "f32.sub" (f32.const -0x1.2976a4p+99) (f32.const 0x1.c6e3b8p-59)) (f32.const -0x1.2976a4p+99)) +(assert_return (invoke "f64.sub" (f64.const -0x1.76cb28ae6c045p+202) (f64.const -0x1.0611f2af4e9b9p+901)) (f64.const 0x1.0611f2af4e9b9p+901)) +(assert_return (invoke "f64.sub" (f64.const 0x1.baf35eff22e9ep-368) (f64.const 0x1.5c3e08ecf73ecp-451)) (f64.const 0x1.baf35eff22e9ep-368)) +(assert_return (invoke "f64.sub" (f64.const -0x1.8fd354b376f1fp-200) (f64.const 0x1.513c860f386ffp-508)) (f64.const -0x1.8fd354b376f1fp-200)) +(assert_return (invoke "f64.sub" (f64.const -0x1.760d447230ae6p-992) (f64.const -0x1.16f788438ae3ep-328)) (f64.const 0x1.16f788438ae3ep-328)) +(assert_return (invoke "f64.sub" (f64.const -0x1.73aab4fcfc7ap+112) (f64.const 0x1.7c589f990b884p+171)) (f64.const -0x1.7c589f990b884p+171)) + +;; Computations that round differently in round-toward-zero mode. +(assert_return (invoke "f32.sub" (f32.const 0x1.ea264cp+95) (f32.const 0x1.852988p-15)) (f32.const 0x1.ea264cp+95)) +(assert_return (invoke "f32.sub" (f32.const -0x1.14ec7cp+19) (f32.const -0x1.0ad3fep-35)) (f32.const -0x1.14ec7cp+19)) +(assert_return (invoke "f32.sub" (f32.const -0x1.3251dap-36) (f32.const -0x1.49c97ep-56)) (f32.const -0x1.3251c6p-36)) +(assert_return (invoke "f32.sub" (f32.const -0x1.13565ep-14) (f32.const 0x1.2f89a8p-13)) (f32.const -0x1.b934d8p-13)) +(assert_return (invoke "f32.sub" (f32.const -0x1.6032b6p-33) (f32.const -0x1.bb5196p-104)) (f32.const -0x1.6032b6p-33)) +(assert_return (invoke "f64.sub" (f64.const -0x1.b5b0797af491p-157) (f64.const -0x1.694b8348189e8p+722)) (f64.const 0x1.694b8348189e8p+722)) +(assert_return (invoke "f64.sub" (f64.const -0x1.72b142826ed73p+759) (f64.const -0x1.010477bc9afbdp+903)) (f64.const 0x1.010477bc9afbdp+903)) +(assert_return (invoke "f64.sub" (f64.const 0x1.83273b6bb94cfp-796) (f64.const 0x1.1a93f948a2abbp+181)) (f64.const -0x1.1a93f948a2abbp+181)) +(assert_return (invoke "f64.sub" (f64.const -0x1.207e7156cbf2p-573) (f64.const 0x1.cf3f12fd3814dp-544)) (f64.const -0x1.cf3f13063c086p-544)) +(assert_return (invoke "f64.sub" (f64.const -0x1.837e6844f1718p-559) (f64.const -0x1.1c29b757f98abp-14)) (f64.const 0x1.1c29b757f98abp-14)) + +;; Computations that round differently on x87. +(assert_return (invoke "f64.sub" (f64.const 0x1.c21151a709b6cp-78) (f64.const 0x1.0a12fff8910f6p-115)) (f64.const 0x1.c21151a701663p-78)) +(assert_return (invoke "f64.sub" (f64.const 0x1.c57912aae2f64p-982) (f64.const 0x1.dbfbd4800b7cfp-1010)) (f64.const 0x1.c579128d2338fp-982)) +(assert_return (invoke "f64.sub" (f64.const 0x1.ffef4399af9c6p-254) (f64.const 0x1.edb96dfaea8b1p-200)) (f64.const -0x1.edb96dfaea8b1p-200)) +(assert_return (invoke "f64.sub" (f64.const -0x1.363eee391cde2p-39) (f64.const -0x1.a65462000265fp-69)) (f64.const -0x1.363eee32838c9p-39)) +(assert_return (invoke "f64.sub" (f64.const 0x1.59016dba002a1p-25) (f64.const 0x1.5d4374f124cccp-3)) (f64.const -0x1.5d436f8d1f15dp-3)) + +;; Computations that round differently when computed via f32. +(assert_return (invoke "f64.sub" (f64.const -0x1.18196bca005cfp-814) (f64.const -0x1.db7b01ce3f52fp-766)) (f64.const 0x1.db7b01ce3f51dp-766)) +(assert_return (invoke "f64.sub" (f64.const -0x1.d17b3528d219p+33) (f64.const 0x1.fd739d4ea220ap+367)) (f64.const -0x1.fd739d4ea220ap+367)) +(assert_return (invoke "f64.sub" (f64.const 0x1.dea46994de319p+114) (f64.const 0x1.b5b19cd55c7d3p-590)) (f64.const 0x1.dea46994de319p+114)) +(assert_return (invoke "f64.sub" (f64.const 0x1.b60f9b2fbd9ecp-489) (f64.const -0x1.6f81c59ec5b8ep-694)) (f64.const 0x1.b60f9b2fbd9ecp-489)) +(assert_return (invoke "f64.sub" (f64.const 0x1.5e423fe8571f4p-57) (f64.const 0x1.9624ed7c162dfp-618)) (f64.const 0x1.5e423fe8571f4p-57)) + +;; pow(e, π) - π +;; https://xkcd.com/217/ +(assert_return (invoke "f32.sub" (f32.const 0x1.724046p+4) (f32.const 0x1.921fb6p+1)) (f32.const 0x1.3ffc5p+4)) +(assert_return (invoke "f64.sub" (f64.const 0x1.724046eb0933ap+4) (f64.const 0x1.921fb54442d18p+1)) (f64.const 0x1.3ffc504280d97p+4)) + +;; https://www.cnet.com/news/googles-calculator-muffs-some-math-problems/ +(assert_return (invoke "f32.sub" (f32.const 2999999) (f32.const 2999998)) (f32.const 1.0)) +(assert_return (invoke "f32.sub" (f32.const 1999999) (f32.const 1999995)) (f32.const 4.0)) +(assert_return (invoke "f32.sub" (f32.const 1999999) (f32.const 1999993)) (f32.const 6.0)) +(assert_return (invoke "f32.sub" (f32.const 400002) (f32.const 400001)) (f32.const 1.0)) +(assert_return (invoke "f32.sub" (f32.const 400002) (f32.const 400000)) (f32.const 2.0)) +(assert_return (invoke "f64.sub" (f64.const 2999999999999999) (f64.const 2999999999999998)) (f64.const 1.0)) +(assert_return (invoke "f64.sub" (f64.const 1999999999999999) (f64.const 1999999999999995)) (f64.const 4.0)) +(assert_return (invoke "f64.sub" (f64.const 1999999999999999) (f64.const 1999999999999993)) (f64.const 6.0)) +(assert_return (invoke "f64.sub" (f64.const 400000000000002) (f64.const 400000000000001)) (f64.const 1.0)) +(assert_return (invoke "f64.sub" (f64.const 400000000000002) (f64.const 400000000000000)) (f64.const 2.0)) + +;; Min normal - max subnormal = min subnormal. +(assert_return (invoke "f32.sub" (f32.const 0x1p-126) (f32.const 0x1.fffffcp-127)) (f32.const 0x1p-149)) +(assert_return (invoke "f64.sub" (f64.const 0x1p-1022) (f64.const 0x0.fffffffffffffp-1022)) (f64.const 0x0.0000000000001p-1022)) + +;; Test subtraction of numbers very close to 1. +(assert_return (invoke "f32.sub" (f32.const 0x1.000002p+0) (f32.const 0x1.fffffep-1)) (f32.const 0x1.8p-23)) +(assert_return (invoke "f32.sub" (f32.const 0x1.000002p+0) (f32.const 0x1.0p+0)) (f32.const 0x1p-23)) +(assert_return (invoke "f32.sub" (f32.const 0x1p+0) (f32.const 0x1.fffffep-1)) (f32.const 0x1p-24)) +(assert_return (invoke "f64.sub" (f64.const 0x1.0000000000001p+0) (f64.const 0x1.fffffffffffffp-1)) (f64.const 0x1.8p-52)) +(assert_return (invoke "f64.sub" (f64.const 0x1.0000000000001p+0) (f64.const 0x1.0p+0)) (f64.const 0x1p-52)) +(assert_return (invoke "f64.sub" (f64.const 0x1p+0) (f64.const 0x1.fffffffffffffp-1)) (f64.const 0x1p-53)) + +;; Test the least value that can be subtracted from the max value to produce a +;; different value. +(assert_return (invoke "f32.sub" (f32.const 0x1.fffffep+127) (f32.const 0x1.fffffep+102)) (f32.const 0x1.fffffep+127)) +(assert_return (invoke "f32.sub" (f32.const 0x1.fffffep+127) (f32.const 0x1p+103)) (f32.const 0x1.fffffcp+127)) +(assert_return (invoke "f64.sub" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1.fffffffffffffp+969)) (f64.const 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64.sub" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1p+970)) (f64.const 0x1.ffffffffffffep+1023)) + +;; Miscellaneous values. +(assert_return (invoke "f32.mul" (f32.const 1e15) (f32.const 1e15)) (f32.const 0x1.93e592p+99)) +(assert_return (invoke "f32.mul" (f32.const 1e20) (f32.const 1e20)) (f32.const inf)) +(assert_return (invoke "f32.mul" (f32.const 1e25) (f32.const 1e25)) (f32.const inf)) +(assert_return (invoke "f64.mul" (f64.const 1e15) (f64.const 1e15)) (f64.const 0x1.93e5939a08ceap+99)) +(assert_return (invoke "f64.mul" (f64.const 1e20) (f64.const 1e20)) (f64.const 0x1.d6329f1c35ca5p+132)) +(assert_return (invoke "f64.mul" (f64.const 1e25) (f64.const 1e25)) (f64.const 0x1.11b0ec57e649bp+166)) + +;; Test for a case of double rounding, example from: +;; http://perso.ens-lyon.fr/jean-michel.muller/Handbook.html +;; section 3.3.1: A typical problem: "double rounding" +(assert_return (invoke "f32.mul" (f32.const 1848874880.0) (f32.const 19954563072.0)) (f32.const 0x1.000002p+65)) +(assert_return (invoke "f64.mul" (f64.const 1848874847.0) (f64.const 19954562207.0)) (f64.const 3.6893488147419111424e+19)) + +;; Test for a historic spreadsheet bug. +;; http://www.joelonsoftware.com/items/2007/09/26b.html +(assert_return (invoke "f32.mul" (f32.const 77.1) (f32.const 850)) (f32.const 65535)) +(assert_return (invoke "f64.mul" (f64.const 77.1) (f64.const 850)) (f64.const 65534.99999999999272404)) + +;; Computations that round differently in round-upward mode. +(assert_return (invoke "f32.mul" (f32.const -0x1.14df2ep+61) (f32.const 0x1.748878p-36)) (f32.const -0x1.92e7e8p+25)) +(assert_return (invoke "f32.mul" (f32.const -0x1.5629e2p+102) (f32.const -0x1.c33012p-102)) (f32.const 0x1.2d8604p+1)) +(assert_return (invoke "f32.mul" (f32.const -0x1.b17694p+92) (f32.const -0x1.e4b56ap-97)) (f32.const 0x1.9a5baep-4)) +(assert_return (invoke "f32.mul" (f32.const -0x1.1626a6p+79) (f32.const -0x1.c57d7p-75)) (f32.const 0x1.ecbaaep+4)) +(assert_return (invoke "f32.mul" (f32.const 0x1.7acf72p+53) (f32.const 0x1.6c89acp+5)) (f32.const 0x1.0db556p+59)) +(assert_return (invoke "f64.mul" (f64.const -0x1.25c293f6f37e4p+425) (f64.const 0x1.f5fd4fa41c6d8p+945)) (f64.const -inf)) +(assert_return (invoke "f64.mul" (f64.const -0x1.cc1ae79fffc5bp-986) (f64.const -0x1.c36ccc2861ca6p-219)) (f64.const 0x0p+0)) +(assert_return (invoke "f64.mul" (f64.const 0x1.c0232b3e64b56p+606) (f64.const -0x1.f6939cf3affaap+106)) (f64.const -0x1.b7e3aedf190d3p+713)) +(assert_return (invoke "f64.mul" (f64.const -0x1.60f289966b271p-313) (f64.const 0x1.28a5497f0c259p+583)) (f64.const -0x1.98fc50bcec259p+270)) +(assert_return (invoke "f64.mul" (f64.const 0x1.37dab12d3afa2p+795) (f64.const 0x1.81e156bd393f1p-858)) (f64.const 0x1.d6126554b8298p-63)) + +;; Computations that round differently in round-downward mode. +(assert_return (invoke "f32.mul" (f32.const -0x1.3f57a2p-89) (f32.const -0x1.041d68p+92)) (f32.const 0x1.4479bp+3)) +(assert_return (invoke "f32.mul" (f32.const 0x1.4d0582p+73) (f32.const 0x1.6e043ap+19)) (f32.const 0x1.dc236p+92)) +(assert_return (invoke "f32.mul" (f32.const -0x1.2fdap-32) (f32.const -0x1.e1731cp+74)) (f32.const 0x1.1db89ep+43)) +(assert_return (invoke "f32.mul" (f32.const 0x1.7bc8fep+67) (f32.const -0x1.3ad592p+15)) (f32.const -0x1.d3115ep+82)) +(assert_return (invoke "f32.mul" (f32.const 0x1.936742p+30) (f32.const -0x1.a7a19p+66)) (f32.const -0x1.4dc71ap+97)) +(assert_return (invoke "f64.mul" (f64.const -0x1.ba737b4ca3b13p-639) (f64.const 0x1.8923309857438p-314)) (f64.const -0x1.53bc0d07baa37p-952)) +(assert_return (invoke "f64.mul" (f64.const 0x1.7c1932e610219p-276) (f64.const -0x1.2605db646489fp-635)) (f64.const -0x1.b48da2b0d2ae3p-911)) +(assert_return (invoke "f64.mul" (f64.const -0x1.e43cdf3b2108p+329) (f64.const -0x1.99d96abbd61d1p+835)) (f64.const inf)) +(assert_return (invoke "f64.mul" (f64.const 0x1.4c19466551da3p+947) (f64.const 0x1.0bdcd6c7646e9p-439)) (f64.const 0x1.5b7cd8c3f638ap+508)) +(assert_return (invoke "f64.mul" (f64.const 0x1.ff1da1726e3dfp+339) (f64.const -0x1.043c44f52b158p+169)) (f64.const -0x1.03c9364bb585cp+509)) + +;; Computations that round differently in round-toward-zero mode. +(assert_return (invoke "f32.mul" (f32.const -0x1.907e8ap+46) (f32.const -0x1.5d3668p+95)) (f32.const inf)) +(assert_return (invoke "f32.mul" (f32.const -0x1.8c9f74p-3) (f32.const 0x1.e2b452p-99)) (f32.const -0x1.75edccp-101)) +(assert_return (invoke "f32.mul" (f32.const -0x1.cc605ap-19) (f32.const 0x1.ec321ap+105)) (f32.const -0x1.ba91a4p+87)) +(assert_return (invoke "f32.mul" (f32.const -0x1.5fbb7ap+56) (f32.const 0x1.a8965ep-96)) (f32.const -0x1.23ae8ep-39)) +(assert_return (invoke "f32.mul" (f32.const -0x1.fb7f12p+16) (f32.const 0x1.3a701ap-119)) (f32.const -0x1.37ac0cp-102)) +(assert_return (invoke "f64.mul" (f64.const -0x1.5b0266454c26bp-496) (f64.const -0x1.af5787e3e0399p+433)) (f64.const 0x1.2457d81949e0bp-62)) +(assert_return (invoke "f64.mul" (f64.const 0x1.0d54a82393d45p+478) (f64.const -0x1.425760807ceaep-764)) (f64.const -0x1.532068c8d0d5dp-286)) +(assert_return (invoke "f64.mul" (f64.const -0x1.b532af981786p+172) (f64.const 0x1.ada95085ba36fp+359)) (f64.const -0x1.6ee38c1e01864p+532)) +(assert_return (invoke "f64.mul" (f64.const 0x1.e132f4d49d1cep+768) (f64.const -0x1.a75afe9a7d864p+374)) (f64.const -inf)) +(assert_return (invoke "f64.mul" (f64.const 0x1.68bbf1cfff90ap+81) (f64.const 0x1.09cd17d652c5p+70)) (f64.const 0x1.768b8d67d794p+151)) + +;; Computations that round differently on x87. +(assert_return (invoke "f64.mul" (f64.const 0x1.f99fb602c89b7p-341) (f64.const 0x1.6caab46a31a2ep-575)) (f64.const 0x1.68201f986e9d7p-915)) +(assert_return (invoke "f64.mul" (f64.const -0x1.86999c5eee379p-9) (f64.const 0x1.6e3b9e0d53e0dp+723)) (f64.const -0x1.17654a0ef35f5p+715)) +(assert_return (invoke "f64.mul" (f64.const -0x1.069571b176f9p+367) (f64.const -0x1.e248b6ab0a0e3p-652)) (f64.const 0x1.eeaff575cae1dp-285)) +(assert_return (invoke "f64.mul" (f64.const 0x1.c217645777dd2p+775) (f64.const 0x1.d93f5715dd646p+60)) (f64.const 0x1.a0064aa1d920dp+836)) +(assert_return (invoke "f64.mul" (f64.const -0x1.848981b6e694ap-276) (f64.const 0x1.f5aacb64a0d19p+896)) (f64.const -0x1.7cb2296e6c2e5p+621)) + +;; Computations that round differently on x87 in double-precision mode. +(assert_return (invoke "f64.mul" (f64.const 0x1.db3bd2a286944p-599) (f64.const 0x1.ce910af1d55cap-425)) (f64.const 0x0.d6accdd538a39p-1022)) +(assert_return (invoke "f64.mul" (f64.const -0x1.aca223916012p-57) (f64.const -0x1.2b2b4958dd228p-966)) (f64.const 0x0.fa74eccae5615p-1022)) +(assert_return (invoke "f64.mul" (f64.const -0x1.bd062def16cffp-488) (f64.const -0x1.7ddd91a0c4c0ep-536)) (f64.const 0x0.a5f4d7769d90dp-1022)) +(assert_return (invoke "f64.mul" (f64.const -0x1.c6a56169e9cep-772) (f64.const 0x1.517d55a474122p-255)) (f64.const -0x0.12baf260afb77p-1022)) +(assert_return (invoke "f64.mul" (f64.const -0x1.08951b0b41705p-516) (f64.const -0x1.102dc27168d09p-507)) (f64.const 0x0.8ca6dbf3f592bp-1022)) + +;; Computations that round differently when computed via f32. +(assert_return (invoke "f64.mul" (f64.const 0x1.8d0dea50c8c9bp+852) (f64.const 0x1.21cac31d87a24p-881)) (f64.const 0x1.c177311f7cd73p-29)) +(assert_return (invoke "f64.mul" (f64.const 0x1.98049118e3063p-7) (f64.const 0x1.6362525151b58p-149)) (f64.const 0x1.1b358514103f9p-155)) +(assert_return (invoke "f64.mul" (f64.const -0x1.ea65cb0631323p+1) (f64.const 0x1.fce683201a19bp-41)) (f64.const -0x1.e76dc8c223667p-39)) +(assert_return (invoke "f64.mul" (f64.const 0x1.e4d235961d543p-373) (f64.const 0x1.bc56f20ef9a48p-205)) (f64.const 0x1.a4c09efcb71d6p-577)) +(assert_return (invoke "f64.mul" (f64.const -0x1.b9612e66faba8p+77) (f64.const 0x1.e2bc6aa782273p-348)) (f64.const -0x1.a026ea4f81db1p-270)) + +;; Test the least positive value with a positive square. +(assert_return (invoke "f32.mul" (f32.const 0x1p-75) (f32.const 0x1p-75)) (f32.const 0x0p+0)) +(assert_return (invoke "f32.mul" (f32.const 0x1.000002p-75) (f32.const 0x1.000002p-75)) (f32.const 0x1p-149)) +(assert_return (invoke "f64.mul" (f64.const 0x1.6a09e667f3bccp-538) (f64.const 0x1.6a09e667f3bccp-538)) (f64.const 0x0p+0)) +(assert_return (invoke "f64.mul" (f64.const 0x1.6a09e667f3bcdp-538) (f64.const 0x1.6a09e667f3bcdp-538)) (f64.const 0x0.0000000000001p-1022)) + +;; Test the greatest positive value with a finite square. +(assert_return (invoke "f32.mul" (f32.const 0x1.fffffep+63) (f32.const 0x1.fffffep+63)) (f32.const 0x1.fffffcp+127)) +(assert_return (invoke "f32.mul" (f32.const 0x1p+64) (f32.const 0x1p+64)) (f32.const inf)) +(assert_return (invoke "f64.mul" (f64.const 0x1.fffffffffffffp+511) (f64.const 0x1.fffffffffffffp+511)) (f64.const 0x1.ffffffffffffep+1023)) +(assert_return (invoke "f64.mul" (f64.const 0x1p+512) (f64.const 0x1p+512)) (f64.const inf)) + +;; Test the squares of values very close to 1. +(assert_return (invoke "f32.mul" (f32.const 0x1.000002p+0) (f32.const 0x1.000002p+0)) (f32.const 0x1.000004p+0)) +(assert_return (invoke "f32.mul" (f32.const 0x1.fffffep-1) (f32.const 0x1.fffffep-1)) (f32.const 0x1.fffffcp-1)) +(assert_return (invoke "f64.mul" (f64.const 0x1.0000000000001p+0) (f64.const 0x1.0000000000001p+0)) (f64.const 0x1.0000000000002p+0)) +(assert_return (invoke "f64.mul" (f64.const 0x1.fffffffffffffp-1) (f64.const 0x1.fffffffffffffp-1)) (f64.const 0x1.ffffffffffffep-1)) + +;; Test multiplication of numbers very close to 1. +(assert_return (invoke "f32.mul" (f32.const 0x1.000002p+0) (f32.const 0x1.fffffep-1)) (f32.const 0x1p+0)) +(assert_return (invoke "f32.mul" (f32.const 0x1.000004p+0) (f32.const 0x1.fffffcp-1)) (f32.const 0x1.000002p+0)) +(assert_return (invoke "f64.mul" (f64.const 0x1.0000000000001p+0) (f64.const 0x1.fffffffffffffp-1)) (f64.const 0x1p+0)) +(assert_return (invoke "f64.mul" (f64.const 0x1.0000000000002p+0) (f64.const 0x1.ffffffffffffep-1)) (f64.const 0x1.0000000000001p+0)) + +;; Test MIN * EPSILON. +;; http://www.mpfr.org/mpfr-2.0.1/patch2 +(assert_return (invoke "f32.mul" (f32.const 0x1p-126) (f32.const 0x1p-23)) (f32.const 0x1p-149)) +(assert_return (invoke "f64.mul" (f64.const 0x1p-1022) (f64.const 0x1p-52)) (f64.const 0x0.0000000000001p-1022)) + +;; http://opencores.org/bug,view,2454 +(assert_return (invoke "f32.mul" (f32.const -0x1.0006p+4) (f32.const 0x1.ap-132)) (f32.const -0x1.a009cp-128)) + +;; Miscellaneous values. +(assert_return (invoke "f32.div" (f32.const 1.123456789) (f32.const 100)) (f32.const 0x1.702264p-7)) +(assert_return (invoke "f32.div" (f32.const 8391667.0) (f32.const 12582905.0)) (f32.const 0x1.55754p-1)) +(assert_return (invoke "f32.div" (f32.const 65536.0) (f32.const 0x1p-37)) (f32.const 0x1p+53)) +(assert_return (invoke "f32.div" (f32.const 0x1.dcbf6ap+0) (f32.const 0x1.fffffep+127)) (f32.const 0x1.dcbf68p-128)) +(assert_return (invoke "f32.div" (f32.const 4) (f32.const 3)) (f32.const 0x1.555556p+0)) +(assert_return (invoke "f64.div" (f64.const 1.123456789) (f64.const 100)) (f64.const 0.01123456789)) +(assert_return (invoke "f64.div" (f64.const 8391667.0) (f64.const 12582905.0)) (f64.const 0x1.55753f1d9ba27p-1)) +(assert_return (invoke "f64.div" (f64.const 65536.0) (f64.const 0x1p-37)) (f64.const 0x1p+53)) +(assert_return (invoke "f64.div" (f64.const 0x1.dcbf6ap+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x0.772fda8p-1022)) +(assert_return (invoke "f64.div" (f64.const 4) (f64.const 3)) (f64.const 0x1.5555555555555p+0)) + +;; Test for a historic hardware bug. +;; https://en.wikipedia.org/wiki/Pentium_FDIV_bug +(assert_return (invoke "f32.div" (f32.const 4195835) (f32.const 3145727)) (f32.const 0x1.557542p+0)) +(assert_return (invoke "f64.div" (f64.const 4195835) (f64.const 3145727)) (f64.const 0x1.557541c7c6b43p+0)) + +;; Computations that round differently in round-upward mode. +(assert_return (invoke "f32.div" (f32.const 0x1.6a6c5ap-48) (f32.const 0x1.fa0b7p+127)) (f32.const 0x0p+0)) +(assert_return (invoke "f32.div" (f32.const 0x1.616fb2p-87) (f32.const 0x1.332172p+68)) (f32.const 0x0p+0)) +(assert_return (invoke "f32.div" (f32.const -0x1.96e778p+16) (f32.const 0x1.eb0c56p-80)) (f32.const -0x1.a8440ap+95)) +(assert_return (invoke "f32.div" (f32.const -0x1.e2624p-76) (f32.const -0x1.ed236ep-122)) (f32.const 0x1.f4d584p+45)) +(assert_return (invoke "f32.div" (f32.const -0x1.e2374ep+41) (f32.const 0x1.71fcdcp-80)) (f32.const -0x1.4da706p+121)) +(assert_return (invoke "f64.div" (f64.const 0x1.163c09d0c38c1p+147) (f64.const 0x1.e04cc737348e6p+223)) (f64.const 0x1.289921caeed23p-77)) +(assert_return (invoke "f64.div" (f64.const 0x1.d6867e741e0a9p-626) (f64.const 0x1.335eb19a9aae4p-972)) (f64.const 0x1.87e342d11f519p+346)) +(assert_return (invoke "f64.div" (f64.const -0x1.d5edf648aeb98p+298) (f64.const 0x1.0dda15b079355p+640)) (f64.const -0x1.bdceaf9734b5cp-342)) +(assert_return (invoke "f64.div" (f64.const -0x1.b683e3934aedap+691) (f64.const 0x1.c364e1df00dffp+246)) (f64.const -0x1.f16456e7afe3bp+444)) +(assert_return (invoke "f64.div" (f64.const -0x1.44ca7539cc851p+540) (f64.const 0x1.58501bccc58fep+453)) (f64.const -0x1.e2f8657e0924ep+86)) + +;; Computations that round differently in round-downward mode. +(assert_return (invoke "f32.div" (f32.const -0x1.c2c54ap+69) (f32.const -0x1.00d142p-86)) (f32.const inf)) +(assert_return (invoke "f32.div" (f32.const 0x1.e35abep-46) (f32.const 0x1.c69dfp+44)) (f32.const 0x1.102eb4p-90)) +(assert_return (invoke "f32.div" (f32.const 0x1.45ff2ap+0) (f32.const -0x1.1e8754p+89)) (f32.const -0x1.23434ep-89)) +(assert_return (invoke "f32.div" (f32.const 0x1.8db18ap-51) (f32.const 0x1.47c678p-128)) (f32.const 0x1.369b96p+77)) +(assert_return (invoke "f32.div" (f32.const 0x1.78599p+90) (f32.const 0x1.534144p+87)) (f32.const 0x1.1bfddcp+3)) +(assert_return (invoke "f64.div" (f64.const 0x0.f331c4f47eb51p-1022) (f64.const -0x1.c7ff45bf6f03ap+362)) (f64.const -0x0p+0)) +(assert_return (invoke "f64.div" (f64.const -0x1.0fc8707b9d19cp-987) (f64.const 0x1.77524d5f4a563p-536)) (f64.const -0x1.72c1a937d231p-452)) +(assert_return (invoke "f64.div" (f64.const -0x1.edb3aa64bb338p-403) (f64.const -0x1.1c7c164320e4p+45)) (f64.const 0x1.bc44cc1c5ae63p-448)) +(assert_return (invoke "f64.div" (f64.const -0x1.6534b34e8686bp+80) (f64.const 0x1.c34a7fc59e3c3p-791)) (f64.const -0x1.95421bf291b66p+870)) +(assert_return (invoke "f64.div" (f64.const -0x1.91f58d7ed1237p+236) (f64.const -0x1.f190d808383c8p+55)) (f64.const 0x1.9d9eb0836f906p+180)) + +;; Computations that round differently in round-toward-zero mode. +(assert_return (invoke "f32.div" (f32.const 0x1.64b2a4p+26) (f32.const 0x1.e95752p-119)) (f32.const inf)) +(assert_return (invoke "f32.div" (f32.const -0x1.53c9b6p+77) (f32.const 0x1.d689ap+27)) (f32.const -0x1.71baa4p+49)) +(assert_return (invoke "f32.div" (f32.const 0x1.664a8ap+38) (f32.const -0x1.59dba2p+96)) (f32.const -0x1.0933f4p-58)) +(assert_return (invoke "f32.div" (f32.const -0x1.99e0fap+111) (f32.const -0x1.c2b5a8p+9)) (f32.const 0x1.d19de6p+101)) +(assert_return (invoke "f32.div" (f32.const -0x1.5a815ap+92) (f32.const -0x1.b5820ap+13)) (f32.const 0x1.9580b8p+78)) +(assert_return (invoke "f64.div" (f64.const -0x1.81fd1e2af7bebp-655) (f64.const 0x1.edefc4eae536cp-691)) (f64.const -0x1.901abdd91b661p+35)) +(assert_return (invoke "f64.div" (f64.const -0x1.47cf932953c43p+782) (f64.const -0x1.bc40496b1f2a1p-553)) (f64.const inf)) +(assert_return (invoke "f64.div" (f64.const -0x1.2bd2e8fbdcad7p-746) (f64.const 0x1.b115674cc476ep-65)) (f64.const -0x1.62752bf19fa81p-682)) +(assert_return (invoke "f64.div" (f64.const -0x1.f923e3fea9efep+317) (f64.const -0x1.8044c74d27a39p-588)) (f64.const 0x1.5086518cc7186p+905)) +(assert_return (invoke "f64.div" (f64.const 0x1.516ed2051d6bbp+181) (f64.const -0x1.c9f455eb9c2eep+214)) (f64.const -0x1.79414d67f2889p-34)) + +;; Computations that round differently on x87. +(assert_return (invoke "f64.div" (f64.const -0x1.9c52726aed366p+585) (f64.const -0x1.7d0568c75660fp+195)) (f64.const 0x1.1507ca2a65f23p+390)) +(assert_return (invoke "f64.div" (f64.const -0x1.522672f461667p+546) (f64.const -0x1.36d36572c9f71p+330)) (f64.const 0x1.1681369370619p+216)) +(assert_return (invoke "f64.div" (f64.const 0x1.01051b4e8cd61p+185) (f64.const -0x1.2cbb5ca3d33ebp+965)) (f64.const -0x1.b59471598a2f3p-781)) +(assert_return (invoke "f64.div" (f64.const 0x1.5f93bb80fc2cbp+217) (f64.const 0x1.7e051aae9f0edp+427)) (f64.const 0x1.d732fa926ba4fp-211)) +(assert_return (invoke "f64.div" (f64.const -0x1.e251d762163ccp+825) (f64.const 0x1.3ee63581e1796p+349)) (f64.const -0x1.8330077d90a07p+476)) + +;; Computations that round differently on x87 in double-precision mode. +(assert_return (invoke "f64.div" (f64.const 0x1.dcbf69f10006dp+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x0.772fda7c4001bp-1022)) +(assert_return (invoke "f64.div" (f64.const 0x1.e14169442fbcap-1011) (f64.const 0x1.505451d62ff7dp+12)) (f64.const 0x0.b727e85f38b39p-1022)) +(assert_return (invoke "f64.div" (f64.const -0x1.d3ebe726ec964p-144) (f64.const -0x1.4a7bfc0b83608p+880)) (f64.const 0x0.5a9d8c50cbf87p-1022)) +(assert_return (invoke "f64.div" (f64.const -0x1.6c3def770aee1p-393) (f64.const -0x1.8b84724347598p+631)) (f64.const 0x0.3af0707fcd0c7p-1022)) +(assert_return (invoke "f64.div" (f64.const 0x1.16abda1bb3cb3p-856) (f64.const 0x1.6c9c7198eb1e6p+166)) (f64.const 0x0.c3a8fd6741649p-1022)) +(assert_return (invoke "f64.div" (f64.const 0x1.7057d6ab553cap-1005) (f64.const -0x1.2abf1e98660ebp+23)) (f64.const -0x0.04ee8d8ec01cdp-1022)) + +;; Computations that round differently when div is mul by reciprocal. +(assert_return (invoke "f32.div" (f32.const 0x1.ada9aap+89) (f32.const 0x1.69884cp+42)) (f32.const 0x1.303e2ep+47)) +(assert_return (invoke "f32.div" (f32.const 0x1.8281c8p+90) (f32.const -0x1.62883cp+106)) (f32.const -0x1.17169cp-16)) +(assert_return (invoke "f32.div" (f32.const 0x1.5c6be2p+81) (f32.const 0x1.d01dfep-1)) (f32.const 0x1.805e32p+81)) +(assert_return (invoke "f32.div" (f32.const -0x1.bbd252p+19) (f32.const -0x1.fba95p+33)) (f32.const 0x1.bf9d56p-15)) +(assert_return (invoke "f32.div" (f32.const -0x1.0f41d6p-42) (f32.const -0x1.3f2dbep+56)) (f32.const 0x1.b320d8p-99)) +(assert_return (invoke "f64.div" (f64.const 0x1.b2348a1c81899p+61) (f64.const -0x1.4a58aad903dd3p-861)) (f64.const -0x1.507c1e2a41b35p+922)) +(assert_return (invoke "f64.div" (f64.const 0x1.23fa5137a918ap-130) (f64.const -0x1.7268db1951263p-521)) (f64.const -0x1.93965e0d896bep+390)) +(assert_return (invoke "f64.div" (f64.const 0x1.dcb3915d82deep+669) (f64.const 0x1.50caaa1dc6b19p+638)) (f64.const 0x1.6a58ec814b09dp+31)) +(assert_return (invoke "f64.div" (f64.const -0x1.046e378c0cc46p+182) (f64.const 0x1.ac925009a922bp+773)) (f64.const -0x1.3720aa94dab18p-592)) +(assert_return (invoke "f64.div" (f64.const -0x1.8945fd69d8e11p-871) (f64.const -0x1.0a37870af809ap-646)) (f64.const 0x1.7a2e286c62382p-225)) + +;; Computations that round differently when computed via f32. +(assert_return (invoke "f64.div" (f64.const 0x1.82002af0ea1f3p-57) (f64.const 0x1.d0a9b0c2fa339p+0)) (f64.const 0x1.a952fbd1fc17cp-58)) +(assert_return (invoke "f64.div" (f64.const 0x1.1e12b515db471p-102) (f64.const -0x1.41fc3c94fba5p-42)) (f64.const -0x1.c6e50cccb7cb6p-61)) +(assert_return (invoke "f64.div" (f64.const 0x1.aba5adcd6f583p-41) (f64.const 0x1.17dfac639ce0fp-112)) (f64.const 0x1.872b0a008c326p+71)) +(assert_return (invoke "f64.div" (f64.const 0x1.cf82510d0ae6bp+89) (f64.const 0x1.0207d86498053p+97)) (f64.const 0x1.cbdc804e2cf14p-8)) +(assert_return (invoke "f64.div" (f64.const 0x1.4c82cbb508e21p-11) (f64.const -0x1.6b57208c2d5d5p+52)) (f64.const -0x1.d48e8b369129ap-64)) + +;; Division involving the maximum subnormal value and the minimum normal value. +(assert_return (invoke "f32.div" (f32.const 0x1p-126) (f32.const 0x1.fffffcp-127)) (f32.const 0x1.000002p+0)) +(assert_return (invoke "f32.div" (f32.const 0x1.fffffcp-127) (f32.const 0x1p-126)) (f32.const 0x1.fffffcp-1)) +(assert_return (invoke "f64.div" (f64.const 0x1p-1022) (f64.const 0x0.fffffffffffffp-1022)) (f64.const 0x1.0000000000001p+0)) +(assert_return (invoke "f64.div" (f64.const 0x0.fffffffffffffp-1022) (f64.const 0x1p-1022)) (f64.const 0x1.ffffffffffffep-1)) + +;; Test the least positive value with a positive quotient with the maximum value. +(assert_return (invoke "f32.div" (f32.const 0x1.fffffep-23) (f32.const 0x1.fffffep+127)) (f32.const 0x0p+0)) +(assert_return (invoke "f32.div" (f32.const 0x1p-22) (f32.const 0x1.fffffep+127)) (f32.const 0x1p-149)) +(assert_return (invoke "f64.div" (f64.const 0x1.fffffffffffffp-52) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x0p+0)) +(assert_return (invoke "f64.div" (f64.const 0x1p-51) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x0.0000000000001p-1022)) + +;; Test the least positive value with a finite reciprocal. +(assert_return (invoke "f32.div" (f32.const 1.0) (f32.const 0x1p-128)) (f32.const inf)) +(assert_return (invoke "f32.div" (f32.const 1.0) (f32.const 0x1.000008p-128)) (f32.const 0x1.fffffp+127)) +(assert_return (invoke "f64.div" (f64.const 1.0) (f64.const 0x0.4p-1022)) (f64.const inf)) +(assert_return (invoke "f64.div" (f64.const 1.0) (f64.const 0x0.4000000000001p-1022)) (f64.const 0x1.ffffffffffff8p+1023)) + +;; Test the least positive value that has a subnormal reciprocal. +(assert_return (invoke "f32.div" (f32.const 1.0) (f32.const 0x1.000002p+126)) (f32.const 0x1.fffffcp-127)) +(assert_return (invoke "f32.div" (f32.const 1.0) (f32.const 0x1p+126)) (f32.const 0x1p-126)) +(assert_return (invoke "f64.div" (f64.const 1.0) (f64.const 0x1.0000000000001p+1022)) (f64.const 0x0.fffffffffffffp-1022)) +(assert_return (invoke "f64.div" (f64.const 1.0) (f64.const 0x1p+1022)) (f64.const 0x1p-1022)) + +;; Test that the last binary digit of 1.0/3.0 is even in f32, +;; https://en.wikipedia.org/wiki/Single-precision_floating-point_format#Single-precision_examples +;; +;; and odd in f64, +;; https://en.wikipedia.org/wiki/Double-precision_floating-point_format#Double-precision_examples +;; +;; and that 1.0/3.0, 3.0/9.0, and 9.0/27.0 all agree. +;; http://www.netlib.org/paranoia +(assert_return (invoke "f32.div" (f32.const 0x1p+0) (f32.const 0x1.8p+1)) (f32.const 0x1.555556p-2)) +(assert_return (invoke "f32.div" (f32.const 0x3p+0) (f32.const 0x1.2p+3)) (f32.const 0x1.555556p-2)) +(assert_return (invoke "f32.div" (f32.const 0x1.2p+3) (f32.const 0x1.bp+4)) (f32.const 0x1.555556p-2)) +(assert_return (invoke "f64.div" (f64.const 0x1p+0) (f64.const 0x1.8p+1)) (f64.const 0x1.5555555555555p-2)) +(assert_return (invoke "f64.div" (f64.const 0x3p+0) (f64.const 0x1.2p+3)) (f64.const 0x1.5555555555555p-2)) +(assert_return (invoke "f64.div" (f64.const 0x1.2p+3) (f64.const 0x1.bp+4)) (f64.const 0x1.5555555555555p-2)) + +;; Test division of numbers very close to 1. +(assert_return (invoke "f32.div" (f32.const 0x1.000002p+0) (f32.const 0x1.fffffep-1)) (f32.const 0x1.000004p+0)) +(assert_return (invoke "f32.div" (f32.const 0x1.fffffep-1) (f32.const 0x1.000002p+0)) (f32.const 0x1.fffffap-1)) +(assert_return (invoke "f32.div" (f32.const 0x1.0p+0) (f32.const 0x1.fffffep-1)) (f32.const 0x1.000002p+0)) +(assert_return (invoke "f32.div" (f32.const 0x1.0p+0) (f32.const 0x1.000002p+0)) (f32.const 0x1.fffffcp-1)) +(assert_return (invoke "f64.div" (f64.const 0x1.0000000000001p+0) (f64.const 0x1.fffffffffffffp-1)) (f64.const 0x1.0000000000002p+0)) +(assert_return (invoke "f64.div" (f64.const 0x1.fffffffffffffp-1) (f64.const 0x1.0000000000001p+0)) (f64.const 0x1.ffffffffffffdp-1)) +(assert_return (invoke "f64.div" (f64.const 0x1.0p+0) (f64.const 0x1.fffffffffffffp-1)) (f64.const 0x1.0000000000001p+0)) +(assert_return (invoke "f64.div" (f64.const 0x1.0p+0) (f64.const 0x1.0000000000001p+0)) (f64.const 0x1.ffffffffffffep-1)) + +;; Test for bugs found in an early RISC-V implementation. +;; https://github.com/riscv/riscv-tests/pull/8 +(assert_return (invoke "f32.sqrt" (f32.const 0x1.56p+7)) (f32.const 0x1.a2744cp+3)) +(assert_return (invoke "f32.sqrt" (f32.const 0x1.594dfcp-23)) (f32.const 0x1.a4789cp-12)) +(assert_return (invoke "f64.sqrt" (f64.const 0x1.56p+7)) (f64.const 0x1.a2744ce9674f5p+3)) +(assert_return (invoke "f64.sqrt" (f64.const 0x1.594dfc70aa105p-23)) (f64.const 0x1.a4789c0e37f99p-12)) + +;; Computations that round differently on x87. +(assert_return (invoke "f64.sqrt" (f64.const 0x1.0263fcc94f259p-164)) (f64.const 0x1.0131485de579fp-82)) +(assert_return (invoke "f64.sqrt" (f64.const 0x1.352dfa278c43dp+338)) (f64.const 0x1.195607dac5417p+169)) +(assert_return (invoke "f64.sqrt" (f64.const 0x1.b15daa23924fap+402)) (f64.const 0x1.4d143db561493p+201)) +(assert_return (invoke "f64.sqrt" (f64.const 0x1.518c8e68cb753p-37)) (f64.const 0x1.9fb8ef1ad5bfdp-19)) +(assert_return (invoke "f64.sqrt" (f64.const 0x1.86d8b6518078ep-370)) (f64.const 0x1.3c5142a48fcadp-185)) + +;; Test another sqrt case on x87. +;; https://gcc.gnu.org/bugzilla/show_bug.cgi?id=52593 +(assert_return (invoke "f64.sqrt" (f64.const 0x1.fffffffffffffp-1)) (f64.const 0x1.fffffffffffffp-1)) + +;; Computations that round differently in round-upward mode. +(assert_return (invoke "f32.sqrt" (f32.const 0x1.098064p-3)) (f32.const 0x1.70b23p-2)) +(assert_return (invoke "f32.sqrt" (f32.const 0x1.d9befp+100)) (f32.const 0x1.5c4052p+50)) +(assert_return (invoke "f32.sqrt" (f32.const 0x1.42b5b6p-4)) (f32.const 0x1.1f6d0ep-2)) +(assert_return (invoke "f32.sqrt" (f32.const 0x1.3684dp-71)) (f32.const 0x1.8ebae2p-36)) +(assert_return (invoke "f32.sqrt" (f32.const 0x1.d8bc4ep-11)) (f32.const 0x1.ebf9eap-6)) +(assert_return (invoke "f64.sqrt" (f64.const 0x1.5c39f220d5704p-924)) (f64.const 0x1.2a92bc24ceae9p-462)) +(assert_return (invoke "f64.sqrt" (f64.const 0x1.53521a635745cp+727)) (f64.const 0x1.a0cfdc4ef8ff1p+363)) +(assert_return (invoke "f64.sqrt" (f64.const 0x1.dfd5bbc9f4678p+385)) (f64.const 0x1.efa817117c94cp+192)) +(assert_return (invoke "f64.sqrt" (f64.const 0x1.33f9640811cd4p+105)) (f64.const 0x1.8d17c9243baa3p+52)) +(assert_return (invoke "f64.sqrt" (f64.const 0x1.6c0ef0267ff45p+999)) (f64.const 0x1.afbcfae3f2b4p+499)) + +;; Computations that round differently in round-downward mode. +(assert_return (invoke "f32.sqrt" (f32.const 0x1.26a62ep+27)) (f32.const 0x1.84685p+13)) +(assert_return (invoke "f32.sqrt" (f32.const 0x1.166002p-113)) (f32.const 0x1.798762p-57)) +(assert_return (invoke "f32.sqrt" (f32.const 0x1.3dfb5p-15)) (f32.const 0x1.937e38p-8)) +(assert_return (invoke "f32.sqrt" (f32.const 0x1.30eb2cp-120)) (f32.const 0x1.176406p-60)) +(assert_return (invoke "f32.sqrt" (f32.const 0x1.cb705cp-123)) (f32.const 0x1.e5020ap-62)) +(assert_return (invoke "f64.sqrt" (f64.const 0x1.edae8aea0543p+695)) (f64.const 0x1.f6c1ea4fc8dd2p+347)) +(assert_return (invoke "f64.sqrt" (f64.const 0x1.f7ee4bda5c9c3p-763)) (f64.const 0x1.fbf30bdaf11c5p-382)) +(assert_return (invoke "f64.sqrt" (f64.const 0x1.a48f348266ad1p-30)) (f64.const 0x1.481ee7540baf7p-15)) +(assert_return (invoke "f64.sqrt" (f64.const 0x1.feb5a1ce3ed9cp-242)) (f64.const 0x1.6995060c20d46p-121)) +(assert_return (invoke "f64.sqrt" (f64.const 0x1.957d9796e3834p+930)) (f64.const 0x1.42305213157bap+465)) + +;; Computations that round differently in round-toward-zero mode. +(assert_return (invoke "f32.sqrt" (f32.const 0x1.65787cp+118)) (f32.const 0x1.2e82a4p+59)) +(assert_return (invoke "f32.sqrt" (f32.const 0x1.736044p+15)) (f32.const 0x1.b40e4p+7)) +(assert_return (invoke "f32.sqrt" (f32.const 0x1.a00edp-1)) (f32.const 0x1.cd8aecp-1)) +(assert_return (invoke "f32.sqrt" (f32.const 0x1.7a4c8p-87)) (f32.const 0x1.b819e4p-44)) +(assert_return (invoke "f32.sqrt" (f32.const 0x1.5d24d4p-94)) (f32.const 0x1.2af75ep-47)) +(assert_return (invoke "f64.sqrt" (f64.const 0x1.a008948ead274p+738)) (f64.const 0x1.4659b37c39b19p+369)) +(assert_return (invoke "f64.sqrt" (f64.const 0x1.70f6199ed21f5p-381)) (f64.const 0x1.b2a2bddf3300dp-191)) +(assert_return (invoke "f64.sqrt" (f64.const 0x1.35c1d49f2a352p+965)) (f64.const 0x1.8e3d9f01a9716p+482)) +(assert_return (invoke "f64.sqrt" (f64.const 0x1.3fbdcfb2b2a15p-45)) (f64.const 0x1.949ba4feca42ap-23)) +(assert_return (invoke "f64.sqrt" (f64.const 0x1.c201b94757145p-492)) (f64.const 0x1.5369ee6bf2967p-246)) + +;; Computations that round differently when computed via f32. +(assert_return (invoke "f64.sqrt" (f64.const -0x1.360e8d0032adp-963)) (f64.const nan:canonical)) +(assert_return (invoke "f64.sqrt" (f64.const 0x1.d9a6f5eef0503p+103)) (f64.const 0x1.ec73f56c166f6p+51)) +(assert_return (invoke "f64.sqrt" (f64.const 0x1.aa051a5c4ec27p-760)) (f64.const 0x1.4a3e771ff5149p-380)) +(assert_return (invoke "f64.sqrt" (f64.const 0x1.e5522a741babep-276)) (f64.const 0x1.607ae2b6feb7dp-138)) +(assert_return (invoke "f64.sqrt" (f64.const 0x1.4832badc0c061p+567)) (f64.const 0x1.99ec7934139b2p+283)) + +;; Test the least value with a sqrt that rounds to one. +(assert_return (invoke "f32.sqrt" (f32.const 0x1.000002p+0)) (f32.const 0x1p+0)) +(assert_return (invoke "f32.sqrt" (f32.const 0x1.000004p+0)) (f32.const 0x1.000002p+0)) +(assert_return (invoke "f64.sqrt" (f64.const 0x1.0000000000001p+0)) (f64.const 0x1p+0)) +(assert_return (invoke "f64.sqrt" (f64.const 0x1.0000000000002p+0)) (f64.const 0x1.0000000000001p+0)) + +;; Test the greatest value less than one for which sqrt is not an identity. +(assert_return (invoke "f32.sqrt" (f32.const 0x1.fffffcp-1)) (f32.const 0x1.fffffep-1)) +(assert_return (invoke "f32.sqrt" (f32.const 0x1.fffffap-1)) (f32.const 0x1.fffffcp-1)) +(assert_return (invoke "f64.sqrt" (f64.const 0x1.ffffffffffffep-1)) (f64.const 0x1.fffffffffffffp-1)) +(assert_return (invoke "f64.sqrt" (f64.const 0x1.ffffffffffffdp-1)) (f64.const 0x1.ffffffffffffep-1)) + +;; Test that the bitwise floating point operators are bitwise on NaN. + +(assert_return (invoke "f32.abs" (f32.const nan:0x0f1e2)) (f32.const nan:0x0f1e2)) +(assert_return (invoke "f32.abs" (f32.const -nan:0x0f1e2)) (f32.const nan:0x0f1e2)) +(assert_return (invoke "f64.abs" (f64.const nan:0x0f1e27a6b)) (f64.const nan:0x0f1e27a6b)) +(assert_return (invoke "f64.abs" (f64.const -nan:0x0f1e27a6b)) (f64.const nan:0x0f1e27a6b)) + +(assert_return (invoke "f32.neg" (f32.const nan:0x0f1e2)) (f32.const -nan:0x0f1e2)) +(assert_return (invoke "f32.neg" (f32.const -nan:0x0f1e2)) (f32.const nan:0x0f1e2)) +(assert_return (invoke "f64.neg" (f64.const nan:0x0f1e27a6b)) (f64.const -nan:0x0f1e27a6b)) +(assert_return (invoke "f64.neg" (f64.const -nan:0x0f1e27a6b)) (f64.const nan:0x0f1e27a6b)) + +(assert_return (invoke "f32.copysign" (f32.const nan:0x0f1e2) (f32.const nan)) (f32.const nan:0x0f1e2)) +(assert_return (invoke "f32.copysign" (f32.const nan:0x0f1e2) (f32.const -nan)) (f32.const -nan:0x0f1e2)) +(assert_return (invoke "f32.copysign" (f32.const -nan:0x0f1e2) (f32.const nan)) (f32.const nan:0x0f1e2)) +(assert_return (invoke "f32.copysign" (f32.const -nan:0x0f1e2) (f32.const -nan)) (f32.const -nan:0x0f1e2)) +(assert_return (invoke "f64.copysign" (f64.const nan:0x0f1e27a6b) (f64.const nan)) (f64.const nan:0x0f1e27a6b)) +(assert_return (invoke "f64.copysign" (f64.const nan:0x0f1e27a6b) (f64.const -nan)) (f64.const -nan:0x0f1e27a6b)) +(assert_return (invoke "f64.copysign" (f64.const -nan:0x0f1e27a6b) (f64.const nan)) (f64.const nan:0x0f1e27a6b)) +(assert_return (invoke "f64.copysign" (f64.const -nan:0x0f1e27a6b) (f64.const -nan)) (f64.const -nan:0x0f1e27a6b)) + +;; Test values close to 1.0. +(assert_return (invoke "f32.ceil" (f32.const 0x1.fffffep-1)) (f32.const 1.0)) +(assert_return (invoke "f32.ceil" (f32.const 0x1.000002p+0)) (f32.const 2.0)) +(assert_return (invoke "f64.ceil" (f64.const 0x1.fffffffffffffp-1)) (f64.const 1.0)) +(assert_return (invoke "f64.ceil" (f64.const 0x1.0000000000001p+0)) (f64.const 2.0)) + +;; Test the maximum and minimum value for which ceil is not an identity operator. +(assert_return (invoke "f32.ceil" (f32.const 0x1.fffffep+22)) (f32.const 0x1p+23)) +(assert_return (invoke "f32.ceil" (f32.const -0x1.fffffep+22)) (f32.const -0x1.fffffcp+22)) +(assert_return (invoke "f64.ceil" (f64.const 0x1.fffffffffffffp+51)) (f64.const 0x1p+52)) +(assert_return (invoke "f64.ceil" (f64.const -0x1.fffffffffffffp+51)) (f64.const -0x1.ffffffffffffep+51)) + +;; Test that implementations don't do the x+0x1p52-0x1p52 trick outside the +;; range where it's safe. +(assert_return (invoke "f32.ceil" (f32.const 0x1.fffffep+23)) (f32.const 0x1.fffffep+23)) +(assert_return (invoke "f32.ceil" (f32.const -0x1.fffffep+23)) (f32.const -0x1.fffffep+23)) +(assert_return (invoke "f64.ceil" (f64.const 0x1.fffffffffffffp+52)) (f64.const 0x1.fffffffffffffp+52)) +(assert_return (invoke "f64.ceil" (f64.const -0x1.fffffffffffffp+52)) (f64.const -0x1.fffffffffffffp+52)) + +;; Test values close to -1.0. +(assert_return (invoke "f32.floor" (f32.const -0x1.fffffep-1)) (f32.const -1.0)) +(assert_return (invoke "f32.floor" (f32.const -0x1.000002p+0)) (f32.const -2.0)) +(assert_return (invoke "f64.floor" (f64.const -0x1.fffffffffffffp-1)) (f64.const -1.0)) +(assert_return (invoke "f64.floor" (f64.const -0x1.0000000000001p+0)) (f64.const -2.0)) + +;; Test the maximum and minimum value for which floor is not an identity operator. +(assert_return (invoke "f32.floor" (f32.const -0x1.fffffep+22)) (f32.const -0x1p+23)) +(assert_return (invoke "f32.floor" (f32.const 0x1.fffffep+22)) (f32.const 0x1.fffffcp+22)) +(assert_return (invoke "f64.floor" (f64.const -0x1.fffffffffffffp+51)) (f64.const -0x1p+52)) +(assert_return (invoke "f64.floor" (f64.const 0x1.fffffffffffffp+51)) (f64.const 0x1.ffffffffffffep+51)) + +;; Test that floor isn't implemented as XMVectorFloor. +;; http://dss.stephanierct.com/DevBlog/?p=8#comment-4 +(assert_return (invoke "f32.floor" (f32.const 88607.0)) (f32.const 88607.0)) +(assert_return (invoke "f64.floor" (f64.const 88607.0)) (f64.const 88607.0)) + +;; Test the maximum and minimum value for which trunc is not an identity operator. +(assert_return (invoke "f32.trunc" (f32.const -0x1.fffffep+22)) (f32.const -0x1.fffffcp+22)) +(assert_return (invoke "f32.trunc" (f32.const 0x1.fffffep+22)) (f32.const 0x1.fffffcp+22)) +(assert_return (invoke "f64.trunc" (f64.const -0x1.fffffffffffffp+51)) (f64.const -0x1.ffffffffffffep+51)) +(assert_return (invoke "f64.trunc" (f64.const 0x1.fffffffffffffp+51)) (f64.const 0x1.ffffffffffffep+51)) + +;; Test that nearest isn't implemented naively. +;; http://blog.frama-c.com/index.php?post/2013/05/02/nearbyintf1 +;; http://blog.frama-c.com/index.php?post/2013/05/04/nearbyintf3 +(assert_return (invoke "f32.nearest" (f32.const 0x1.000002p+23)) (f32.const 0x1.000002p+23)) +(assert_return (invoke "f32.nearest" (f32.const 0x1.000004p+23)) (f32.const 0x1.000004p+23)) +(assert_return (invoke "f32.nearest" (f32.const 0x1.fffffep-2)) (f32.const 0.0)) +(assert_return (invoke "f32.nearest" (f32.const 0x1.fffffep+47)) (f32.const 0x1.fffffep+47)) +(assert_return (invoke "f64.nearest" (f64.const 0x1.0000000000001p+52)) (f64.const 0x1.0000000000001p+52)) +(assert_return (invoke "f64.nearest" (f64.const 0x1.0000000000002p+52)) (f64.const 0x1.0000000000002p+52)) +(assert_return (invoke "f64.nearest" (f64.const 0x1.fffffffffffffp-2)) (f64.const 0.0)) +(assert_return (invoke "f64.nearest" (f64.const 0x1.fffffffffffffp+105)) (f64.const 0x1.fffffffffffffp+105)) + +;; Nearest should not round halfway cases away from zero (as C's round(3) does) +;; or up (as JS's Math.round does). +(assert_return (invoke "f32.nearest" (f32.const 4.5)) (f32.const 4.0)) +(assert_return (invoke "f32.nearest" (f32.const -4.5)) (f32.const -4.0)) +(assert_return (invoke "f32.nearest" (f32.const -3.5)) (f32.const -4.0)) +(assert_return (invoke "f64.nearest" (f64.const 4.5)) (f64.const 4.0)) +(assert_return (invoke "f64.nearest" (f64.const -4.5)) (f64.const -4.0)) +(assert_return (invoke "f64.nearest" (f64.const -3.5)) (f64.const -4.0)) + +;; Test the maximum and minimum value for which nearest is not an identity operator. +(assert_return (invoke "f32.nearest" (f32.const -0x1.fffffep+22)) (f32.const -0x1p+23)) +(assert_return (invoke "f32.nearest" (f32.const 0x1.fffffep+22)) (f32.const 0x1p+23)) +(assert_return (invoke "f64.nearest" (f64.const -0x1.fffffffffffffp+51)) (f64.const -0x1p+52)) +(assert_return (invoke "f64.nearest" (f64.const 0x1.fffffffffffffp+51)) (f64.const 0x1p+52)) diff --git a/runtime/near-vm/tests/wast/spec/forward.wast b/runtime/near-vm/tests/wast/spec/forward.wast new file mode 100644 index 00000000000..7bb3770d7d5 --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/forward.wast @@ -0,0 +1,20 @@ +(module + (func $even (export "even") (param $n i32) (result i32) + (if (result i32) (i32.eq (local.get $n) (i32.const 0)) + (then (i32.const 1)) + (else (call $odd (i32.sub (local.get $n) (i32.const 1)))) + ) + ) + + (func $odd (export "odd") (param $n i32) (result i32) + (if (result i32) (i32.eq (local.get $n) (i32.const 0)) + (then (i32.const 0)) + (else (call $even (i32.sub (local.get $n) (i32.const 1)))) + ) + ) +) + +(assert_return (invoke "even" (i32.const 13)) (i32.const 0)) +(assert_return (invoke "even" (i32.const 20)) (i32.const 1)) +(assert_return (invoke "odd" (i32.const 13)) (i32.const 1)) +(assert_return (invoke "odd" (i32.const 20)) (i32.const 0)) diff --git a/runtime/near-vm/tests/wast/spec/func.wast b/runtime/near-vm/tests/wast/spec/func.wast new file mode 100644 index 00000000000..7189257c993 --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/func.wast @@ -0,0 +1,961 @@ +;; Test `func` declarations, i.e. functions + +(module + ;; Auxiliary definition + (type $sig (func)) + (func $dummy) + + ;; Syntax + + (func) + (func (export "f")) + (func $f) + (func $h (export "g")) + + (func (local)) + (func (local) (local)) + (func (local i32)) + (func (local $x i32)) + (func (local i32 f64 i64)) + (func (local i32) (local f64)) + (func (local i32 f32) (local $x i64) (local) (local i32 f64)) + + (func (param)) + (func (param) (param)) + (func (param i32)) + (func (param $x i32)) + (func (param i32 f64 i64)) + (func (param i32) (param f64)) + (func (param i32 f32) (param $x i64) (param) (param i32 f64)) + + (func (result)) + (func (result) (result)) + (func (result i32) (unreachable)) + (func (result i32 f64 f32) (unreachable)) + (func (result i32) (result f64) (unreachable)) + (func (result i32 f32) (result i64) (result) (result i32 f64) (unreachable)) + + (type $sig-1 (func)) + (type $sig-2 (func (result i32))) + (type $sig-3 (func (param $x i32))) + (type $sig-4 (func (param i32 f64 i32) (result i32))) + + (func (export "type-use-1") (type $sig-1)) + (func (export "type-use-2") (type $sig-2) (i32.const 0)) + (func (export "type-use-3") (type $sig-3)) + (func (export "type-use-4") (type $sig-4) (i32.const 0)) + (func (export "type-use-5") (type $sig-2) (result i32) (i32.const 0)) + (func (export "type-use-6") (type $sig-3) (param i32)) + (func (export "type-use-7") + (type $sig-4) (param i32) (param f64 i32) (result i32) (i32.const 0) + ) + + (func (type $sig)) + (func (type $forward)) ;; forward reference + + (func $complex + (param i32 f32) (param $x i64) (param) (param i32) + (result) (result i32) (result) (result i64 i32) + (local f32) (local $y i32) (local i64 i32) (local) (local f64 i32) + (unreachable) (unreachable) + ) + (func $complex-sig + (type $sig) + (local f32) (local $y i32) (local i64 i32) (local) (local f64 i32) + (unreachable) (unreachable) + ) + + (type $forward (func)) + + ;; Typing of locals + + (func (export "local-first-i32") (result i32) (local i32 i32) (local.get 0)) + (func (export "local-first-i64") (result i64) (local i64 i64) (local.get 0)) + (func (export "local-first-f32") (result f32) (local f32 f32) (local.get 0)) + (func (export "local-first-f64") (result f64) (local f64 f64) (local.get 0)) + (func (export "local-second-i32") (result i32) (local i32 i32) (local.get 1)) + (func (export "local-second-i64") (result i64) (local i64 i64) (local.get 1)) + (func (export "local-second-f32") (result f32) (local f32 f32) (local.get 1)) + (func (export "local-second-f64") (result f64) (local f64 f64) (local.get 1)) + (func (export "local-mixed") (result f64) + (local f32) (local $x i32) (local i64 i32) (local) (local f64 i32) + (drop (f32.neg (local.get 0))) + (drop (i32.eqz (local.get 1))) + (drop (i64.eqz (local.get 2))) + (drop (i32.eqz (local.get 3))) + (drop (f64.neg (local.get 4))) + (drop (i32.eqz (local.get 5))) + (local.get 4) + ) + + ;; Typing of parameters + + (func (export "param-first-i32") (param i32 i32) (result i32) (local.get 0)) + (func (export "param-first-i64") (param i64 i64) (result i64) (local.get 0)) + (func (export "param-first-f32") (param f32 f32) (result f32) (local.get 0)) + (func (export "param-first-f64") (param f64 f64) (result f64) (local.get 0)) + (func (export "param-second-i32") (param i32 i32) (result i32) (local.get 1)) + (func (export "param-second-i64") (param i64 i64) (result i64) (local.get 1)) + (func (export "param-second-f32") (param f32 f32) (result f32) (local.get 1)) + (func (export "param-second-f64") (param f64 f64) (result f64) (local.get 1)) + (func (export "param-mixed") (param f32 i32) (param) (param $x i64) (param i32 f64 i32) + (result f64) + (drop (f32.neg (local.get 0))) + (drop (i32.eqz (local.get 1))) + (drop (i64.eqz (local.get 2))) + (drop (i32.eqz (local.get 3))) + (drop (f64.neg (local.get 4))) + (drop (i32.eqz (local.get 5))) + (local.get 4) + ) + + ;; Typing of results + + (func (export "empty")) + (func (export "value-void") (call $dummy)) + (func (export "value-i32") (result i32) (i32.const 77)) + (func (export "value-i64") (result i64) (i64.const 7777)) + (func (export "value-f32") (result f32) (f32.const 77.7)) + (func (export "value-f64") (result f64) (f64.const 77.77)) + (func (export "value-i32-f64") (result i32 f64) (i32.const 77) (f64.const 7)) + (func (export "value-i32-i32-i32") (result i32 i32 i32) + (i32.const 1) (i32.const 2) (i32.const 3) + ) + (func (export "value-block-void") (block (call $dummy) (call $dummy))) + (func (export "value-block-i32") (result i32) + (block (result i32) (call $dummy) (i32.const 77)) + ) + (func (export "value-block-i32-i64") (result i32 i64) + (block (result i32 i64) (call $dummy) (i32.const 1) (i64.const 2)) + ) + + (func (export "return-empty") (return)) + (func (export "return-i32") (result i32) (return (i32.const 78))) + (func (export "return-i64") (result i64) (return (i64.const 7878))) + (func (export "return-f32") (result f32) (return (f32.const 78.7))) + (func (export "return-f64") (result f64) (return (f64.const 78.78))) + (func (export "return-i32-f64") (result i32 f64) + (return (i32.const 78) (f64.const 78.78)) + ) + (func (export "return-i32-i32-i32") (result i32 i32 i32) + (return (i32.const 1) (i32.const 2) (i32.const 3)) + ) + (func (export "return-block-i32") (result i32) + (return (block (result i32) (call $dummy) (i32.const 77))) + ) + (func (export "return-block-i32-i64") (result i32 i64) + (return (block (result i32 i64) (call $dummy) (i32.const 1) (i64.const 2))) + ) + + (func (export "break-empty") (br 0)) + (func (export "break-i32") (result i32) (br 0 (i32.const 79))) + (func (export "break-i64") (result i64) (br 0 (i64.const 7979))) + (func (export "break-f32") (result f32) (br 0 (f32.const 79.9))) + (func (export "break-f64") (result f64) (br 0 (f64.const 79.79))) + (func (export "break-i32-f64") (result i32 f64) + (br 0 (i32.const 79) (f64.const 79.79)) + ) + (func (export "break-i32-i32-i32") (result i32 i32 i32) + (br 0 (i32.const 1) (i32.const 2) (i32.const 3)) + ) + (func (export "break-block-i32") (result i32) + (br 0 (block (result i32) (call $dummy) (i32.const 77))) + ) + (func (export "break-block-i32-i64") (result i32 i64) + (br 0 (block (result i32 i64) (call $dummy) (i32.const 1) (i64.const 2))) + ) + + (func (export "break-br_if-empty") (param i32) + (br_if 0 (local.get 0)) + ) + (func (export "break-br_if-num") (param i32) (result i32) + (drop (br_if 0 (i32.const 50) (local.get 0))) (i32.const 51) + ) + (func (export "break-br_if-num-num") (param i32) (result i32 i64) + (drop (drop (br_if 0 (i32.const 50) (i64.const 51) (local.get 0)))) + (i32.const 51) (i64.const 52) + ) + + (func (export "break-br_table-empty") (param i32) + (br_table 0 0 0 (local.get 0)) + ) + (func (export "break-br_table-num") (param i32) (result i32) + (br_table 0 0 (i32.const 50) (local.get 0)) (i32.const 51) + ) + (func (export "break-br_table-num-num") (param i32) (result i32 i64) + (br_table 0 0 (i32.const 50) (i64.const 51) (local.get 0)) + (i32.const 51) (i64.const 52) + ) + (func (export "break-br_table-nested-empty") (param i32) + (block (br_table 0 1 0 (local.get 0))) + ) + (func (export "break-br_table-nested-num") (param i32) (result i32) + (i32.add + (block (result i32) + (br_table 0 1 0 (i32.const 50) (local.get 0)) (i32.const 51) + ) + (i32.const 2) + ) + ) + (func (export "break-br_table-nested-num-num") (param i32) (result i32 i32) + (i32.add + (block (result i32 i32) + (br_table 0 1 0 (i32.const 50) (i32.const 51) (local.get 0)) + (i32.const 51) (i32.const -3) + ) + ) + (i32.const 52) + ) + + ;; Large signatures + + (func (export "large-sig") + (param i32 i64 f32 f32 i32 f64 f32 i32 i32 i32 f32 f64 f64 f64 i32 i32 f32) + (result f64 f32 i32 i32 i32 i64 f32 i32 i32 f32 f64 f64 i32 f32 i32 f64) + (local.get 5) + (local.get 2) + (local.get 0) + (local.get 8) + (local.get 7) + (local.get 1) + (local.get 3) + (local.get 9) + (local.get 4) + (local.get 6) + (local.get 13) + (local.get 11) + (local.get 15) + (local.get 16) + (local.get 14) + (local.get 12) + ) + + ;; Default initialization of locals + + (func (export "init-local-i32") (result i32) (local i32) (local.get 0)) + (func (export "init-local-i64") (result i64) (local i64) (local.get 0)) + (func (export "init-local-f32") (result f32) (local f32) (local.get 0)) + (func (export "init-local-f64") (result f64) (local f64) (local.get 0)) +) + +(assert_return (invoke "type-use-1")) +(assert_return (invoke "type-use-2") (i32.const 0)) +(assert_return (invoke "type-use-3" (i32.const 1))) +(assert_return + (invoke "type-use-4" (i32.const 1) (f64.const 1) (i32.const 1)) + (i32.const 0) +) +(assert_return (invoke "type-use-5") (i32.const 0)) +(assert_return (invoke "type-use-6" (i32.const 1))) +(assert_return + (invoke "type-use-7" (i32.const 1) (f64.const 1) (i32.const 1)) + (i32.const 0) +) + +(assert_return (invoke "local-first-i32") (i32.const 0)) +(assert_return (invoke "local-first-i64") (i64.const 0)) +(assert_return (invoke "local-first-f32") (f32.const 0)) +(assert_return (invoke "local-first-f64") (f64.const 0)) +(assert_return (invoke "local-second-i32") (i32.const 0)) +(assert_return (invoke "local-second-i64") (i64.const 0)) +(assert_return (invoke "local-second-f32") (f32.const 0)) +(assert_return (invoke "local-second-f64") (f64.const 0)) +(assert_return (invoke "local-mixed") (f64.const 0)) + +(assert_return + (invoke "param-first-i32" (i32.const 2) (i32.const 3)) (i32.const 2) +) +(assert_return + (invoke "param-first-i64" (i64.const 2) (i64.const 3)) (i64.const 2) +) +(assert_return + (invoke "param-first-f32" (f32.const 2) (f32.const 3)) (f32.const 2) +) +(assert_return + (invoke "param-first-f64" (f64.const 2) (f64.const 3)) (f64.const 2) +) +(assert_return + (invoke "param-second-i32" (i32.const 2) (i32.const 3)) (i32.const 3) +) +(assert_return + (invoke "param-second-i64" (i64.const 2) (i64.const 3)) (i64.const 3) +) +(assert_return + (invoke "param-second-f32" (f32.const 2) (f32.const 3)) (f32.const 3) +) +(assert_return + (invoke "param-second-f64" (f64.const 2) (f64.const 3)) (f64.const 3) +) + +(assert_return + (invoke "param-mixed" + (f32.const 1) (i32.const 2) (i64.const 3) + (i32.const 4) (f64.const 5.5) (i32.const 6) + ) + (f64.const 5.5) +) + +(assert_return (invoke "empty")) +(assert_return (invoke "value-void")) +(assert_return (invoke "value-i32") (i32.const 77)) +(assert_return (invoke "value-i64") (i64.const 7777)) +(assert_return (invoke "value-f32") (f32.const 77.7)) +(assert_return (invoke "value-f64") (f64.const 77.77)) +(assert_return (invoke "value-i32-f64") (i32.const 77) (f64.const 7)) +(assert_return (invoke "value-i32-i32-i32") + (i32.const 1) (i32.const 2) (i32.const 3) +) +(assert_return (invoke "value-block-void")) +(assert_return (invoke "value-block-i32") (i32.const 77)) +(assert_return (invoke "value-block-i32-i64") (i32.const 1) (i64.const 2)) + +(assert_return (invoke "return-empty")) +(assert_return (invoke "return-i32") (i32.const 78)) +(assert_return (invoke "return-i64") (i64.const 7878)) +(assert_return (invoke "return-f32") (f32.const 78.7)) +(assert_return (invoke "return-f64") (f64.const 78.78)) +(assert_return (invoke "return-i32-f64") (i32.const 78) (f64.const 78.78)) +(assert_return (invoke "return-i32-i32-i32") + (i32.const 1) (i32.const 2) (i32.const 3) +) +(assert_return (invoke "return-block-i32") (i32.const 77)) +(assert_return (invoke "return-block-i32-i64") (i32.const 1) (i64.const 2)) + +(assert_return (invoke "break-empty")) +(assert_return (invoke "break-i32") (i32.const 79)) +(assert_return (invoke "break-i64") (i64.const 7979)) +(assert_return (invoke "break-f32") (f32.const 79.9)) +(assert_return (invoke "break-f64") (f64.const 79.79)) +(assert_return (invoke "break-i32-f64") (i32.const 79) (f64.const 79.79)) +(assert_return (invoke "break-i32-i32-i32") + (i32.const 1) (i32.const 2) (i32.const 3) +) +(assert_return (invoke "break-block-i32") (i32.const 77)) +(assert_return (invoke "break-block-i32-i64") (i32.const 1) (i64.const 2)) + +(assert_return (invoke "break-br_if-empty" (i32.const 0))) +(assert_return (invoke "break-br_if-empty" (i32.const 2))) +(assert_return (invoke "break-br_if-num" (i32.const 0)) (i32.const 51)) +(assert_return (invoke "break-br_if-num" (i32.const 1)) (i32.const 50)) +(assert_return (invoke "break-br_if-num-num" (i32.const 0)) + (i32.const 51) (i64.const 52) +) +(assert_return (invoke "break-br_if-num-num" (i32.const 1)) + (i32.const 50) (i64.const 51) +) + +(assert_return (invoke "break-br_table-empty" (i32.const 0))) +(assert_return (invoke "break-br_table-empty" (i32.const 1))) +(assert_return (invoke "break-br_table-empty" (i32.const 5))) +(assert_return (invoke "break-br_table-empty" (i32.const -1))) +(assert_return (invoke "break-br_table-num" (i32.const 0)) (i32.const 50)) +(assert_return (invoke "break-br_table-num" (i32.const 1)) (i32.const 50)) +(assert_return (invoke "break-br_table-num" (i32.const 10)) (i32.const 50)) +(assert_return (invoke "break-br_table-num" (i32.const -100)) (i32.const 50)) +(assert_return (invoke "break-br_table-num-num" (i32.const 0)) + (i32.const 50) (i64.const 51) +) +(assert_return (invoke "break-br_table-num-num" (i32.const 1)) + (i32.const 50) (i64.const 51) +) +(assert_return (invoke "break-br_table-num-num" (i32.const 10)) + (i32.const 50) (i64.const 51) +) +(assert_return (invoke "break-br_table-num-num" (i32.const -100)) + (i32.const 50) (i64.const 51) +) +(assert_return (invoke "break-br_table-nested-empty" (i32.const 0))) +(assert_return (invoke "break-br_table-nested-empty" (i32.const 1))) +(assert_return (invoke "break-br_table-nested-empty" (i32.const 3))) +(assert_return (invoke "break-br_table-nested-empty" (i32.const -2))) +(assert_return + (invoke "break-br_table-nested-num" (i32.const 0)) (i32.const 52) +) +(assert_return + (invoke "break-br_table-nested-num" (i32.const 1)) (i32.const 50) +) +(assert_return + (invoke "break-br_table-nested-num" (i32.const 2)) (i32.const 52) +) +(assert_return + (invoke "break-br_table-nested-num" (i32.const -3)) (i32.const 52) +) +(assert_return + (invoke "break-br_table-nested-num-num" (i32.const 0)) + (i32.const 101) (i32.const 52) +) +(assert_return + (invoke "break-br_table-nested-num-num" (i32.const 1)) + (i32.const 50) (i32.const 51) +) +(assert_return + (invoke "break-br_table-nested-num-num" (i32.const 2)) + (i32.const 101) (i32.const 52) +) +(assert_return + (invoke "break-br_table-nested-num-num" (i32.const -3)) + (i32.const 101) (i32.const 52) +) + +(assert_return + (invoke "large-sig" + (i32.const 0) (i64.const 1) (f32.const 2) (f32.const 3) + (i32.const 4) (f64.const 5) (f32.const 6) (i32.const 7) + (i32.const 8) (i32.const 9) (f32.const 10) (f64.const 11) + (f64.const 12) (f64.const 13) (i32.const 14) (i32.const 15) + (f32.const 16) + ) + (f64.const 5) (f32.const 2) (i32.const 0) (i32.const 8) + (i32.const 7) (i64.const 1) (f32.const 3) (i32.const 9) + (i32.const 4) (f32.const 6) (f64.const 13) (f64.const 11) + (i32.const 15) (f32.const 16) (i32.const 14) (f64.const 12) +) + +(assert_return (invoke "init-local-i32") (i32.const 0)) +(assert_return (invoke "init-local-i64") (i64.const 0)) +(assert_return (invoke "init-local-f32") (f32.const 0)) +(assert_return (invoke "init-local-f64") (f64.const 0)) + + +;; Expansion of inline function types + +(module + (func $f (result f64) (f64.const 0)) ;; adds implicit type definition + (func $g (param i32)) ;; reuses explicit type definition + (type $t (func (param i32))) + + (func $i32->void (type 0)) ;; (param i32) + (func $void->f64 (type 1) (f64.const 0)) ;; (result f64) + (func $check + (call $i32->void (i32.const 0)) + (drop (call $void->f64)) + ) +) + +(assert_invalid + (module + (func $f (result f64) (f64.const 0)) ;; adds implicit type definition + (func $g (param i32)) ;; reuses explicit type definition + (func $h (result f64) (f64.const 1)) ;; reuses implicit type definition + (type $t (func (param i32))) + + (func (type 2)) ;; does not exist + ) + "unknown type" +) + +(assert_malformed + (module quote + "(func $f (result f64) (f64.const 0))" ;; adds implicit type definition + "(func $g (param i32))" ;; reuses explicit type definition + "(func $h (result f64) (f64.const 1))" ;; reuses implicit type definition + "(type $t (func (param i32)))" + + "(func (type 2) (param i32))" ;; does not exist + ) + "unknown type" +) + +(module + (type $proc (func (result i32))) + (type $sig (func (param i32) (result i32))) + + (func (export "f") (type $sig) + (local $var i32) + (local.get $var) + ) + + (func $g (type $sig) + (local $var i32) + (local.get $var) + ) + (func (export "g") (type $sig) + (call $g (local.get 0)) + ) + + (func (export "p") (type $proc) + (local $var i32) + (local.set 0 (i32.const 42)) + (local.get $var) + ) +) + +(assert_return (invoke "f" (i32.const 42)) (i32.const 0)) +(assert_return (invoke "g" (i32.const 42)) (i32.const 0)) +(assert_return (invoke "p") (i32.const 42)) + + +(module + (type $sig (func)) + + (func $empty-sig-1) ;; should be assigned type $sig + (func $complex-sig-1 (param f64 i64 f64 i64 f64 i64 f32 i32)) + (func $empty-sig-2) ;; should be assigned type $sig + (func $complex-sig-2 (param f64 i64 f64 i64 f64 i64 f32 i32)) + (func $complex-sig-3 (param f64 i64 f64 i64 f64 i64 f32 i32)) + (func $complex-sig-4 (param i64 i64 f64 i64 f64 i64 f32 i32)) + (func $complex-sig-5 (param i64 i64 f64 i64 f64 i64 f32 i32)) + + (type $empty-sig-duplicate (func)) + (type $complex-sig-duplicate (func (param i64 i64 f64 i64 f64 i64 f32 i32))) + (table funcref + (elem + $complex-sig-3 $empty-sig-2 $complex-sig-1 $complex-sig-3 $empty-sig-1 + $complex-sig-4 $complex-sig-5 + ) + ) + + (func (export "signature-explicit-reused") + (call_indirect (type $sig) (i32.const 1)) + (call_indirect (type $sig) (i32.const 4)) + ) + + (func (export "signature-implicit-reused") + ;; The implicit index 3 in this test depends on the function and + ;; type definitions, and may need adapting if they change. + (call_indirect (type 3) + (f64.const 0) (i64.const 0) (f64.const 0) (i64.const 0) + (f64.const 0) (i64.const 0) (f32.const 0) (i32.const 0) + (i32.const 0) + ) + (call_indirect (type 3) + (f64.const 0) (i64.const 0) (f64.const 0) (i64.const 0) + (f64.const 0) (i64.const 0) (f32.const 0) (i32.const 0) + (i32.const 2) + ) + (call_indirect (type 3) + (f64.const 0) (i64.const 0) (f64.const 0) (i64.const 0) + (f64.const 0) (i64.const 0) (f32.const 0) (i32.const 0) + (i32.const 3) + ) + ) + + (func (export "signature-explicit-duplicate") + (call_indirect (type $empty-sig-duplicate) (i32.const 1)) + ) + + (func (export "signature-implicit-duplicate") + (call_indirect (type $complex-sig-duplicate) + (i64.const 0) (i64.const 0) (f64.const 0) (i64.const 0) + (f64.const 0) (i64.const 0) (f32.const 0) (i32.const 0) + (i32.const 5) + ) + (call_indirect (type $complex-sig-duplicate) + (i64.const 0) (i64.const 0) (f64.const 0) (i64.const 0) + (f64.const 0) (i64.const 0) (f32.const 0) (i32.const 0) + (i32.const 6) + ) + ) +) + +(assert_return (invoke "signature-explicit-reused")) +(assert_return (invoke "signature-implicit-reused")) +(assert_return (invoke "signature-explicit-duplicate")) +(assert_return (invoke "signature-implicit-duplicate")) + + +;; Malformed type use + +(assert_malformed + (module quote + "(type $sig (func (param i32) (result i32)))" + "(func (type $sig) (result i32) (param i32) (i32.const 0))" + ) + "unexpected token" +) +(assert_malformed + (module quote + "(type $sig (func (param i32) (result i32)))" + "(func (param i32) (type $sig) (result i32) (i32.const 0))" + ) + "unexpected token" +) +(assert_malformed + (module quote + "(type $sig (func (param i32) (result i32)))" + "(func (param i32) (result i32) (type $sig) (i32.const 0))" + ) + "unexpected token" +) +(assert_malformed + (module quote + "(type $sig (func (param i32) (result i32)))" + "(func (result i32) (type $sig) (param i32) (i32.const 0))" + ) + "unexpected token" +) +(assert_malformed + (module quote + "(type $sig (func (param i32) (result i32)))" + "(func (result i32) (param i32) (type $sig) (i32.const 0))" + ) + "unexpected token" +) +(assert_malformed + (module quote + "(func (result i32) (param i32) (i32.const 0))" + ) + "unexpected token" +) + +(assert_malformed + (module quote + "(type $sig (func))" + "(func (type $sig) (result i32) (i32.const 0))" + ) + "inline function type" +) +(assert_malformed + (module quote + "(type $sig (func (param i32) (result i32)))" + "(func (type $sig) (result i32) (i32.const 0))" + ) + "inline function type" +) +(assert_malformed + (module quote + "(type $sig (func (param i32) (result i32)))" + "(func (type $sig) (param i32) (i32.const 0))" + ) + "inline function type" +) +(assert_malformed + (module quote + "(type $sig (func (param i32 i32) (result i32)))" + "(func (type $sig) (param i32) (result i32) (unreachable))" + ) + "inline function type" +) + + +;; Invalid typing of locals + +(assert_invalid + (module (func $type-local-num-vs-num (result i64) (local i32) (local.get 0))) + "type mismatch" +) +(assert_invalid + (module (func $type-local-num-vs-num (local f32) (i32.eqz (local.get 0)))) + "type mismatch" +) +(assert_invalid + (module (func $type-local-num-vs-num (local f64 i64) (f64.neg (local.get 1)))) + "type mismatch" +) + + +;; Invalid typing of 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" +) + + +;; Invalid typing of result + +(assert_invalid + (module (func $type-empty-i32 (result i32))) + "type mismatch" +) +(assert_invalid + (module (func $type-empty-i64 (result i64))) + "type mismatch" +) +(assert_invalid + (module (func $type-empty-f32 (result f32))) + "type mismatch" +) +(assert_invalid + (module (func $type-empty-f64 (result f64))) + "type mismatch" +) +(assert_invalid + (module (func $type-empty-f64-i32 (result f64 i32))) + "type mismatch" +) + +(assert_invalid + (module (func $type-value-void-vs-num (result i32) + (nop) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-value-void-vs-nums (result i32 i32) + (nop) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-value-num-vs-void + (i32.const 0) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-value-nums-vs-void + (i32.const 0) (i64.const 0) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-value-num-vs-num (result i32) + (f32.const 0) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-value-num-vs-nums (result f32 f32) + (f32.const 0) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-value-nums-vs-num (result f32) + (f32.const 0) (f32.const 0) + )) + "type mismatch" +) + +(assert_invalid + (module (func $type-return-last-empty-vs-num (result i32) + (return) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-return-last-empty-vs-nums (result i32 i32) + (return) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-return-last-void-vs-num (result i32) + (return (nop)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-return-last-void-vs-nums (result i32 i64) + (return (nop)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-return-last-num-vs-num (result i32) + (return (i64.const 0)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-return-last-num-vs-nums (result i64 i64) + (return (i64.const 0)) + )) + "type mismatch" +) + +(assert_invalid + (module (func $type-return-empty-vs-num (result i32) + (return) (i32.const 1) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-return-empty-vs-nums (result i32 i32) + (return) (i32.const 1) (i32.const 2) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-return-partial-vs-nums (result i32 i32) + (i32.const 1) (return) (i32.const 2) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-return-void-vs-num (result i32) + (return (nop)) (i32.const 1) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-return-void-vs-nums (result i32 i32) + (return (nop)) (i32.const 1) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-return-num-vs-num (result i32) + (return (i64.const 1)) (i32.const 1) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-return-num-vs-nums (result i32 i32) + (return (i64.const 1)) (i32.const 1) (i32.const 2) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-return-first-num-vs-num (result i32) + (return (i64.const 1)) (return (i32.const 1)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-return-first-num-vs-nums (result i32 i32) + (return (i32.const 1)) (return (i32.const 1) (i32.const 2)) + )) + "type mismatch" +) + +(assert_invalid + (module (func $type-break-last-void-vs-num (result i32) + (br 0) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-last-void-vs-nums (result i32 i32) + (br 0) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-last-num-vs-num (result i32) + (br 0 (f32.const 0)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-last-num-vs-nums (result i32 i32) + (br 0 (i32.const 0)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-void-vs-num (result i32) + (br 0) (i32.const 1) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-void-vs-nums (result i32 i32) + (br 0) (i32.const 1) (i32.const 2) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-num-vs-num (result i32) + (br 0 (i64.const 1)) (i32.const 1) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-num-vs-nums (result i32 i32) + (br 0 (i32.const 1)) (i32.const 1) (i32.const 2) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-first-num-vs-num (result i32) + (br 0 (i64.const 1)) (br 0 (i32.const 1)) + )) + "type mismatch" +) + +(assert_invalid + (module (func $type-break-nested-empty-vs-num (result i32) + (block (br 1)) (br 0 (i32.const 1)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-nested-empty-vs-nums (result i32 i32) + (block (br 1)) (br 0 (i32.const 1) (i32.const 2)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-nested-void-vs-num (result i32) + (block (br 1 (nop))) (br 0 (i32.const 1)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-nested-void-vs-nums (result i32 i32) + (block (br 1 (nop))) (br 0 (i32.const 1) (i32.const 2)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-nested-num-vs-num (result i32) + (block (br 1 (i64.const 1))) (br 0 (i32.const 1)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-nested-num-vs-nums (result i32 i32) + (block (result i32) (br 1 (i32.const 1))) (br 0 (i32.const 1) (i32.const 2)) + )) + "type mismatch" +) + + +;; Syntax errors + +(assert_malformed + (module quote "(func (nop) (local i32))") + "unexpected token" +) +(assert_malformed + (module quote "(func (nop) (param i32))") + "unexpected token" +) +(assert_malformed + (module quote "(func (nop) (result i32))") + "unexpected token" +) +(assert_malformed + (module quote "(func (local i32) (param i32))") + "unexpected token" +) +(assert_malformed + (module quote "(func (local i32) (result i32) (local.get 0))") + "unexpected token" +) +(assert_malformed + (module quote "(func (result i32) (param i32) (local.get 0))") + "unexpected token" +) + +;; Duplicate name errors + +(assert_malformed (module quote + "(func $foo)" + "(func $foo)") + "duplicate func") +(assert_malformed (module quote + "(import \"\" \"\" (func $foo))" + "(func $foo)") + "duplicate func") +(assert_malformed (module quote + "(import \"\" \"\" (func $foo))" + "(import \"\" \"\" (func $foo))") + "duplicate func") + +(assert_malformed (module quote "(func (param $foo i32) (param $foo i32))") + "duplicate local") +(assert_malformed (module quote "(func (param $foo i32) (local $foo i32))") + "duplicate local") +(assert_malformed (module quote "(func (local $foo i32) (local $foo i32))") + "duplicate local") diff --git a/runtime/near-vm/tests/wast/spec/func_ptrs.wast b/runtime/near-vm/tests/wast/spec/func_ptrs.wast new file mode 100644 index 00000000000..f6f8e2c429d --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/func_ptrs.wast @@ -0,0 +1,106 @@ +(module + (type (func)) ;; 0: void -> void + (type $S (func)) ;; 1: void -> void + (type (func (param))) ;; 2: void -> void + (type (func (result i32))) ;; 3: void -> i32 + (type (func (param) (result i32))) ;; 4: void -> i32 + (type $T (func (param i32) (result i32))) ;; 5: i32 -> i32 + (type $U (func (param i32))) ;; 6: i32 -> void + + (func $print (import "spectest" "print_i32") (type 6)) + + (func (type 0)) + (func (type $S)) + + (func (export "one") (type 4) (i32.const 13)) + (func (export "two") (type $T) (i32.add (local.get 0) (i32.const 1))) + + ;; Both signature and parameters are allowed (and required to match) + ;; since this allows the naming of parameters. + (func (export "three") (type $T) (param $a i32) (result i32) + (i32.sub (local.get 0) (i32.const 2)) + ) + + (func (export "four") (type $U) (call $print (local.get 0))) +) + +(assert_return (invoke "one") (i32.const 13)) +(assert_return (invoke "two" (i32.const 13)) (i32.const 14)) +(assert_return (invoke "three" (i32.const 13)) (i32.const 11)) +(invoke "four" (i32.const 83)) + +(assert_invalid (module (elem (i32.const 0))) "unknown table") +(assert_invalid (module (elem (i32.const 0) 0) (func)) "unknown table") + +(assert_invalid + (module (table 1 funcref) (elem (i64.const 0))) + "type mismatch" +) +(assert_invalid + (module (table 1 funcref) (elem (i32.ctz (i32.const 0)))) + "constant expression required" +) +(assert_invalid + (module (table 1 funcref) (elem (nop))) + "constant expression required" +) + +(assert_invalid (module (func (type 42))) "unknown type") +(assert_invalid (module (import "spectest" "print_i32" (func (type 43)))) "unknown type") + +(module + (type $T (func (param) (result i32))) + (type $U (func (param) (result i32))) + (table funcref (elem $t1 $t2 $t3 $u1 $u2 $t1 $t3)) + + (func $t1 (type $T) (i32.const 1)) + (func $t2 (type $T) (i32.const 2)) + (func $t3 (type $T) (i32.const 3)) + (func $u1 (type $U) (i32.const 4)) + (func $u2 (type $U) (i32.const 5)) + + (func (export "callt") (param $i i32) (result i32) + (call_indirect (type $T) (local.get $i)) + ) + + (func (export "callu") (param $i i32) (result i32) + (call_indirect (type $U) (local.get $i)) + ) +) + +(assert_return (invoke "callt" (i32.const 0)) (i32.const 1)) +(assert_return (invoke "callt" (i32.const 1)) (i32.const 2)) +(assert_return (invoke "callt" (i32.const 2)) (i32.const 3)) +(assert_return (invoke "callt" (i32.const 3)) (i32.const 4)) +(assert_return (invoke "callt" (i32.const 4)) (i32.const 5)) +(assert_return (invoke "callt" (i32.const 5)) (i32.const 1)) +(assert_return (invoke "callt" (i32.const 6)) (i32.const 3)) +(assert_trap (invoke "callt" (i32.const 7)) "undefined element") +(assert_trap (invoke "callt" (i32.const 100)) "undefined element") +(assert_trap (invoke "callt" (i32.const -1)) "undefined element") + +(assert_return (invoke "callu" (i32.const 0)) (i32.const 1)) +(assert_return (invoke "callu" (i32.const 1)) (i32.const 2)) +(assert_return (invoke "callu" (i32.const 2)) (i32.const 3)) +(assert_return (invoke "callu" (i32.const 3)) (i32.const 4)) +(assert_return (invoke "callu" (i32.const 4)) (i32.const 5)) +(assert_return (invoke "callu" (i32.const 5)) (i32.const 1)) +(assert_return (invoke "callu" (i32.const 6)) (i32.const 3)) +(assert_trap (invoke "callu" (i32.const 7)) "undefined element") +(assert_trap (invoke "callu" (i32.const 100)) "undefined element") +(assert_trap (invoke "callu" (i32.const -1)) "undefined element") + +(module + (type $T (func (result i32))) + (table funcref (elem 0 1)) + + (func $t1 (type $T) (i32.const 1)) + (func $t2 (type $T) (i32.const 2)) + + (func (export "callt") (param $i i32) (result i32) + (call_indirect (type $T) (local.get $i)) + ) +) + +(assert_return (invoke "callt" (i32.const 0)) (i32.const 1)) +(assert_return (invoke "callt" (i32.const 1)) (i32.const 2)) diff --git a/runtime/near-vm/tests/wast/spec/global.wast b/runtime/near-vm/tests/wast/spec/global.wast new file mode 100644 index 00000000000..9fa5e22311a --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/global.wast @@ -0,0 +1,624 @@ +;; Test globals + +(module + (global (import "spectest" "global_i32") i32) + (global (import "spectest" "global_i64") i64) + + (global $a i32 (i32.const -2)) + (global (;3;) f32 (f32.const -3)) + (global (;4;) f64 (f64.const -4)) + (global $b i64 (i64.const -5)) + + (global $x (mut i32) (i32.const -12)) + (global (;7;) (mut f32) (f32.const -13)) + (global (;8;) (mut f64) (f64.const -14)) + (global $y (mut i64) (i64.const -15)) + + (global $z1 i32 (global.get 0)) + (global $z2 i64 (global.get 1)) + + (global $r externref (ref.null extern)) + (global $mr (mut externref) (ref.null extern)) + (global funcref (ref.null func)) + + (func (export "get-a") (result i32) (global.get $a)) + (func (export "get-b") (result i64) (global.get $b)) + (func (export "get-r") (result externref) (global.get $r)) + (func (export "get-mr") (result externref) (global.get $mr)) + (func (export "get-x") (result i32) (global.get $x)) + (func (export "get-y") (result i64) (global.get $y)) + (func (export "get-z1") (result i32) (global.get $z1)) + (func (export "get-z2") (result i64) (global.get $z2)) + (func (export "set-x") (param i32) (global.set $x (local.get 0))) + (func (export "set-y") (param i64) (global.set $y (local.get 0))) + (func (export "set-mr") (param externref) (global.set $mr (local.get 0))) + + (func (export "get-3") (result f32) (global.get 3)) + (func (export "get-4") (result f64) (global.get 4)) + (func (export "get-7") (result f32) (global.get 7)) + (func (export "get-8") (result f64) (global.get 8)) + (func (export "set-7") (param f32) (global.set 7 (local.get 0))) + (func (export "set-8") (param f64) (global.set 8 (local.get 0))) + + ;; As the argument of control constructs and instructions + + (memory 1) + + (func $dummy) + + (func (export "as-select-first") (result i32) + (select (global.get $x) (i32.const 2) (i32.const 3)) + ) + (func (export "as-select-mid") (result i32) + (select (i32.const 2) (global.get $x) (i32.const 3)) + ) + (func (export "as-select-last") (result i32) + (select (i32.const 2) (i32.const 3) (global.get $x)) + ) + + (func (export "as-loop-first") (result i32) + (loop (result i32) + (global.get $x) (call $dummy) (call $dummy) + ) + ) + (func (export "as-loop-mid") (result i32) + (loop (result i32) + (call $dummy) (global.get $x) (call $dummy) + ) + ) + (func (export "as-loop-last") (result i32) + (loop (result i32) + (call $dummy) (call $dummy) (global.get $x) + ) + ) + + (func (export "as-if-condition") (result i32) + (if (result i32) (global.get $x) + (then (call $dummy) (i32.const 2)) + (else (call $dummy) (i32.const 3)) + ) + ) + (func (export "as-if-then") (result i32) + (if (result i32) (i32.const 1) + (then (global.get $x)) (else (i32.const 2)) + ) + ) + (func (export "as-if-else") (result i32) + (if (result i32) (i32.const 0) + (then (i32.const 2)) (else (global.get $x)) + ) + ) + + (func (export "as-br_if-first") (result i32) + (block (result i32) + (br_if 0 (global.get $x) (i32.const 2)) + (return (i32.const 3)) + ) + ) + (func (export "as-br_if-last") (result i32) + (block (result i32) + (br_if 0 (i32.const 2) (global.get $x)) + (return (i32.const 3)) + ) + ) + + (func (export "as-br_table-first") (result i32) + (block (result i32) + (global.get $x) (i32.const 2) (br_table 0 0) + ) + ) + (func (export "as-br_table-last") (result i32) + (block (result i32) + (i32.const 2) (global.get $x) (br_table 0 0) + ) + ) + + (func $func (param i32 i32) (result i32) (local.get 0)) + (type $check (func (param i32 i32) (result i32))) + (table funcref (elem $func)) + (func (export "as-call_indirect-first") (result i32) + (block (result i32) + (call_indirect (type $check) + (global.get $x) (i32.const 2) (i32.const 0) + ) + ) + ) + (func (export "as-call_indirect-mid") (result i32) + (block (result i32) + (call_indirect (type $check) + (i32.const 2) (global.get $x) (i32.const 0) + ) + ) + ) + (func (export "as-call_indirect-last") (result i32) + (block (result i32) + (call_indirect (type $check) + (i32.const 2) (i32.const 0) (global.get $x) + ) + ) + ) + + (func (export "as-store-first") + (global.get $x) (i32.const 1) (i32.store) + ) + (func (export "as-store-last") + (i32.const 0) (global.get $x) (i32.store) + ) + (func (export "as-load-operand") (result i32) + (i32.load (global.get $x)) + ) + (func (export "as-memory.grow-value") (result i32) + (memory.grow (global.get $x)) + ) + + (func $f (param i32) (result i32) (local.get 0)) + (func (export "as-call-value") (result i32) + (call $f (global.get $x)) + ) + + (func (export "as-return-value") (result i32) + (global.get $x) (return) + ) + (func (export "as-drop-operand") + (drop (global.get $x)) + ) + (func (export "as-br-value") (result i32) + (block (result i32) (br 0 (global.get $x))) + ) + + (func (export "as-local.set-value") (param i32) (result i32) + (local.set 0 (global.get $x)) + (local.get 0) + ) + (func (export "as-local.tee-value") (param i32) (result i32) + (local.tee 0 (global.get $x)) + ) + (func (export "as-global.set-value") (result i32) + (global.set $x (global.get $x)) + (global.get $x) + ) + + (func (export "as-unary-operand") (result i32) + (i32.eqz (global.get $x)) + ) + (func (export "as-binary-operand") (result i32) + (i32.mul + (global.get $x) (global.get $x) + ) + ) + (func (export "as-compare-operand") (result i32) + (i32.gt_u + (global.get 0) (i32.const 1) + ) + ) +) + +(assert_return (invoke "get-a") (i32.const -2)) +(assert_return (invoke "get-b") (i64.const -5)) +(assert_return (invoke "get-r") (ref.null extern)) +(assert_return (invoke "get-mr") (ref.null extern)) +(assert_return (invoke "get-x") (i32.const -12)) +(assert_return (invoke "get-y") (i64.const -15)) +(assert_return (invoke "get-z1") (i32.const 666)) +(assert_return (invoke "get-z2") (i64.const 666)) + +(assert_return (invoke "get-3") (f32.const -3)) +(assert_return (invoke "get-4") (f64.const -4)) +(assert_return (invoke "get-7") (f32.const -13)) +(assert_return (invoke "get-8") (f64.const -14)) + +(assert_return (invoke "set-x" (i32.const 6))) +(assert_return (invoke "set-y" (i64.const 7))) + +(assert_return (invoke "set-7" (f32.const 8))) +(assert_return (invoke "set-8" (f64.const 9))) + +(assert_return (invoke "get-x") (i32.const 6)) +(assert_return (invoke "get-y") (i64.const 7)) +(assert_return (invoke "get-7") (f32.const 8)) +(assert_return (invoke "get-8") (f64.const 9)) + +(assert_return (invoke "set-7" (f32.const 8))) +(assert_return (invoke "set-8" (f64.const 9))) +(assert_return (invoke "set-mr" (ref.extern 10))) + +(assert_return (invoke "get-x") (i32.const 6)) +(assert_return (invoke "get-y") (i64.const 7)) +(assert_return (invoke "get-7") (f32.const 8)) +(assert_return (invoke "get-8") (f64.const 9)) +(assert_return (invoke "get-mr") (ref.extern 10)) + +(assert_return (invoke "as-select-first") (i32.const 6)) +(assert_return (invoke "as-select-mid") (i32.const 2)) +(assert_return (invoke "as-select-last") (i32.const 2)) + +(assert_return (invoke "as-loop-first") (i32.const 6)) +(assert_return (invoke "as-loop-mid") (i32.const 6)) +(assert_return (invoke "as-loop-last") (i32.const 6)) + +(assert_return (invoke "as-if-condition") (i32.const 2)) +(assert_return (invoke "as-if-then") (i32.const 6)) +(assert_return (invoke "as-if-else") (i32.const 6)) + +(assert_return (invoke "as-br_if-first") (i32.const 6)) +(assert_return (invoke "as-br_if-last") (i32.const 2)) + +(assert_return (invoke "as-br_table-first") (i32.const 6)) +(assert_return (invoke "as-br_table-last") (i32.const 2)) + +(assert_return (invoke "as-call_indirect-first") (i32.const 6)) +(assert_return (invoke "as-call_indirect-mid") (i32.const 2)) +(assert_trap (invoke "as-call_indirect-last") "undefined element") + +(assert_return (invoke "as-store-first")) +(assert_return (invoke "as-store-last")) +(assert_return (invoke "as-load-operand") (i32.const 1)) +(assert_return (invoke "as-memory.grow-value") (i32.const 1)) + +(assert_return (invoke "as-call-value") (i32.const 6)) + +(assert_return (invoke "as-return-value") (i32.const 6)) +(assert_return (invoke "as-drop-operand")) +(assert_return (invoke "as-br-value") (i32.const 6)) + +(assert_return (invoke "as-local.set-value" (i32.const 1)) (i32.const 6)) +(assert_return (invoke "as-local.tee-value" (i32.const 1)) (i32.const 6)) +(assert_return (invoke "as-global.set-value") (i32.const 6)) + +(assert_return (invoke "as-unary-operand") (i32.const 0)) +(assert_return (invoke "as-binary-operand") (i32.const 36)) +(assert_return (invoke "as-compare-operand") (i32.const 1)) + +(assert_invalid + (module (global f32 (f32.const 0)) (func (global.set 0 (f32.const 1)))) + "global is immutable" +) + +(assert_invalid + (module (import "spectest" "global_i32" (global i32)) (func (global.set 0 (i32.const 1)))) + "global is immutable" +) + +;; mutable globals can be exported +(module (global (mut f32) (f32.const 0)) (export "a" (global 0))) +(module (global (export "a") (mut f32) (f32.const 0))) + +(assert_invalid + (module (global f32 (f32.neg (f32.const 0)))) + "constant expression required" +) + +(assert_invalid + (module (global f32 (local.get 0))) + "constant expression required" +) + +(assert_invalid + (module (global f32 (f32.neg (f32.const 1)))) + "constant expression required" +) + +(assert_invalid + (module (global i32 (i32.const 0) (nop))) + "constant expression required" +) + +(assert_invalid + (module (global i32 (i32.ctz (i32.const 0)))) + "constant expression required" +) + +(assert_invalid + (module (global i32 (nop))) + "constant expression required" +) + +(assert_invalid + (module (global i32 (f32.const 0))) + "type mismatch" +) + +(assert_invalid + (module (global i32 (i32.const 0) (i32.const 0))) + "type mismatch" +) + +(assert_invalid + (module (global i32 (;empty instruction sequence;))) + "type mismatch" +) + +(assert_invalid + (module (global (import "" "") externref) (global funcref (global.get 0))) + "type mismatch" +) + +(assert_invalid + (module (global (import "test" "global-i32") i32) (global i32 (global.get 0) (global.get 0))) + "type mismatch" +) + +(assert_invalid + (module (global (import "test" "global-i32") i32) (global i32 (i32.const 0) (global.get 0))) + "type mismatch" +) + +(assert_invalid + (module (global i32 (global.get 0))) + "unknown global" +) + +(assert_invalid + (module (global i32 (global.get 1)) (global i32 (i32.const 0))) + "unknown global" +) + +(assert_invalid + (module (global (import "test" "global-i32") i32) (global i32 (global.get 2))) + "unknown global" +) + +(assert_invalid + (module (global (import "test" "global-mut-i32") (mut i32)) (global i32 (global.get 0))) + "constant expression required" +) + +(module + (import "spectest" "global_i32" (global i32)) +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\98\80\80\80\00" ;; import section + "\01" ;; length 1 + "\08\73\70\65\63\74\65\73\74" ;; "spectest" + "\0a\67\6c\6f\62\61\6c\5f\69\33\32" ;; "global_i32" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\02" ;; malformed mutability + ) + "malformed mutability" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\98\80\80\80\00" ;; import section + "\01" ;; length 1 + "\08\73\70\65\63\74\65\73\74" ;; "spectest" + "\0a\67\6c\6f\62\61\6c\5f\69\33\32" ;; "global_i32" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\ff" ;; malformed mutability + ) + "malformed mutability" +) + +(module + (global i32 (i32.const 0)) +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\06\86\80\80\80\00" ;; global section + "\01" ;; length 1 + "\7f" ;; i32 + "\02" ;; malformed mutability + "\41\00" ;; i32.const 0 + "\0b" ;; end + ) + "malformed mutability" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\06\86\80\80\80\00" ;; global section + "\01" ;; length 1 + "\7f" ;; i32 + "\ff" ;; malformed mutability + "\41\00" ;; i32.const 0 + "\0b" ;; end + ) + "malformed mutability" +) + +;; global.get with invalid index +(assert_invalid + (module (func (result i32) (global.get 0))) + "unknown global" +) + +(assert_invalid + (module + (global i32 (i32.const 0)) + (func (result i32) (global.get 1)) + ) + "unknown global" +) + +(assert_invalid + (module + (import "spectest" "global_i32" (global i32)) + (func (result i32) (global.get 1)) + ) + "unknown global" +) + +(assert_invalid + (module + (import "spectest" "global_i32" (global i32)) + (global i32 (i32.const 0)) + (func (result i32) (global.get 2)) + ) + "unknown global" +) + +;; global.set with invalid index +(assert_invalid + (module (func (i32.const 0) (global.set 0))) + "unknown global" +) + +(assert_invalid + (module + (global i32 (i32.const 0)) + (func (i32.const 0) (global.set 1)) + ) + "unknown global" +) + +(assert_invalid + (module + (import "spectest" "global_i32" (global i32)) + (func (i32.const 0) (global.set 1)) + ) + "unknown global" +) + +(assert_invalid + (module + (import "spectest" "global_i32" (global i32)) + (global i32 (i32.const 0)) + (func (i32.const 0) (global.set 2)) + ) + "unknown global" +) + + +(assert_invalid + (module + (global $x (mut i32) (i32.const 0)) + (func $type-global.set-value-empty + (global.set $x) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (global $x (mut i32) (i32.const 0)) + (func $type-global.set-value-empty-in-block + (i32.const 0) + (block (global.set $x)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (global $x (mut i32) (i32.const 0)) + (func $type-global.set-value-empty-in-loop + (i32.const 0) + (loop (global.set $x)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (global $x (mut i32) (i32.const 0)) + (func $type-global.set-value-empty-in-then + (i32.const 0) (i32.const 0) + (if (then (global.set $x))) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (global $x (mut i32) (i32.const 0)) + (func $type-global.set-value-empty-in-else + (i32.const 0) (i32.const 0) + (if (result i32) (then (i32.const 0)) (else (global.set $x))) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (global $x (mut i32) (i32.const 0)) + (func $type-global.set-value-empty-in-br + (i32.const 0) + (block (br 0 (global.set $x))) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (global $x (mut i32) (i32.const 0)) + (func $type-global.set-value-empty-in-br_if + (i32.const 0) + (block (br_if 0 (global.set $x))) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (global $x (mut i32) (i32.const 0)) + (func $type-global.set-value-empty-in-br_table + (i32.const 0) + (block (br_table 0 (global.set $x))) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (global $x (mut i32) (i32.const 0)) + (func $type-global.set-value-empty-in-return + (return (global.set $x)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (global $x (mut i32) (i32.const 0)) + (func $type-global.set-value-empty-in-select + (select (global.set $x) (i32.const 1) (i32.const 2)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (global $x (mut i32) (i32.const 0)) + (func $type-global.set-value-empty-in-call + (call 1 (global.set $x)) + ) + (func (param i32) (result i32) (local.get 0)) + ) + "type mismatch" +) +(assert_invalid + (module + (global $x (mut i32) (i32.const 0)) + (func $f (param i32) (result i32) (local.get 0)) + (type $sig (func (param i32) (result i32))) + (table funcref (elem $f)) + (func $type-global.set-value-empty-in-call_indirect + (block (result i32) + (call_indirect (type $sig) + (global.set $x) (i32.const 0) + ) + ) + ) + ) + "type mismatch" +) + +;; Duplicate identifier errors + +(assert_malformed (module quote + "(global $foo i32 (i32.const 0))" + "(global $foo i32 (i32.const 0))") + "duplicate global") +(assert_malformed (module quote + "(import \"\" \"\" (global $foo i32))" + "(global $foo i32 (i32.const 0))") + "duplicate global") +(assert_malformed (module quote + "(import \"\" \"\" (global $foo i32))" + "(import \"\" \"\" (global $foo i32))") + "duplicate global") diff --git a/runtime/near-vm/tests/wast/spec/i32.wast b/runtime/near-vm/tests/wast/spec/i32.wast new file mode 100644 index 00000000000..32862c34755 --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/i32.wast @@ -0,0 +1,976 @@ +;; i32 operations + +(module + (func (export "add") (param $x i32) (param $y i32) (result i32) (i32.add (local.get $x) (local.get $y))) + (func (export "sub") (param $x i32) (param $y i32) (result i32) (i32.sub (local.get $x) (local.get $y))) + (func (export "mul") (param $x i32) (param $y i32) (result i32) (i32.mul (local.get $x) (local.get $y))) + (func (export "div_s") (param $x i32) (param $y i32) (result i32) (i32.div_s (local.get $x) (local.get $y))) + (func (export "div_u") (param $x i32) (param $y i32) (result i32) (i32.div_u (local.get $x) (local.get $y))) + (func (export "rem_s") (param $x i32) (param $y i32) (result i32) (i32.rem_s (local.get $x) (local.get $y))) + (func (export "rem_u") (param $x i32) (param $y i32) (result i32) (i32.rem_u (local.get $x) (local.get $y))) + (func (export "and") (param $x i32) (param $y i32) (result i32) (i32.and (local.get $x) (local.get $y))) + (func (export "or") (param $x i32) (param $y i32) (result i32) (i32.or (local.get $x) (local.get $y))) + (func (export "xor") (param $x i32) (param $y i32) (result i32) (i32.xor (local.get $x) (local.get $y))) + (func (export "shl") (param $x i32) (param $y i32) (result i32) (i32.shl (local.get $x) (local.get $y))) + (func (export "shr_s") (param $x i32) (param $y i32) (result i32) (i32.shr_s (local.get $x) (local.get $y))) + (func (export "shr_u") (param $x i32) (param $y i32) (result i32) (i32.shr_u (local.get $x) (local.get $y))) + (func (export "rotl") (param $x i32) (param $y i32) (result i32) (i32.rotl (local.get $x) (local.get $y))) + (func (export "rotr") (param $x i32) (param $y i32) (result i32) (i32.rotr (local.get $x) (local.get $y))) + (func (export "clz") (param $x i32) (result i32) (i32.clz (local.get $x))) + (func (export "ctz") (param $x i32) (result i32) (i32.ctz (local.get $x))) + (func (export "popcnt") (param $x i32) (result i32) (i32.popcnt (local.get $x))) + (func (export "extend8_s") (param $x i32) (result i32) (i32.extend8_s (local.get $x))) + (func (export "extend16_s") (param $x i32) (result i32) (i32.extend16_s (local.get $x))) + (func (export "eqz") (param $x i32) (result i32) (i32.eqz (local.get $x))) + (func (export "eq") (param $x i32) (param $y i32) (result i32) (i32.eq (local.get $x) (local.get $y))) + (func (export "ne") (param $x i32) (param $y i32) (result i32) (i32.ne (local.get $x) (local.get $y))) + (func (export "lt_s") (param $x i32) (param $y i32) (result i32) (i32.lt_s (local.get $x) (local.get $y))) + (func (export "lt_u") (param $x i32) (param $y i32) (result i32) (i32.lt_u (local.get $x) (local.get $y))) + (func (export "le_s") (param $x i32) (param $y i32) (result i32) (i32.le_s (local.get $x) (local.get $y))) + (func (export "le_u") (param $x i32) (param $y i32) (result i32) (i32.le_u (local.get $x) (local.get $y))) + (func (export "gt_s") (param $x i32) (param $y i32) (result i32) (i32.gt_s (local.get $x) (local.get $y))) + (func (export "gt_u") (param $x i32) (param $y i32) (result i32) (i32.gt_u (local.get $x) (local.get $y))) + (func (export "ge_s") (param $x i32) (param $y i32) (result i32) (i32.ge_s (local.get $x) (local.get $y))) + (func (export "ge_u") (param $x i32) (param $y i32) (result i32) (i32.ge_u (local.get $x) (local.get $y))) +) + +(assert_return (invoke "add" (i32.const 1) (i32.const 1)) (i32.const 2)) +(assert_return (invoke "add" (i32.const 1) (i32.const 0)) (i32.const 1)) +(assert_return (invoke "add" (i32.const -1) (i32.const -1)) (i32.const -2)) +(assert_return (invoke "add" (i32.const -1) (i32.const 1)) (i32.const 0)) +(assert_return (invoke "add" (i32.const 0x7fffffff) (i32.const 1)) (i32.const 0x80000000)) +(assert_return (invoke "add" (i32.const 0x80000000) (i32.const -1)) (i32.const 0x7fffffff)) +(assert_return (invoke "add" (i32.const 0x80000000) (i32.const 0x80000000)) (i32.const 0)) +(assert_return (invoke "add" (i32.const 0x3fffffff) (i32.const 1)) (i32.const 0x40000000)) + +(assert_return (invoke "sub" (i32.const 1) (i32.const 1)) (i32.const 0)) +(assert_return (invoke "sub" (i32.const 1) (i32.const 0)) (i32.const 1)) +(assert_return (invoke "sub" (i32.const -1) (i32.const -1)) (i32.const 0)) +(assert_return (invoke "sub" (i32.const 0x7fffffff) (i32.const -1)) (i32.const 0x80000000)) +(assert_return (invoke "sub" (i32.const 0x80000000) (i32.const 1)) (i32.const 0x7fffffff)) +(assert_return (invoke "sub" (i32.const 0x80000000) (i32.const 0x80000000)) (i32.const 0)) +(assert_return (invoke "sub" (i32.const 0x3fffffff) (i32.const -1)) (i32.const 0x40000000)) + +(assert_return (invoke "mul" (i32.const 1) (i32.const 1)) (i32.const 1)) +(assert_return (invoke "mul" (i32.const 1) (i32.const 0)) (i32.const 0)) +(assert_return (invoke "mul" (i32.const -1) (i32.const -1)) (i32.const 1)) +(assert_return (invoke "mul" (i32.const 0x10000000) (i32.const 4096)) (i32.const 0)) +(assert_return (invoke "mul" (i32.const 0x80000000) (i32.const 0)) (i32.const 0)) +(assert_return (invoke "mul" (i32.const 0x80000000) (i32.const -1)) (i32.const 0x80000000)) +(assert_return (invoke "mul" (i32.const 0x7fffffff) (i32.const -1)) (i32.const 0x80000001)) +(assert_return (invoke "mul" (i32.const 0x01234567) (i32.const 0x76543210)) (i32.const 0x358e7470)) +(assert_return (invoke "mul" (i32.const 0x7fffffff) (i32.const 0x7fffffff)) (i32.const 1)) + +(assert_trap (invoke "div_s" (i32.const 1) (i32.const 0)) "integer divide by zero") +(assert_trap (invoke "div_s" (i32.const 0) (i32.const 0)) "integer divide by zero") +(assert_trap (invoke "div_s" (i32.const 0x80000000) (i32.const -1)) "integer overflow") +(assert_trap (invoke "div_s" (i32.const 0x80000000) (i32.const 0)) "integer divide by zero") +(assert_return (invoke "div_s" (i32.const 1) (i32.const 1)) (i32.const 1)) +(assert_return (invoke "div_s" (i32.const 0) (i32.const 1)) (i32.const 0)) +(assert_return (invoke "div_s" (i32.const 0) (i32.const -1)) (i32.const 0)) +(assert_return (invoke "div_s" (i32.const -1) (i32.const -1)) (i32.const 1)) +(assert_return (invoke "div_s" (i32.const 0x80000000) (i32.const 2)) (i32.const 0xc0000000)) +(assert_return (invoke "div_s" (i32.const 0x80000001) (i32.const 1000)) (i32.const 0xffdf3b65)) +(assert_return (invoke "div_s" (i32.const 5) (i32.const 2)) (i32.const 2)) +(assert_return (invoke "div_s" (i32.const -5) (i32.const 2)) (i32.const -2)) +(assert_return (invoke "div_s" (i32.const 5) (i32.const -2)) (i32.const -2)) +(assert_return (invoke "div_s" (i32.const -5) (i32.const -2)) (i32.const 2)) +(assert_return (invoke "div_s" (i32.const 7) (i32.const 3)) (i32.const 2)) +(assert_return (invoke "div_s" (i32.const -7) (i32.const 3)) (i32.const -2)) +(assert_return (invoke "div_s" (i32.const 7) (i32.const -3)) (i32.const -2)) +(assert_return (invoke "div_s" (i32.const -7) (i32.const -3)) (i32.const 2)) +(assert_return (invoke "div_s" (i32.const 11) (i32.const 5)) (i32.const 2)) +(assert_return (invoke "div_s" (i32.const 17) (i32.const 7)) (i32.const 2)) + +(assert_trap (invoke "div_u" (i32.const 1) (i32.const 0)) "integer divide by zero") +(assert_trap (invoke "div_u" (i32.const 0) (i32.const 0)) "integer divide by zero") +(assert_return (invoke "div_u" (i32.const 1) (i32.const 1)) (i32.const 1)) +(assert_return (invoke "div_u" (i32.const 0) (i32.const 1)) (i32.const 0)) +(assert_return (invoke "div_u" (i32.const -1) (i32.const -1)) (i32.const 1)) +(assert_return (invoke "div_u" (i32.const 0x80000000) (i32.const -1)) (i32.const 0)) +(assert_return (invoke "div_u" (i32.const 0x80000000) (i32.const 2)) (i32.const 0x40000000)) +(assert_return (invoke "div_u" (i32.const 0x8ff00ff0) (i32.const 0x10001)) (i32.const 0x8fef)) +(assert_return (invoke "div_u" (i32.const 0x80000001) (i32.const 1000)) (i32.const 0x20c49b)) +(assert_return (invoke "div_u" (i32.const 5) (i32.const 2)) (i32.const 2)) +(assert_return (invoke "div_u" (i32.const -5) (i32.const 2)) (i32.const 0x7ffffffd)) +(assert_return (invoke "div_u" (i32.const 5) (i32.const -2)) (i32.const 0)) +(assert_return (invoke "div_u" (i32.const -5) (i32.const -2)) (i32.const 0)) +(assert_return (invoke "div_u" (i32.const 7) (i32.const 3)) (i32.const 2)) +(assert_return (invoke "div_u" (i32.const 11) (i32.const 5)) (i32.const 2)) +(assert_return (invoke "div_u" (i32.const 17) (i32.const 7)) (i32.const 2)) + +(assert_trap (invoke "rem_s" (i32.const 1) (i32.const 0)) "integer divide by zero") +(assert_trap (invoke "rem_s" (i32.const 0) (i32.const 0)) "integer divide by zero") +(assert_return (invoke "rem_s" (i32.const 0x7fffffff) (i32.const -1)) (i32.const 0)) +(assert_return (invoke "rem_s" (i32.const 1) (i32.const 1)) (i32.const 0)) +(assert_return (invoke "rem_s" (i32.const 0) (i32.const 1)) (i32.const 0)) +(assert_return (invoke "rem_s" (i32.const 0) (i32.const -1)) (i32.const 0)) +(assert_return (invoke "rem_s" (i32.const -1) (i32.const -1)) (i32.const 0)) +(assert_return (invoke "rem_s" (i32.const 0x80000000) (i32.const -1)) (i32.const 0)) +(assert_return (invoke "rem_s" (i32.const 0x80000000) (i32.const 2)) (i32.const 0)) +(assert_return (invoke "rem_s" (i32.const 0x80000001) (i32.const 1000)) (i32.const -647)) +(assert_return (invoke "rem_s" (i32.const 5) (i32.const 2)) (i32.const 1)) +(assert_return (invoke "rem_s" (i32.const -5) (i32.const 2)) (i32.const -1)) +(assert_return (invoke "rem_s" (i32.const 5) (i32.const -2)) (i32.const 1)) +(assert_return (invoke "rem_s" (i32.const -5) (i32.const -2)) (i32.const -1)) +(assert_return (invoke "rem_s" (i32.const 7) (i32.const 3)) (i32.const 1)) +(assert_return (invoke "rem_s" (i32.const -7) (i32.const 3)) (i32.const -1)) +(assert_return (invoke "rem_s" (i32.const 7) (i32.const -3)) (i32.const 1)) +(assert_return (invoke "rem_s" (i32.const -7) (i32.const -3)) (i32.const -1)) +(assert_return (invoke "rem_s" (i32.const 11) (i32.const 5)) (i32.const 1)) +(assert_return (invoke "rem_s" (i32.const 17) (i32.const 7)) (i32.const 3)) + +(assert_trap (invoke "rem_u" (i32.const 1) (i32.const 0)) "integer divide by zero") +(assert_trap (invoke "rem_u" (i32.const 0) (i32.const 0)) "integer divide by zero") +(assert_return (invoke "rem_u" (i32.const 1) (i32.const 1)) (i32.const 0)) +(assert_return (invoke "rem_u" (i32.const 0) (i32.const 1)) (i32.const 0)) +(assert_return (invoke "rem_u" (i32.const -1) (i32.const -1)) (i32.const 0)) +(assert_return (invoke "rem_u" (i32.const 0x80000000) (i32.const -1)) (i32.const 0x80000000)) +(assert_return (invoke "rem_u" (i32.const 0x80000000) (i32.const 2)) (i32.const 0)) +(assert_return (invoke "rem_u" (i32.const 0x8ff00ff0) (i32.const 0x10001)) (i32.const 0x8001)) +(assert_return (invoke "rem_u" (i32.const 0x80000001) (i32.const 1000)) (i32.const 649)) +(assert_return (invoke "rem_u" (i32.const 5) (i32.const 2)) (i32.const 1)) +(assert_return (invoke "rem_u" (i32.const -5) (i32.const 2)) (i32.const 1)) +(assert_return (invoke "rem_u" (i32.const 5) (i32.const -2)) (i32.const 5)) +(assert_return (invoke "rem_u" (i32.const -5) (i32.const -2)) (i32.const -5)) +(assert_return (invoke "rem_u" (i32.const 7) (i32.const 3)) (i32.const 1)) +(assert_return (invoke "rem_u" (i32.const 11) (i32.const 5)) (i32.const 1)) +(assert_return (invoke "rem_u" (i32.const 17) (i32.const 7)) (i32.const 3)) + +(assert_return (invoke "and" (i32.const 1) (i32.const 0)) (i32.const 0)) +(assert_return (invoke "and" (i32.const 0) (i32.const 1)) (i32.const 0)) +(assert_return (invoke "and" (i32.const 1) (i32.const 1)) (i32.const 1)) +(assert_return (invoke "and" (i32.const 0) (i32.const 0)) (i32.const 0)) +(assert_return (invoke "and" (i32.const 0x7fffffff) (i32.const 0x80000000)) (i32.const 0)) +(assert_return (invoke "and" (i32.const 0x7fffffff) (i32.const -1)) (i32.const 0x7fffffff)) +(assert_return (invoke "and" (i32.const 0xf0f0ffff) (i32.const 0xfffff0f0)) (i32.const 0xf0f0f0f0)) +(assert_return (invoke "and" (i32.const 0xffffffff) (i32.const 0xffffffff)) (i32.const 0xffffffff)) + +(assert_return (invoke "or" (i32.const 1) (i32.const 0)) (i32.const 1)) +(assert_return (invoke "or" (i32.const 0) (i32.const 1)) (i32.const 1)) +(assert_return (invoke "or" (i32.const 1) (i32.const 1)) (i32.const 1)) +(assert_return (invoke "or" (i32.const 0) (i32.const 0)) (i32.const 0)) +(assert_return (invoke "or" (i32.const 0x7fffffff) (i32.const 0x80000000)) (i32.const -1)) +(assert_return (invoke "or" (i32.const 0x80000000) (i32.const 0)) (i32.const 0x80000000)) +(assert_return (invoke "or" (i32.const 0xf0f0ffff) (i32.const 0xfffff0f0)) (i32.const 0xffffffff)) +(assert_return (invoke "or" (i32.const 0xffffffff) (i32.const 0xffffffff)) (i32.const 0xffffffff)) + +(assert_return (invoke "xor" (i32.const 1) (i32.const 0)) (i32.const 1)) +(assert_return (invoke "xor" (i32.const 0) (i32.const 1)) (i32.const 1)) +(assert_return (invoke "xor" (i32.const 1) (i32.const 1)) (i32.const 0)) +(assert_return (invoke "xor" (i32.const 0) (i32.const 0)) (i32.const 0)) +(assert_return (invoke "xor" (i32.const 0x7fffffff) (i32.const 0x80000000)) (i32.const -1)) +(assert_return (invoke "xor" (i32.const 0x80000000) (i32.const 0)) (i32.const 0x80000000)) +(assert_return (invoke "xor" (i32.const -1) (i32.const 0x80000000)) (i32.const 0x7fffffff)) +(assert_return (invoke "xor" (i32.const -1) (i32.const 0x7fffffff)) (i32.const 0x80000000)) +(assert_return (invoke "xor" (i32.const 0xf0f0ffff) (i32.const 0xfffff0f0)) (i32.const 0x0f0f0f0f)) +(assert_return (invoke "xor" (i32.const 0xffffffff) (i32.const 0xffffffff)) (i32.const 0)) + +(assert_return (invoke "shl" (i32.const 1) (i32.const 1)) (i32.const 2)) +(assert_return (invoke "shl" (i32.const 1) (i32.const 0)) (i32.const 1)) +(assert_return (invoke "shl" (i32.const 0x7fffffff) (i32.const 1)) (i32.const 0xfffffffe)) +(assert_return (invoke "shl" (i32.const 0xffffffff) (i32.const 1)) (i32.const 0xfffffffe)) +(assert_return (invoke "shl" (i32.const 0x80000000) (i32.const 1)) (i32.const 0)) +(assert_return (invoke "shl" (i32.const 0x40000000) (i32.const 1)) (i32.const 0x80000000)) +(assert_return (invoke "shl" (i32.const 1) (i32.const 31)) (i32.const 0x80000000)) +(assert_return (invoke "shl" (i32.const 1) (i32.const 32)) (i32.const 1)) +(assert_return (invoke "shl" (i32.const 1) (i32.const 33)) (i32.const 2)) +(assert_return (invoke "shl" (i32.const 1) (i32.const -1)) (i32.const 0x80000000)) +(assert_return (invoke "shl" (i32.const 1) (i32.const 0x7fffffff)) (i32.const 0x80000000)) + +(assert_return (invoke "shr_s" (i32.const 1) (i32.const 1)) (i32.const 0)) +(assert_return (invoke "shr_s" (i32.const 1) (i32.const 0)) (i32.const 1)) +(assert_return (invoke "shr_s" (i32.const -1) (i32.const 1)) (i32.const -1)) +(assert_return (invoke "shr_s" (i32.const 0x7fffffff) (i32.const 1)) (i32.const 0x3fffffff)) +(assert_return (invoke "shr_s" (i32.const 0x80000000) (i32.const 1)) (i32.const 0xc0000000)) +(assert_return (invoke "shr_s" (i32.const 0x40000000) (i32.const 1)) (i32.const 0x20000000)) +(assert_return (invoke "shr_s" (i32.const 1) (i32.const 32)) (i32.const 1)) +(assert_return (invoke "shr_s" (i32.const 1) (i32.const 33)) (i32.const 0)) +(assert_return (invoke "shr_s" (i32.const 1) (i32.const -1)) (i32.const 0)) +(assert_return (invoke "shr_s" (i32.const 1) (i32.const 0x7fffffff)) (i32.const 0)) +(assert_return (invoke "shr_s" (i32.const 1) (i32.const 0x80000000)) (i32.const 1)) +(assert_return (invoke "shr_s" (i32.const 0x80000000) (i32.const 31)) (i32.const -1)) +(assert_return (invoke "shr_s" (i32.const -1) (i32.const 32)) (i32.const -1)) +(assert_return (invoke "shr_s" (i32.const -1) (i32.const 33)) (i32.const -1)) +(assert_return (invoke "shr_s" (i32.const -1) (i32.const -1)) (i32.const -1)) +(assert_return (invoke "shr_s" (i32.const -1) (i32.const 0x7fffffff)) (i32.const -1)) +(assert_return (invoke "shr_s" (i32.const -1) (i32.const 0x80000000)) (i32.const -1)) + +(assert_return (invoke "shr_u" (i32.const 1) (i32.const 1)) (i32.const 0)) +(assert_return (invoke "shr_u" (i32.const 1) (i32.const 0)) (i32.const 1)) +(assert_return (invoke "shr_u" (i32.const -1) (i32.const 1)) (i32.const 0x7fffffff)) +(assert_return (invoke "shr_u" (i32.const 0x7fffffff) (i32.const 1)) (i32.const 0x3fffffff)) +(assert_return (invoke "shr_u" (i32.const 0x80000000) (i32.const 1)) (i32.const 0x40000000)) +(assert_return (invoke "shr_u" (i32.const 0x40000000) (i32.const 1)) (i32.const 0x20000000)) +(assert_return (invoke "shr_u" (i32.const 1) (i32.const 32)) (i32.const 1)) +(assert_return (invoke "shr_u" (i32.const 1) (i32.const 33)) (i32.const 0)) +(assert_return (invoke "shr_u" (i32.const 1) (i32.const -1)) (i32.const 0)) +(assert_return (invoke "shr_u" (i32.const 1) (i32.const 0x7fffffff)) (i32.const 0)) +(assert_return (invoke "shr_u" (i32.const 1) (i32.const 0x80000000)) (i32.const 1)) +(assert_return (invoke "shr_u" (i32.const 0x80000000) (i32.const 31)) (i32.const 1)) +(assert_return (invoke "shr_u" (i32.const -1) (i32.const 32)) (i32.const -1)) +(assert_return (invoke "shr_u" (i32.const -1) (i32.const 33)) (i32.const 0x7fffffff)) +(assert_return (invoke "shr_u" (i32.const -1) (i32.const -1)) (i32.const 1)) +(assert_return (invoke "shr_u" (i32.const -1) (i32.const 0x7fffffff)) (i32.const 1)) +(assert_return (invoke "shr_u" (i32.const -1) (i32.const 0x80000000)) (i32.const -1)) + +(assert_return (invoke "rotl" (i32.const 1) (i32.const 1)) (i32.const 2)) +(assert_return (invoke "rotl" (i32.const 1) (i32.const 0)) (i32.const 1)) +(assert_return (invoke "rotl" (i32.const -1) (i32.const 1)) (i32.const -1)) +(assert_return (invoke "rotl" (i32.const 1) (i32.const 32)) (i32.const 1)) +(assert_return (invoke "rotl" (i32.const 0xabcd9876) (i32.const 1)) (i32.const 0x579b30ed)) +(assert_return (invoke "rotl" (i32.const 0xfe00dc00) (i32.const 4)) (i32.const 0xe00dc00f)) +(assert_return (invoke "rotl" (i32.const 0xb0c1d2e3) (i32.const 5)) (i32.const 0x183a5c76)) +(assert_return (invoke "rotl" (i32.const 0x00008000) (i32.const 37)) (i32.const 0x00100000)) +(assert_return (invoke "rotl" (i32.const 0xb0c1d2e3) (i32.const 0xff05)) (i32.const 0x183a5c76)) +(assert_return (invoke "rotl" (i32.const 0x769abcdf) (i32.const 0xffffffed)) (i32.const 0x579beed3)) +(assert_return (invoke "rotl" (i32.const 0x769abcdf) (i32.const 0x8000000d)) (i32.const 0x579beed3)) +(assert_return (invoke "rotl" (i32.const 1) (i32.const 31)) (i32.const 0x80000000)) +(assert_return (invoke "rotl" (i32.const 0x80000000) (i32.const 1)) (i32.const 1)) + +(assert_return (invoke "rotr" (i32.const 1) (i32.const 1)) (i32.const 0x80000000)) +(assert_return (invoke "rotr" (i32.const 1) (i32.const 0)) (i32.const 1)) +(assert_return (invoke "rotr" (i32.const -1) (i32.const 1)) (i32.const -1)) +(assert_return (invoke "rotr" (i32.const 1) (i32.const 32)) (i32.const 1)) +(assert_return (invoke "rotr" (i32.const 0xff00cc00) (i32.const 1)) (i32.const 0x7f806600)) +(assert_return (invoke "rotr" (i32.const 0x00080000) (i32.const 4)) (i32.const 0x00008000)) +(assert_return (invoke "rotr" (i32.const 0xb0c1d2e3) (i32.const 5)) (i32.const 0x1d860e97)) +(assert_return (invoke "rotr" (i32.const 0x00008000) (i32.const 37)) (i32.const 0x00000400)) +(assert_return (invoke "rotr" (i32.const 0xb0c1d2e3) (i32.const 0xff05)) (i32.const 0x1d860e97)) +(assert_return (invoke "rotr" (i32.const 0x769abcdf) (i32.const 0xffffffed)) (i32.const 0xe6fbb4d5)) +(assert_return (invoke "rotr" (i32.const 0x769abcdf) (i32.const 0x8000000d)) (i32.const 0xe6fbb4d5)) +(assert_return (invoke "rotr" (i32.const 1) (i32.const 31)) (i32.const 2)) +(assert_return (invoke "rotr" (i32.const 0x80000000) (i32.const 31)) (i32.const 1)) + +(assert_return (invoke "clz" (i32.const 0xffffffff)) (i32.const 0)) +(assert_return (invoke "clz" (i32.const 0)) (i32.const 32)) +(assert_return (invoke "clz" (i32.const 0x00008000)) (i32.const 16)) +(assert_return (invoke "clz" (i32.const 0xff)) (i32.const 24)) +(assert_return (invoke "clz" (i32.const 0x80000000)) (i32.const 0)) +(assert_return (invoke "clz" (i32.const 1)) (i32.const 31)) +(assert_return (invoke "clz" (i32.const 2)) (i32.const 30)) +(assert_return (invoke "clz" (i32.const 0x7fffffff)) (i32.const 1)) + +(assert_return (invoke "ctz" (i32.const -1)) (i32.const 0)) +(assert_return (invoke "ctz" (i32.const 0)) (i32.const 32)) +(assert_return (invoke "ctz" (i32.const 0x00008000)) (i32.const 15)) +(assert_return (invoke "ctz" (i32.const 0x00010000)) (i32.const 16)) +(assert_return (invoke "ctz" (i32.const 0x80000000)) (i32.const 31)) +(assert_return (invoke "ctz" (i32.const 0x7fffffff)) (i32.const 0)) + +(assert_return (invoke "popcnt" (i32.const -1)) (i32.const 32)) +(assert_return (invoke "popcnt" (i32.const 0)) (i32.const 0)) +(assert_return (invoke "popcnt" (i32.const 0x00008000)) (i32.const 1)) +(assert_return (invoke "popcnt" (i32.const 0x80008000)) (i32.const 2)) +(assert_return (invoke "popcnt" (i32.const 0x7fffffff)) (i32.const 31)) +(assert_return (invoke "popcnt" (i32.const 0xAAAAAAAA)) (i32.const 16)) +(assert_return (invoke "popcnt" (i32.const 0x55555555)) (i32.const 16)) +(assert_return (invoke "popcnt" (i32.const 0xDEADBEEF)) (i32.const 24)) + +(assert_return (invoke "extend8_s" (i32.const 0)) (i32.const 0)) +(assert_return (invoke "extend8_s" (i32.const 0x7f)) (i32.const 127)) +(assert_return (invoke "extend8_s" (i32.const 0x80)) (i32.const -128)) +(assert_return (invoke "extend8_s" (i32.const 0xff)) (i32.const -1)) +(assert_return (invoke "extend8_s" (i32.const 0x012345_00)) (i32.const 0)) +(assert_return (invoke "extend8_s" (i32.const 0xfedcba_80)) (i32.const -0x80)) +(assert_return (invoke "extend8_s" (i32.const -1)) (i32.const -1)) + +(assert_return (invoke "extend16_s" (i32.const 0)) (i32.const 0)) +(assert_return (invoke "extend16_s" (i32.const 0x7fff)) (i32.const 32767)) +(assert_return (invoke "extend16_s" (i32.const 0x8000)) (i32.const -32768)) +(assert_return (invoke "extend16_s" (i32.const 0xffff)) (i32.const -1)) +(assert_return (invoke "extend16_s" (i32.const 0x0123_0000)) (i32.const 0)) +(assert_return (invoke "extend16_s" (i32.const 0xfedc_8000)) (i32.const -0x8000)) +(assert_return (invoke "extend16_s" (i32.const -1)) (i32.const -1)) + +(assert_return (invoke "eqz" (i32.const 0)) (i32.const 1)) +(assert_return (invoke "eqz" (i32.const 1)) (i32.const 0)) +(assert_return (invoke "eqz" (i32.const 0x80000000)) (i32.const 0)) +(assert_return (invoke "eqz" (i32.const 0x7fffffff)) (i32.const 0)) +(assert_return (invoke "eqz" (i32.const 0xffffffff)) (i32.const 0)) + +(assert_return (invoke "eq" (i32.const 0) (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 1)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 0x80000000) (i32.const 0x80000000)) (i32.const 1)) +(assert_return (invoke "eq" (i32.const 0x7fffffff) (i32.const 0x7fffffff)) (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 0)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 0) (i32.const 1)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 0x80000000) (i32.const 0)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 0) (i32.const 0x80000000)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 0x80000000) (i32.const -1)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const -1) (i32.const 0x80000000)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 0x80000000) (i32.const 0x7fffffff)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 0x7fffffff) (i32.const 0x80000000)) (i32.const 0)) + +(assert_return (invoke "ne" (i32.const 0) (i32.const 0)) (i32.const 0)) +(assert_return (invoke "ne" (i32.const 1) (i32.const 1)) (i32.const 0)) +(assert_return (invoke "ne" (i32.const -1) (i32.const 1)) (i32.const 1)) +(assert_return (invoke "ne" (i32.const 0x80000000) (i32.const 0x80000000)) (i32.const 0)) +(assert_return (invoke "ne" (i32.const 0x7fffffff) (i32.const 0x7fffffff)) (i32.const 0)) +(assert_return (invoke "ne" (i32.const -1) (i32.const -1)) (i32.const 0)) +(assert_return (invoke "ne" (i32.const 1) (i32.const 0)) (i32.const 1)) +(assert_return (invoke "ne" (i32.const 0) (i32.const 1)) (i32.const 1)) +(assert_return (invoke "ne" (i32.const 0x80000000) (i32.const 0)) (i32.const 1)) +(assert_return (invoke "ne" (i32.const 0) (i32.const 0x80000000)) (i32.const 1)) +(assert_return (invoke "ne" (i32.const 0x80000000) (i32.const -1)) (i32.const 1)) +(assert_return (invoke "ne" (i32.const -1) (i32.const 0x80000000)) (i32.const 1)) +(assert_return (invoke "ne" (i32.const 0x80000000) (i32.const 0x7fffffff)) (i32.const 1)) +(assert_return (invoke "ne" (i32.const 0x7fffffff) (i32.const 0x80000000)) (i32.const 1)) + +(assert_return (invoke "lt_s" (i32.const 0) (i32.const 0)) (i32.const 0)) +(assert_return (invoke "lt_s" (i32.const 1) (i32.const 1)) (i32.const 0)) +(assert_return (invoke "lt_s" (i32.const -1) (i32.const 1)) (i32.const 1)) +(assert_return (invoke "lt_s" (i32.const 0x80000000) (i32.const 0x80000000)) (i32.const 0)) +(assert_return (invoke "lt_s" (i32.const 0x7fffffff) (i32.const 0x7fffffff)) (i32.const 0)) +(assert_return (invoke "lt_s" (i32.const -1) (i32.const -1)) (i32.const 0)) +(assert_return (invoke "lt_s" (i32.const 1) (i32.const 0)) (i32.const 0)) +(assert_return (invoke "lt_s" (i32.const 0) (i32.const 1)) (i32.const 1)) +(assert_return (invoke "lt_s" (i32.const 0x80000000) (i32.const 0)) (i32.const 1)) +(assert_return (invoke "lt_s" (i32.const 0) (i32.const 0x80000000)) (i32.const 0)) +(assert_return (invoke "lt_s" (i32.const 0x80000000) (i32.const -1)) (i32.const 1)) +(assert_return (invoke "lt_s" (i32.const -1) (i32.const 0x80000000)) (i32.const 0)) +(assert_return (invoke "lt_s" (i32.const 0x80000000) (i32.const 0x7fffffff)) (i32.const 1)) +(assert_return (invoke "lt_s" (i32.const 0x7fffffff) (i32.const 0x80000000)) (i32.const 0)) + +(assert_return (invoke "lt_u" (i32.const 0) (i32.const 0)) (i32.const 0)) +(assert_return (invoke "lt_u" (i32.const 1) (i32.const 1)) (i32.const 0)) +(assert_return (invoke "lt_u" (i32.const -1) (i32.const 1)) (i32.const 0)) +(assert_return (invoke "lt_u" (i32.const 0x80000000) (i32.const 0x80000000)) (i32.const 0)) +(assert_return (invoke "lt_u" (i32.const 0x7fffffff) (i32.const 0x7fffffff)) (i32.const 0)) +(assert_return (invoke "lt_u" (i32.const -1) (i32.const -1)) (i32.const 0)) +(assert_return (invoke "lt_u" (i32.const 1) (i32.const 0)) (i32.const 0)) +(assert_return (invoke "lt_u" (i32.const 0) (i32.const 1)) (i32.const 1)) +(assert_return (invoke "lt_u" (i32.const 0x80000000) (i32.const 0)) (i32.const 0)) +(assert_return (invoke "lt_u" (i32.const 0) (i32.const 0x80000000)) (i32.const 1)) +(assert_return (invoke "lt_u" (i32.const 0x80000000) (i32.const -1)) (i32.const 1)) +(assert_return (invoke "lt_u" (i32.const -1) (i32.const 0x80000000)) (i32.const 0)) +(assert_return (invoke "lt_u" (i32.const 0x80000000) (i32.const 0x7fffffff)) (i32.const 0)) +(assert_return (invoke "lt_u" (i32.const 0x7fffffff) (i32.const 0x80000000)) (i32.const 1)) + +(assert_return (invoke "le_s" (i32.const 0) (i32.const 0)) (i32.const 1)) +(assert_return (invoke "le_s" (i32.const 1) (i32.const 1)) (i32.const 1)) +(assert_return (invoke "le_s" (i32.const -1) (i32.const 1)) (i32.const 1)) +(assert_return (invoke "le_s" (i32.const 0x80000000) (i32.const 0x80000000)) (i32.const 1)) +(assert_return (invoke "le_s" (i32.const 0x7fffffff) (i32.const 0x7fffffff)) (i32.const 1)) +(assert_return (invoke "le_s" (i32.const -1) (i32.const -1)) (i32.const 1)) +(assert_return (invoke "le_s" (i32.const 1) (i32.const 0)) (i32.const 0)) +(assert_return (invoke "le_s" (i32.const 0) (i32.const 1)) (i32.const 1)) +(assert_return (invoke "le_s" (i32.const 0x80000000) (i32.const 0)) (i32.const 1)) +(assert_return (invoke "le_s" (i32.const 0) (i32.const 0x80000000)) (i32.const 0)) +(assert_return (invoke "le_s" (i32.const 0x80000000) (i32.const -1)) (i32.const 1)) +(assert_return (invoke "le_s" (i32.const -1) (i32.const 0x80000000)) (i32.const 0)) +(assert_return (invoke "le_s" (i32.const 0x80000000) (i32.const 0x7fffffff)) (i32.const 1)) +(assert_return (invoke "le_s" (i32.const 0x7fffffff) (i32.const 0x80000000)) (i32.const 0)) + +(assert_return (invoke "le_u" (i32.const 0) (i32.const 0)) (i32.const 1)) +(assert_return (invoke "le_u" (i32.const 1) (i32.const 1)) (i32.const 1)) +(assert_return (invoke "le_u" (i32.const -1) (i32.const 1)) (i32.const 0)) +(assert_return (invoke "le_u" (i32.const 0x80000000) (i32.const 0x80000000)) (i32.const 1)) +(assert_return (invoke "le_u" (i32.const 0x7fffffff) (i32.const 0x7fffffff)) (i32.const 1)) +(assert_return (invoke "le_u" (i32.const -1) (i32.const -1)) (i32.const 1)) +(assert_return (invoke "le_u" (i32.const 1) (i32.const 0)) (i32.const 0)) +(assert_return (invoke "le_u" (i32.const 0) (i32.const 1)) (i32.const 1)) +(assert_return (invoke "le_u" (i32.const 0x80000000) (i32.const 0)) (i32.const 0)) +(assert_return (invoke "le_u" (i32.const 0) (i32.const 0x80000000)) (i32.const 1)) +(assert_return (invoke "le_u" (i32.const 0x80000000) (i32.const -1)) (i32.const 1)) +(assert_return (invoke "le_u" (i32.const -1) (i32.const 0x80000000)) (i32.const 0)) +(assert_return (invoke "le_u" (i32.const 0x80000000) (i32.const 0x7fffffff)) (i32.const 0)) +(assert_return (invoke "le_u" (i32.const 0x7fffffff) (i32.const 0x80000000)) (i32.const 1)) + +(assert_return (invoke "gt_s" (i32.const 0) (i32.const 0)) (i32.const 0)) +(assert_return (invoke "gt_s" (i32.const 1) (i32.const 1)) (i32.const 0)) +(assert_return (invoke "gt_s" (i32.const -1) (i32.const 1)) (i32.const 0)) +(assert_return (invoke "gt_s" (i32.const 0x80000000) (i32.const 0x80000000)) (i32.const 0)) +(assert_return (invoke "gt_s" (i32.const 0x7fffffff) (i32.const 0x7fffffff)) (i32.const 0)) +(assert_return (invoke "gt_s" (i32.const -1) (i32.const -1)) (i32.const 0)) +(assert_return (invoke "gt_s" (i32.const 1) (i32.const 0)) (i32.const 1)) +(assert_return (invoke "gt_s" (i32.const 0) (i32.const 1)) (i32.const 0)) +(assert_return (invoke "gt_s" (i32.const 0x80000000) (i32.const 0)) (i32.const 0)) +(assert_return (invoke "gt_s" (i32.const 0) (i32.const 0x80000000)) (i32.const 1)) +(assert_return (invoke "gt_s" (i32.const 0x80000000) (i32.const -1)) (i32.const 0)) +(assert_return (invoke "gt_s" (i32.const -1) (i32.const 0x80000000)) (i32.const 1)) +(assert_return (invoke "gt_s" (i32.const 0x80000000) (i32.const 0x7fffffff)) (i32.const 0)) +(assert_return (invoke "gt_s" (i32.const 0x7fffffff) (i32.const 0x80000000)) (i32.const 1)) + +(assert_return (invoke "gt_u" (i32.const 0) (i32.const 0)) (i32.const 0)) +(assert_return (invoke "gt_u" (i32.const 1) (i32.const 1)) (i32.const 0)) +(assert_return (invoke "gt_u" (i32.const -1) (i32.const 1)) (i32.const 1)) +(assert_return (invoke "gt_u" (i32.const 0x80000000) (i32.const 0x80000000)) (i32.const 0)) +(assert_return (invoke "gt_u" (i32.const 0x7fffffff) (i32.const 0x7fffffff)) (i32.const 0)) +(assert_return (invoke "gt_u" (i32.const -1) (i32.const -1)) (i32.const 0)) +(assert_return (invoke "gt_u" (i32.const 1) (i32.const 0)) (i32.const 1)) +(assert_return (invoke "gt_u" (i32.const 0) (i32.const 1)) (i32.const 0)) +(assert_return (invoke "gt_u" (i32.const 0x80000000) (i32.const 0)) (i32.const 1)) +(assert_return (invoke "gt_u" (i32.const 0) (i32.const 0x80000000)) (i32.const 0)) +(assert_return (invoke "gt_u" (i32.const 0x80000000) (i32.const -1)) (i32.const 0)) +(assert_return (invoke "gt_u" (i32.const -1) (i32.const 0x80000000)) (i32.const 1)) +(assert_return (invoke "gt_u" (i32.const 0x80000000) (i32.const 0x7fffffff)) (i32.const 1)) +(assert_return (invoke "gt_u" (i32.const 0x7fffffff) (i32.const 0x80000000)) (i32.const 0)) + +(assert_return (invoke "ge_s" (i32.const 0) (i32.const 0)) (i32.const 1)) +(assert_return (invoke "ge_s" (i32.const 1) (i32.const 1)) (i32.const 1)) +(assert_return (invoke "ge_s" (i32.const -1) (i32.const 1)) (i32.const 0)) +(assert_return (invoke "ge_s" (i32.const 0x80000000) (i32.const 0x80000000)) (i32.const 1)) +(assert_return (invoke "ge_s" (i32.const 0x7fffffff) (i32.const 0x7fffffff)) (i32.const 1)) +(assert_return (invoke "ge_s" (i32.const -1) (i32.const -1)) (i32.const 1)) +(assert_return (invoke "ge_s" (i32.const 1) (i32.const 0)) (i32.const 1)) +(assert_return (invoke "ge_s" (i32.const 0) (i32.const 1)) (i32.const 0)) +(assert_return (invoke "ge_s" (i32.const 0x80000000) (i32.const 0)) (i32.const 0)) +(assert_return (invoke "ge_s" (i32.const 0) (i32.const 0x80000000)) (i32.const 1)) +(assert_return (invoke "ge_s" (i32.const 0x80000000) (i32.const -1)) (i32.const 0)) +(assert_return (invoke "ge_s" (i32.const -1) (i32.const 0x80000000)) (i32.const 1)) +(assert_return (invoke "ge_s" (i32.const 0x80000000) (i32.const 0x7fffffff)) (i32.const 0)) +(assert_return (invoke "ge_s" (i32.const 0x7fffffff) (i32.const 0x80000000)) (i32.const 1)) + +(assert_return (invoke "ge_u" (i32.const 0) (i32.const 0)) (i32.const 1)) +(assert_return (invoke "ge_u" (i32.const 1) (i32.const 1)) (i32.const 1)) +(assert_return (invoke "ge_u" (i32.const -1) (i32.const 1)) (i32.const 1)) +(assert_return (invoke "ge_u" (i32.const 0x80000000) (i32.const 0x80000000)) (i32.const 1)) +(assert_return (invoke "ge_u" (i32.const 0x7fffffff) (i32.const 0x7fffffff)) (i32.const 1)) +(assert_return (invoke "ge_u" (i32.const -1) (i32.const -1)) (i32.const 1)) +(assert_return (invoke "ge_u" (i32.const 1) (i32.const 0)) (i32.const 1)) +(assert_return (invoke "ge_u" (i32.const 0) (i32.const 1)) (i32.const 0)) +(assert_return (invoke "ge_u" (i32.const 0x80000000) (i32.const 0)) (i32.const 1)) +(assert_return (invoke "ge_u" (i32.const 0) (i32.const 0x80000000)) (i32.const 0)) +(assert_return (invoke "ge_u" (i32.const 0x80000000) (i32.const -1)) (i32.const 0)) +(assert_return (invoke "ge_u" (i32.const -1) (i32.const 0x80000000)) (i32.const 1)) +(assert_return (invoke "ge_u" (i32.const 0x80000000) (i32.const 0x7fffffff)) (i32.const 1)) +(assert_return (invoke "ge_u" (i32.const 0x7fffffff) (i32.const 0x80000000)) (i32.const 0)) + + +(assert_invalid + (module + (func $type-unary-operand-empty + (i32.eqz) (drop) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-unary-operand-empty-in-block + (i32.const 0) + (block (i32.eqz) (drop)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-unary-operand-empty-in-loop + (i32.const 0) + (loop (i32.eqz) (drop)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-unary-operand-empty-in-if + (i32.const 0) (i32.const 0) + (if (then (i32.eqz) (drop))) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-unary-operand-empty-in-else + (i32.const 0) (i32.const 0) + (if (result i32) (then (i32.const 0)) (else (i32.eqz))) (drop) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-unary-operand-empty-in-br + (i32.const 0) + (block (br 0 (i32.eqz)) (drop)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-unary-operand-empty-in-br_if + (i32.const 0) + (block (br_if 0 (i32.eqz) (i32.const 1)) (drop)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-unary-operand-empty-in-br_table + (i32.const 0) + (block (br_table 0 (i32.eqz)) (drop)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-unary-operand-empty-in-return + (return (i32.eqz)) (drop) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-unary-operand-empty-in-select + (select (i32.eqz) (i32.const 1) (i32.const 2)) (drop) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-unary-operand-empty-in-call + (call 1 (i32.eqz)) (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-unary-operand-empty-in-call_indirect + (block (result i32) + (call_indirect (type $sig) + (i32.eqz) (i32.const 0) + ) + (drop) + ) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-unary-operand-empty-in-local.set + (local i32) + (local.set 0 (i32.eqz)) (local.get 0) (drop) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-unary-operand-empty-in-local.tee + (local i32) + (local.tee 0 (i32.eqz)) (drop) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (global $x (mut i32) (i32.const 0)) + (func $type-unary-operand-empty-in-global.set + (global.set $x (i32.eqz)) (global.get $x) (drop) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (memory 0) + (func $type-unary-operand-empty-in-memory.grow + (memory.grow (i32.eqz)) (drop) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (memory 0) + (func $type-unary-operand-empty-in-load + (i32.load (i32.eqz)) (drop) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (memory 1) + (func $type-unary-operand-empty-in-store + (i32.store (i32.eqz) (i32.const 1)) + ) + ) + "type mismatch" +) + +(assert_invalid + (module + (func $type-binary-1st-operand-empty + (i32.add) (drop) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-binary-2nd-operand-empty + (i32.const 0) (i32.add) (drop) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-binary-1st-operand-empty-in-block + (i32.const 0) (i32.const 0) + (block (i32.add) (drop)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-binary-2nd-operand-empty-in-block + (i32.const 0) + (block (i32.const 0) (i32.add) (drop)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-binary-1st-operand-empty-in-loop + (i32.const 0) (i32.const 0) + (loop (i32.add) (drop)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-binary-2nd-operand-empty-in-loop + (i32.const 0) + (loop (i32.const 0) (i32.add) (drop)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-binary-1st-operand-empty-in-if + (i32.const 0) (i32.const 0) (i32.const 0) + (if (i32.add) (then (drop))) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-binary-2nd-operand-empty-in-if + (i32.const 0) (i32.const 0) + (if (i32.const 0) (then (i32.add)) (else (drop))) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-binary-1st-operand-empty-in-else + (i32.const 0) (i32.const 0) (i32.const 0) + (if (result i32) (then (i32.const 0)) (else (i32.add) (i32.const 0))) + (drop) (drop) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-binary-2nd-operand-empty-in-else + (i32.const 0) (i32.const 0) + (if (result i32) (then (i32.const 0)) (else (i32.add))) + (drop) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-binary-1st-operand-empty-in-br + (i32.const 0) (i32.const 0) + (block (br 0 (i32.add)) (drop)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-binary-2nd-operand-empty-in-br + (i32.const 0) + (block (br 0 (i32.const 0) (i32.add)) (drop)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-binary-1st-operand-empty-in-br_if + (i32.const 0) (i32.const 0) + (block (br_if 0 (i32.add) (i32.const 1)) (drop)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-binary-2nd-operand-empty-in-br_if + (i32.const 0) + (block (br_if 0 (i32.const 0) (i32.add) (i32.const 1)) (drop)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-binary-1st-operand-empty-in-br_table + (i32.const 0) (i32.const 0) + (block (br_table 0 (i32.add)) (drop)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-binary-2nd-operand-empty-in-br_table + (i32.const 0) + (block (br_table 0 (i32.const 0) (i32.add)) (drop)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-binary-1st-operand-empty-in-return + (return (i32.add)) (drop) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-binary-2nd-operand-empty-in-return + (return (i32.const 0) (i32.add)) (drop) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-binary-1st-operand-empty-in-select + (select (i32.add) (i32.const 1) (i32.const 2)) (drop) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-binary-2nd-operand-empty-in-select + (select (i32.const 0) (i32.add) (i32.const 1) (i32.const 2)) (drop) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-binary-1st-operand-empty-in-call + (call 1 (i32.add)) (drop) + ) + (func (param i32 i32) (result i32) (local.get 0)) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-binary-2nd-operand-empty-in-call + (call 1 (i32.const 0) (i32.add)) (drop) + ) + (func (param i32 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-binary-1st-operand-empty-in-call_indirect + (block (result i32) + (call_indirect (type $sig) + (i32.add) (i32.const 0) + ) + (drop) + ) + ) + ) + "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-binary-2nd-operand-empty-in-call_indirect + (block (result i32) + (call_indirect (type $sig) + (i32.const 0) (i32.add) (i32.const 0) + ) + (drop) + ) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-binary-1st-operand-empty-in-local.set + (local i32) + (local.set 0 (i32.add)) (local.get 0) (drop) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-binary-2nd-operand-empty-in-local.set + (local i32) + (local.set 0 (i32.const 0) (i32.add)) (local.get 0) (drop) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-binary-1st-operand-empty-in-local.tee + (local i32) + (local.tee 0 (i32.add)) (drop) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-binary-2nd-operand-empty-in-local.tee + (local i32) + (local.tee 0 (i32.const 0) (i32.add)) (drop) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (global $x (mut i32) (i32.const 0)) + (func $type-binary-1st-operand-empty-in-global.set + (global.set $x (i32.add)) (global.get $x) (drop) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (global $x (mut i32) (i32.const 0)) + (func $type-binary-2nd-operand-empty-in-global.set + (global.set $x (i32.const 0) (i32.add)) (global.get $x) (drop) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (memory 0) + (func $type-binary-1st-operand-empty-in-memory.grow + (memory.grow (i32.add)) (drop) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (memory 0) + (func $type-binary-2nd-operand-empty-in-memory.grow + (memory.grow (i32.const 0) (i32.add)) (drop) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (memory 0) + (func $type-binary-1st-operand-empty-in-load + (i32.load (i32.add)) (drop) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (memory 0) + (func $type-binary-2nd-operand-empty-in-load + (i32.load (i32.const 0) (i32.add)) (drop) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (memory 1) + (func $type-binary-1st-operand-empty-in-store + (i32.store (i32.add) (i32.const 1)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (memory 1) + (func $type-binary-2nd-operand-empty-in-store + (i32.store (i32.const 1) (i32.add) (i32.const 0)) + ) + ) + "type mismatch" +) + + +;; Type check + +(assert_invalid (module (func (result i32) (i32.add (i64.const 0) (f32.const 0)))) "type mismatch") +(assert_invalid (module (func (result i32) (i32.and (i64.const 0) (f32.const 0)))) "type mismatch") +(assert_invalid (module (func (result i32) (i32.div_s (i64.const 0) (f32.const 0)))) "type mismatch") +(assert_invalid (module (func (result i32) (i32.div_u (i64.const 0) (f32.const 0)))) "type mismatch") +(assert_invalid (module (func (result i32) (i32.mul (i64.const 0) (f32.const 0)))) "type mismatch") +(assert_invalid (module (func (result i32) (i32.or (i64.const 0) (f32.const 0)))) "type mismatch") +(assert_invalid (module (func (result i32) (i32.rem_s (i64.const 0) (f32.const 0)))) "type mismatch") +(assert_invalid (module (func (result i32) (i32.rem_u (i64.const 0) (f32.const 0)))) "type mismatch") +(assert_invalid (module (func (result i32) (i32.rotl (i64.const 0) (f32.const 0)))) "type mismatch") +(assert_invalid (module (func (result i32) (i32.rotr (i64.const 0) (f32.const 0)))) "type mismatch") +(assert_invalid (module (func (result i32) (i32.shl (i64.const 0) (f32.const 0)))) "type mismatch") +(assert_invalid (module (func (result i32) (i32.shr_s (i64.const 0) (f32.const 0)))) "type mismatch") +(assert_invalid (module (func (result i32) (i32.shr_u (i64.const 0) (f32.const 0)))) "type mismatch") +(assert_invalid (module (func (result i32) (i32.sub (i64.const 0) (f32.const 0)))) "type mismatch") +(assert_invalid (module (func (result i32) (i32.xor (i64.const 0) (f32.const 0)))) "type mismatch") +(assert_invalid (module (func (result i32) (i32.eqz (i64.const 0)))) "type mismatch") +(assert_invalid (module (func (result i32) (i32.clz (i64.const 0)))) "type mismatch") +(assert_invalid (module (func (result i32) (i32.ctz (i64.const 0)))) "type mismatch") +(assert_invalid (module (func (result i32) (i32.popcnt (i64.const 0)))) "type mismatch") +(assert_invalid (module (func (result i32) (i32.eq (i64.const 0) (f32.const 0)))) "type mismatch") +(assert_invalid (module (func (result i32) (i32.ge_s (i64.const 0) (f32.const 0)))) "type mismatch") +(assert_invalid (module (func (result i32) (i32.ge_u (i64.const 0) (f32.const 0)))) "type mismatch") +(assert_invalid (module (func (result i32) (i32.gt_s (i64.const 0) (f32.const 0)))) "type mismatch") +(assert_invalid (module (func (result i32) (i32.gt_u (i64.const 0) (f32.const 0)))) "type mismatch") +(assert_invalid (module (func (result i32) (i32.le_s (i64.const 0) (f32.const 0)))) "type mismatch") +(assert_invalid (module (func (result i32) (i32.le_u (i64.const 0) (f32.const 0)))) "type mismatch") +(assert_invalid (module (func (result i32) (i32.lt_s (i64.const 0) (f32.const 0)))) "type mismatch") +(assert_invalid (module (func (result i32) (i32.lt_u (i64.const 0) (f32.const 0)))) "type mismatch") +(assert_invalid (module (func (result i32) (i32.ne (i64.const 0) (f32.const 0)))) "type mismatch") diff --git a/runtime/near-vm/tests/wast/spec/i64.wast b/runtime/near-vm/tests/wast/spec/i64.wast new file mode 100644 index 00000000000..baeed0ce1ba --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/i64.wast @@ -0,0 +1,485 @@ +;; i64 operations + +(module + (func (export "add") (param $x i64) (param $y i64) (result i64) (i64.add (local.get $x) (local.get $y))) + (func (export "sub") (param $x i64) (param $y i64) (result i64) (i64.sub (local.get $x) (local.get $y))) + (func (export "mul") (param $x i64) (param $y i64) (result i64) (i64.mul (local.get $x) (local.get $y))) + (func (export "div_s") (param $x i64) (param $y i64) (result i64) (i64.div_s (local.get $x) (local.get $y))) + (func (export "div_u") (param $x i64) (param $y i64) (result i64) (i64.div_u (local.get $x) (local.get $y))) + (func (export "rem_s") (param $x i64) (param $y i64) (result i64) (i64.rem_s (local.get $x) (local.get $y))) + (func (export "rem_u") (param $x i64) (param $y i64) (result i64) (i64.rem_u (local.get $x) (local.get $y))) + (func (export "and") (param $x i64) (param $y i64) (result i64) (i64.and (local.get $x) (local.get $y))) + (func (export "or") (param $x i64) (param $y i64) (result i64) (i64.or (local.get $x) (local.get $y))) + (func (export "xor") (param $x i64) (param $y i64) (result i64) (i64.xor (local.get $x) (local.get $y))) + (func (export "shl") (param $x i64) (param $y i64) (result i64) (i64.shl (local.get $x) (local.get $y))) + (func (export "shr_s") (param $x i64) (param $y i64) (result i64) (i64.shr_s (local.get $x) (local.get $y))) + (func (export "shr_u") (param $x i64) (param $y i64) (result i64) (i64.shr_u (local.get $x) (local.get $y))) + (func (export "rotl") (param $x i64) (param $y i64) (result i64) (i64.rotl (local.get $x) (local.get $y))) + (func (export "rotr") (param $x i64) (param $y i64) (result i64) (i64.rotr (local.get $x) (local.get $y))) + (func (export "clz") (param $x i64) (result i64) (i64.clz (local.get $x))) + (func (export "ctz") (param $x i64) (result i64) (i64.ctz (local.get $x))) + (func (export "popcnt") (param $x i64) (result i64) (i64.popcnt (local.get $x))) + (func (export "extend8_s") (param $x i64) (result i64) (i64.extend8_s (local.get $x))) + (func (export "extend16_s") (param $x i64) (result i64) (i64.extend16_s (local.get $x))) + (func (export "extend32_s") (param $x i64) (result i64) (i64.extend32_s (local.get $x))) + (func (export "eqz") (param $x i64) (result i32) (i64.eqz (local.get $x))) + (func (export "eq") (param $x i64) (param $y i64) (result i32) (i64.eq (local.get $x) (local.get $y))) + (func (export "ne") (param $x i64) (param $y i64) (result i32) (i64.ne (local.get $x) (local.get $y))) + (func (export "lt_s") (param $x i64) (param $y i64) (result i32) (i64.lt_s (local.get $x) (local.get $y))) + (func (export "lt_u") (param $x i64) (param $y i64) (result i32) (i64.lt_u (local.get $x) (local.get $y))) + (func (export "le_s") (param $x i64) (param $y i64) (result i32) (i64.le_s (local.get $x) (local.get $y))) + (func (export "le_u") (param $x i64) (param $y i64) (result i32) (i64.le_u (local.get $x) (local.get $y))) + (func (export "gt_s") (param $x i64) (param $y i64) (result i32) (i64.gt_s (local.get $x) (local.get $y))) + (func (export "gt_u") (param $x i64) (param $y i64) (result i32) (i64.gt_u (local.get $x) (local.get $y))) + (func (export "ge_s") (param $x i64) (param $y i64) (result i32) (i64.ge_s (local.get $x) (local.get $y))) + (func (export "ge_u") (param $x i64) (param $y i64) (result i32) (i64.ge_u (local.get $x) (local.get $y))) +) + +(assert_return (invoke "add" (i64.const 1) (i64.const 1)) (i64.const 2)) +(assert_return (invoke "add" (i64.const 1) (i64.const 0)) (i64.const 1)) +(assert_return (invoke "add" (i64.const -1) (i64.const -1)) (i64.const -2)) +(assert_return (invoke "add" (i64.const -1) (i64.const 1)) (i64.const 0)) +(assert_return (invoke "add" (i64.const 0x7fffffffffffffff) (i64.const 1)) (i64.const 0x8000000000000000)) +(assert_return (invoke "add" (i64.const 0x8000000000000000) (i64.const -1)) (i64.const 0x7fffffffffffffff)) +(assert_return (invoke "add" (i64.const 0x8000000000000000) (i64.const 0x8000000000000000)) (i64.const 0)) +(assert_return (invoke "add" (i64.const 0x3fffffff) (i64.const 1)) (i64.const 0x40000000)) + +(assert_return (invoke "sub" (i64.const 1) (i64.const 1)) (i64.const 0)) +(assert_return (invoke "sub" (i64.const 1) (i64.const 0)) (i64.const 1)) +(assert_return (invoke "sub" (i64.const -1) (i64.const -1)) (i64.const 0)) +(assert_return (invoke "sub" (i64.const 0x7fffffffffffffff) (i64.const -1)) (i64.const 0x8000000000000000)) +(assert_return (invoke "sub" (i64.const 0x8000000000000000) (i64.const 1)) (i64.const 0x7fffffffffffffff)) +(assert_return (invoke "sub" (i64.const 0x8000000000000000) (i64.const 0x8000000000000000)) (i64.const 0)) +(assert_return (invoke "sub" (i64.const 0x3fffffff) (i64.const -1)) (i64.const 0x40000000)) + +(assert_return (invoke "mul" (i64.const 1) (i64.const 1)) (i64.const 1)) +(assert_return (invoke "mul" (i64.const 1) (i64.const 0)) (i64.const 0)) +(assert_return (invoke "mul" (i64.const -1) (i64.const -1)) (i64.const 1)) +(assert_return (invoke "mul" (i64.const 0x1000000000000000) (i64.const 4096)) (i64.const 0)) +(assert_return (invoke "mul" (i64.const 0x8000000000000000) (i64.const 0)) (i64.const 0)) +(assert_return (invoke "mul" (i64.const 0x8000000000000000) (i64.const -1)) (i64.const 0x8000000000000000)) +(assert_return (invoke "mul" (i64.const 0x7fffffffffffffff) (i64.const -1)) (i64.const 0x8000000000000001)) +(assert_return (invoke "mul" (i64.const 0x0123456789abcdef) (i64.const 0xfedcba9876543210)) (i64.const 0x2236d88fe5618cf0)) +(assert_return (invoke "mul" (i64.const 0x7fffffffffffffff) (i64.const 0x7fffffffffffffff)) (i64.const 1)) + +(assert_trap (invoke "div_s" (i64.const 1) (i64.const 0)) "integer divide by zero") +(assert_trap (invoke "div_s" (i64.const 0) (i64.const 0)) "integer divide by zero") +(assert_trap (invoke "div_s" (i64.const 0x8000000000000000) (i64.const -1)) "integer overflow") +(assert_trap (invoke "div_s" (i64.const 0x8000000000000000) (i64.const 0)) "integer divide by zero") +(assert_return (invoke "div_s" (i64.const 1) (i64.const 1)) (i64.const 1)) +(assert_return (invoke "div_s" (i64.const 0) (i64.const 1)) (i64.const 0)) +(assert_return (invoke "div_s" (i64.const 0) (i64.const -1)) (i64.const 0)) +(assert_return (invoke "div_s" (i64.const -1) (i64.const -1)) (i64.const 1)) +(assert_return (invoke "div_s" (i64.const 0x8000000000000000) (i64.const 2)) (i64.const 0xc000000000000000)) +(assert_return (invoke "div_s" (i64.const 0x8000000000000001) (i64.const 1000)) (i64.const 0xffdf3b645a1cac09)) +(assert_return (invoke "div_s" (i64.const 5) (i64.const 2)) (i64.const 2)) +(assert_return (invoke "div_s" (i64.const -5) (i64.const 2)) (i64.const -2)) +(assert_return (invoke "div_s" (i64.const 5) (i64.const -2)) (i64.const -2)) +(assert_return (invoke "div_s" (i64.const -5) (i64.const -2)) (i64.const 2)) +(assert_return (invoke "div_s" (i64.const 7) (i64.const 3)) (i64.const 2)) +(assert_return (invoke "div_s" (i64.const -7) (i64.const 3)) (i64.const -2)) +(assert_return (invoke "div_s" (i64.const 7) (i64.const -3)) (i64.const -2)) +(assert_return (invoke "div_s" (i64.const -7) (i64.const -3)) (i64.const 2)) +(assert_return (invoke "div_s" (i64.const 11) (i64.const 5)) (i64.const 2)) +(assert_return (invoke "div_s" (i64.const 17) (i64.const 7)) (i64.const 2)) + +(assert_trap (invoke "div_u" (i64.const 1) (i64.const 0)) "integer divide by zero") +(assert_trap (invoke "div_u" (i64.const 0) (i64.const 0)) "integer divide by zero") +(assert_return (invoke "div_u" (i64.const 1) (i64.const 1)) (i64.const 1)) +(assert_return (invoke "div_u" (i64.const 0) (i64.const 1)) (i64.const 0)) +(assert_return (invoke "div_u" (i64.const -1) (i64.const -1)) (i64.const 1)) +(assert_return (invoke "div_u" (i64.const 0x8000000000000000) (i64.const -1)) (i64.const 0)) +(assert_return (invoke "div_u" (i64.const 0x8000000000000000) (i64.const 2)) (i64.const 0x4000000000000000)) +(assert_return (invoke "div_u" (i64.const 0x8ff00ff00ff00ff0) (i64.const 0x100000001)) (i64.const 0x8ff00fef)) +(assert_return (invoke "div_u" (i64.const 0x8000000000000001) (i64.const 1000)) (i64.const 0x20c49ba5e353f7)) +(assert_return (invoke "div_u" (i64.const 5) (i64.const 2)) (i64.const 2)) +(assert_return (invoke "div_u" (i64.const -5) (i64.const 2)) (i64.const 0x7ffffffffffffffd)) +(assert_return (invoke "div_u" (i64.const 5) (i64.const -2)) (i64.const 0)) +(assert_return (invoke "div_u" (i64.const -5) (i64.const -2)) (i64.const 0)) +(assert_return (invoke "div_u" (i64.const 7) (i64.const 3)) (i64.const 2)) +(assert_return (invoke "div_u" (i64.const 11) (i64.const 5)) (i64.const 2)) +(assert_return (invoke "div_u" (i64.const 17) (i64.const 7)) (i64.const 2)) + +(assert_trap (invoke "rem_s" (i64.const 1) (i64.const 0)) "integer divide by zero") +(assert_trap (invoke "rem_s" (i64.const 0) (i64.const 0)) "integer divide by zero") +(assert_return (invoke "rem_s" (i64.const 0x7fffffffffffffff) (i64.const -1)) (i64.const 0)) +(assert_return (invoke "rem_s" (i64.const 1) (i64.const 1)) (i64.const 0)) +(assert_return (invoke "rem_s" (i64.const 0) (i64.const 1)) (i64.const 0)) +(assert_return (invoke "rem_s" (i64.const 0) (i64.const -1)) (i64.const 0)) +(assert_return (invoke "rem_s" (i64.const -1) (i64.const -1)) (i64.const 0)) +(assert_return (invoke "rem_s" (i64.const 0x8000000000000000) (i64.const -1)) (i64.const 0)) +(assert_return (invoke "rem_s" (i64.const 0x8000000000000000) (i64.const 2)) (i64.const 0)) +(assert_return (invoke "rem_s" (i64.const 0x8000000000000001) (i64.const 1000)) (i64.const -807)) +(assert_return (invoke "rem_s" (i64.const 5) (i64.const 2)) (i64.const 1)) +(assert_return (invoke "rem_s" (i64.const -5) (i64.const 2)) (i64.const -1)) +(assert_return (invoke "rem_s" (i64.const 5) (i64.const -2)) (i64.const 1)) +(assert_return (invoke "rem_s" (i64.const -5) (i64.const -2)) (i64.const -1)) +(assert_return (invoke "rem_s" (i64.const 7) (i64.const 3)) (i64.const 1)) +(assert_return (invoke "rem_s" (i64.const -7) (i64.const 3)) (i64.const -1)) +(assert_return (invoke "rem_s" (i64.const 7) (i64.const -3)) (i64.const 1)) +(assert_return (invoke "rem_s" (i64.const -7) (i64.const -3)) (i64.const -1)) +(assert_return (invoke "rem_s" (i64.const 11) (i64.const 5)) (i64.const 1)) +(assert_return (invoke "rem_s" (i64.const 17) (i64.const 7)) (i64.const 3)) + +(assert_trap (invoke "rem_u" (i64.const 1) (i64.const 0)) "integer divide by zero") +(assert_trap (invoke "rem_u" (i64.const 0) (i64.const 0)) "integer divide by zero") +(assert_return (invoke "rem_u" (i64.const 1) (i64.const 1)) (i64.const 0)) +(assert_return (invoke "rem_u" (i64.const 0) (i64.const 1)) (i64.const 0)) +(assert_return (invoke "rem_u" (i64.const -1) (i64.const -1)) (i64.const 0)) +(assert_return (invoke "rem_u" (i64.const 0x8000000000000000) (i64.const -1)) (i64.const 0x8000000000000000)) +(assert_return (invoke "rem_u" (i64.const 0x8000000000000000) (i64.const 2)) (i64.const 0)) +(assert_return (invoke "rem_u" (i64.const 0x8ff00ff00ff00ff0) (i64.const 0x100000001)) (i64.const 0x80000001)) +(assert_return (invoke "rem_u" (i64.const 0x8000000000000001) (i64.const 1000)) (i64.const 809)) +(assert_return (invoke "rem_u" (i64.const 5) (i64.const 2)) (i64.const 1)) +(assert_return (invoke "rem_u" (i64.const -5) (i64.const 2)) (i64.const 1)) +(assert_return (invoke "rem_u" (i64.const 5) (i64.const -2)) (i64.const 5)) +(assert_return (invoke "rem_u" (i64.const -5) (i64.const -2)) (i64.const -5)) +(assert_return (invoke "rem_u" (i64.const 7) (i64.const 3)) (i64.const 1)) +(assert_return (invoke "rem_u" (i64.const 11) (i64.const 5)) (i64.const 1)) +(assert_return (invoke "rem_u" (i64.const 17) (i64.const 7)) (i64.const 3)) + +(assert_return (invoke "and" (i64.const 1) (i64.const 0)) (i64.const 0)) +(assert_return (invoke "and" (i64.const 0) (i64.const 1)) (i64.const 0)) +(assert_return (invoke "and" (i64.const 1) (i64.const 1)) (i64.const 1)) +(assert_return (invoke "and" (i64.const 0) (i64.const 0)) (i64.const 0)) +(assert_return (invoke "and" (i64.const 0x7fffffffffffffff) (i64.const 0x8000000000000000)) (i64.const 0)) +(assert_return (invoke "and" (i64.const 0x7fffffffffffffff) (i64.const -1)) (i64.const 0x7fffffffffffffff)) +(assert_return (invoke "and" (i64.const 0xf0f0ffff) (i64.const 0xfffff0f0)) (i64.const 0xf0f0f0f0)) +(assert_return (invoke "and" (i64.const 0xffffffffffffffff) (i64.const 0xffffffffffffffff)) (i64.const 0xffffffffffffffff)) + +(assert_return (invoke "or" (i64.const 1) (i64.const 0)) (i64.const 1)) +(assert_return (invoke "or" (i64.const 0) (i64.const 1)) (i64.const 1)) +(assert_return (invoke "or" (i64.const 1) (i64.const 1)) (i64.const 1)) +(assert_return (invoke "or" (i64.const 0) (i64.const 0)) (i64.const 0)) +(assert_return (invoke "or" (i64.const 0x7fffffffffffffff) (i64.const 0x8000000000000000)) (i64.const -1)) +(assert_return (invoke "or" (i64.const 0x8000000000000000) (i64.const 0)) (i64.const 0x8000000000000000)) +(assert_return (invoke "or" (i64.const 0xf0f0ffff) (i64.const 0xfffff0f0)) (i64.const 0xffffffff)) +(assert_return (invoke "or" (i64.const 0xffffffffffffffff) (i64.const 0xffffffffffffffff)) (i64.const 0xffffffffffffffff)) + +(assert_return (invoke "xor" (i64.const 1) (i64.const 0)) (i64.const 1)) +(assert_return (invoke "xor" (i64.const 0) (i64.const 1)) (i64.const 1)) +(assert_return (invoke "xor" (i64.const 1) (i64.const 1)) (i64.const 0)) +(assert_return (invoke "xor" (i64.const 0) (i64.const 0)) (i64.const 0)) +(assert_return (invoke "xor" (i64.const 0x7fffffffffffffff) (i64.const 0x8000000000000000)) (i64.const -1)) +(assert_return (invoke "xor" (i64.const 0x8000000000000000) (i64.const 0)) (i64.const 0x8000000000000000)) +(assert_return (invoke "xor" (i64.const -1) (i64.const 0x8000000000000000)) (i64.const 0x7fffffffffffffff)) +(assert_return (invoke "xor" (i64.const -1) (i64.const 0x7fffffffffffffff)) (i64.const 0x8000000000000000)) +(assert_return (invoke "xor" (i64.const 0xf0f0ffff) (i64.const 0xfffff0f0)) (i64.const 0x0f0f0f0f)) +(assert_return (invoke "xor" (i64.const 0xffffffffffffffff) (i64.const 0xffffffffffffffff)) (i64.const 0)) + +(assert_return (invoke "shl" (i64.const 1) (i64.const 1)) (i64.const 2)) +(assert_return (invoke "shl" (i64.const 1) (i64.const 0)) (i64.const 1)) +(assert_return (invoke "shl" (i64.const 0x7fffffffffffffff) (i64.const 1)) (i64.const 0xfffffffffffffffe)) +(assert_return (invoke "shl" (i64.const 0xffffffffffffffff) (i64.const 1)) (i64.const 0xfffffffffffffffe)) +(assert_return (invoke "shl" (i64.const 0x8000000000000000) (i64.const 1)) (i64.const 0)) +(assert_return (invoke "shl" (i64.const 0x4000000000000000) (i64.const 1)) (i64.const 0x8000000000000000)) +(assert_return (invoke "shl" (i64.const 1) (i64.const 63)) (i64.const 0x8000000000000000)) +(assert_return (invoke "shl" (i64.const 1) (i64.const 64)) (i64.const 1)) +(assert_return (invoke "shl" (i64.const 1) (i64.const 65)) (i64.const 2)) +(assert_return (invoke "shl" (i64.const 1) (i64.const -1)) (i64.const 0x8000000000000000)) +(assert_return (invoke "shl" (i64.const 1) (i64.const 0x7fffffffffffffff)) (i64.const 0x8000000000000000)) + +(assert_return (invoke "shr_s" (i64.const 1) (i64.const 1)) (i64.const 0)) +(assert_return (invoke "shr_s" (i64.const 1) (i64.const 0)) (i64.const 1)) +(assert_return (invoke "shr_s" (i64.const -1) (i64.const 1)) (i64.const -1)) +(assert_return (invoke "shr_s" (i64.const 0x7fffffffffffffff) (i64.const 1)) (i64.const 0x3fffffffffffffff)) +(assert_return (invoke "shr_s" (i64.const 0x8000000000000000) (i64.const 1)) (i64.const 0xc000000000000000)) +(assert_return (invoke "shr_s" (i64.const 0x4000000000000000) (i64.const 1)) (i64.const 0x2000000000000000)) +(assert_return (invoke "shr_s" (i64.const 1) (i64.const 64)) (i64.const 1)) +(assert_return (invoke "shr_s" (i64.const 1) (i64.const 65)) (i64.const 0)) +(assert_return (invoke "shr_s" (i64.const 1) (i64.const -1)) (i64.const 0)) +(assert_return (invoke "shr_s" (i64.const 1) (i64.const 0x7fffffffffffffff)) (i64.const 0)) +(assert_return (invoke "shr_s" (i64.const 1) (i64.const 0x8000000000000000)) (i64.const 1)) +(assert_return (invoke "shr_s" (i64.const 0x8000000000000000) (i64.const 63)) (i64.const -1)) +(assert_return (invoke "shr_s" (i64.const -1) (i64.const 64)) (i64.const -1)) +(assert_return (invoke "shr_s" (i64.const -1) (i64.const 65)) (i64.const -1)) +(assert_return (invoke "shr_s" (i64.const -1) (i64.const -1)) (i64.const -1)) +(assert_return (invoke "shr_s" (i64.const -1) (i64.const 0x7fffffffffffffff)) (i64.const -1)) +(assert_return (invoke "shr_s" (i64.const -1) (i64.const 0x8000000000000000)) (i64.const -1)) + +(assert_return (invoke "shr_u" (i64.const 1) (i64.const 1)) (i64.const 0)) +(assert_return (invoke "shr_u" (i64.const 1) (i64.const 0)) (i64.const 1)) +(assert_return (invoke "shr_u" (i64.const -1) (i64.const 1)) (i64.const 0x7fffffffffffffff)) +(assert_return (invoke "shr_u" (i64.const 0x7fffffffffffffff) (i64.const 1)) (i64.const 0x3fffffffffffffff)) +(assert_return (invoke "shr_u" (i64.const 0x8000000000000000) (i64.const 1)) (i64.const 0x4000000000000000)) +(assert_return (invoke "shr_u" (i64.const 0x4000000000000000) (i64.const 1)) (i64.const 0x2000000000000000)) +(assert_return (invoke "shr_u" (i64.const 1) (i64.const 64)) (i64.const 1)) +(assert_return (invoke "shr_u" (i64.const 1) (i64.const 65)) (i64.const 0)) +(assert_return (invoke "shr_u" (i64.const 1) (i64.const -1)) (i64.const 0)) +(assert_return (invoke "shr_u" (i64.const 1) (i64.const 0x7fffffffffffffff)) (i64.const 0)) +(assert_return (invoke "shr_u" (i64.const 1) (i64.const 0x8000000000000000)) (i64.const 1)) +(assert_return (invoke "shr_u" (i64.const 0x8000000000000000) (i64.const 63)) (i64.const 1)) +(assert_return (invoke "shr_u" (i64.const -1) (i64.const 64)) (i64.const -1)) +(assert_return (invoke "shr_u" (i64.const -1) (i64.const 65)) (i64.const 0x7fffffffffffffff)) +(assert_return (invoke "shr_u" (i64.const -1) (i64.const -1)) (i64.const 1)) +(assert_return (invoke "shr_u" (i64.const -1) (i64.const 0x7fffffffffffffff)) (i64.const 1)) +(assert_return (invoke "shr_u" (i64.const -1) (i64.const 0x8000000000000000)) (i64.const -1)) + +(assert_return (invoke "rotl" (i64.const 1) (i64.const 1)) (i64.const 2)) +(assert_return (invoke "rotl" (i64.const 1) (i64.const 0)) (i64.const 1)) +(assert_return (invoke "rotl" (i64.const -1) (i64.const 1)) (i64.const -1)) +(assert_return (invoke "rotl" (i64.const 1) (i64.const 64)) (i64.const 1)) +(assert_return (invoke "rotl" (i64.const 0xabcd987602468ace) (i64.const 1)) (i64.const 0x579b30ec048d159d)) +(assert_return (invoke "rotl" (i64.const 0xfe000000dc000000) (i64.const 4)) (i64.const 0xe000000dc000000f)) +(assert_return (invoke "rotl" (i64.const 0xabcd1234ef567809) (i64.const 53)) (i64.const 0x013579a2469deacf)) +(assert_return (invoke "rotl" (i64.const 0xabd1234ef567809c) (i64.const 63)) (i64.const 0x55e891a77ab3c04e)) +(assert_return (invoke "rotl" (i64.const 0xabcd1234ef567809) (i64.const 0xf5)) (i64.const 0x013579a2469deacf)) +(assert_return (invoke "rotl" (i64.const 0xabcd7294ef567809) (i64.const 0xffffffffffffffed)) (i64.const 0xcf013579ae529dea)) +(assert_return (invoke "rotl" (i64.const 0xabd1234ef567809c) (i64.const 0x800000000000003f)) (i64.const 0x55e891a77ab3c04e)) +(assert_return (invoke "rotl" (i64.const 1) (i64.const 63)) (i64.const 0x8000000000000000)) +(assert_return (invoke "rotl" (i64.const 0x8000000000000000) (i64.const 1)) (i64.const 1)) + +(assert_return (invoke "rotr" (i64.const 1) (i64.const 1)) (i64.const 0x8000000000000000)) +(assert_return (invoke "rotr" (i64.const 1) (i64.const 0)) (i64.const 1)) +(assert_return (invoke "rotr" (i64.const -1) (i64.const 1)) (i64.const -1)) +(assert_return (invoke "rotr" (i64.const 1) (i64.const 64)) (i64.const 1)) +(assert_return (invoke "rotr" (i64.const 0xabcd987602468ace) (i64.const 1)) (i64.const 0x55e6cc3b01234567)) +(assert_return (invoke "rotr" (i64.const 0xfe000000dc000000) (i64.const 4)) (i64.const 0x0fe000000dc00000)) +(assert_return (invoke "rotr" (i64.const 0xabcd1234ef567809) (i64.const 53)) (i64.const 0x6891a77ab3c04d5e)) +(assert_return (invoke "rotr" (i64.const 0xabd1234ef567809c) (i64.const 63)) (i64.const 0x57a2469deacf0139)) +(assert_return (invoke "rotr" (i64.const 0xabcd1234ef567809) (i64.const 0xf5)) (i64.const 0x6891a77ab3c04d5e)) +(assert_return (invoke "rotr" (i64.const 0xabcd7294ef567809) (i64.const 0xffffffffffffffed)) (i64.const 0x94a77ab3c04d5e6b)) +(assert_return (invoke "rotr" (i64.const 0xabd1234ef567809c) (i64.const 0x800000000000003f)) (i64.const 0x57a2469deacf0139)) +(assert_return (invoke "rotr" (i64.const 1) (i64.const 63)) (i64.const 2)) +(assert_return (invoke "rotr" (i64.const 0x8000000000000000) (i64.const 63)) (i64.const 1)) + +(assert_return (invoke "clz" (i64.const 0xffffffffffffffff)) (i64.const 0)) +(assert_return (invoke "clz" (i64.const 0)) (i64.const 64)) +(assert_return (invoke "clz" (i64.const 0x00008000)) (i64.const 48)) +(assert_return (invoke "clz" (i64.const 0xff)) (i64.const 56)) +(assert_return (invoke "clz" (i64.const 0x8000000000000000)) (i64.const 0)) +(assert_return (invoke "clz" (i64.const 1)) (i64.const 63)) +(assert_return (invoke "clz" (i64.const 2)) (i64.const 62)) +(assert_return (invoke "clz" (i64.const 0x7fffffffffffffff)) (i64.const 1)) + +(assert_return (invoke "ctz" (i64.const -1)) (i64.const 0)) +(assert_return (invoke "ctz" (i64.const 0)) (i64.const 64)) +(assert_return (invoke "ctz" (i64.const 0x00008000)) (i64.const 15)) +(assert_return (invoke "ctz" (i64.const 0x00010000)) (i64.const 16)) +(assert_return (invoke "ctz" (i64.const 0x8000000000000000)) (i64.const 63)) +(assert_return (invoke "ctz" (i64.const 0x7fffffffffffffff)) (i64.const 0)) + +(assert_return (invoke "popcnt" (i64.const -1)) (i64.const 64)) +(assert_return (invoke "popcnt" (i64.const 0)) (i64.const 0)) +(assert_return (invoke "popcnt" (i64.const 0x00008000)) (i64.const 1)) +(assert_return (invoke "popcnt" (i64.const 0x8000800080008000)) (i64.const 4)) +(assert_return (invoke "popcnt" (i64.const 0x7fffffffffffffff)) (i64.const 63)) +(assert_return (invoke "popcnt" (i64.const 0xAAAAAAAA55555555)) (i64.const 32)) +(assert_return (invoke "popcnt" (i64.const 0x99999999AAAAAAAA)) (i64.const 32)) +(assert_return (invoke "popcnt" (i64.const 0xDEADBEEFDEADBEEF)) (i64.const 48)) + +(assert_return (invoke "extend8_s" (i64.const 0)) (i64.const 0)) +(assert_return (invoke "extend8_s" (i64.const 0x7f)) (i64.const 127)) +(assert_return (invoke "extend8_s" (i64.const 0x80)) (i64.const -128)) +(assert_return (invoke "extend8_s" (i64.const 0xff)) (i64.const -1)) +(assert_return (invoke "extend8_s" (i64.const 0x01234567_89abcd_00)) (i64.const 0)) +(assert_return (invoke "extend8_s" (i64.const 0xfedcba98_765432_80)) (i64.const -0x80)) +(assert_return (invoke "extend8_s" (i64.const -1)) (i64.const -1)) + +(assert_return (invoke "extend16_s" (i64.const 0)) (i64.const 0)) +(assert_return (invoke "extend16_s" (i64.const 0x7fff)) (i64.const 32767)) +(assert_return (invoke "extend16_s" (i64.const 0x8000)) (i64.const -32768)) +(assert_return (invoke "extend16_s" (i64.const 0xffff)) (i64.const -1)) +(assert_return (invoke "extend16_s" (i64.const 0x12345678_9abc_0000)) (i64.const 0)) +(assert_return (invoke "extend16_s" (i64.const 0xfedcba98_7654_8000)) (i64.const -0x8000)) +(assert_return (invoke "extend16_s" (i64.const -1)) (i64.const -1)) + +(assert_return (invoke "extend32_s" (i64.const 0)) (i64.const 0)) +(assert_return (invoke "extend32_s" (i64.const 0x7fff)) (i64.const 32767)) +(assert_return (invoke "extend32_s" (i64.const 0x8000)) (i64.const 32768)) +(assert_return (invoke "extend32_s" (i64.const 0xffff)) (i64.const 65535)) +(assert_return (invoke "extend32_s" (i64.const 0x7fffffff)) (i64.const 0x7fffffff)) +(assert_return (invoke "extend32_s" (i64.const 0x80000000)) (i64.const -0x80000000)) +(assert_return (invoke "extend32_s" (i64.const 0xffffffff)) (i64.const -1)) +(assert_return (invoke "extend32_s" (i64.const 0x01234567_00000000)) (i64.const 0)) +(assert_return (invoke "extend32_s" (i64.const 0xfedcba98_80000000)) (i64.const -0x80000000)) +(assert_return (invoke "extend32_s" (i64.const -1)) (i64.const -1)) + +(assert_return (invoke "eqz" (i64.const 0)) (i32.const 1)) +(assert_return (invoke "eqz" (i64.const 1)) (i32.const 0)) +(assert_return (invoke "eqz" (i64.const 0x8000000000000000)) (i32.const 0)) +(assert_return (invoke "eqz" (i64.const 0x7fffffffffffffff)) (i32.const 0)) +(assert_return (invoke "eqz" (i64.const 0xffffffffffffffff)) (i32.const 0)) + +(assert_return (invoke "eq" (i64.const 0) (i64.const 0)) (i32.const 1)) +(assert_return (invoke "eq" (i64.const 1) (i64.const 1)) (i32.const 1)) +(assert_return (invoke "eq" (i64.const -1) (i64.const 1)) (i32.const 0)) +(assert_return (invoke "eq" (i64.const 0x8000000000000000) (i64.const 0x8000000000000000)) (i32.const 1)) +(assert_return (invoke "eq" (i64.const 0x7fffffffffffffff) (i64.const 0x7fffffffffffffff)) (i32.const 1)) +(assert_return (invoke "eq" (i64.const -1) (i64.const -1)) (i32.const 1)) +(assert_return (invoke "eq" (i64.const 1) (i64.const 0)) (i32.const 0)) +(assert_return (invoke "eq" (i64.const 0) (i64.const 1)) (i32.const 0)) +(assert_return (invoke "eq" (i64.const 0x8000000000000000) (i64.const 0)) (i32.const 0)) +(assert_return (invoke "eq" (i64.const 0) (i64.const 0x8000000000000000)) (i32.const 0)) +(assert_return (invoke "eq" (i64.const 0x8000000000000000) (i64.const -1)) (i32.const 0)) +(assert_return (invoke "eq" (i64.const -1) (i64.const 0x8000000000000000)) (i32.const 0)) +(assert_return (invoke "eq" (i64.const 0x8000000000000000) (i64.const 0x7fffffffffffffff)) (i32.const 0)) +(assert_return (invoke "eq" (i64.const 0x7fffffffffffffff) (i64.const 0x8000000000000000)) (i32.const 0)) + +(assert_return (invoke "ne" (i64.const 0) (i64.const 0)) (i32.const 0)) +(assert_return (invoke "ne" (i64.const 1) (i64.const 1)) (i32.const 0)) +(assert_return (invoke "ne" (i64.const -1) (i64.const 1)) (i32.const 1)) +(assert_return (invoke "ne" (i64.const 0x8000000000000000) (i64.const 0x8000000000000000)) (i32.const 0)) +(assert_return (invoke "ne" (i64.const 0x7fffffffffffffff) (i64.const 0x7fffffffffffffff)) (i32.const 0)) +(assert_return (invoke "ne" (i64.const -1) (i64.const -1)) (i32.const 0)) +(assert_return (invoke "ne" (i64.const 1) (i64.const 0)) (i32.const 1)) +(assert_return (invoke "ne" (i64.const 0) (i64.const 1)) (i32.const 1)) +(assert_return (invoke "ne" (i64.const 0x8000000000000000) (i64.const 0)) (i32.const 1)) +(assert_return (invoke "ne" (i64.const 0) (i64.const 0x8000000000000000)) (i32.const 1)) +(assert_return (invoke "ne" (i64.const 0x8000000000000000) (i64.const -1)) (i32.const 1)) +(assert_return (invoke "ne" (i64.const -1) (i64.const 0x8000000000000000)) (i32.const 1)) +(assert_return (invoke "ne" (i64.const 0x8000000000000000) (i64.const 0x7fffffffffffffff)) (i32.const 1)) +(assert_return (invoke "ne" (i64.const 0x7fffffffffffffff) (i64.const 0x8000000000000000)) (i32.const 1)) + +(assert_return (invoke "lt_s" (i64.const 0) (i64.const 0)) (i32.const 0)) +(assert_return (invoke "lt_s" (i64.const 1) (i64.const 1)) (i32.const 0)) +(assert_return (invoke "lt_s" (i64.const -1) (i64.const 1)) (i32.const 1)) +(assert_return (invoke "lt_s" (i64.const 0x8000000000000000) (i64.const 0x8000000000000000)) (i32.const 0)) +(assert_return (invoke "lt_s" (i64.const 0x7fffffffffffffff) (i64.const 0x7fffffffffffffff)) (i32.const 0)) +(assert_return (invoke "lt_s" (i64.const -1) (i64.const -1)) (i32.const 0)) +(assert_return (invoke "lt_s" (i64.const 1) (i64.const 0)) (i32.const 0)) +(assert_return (invoke "lt_s" (i64.const 0) (i64.const 1)) (i32.const 1)) +(assert_return (invoke "lt_s" (i64.const 0x8000000000000000) (i64.const 0)) (i32.const 1)) +(assert_return (invoke "lt_s" (i64.const 0) (i64.const 0x8000000000000000)) (i32.const 0)) +(assert_return (invoke "lt_s" (i64.const 0x8000000000000000) (i64.const -1)) (i32.const 1)) +(assert_return (invoke "lt_s" (i64.const -1) (i64.const 0x8000000000000000)) (i32.const 0)) +(assert_return (invoke "lt_s" (i64.const 0x8000000000000000) (i64.const 0x7fffffffffffffff)) (i32.const 1)) +(assert_return (invoke "lt_s" (i64.const 0x7fffffffffffffff) (i64.const 0x8000000000000000)) (i32.const 0)) + +(assert_return (invoke "lt_u" (i64.const 0) (i64.const 0)) (i32.const 0)) +(assert_return (invoke "lt_u" (i64.const 1) (i64.const 1)) (i32.const 0)) +(assert_return (invoke "lt_u" (i64.const -1) (i64.const 1)) (i32.const 0)) +(assert_return (invoke "lt_u" (i64.const 0x8000000000000000) (i64.const 0x8000000000000000)) (i32.const 0)) +(assert_return (invoke "lt_u" (i64.const 0x7fffffffffffffff) (i64.const 0x7fffffffffffffff)) (i32.const 0)) +(assert_return (invoke "lt_u" (i64.const -1) (i64.const -1)) (i32.const 0)) +(assert_return (invoke "lt_u" (i64.const 1) (i64.const 0)) (i32.const 0)) +(assert_return (invoke "lt_u" (i64.const 0) (i64.const 1)) (i32.const 1)) +(assert_return (invoke "lt_u" (i64.const 0x8000000000000000) (i64.const 0)) (i32.const 0)) +(assert_return (invoke "lt_u" (i64.const 0) (i64.const 0x8000000000000000)) (i32.const 1)) +(assert_return (invoke "lt_u" (i64.const 0x8000000000000000) (i64.const -1)) (i32.const 1)) +(assert_return (invoke "lt_u" (i64.const -1) (i64.const 0x8000000000000000)) (i32.const 0)) +(assert_return (invoke "lt_u" (i64.const 0x8000000000000000) (i64.const 0x7fffffffffffffff)) (i32.const 0)) +(assert_return (invoke "lt_u" (i64.const 0x7fffffffffffffff) (i64.const 0x8000000000000000)) (i32.const 1)) + +(assert_return (invoke "le_s" (i64.const 0) (i64.const 0)) (i32.const 1)) +(assert_return (invoke "le_s" (i64.const 1) (i64.const 1)) (i32.const 1)) +(assert_return (invoke "le_s" (i64.const -1) (i64.const 1)) (i32.const 1)) +(assert_return (invoke "le_s" (i64.const 0x8000000000000000) (i64.const 0x8000000000000000)) (i32.const 1)) +(assert_return (invoke "le_s" (i64.const 0x7fffffffffffffff) (i64.const 0x7fffffffffffffff)) (i32.const 1)) +(assert_return (invoke "le_s" (i64.const -1) (i64.const -1)) (i32.const 1)) +(assert_return (invoke "le_s" (i64.const 1) (i64.const 0)) (i32.const 0)) +(assert_return (invoke "le_s" (i64.const 0) (i64.const 1)) (i32.const 1)) +(assert_return (invoke "le_s" (i64.const 0x8000000000000000) (i64.const 0)) (i32.const 1)) +(assert_return (invoke "le_s" (i64.const 0) (i64.const 0x8000000000000000)) (i32.const 0)) +(assert_return (invoke "le_s" (i64.const 0x8000000000000000) (i64.const -1)) (i32.const 1)) +(assert_return (invoke "le_s" (i64.const -1) (i64.const 0x8000000000000000)) (i32.const 0)) +(assert_return (invoke "le_s" (i64.const 0x8000000000000000) (i64.const 0x7fffffffffffffff)) (i32.const 1)) +(assert_return (invoke "le_s" (i64.const 0x7fffffffffffffff) (i64.const 0x8000000000000000)) (i32.const 0)) + +(assert_return (invoke "le_u" (i64.const 0) (i64.const 0)) (i32.const 1)) +(assert_return (invoke "le_u" (i64.const 1) (i64.const 1)) (i32.const 1)) +(assert_return (invoke "le_u" (i64.const -1) (i64.const 1)) (i32.const 0)) +(assert_return (invoke "le_u" (i64.const 0x8000000000000000) (i64.const 0x8000000000000000)) (i32.const 1)) +(assert_return (invoke "le_u" (i64.const 0x7fffffffffffffff) (i64.const 0x7fffffffffffffff)) (i32.const 1)) +(assert_return (invoke "le_u" (i64.const -1) (i64.const -1)) (i32.const 1)) +(assert_return (invoke "le_u" (i64.const 1) (i64.const 0)) (i32.const 0)) +(assert_return (invoke "le_u" (i64.const 0) (i64.const 1)) (i32.const 1)) +(assert_return (invoke "le_u" (i64.const 0x8000000000000000) (i64.const 0)) (i32.const 0)) +(assert_return (invoke "le_u" (i64.const 0) (i64.const 0x8000000000000000)) (i32.const 1)) +(assert_return (invoke "le_u" (i64.const 0x8000000000000000) (i64.const -1)) (i32.const 1)) +(assert_return (invoke "le_u" (i64.const -1) (i64.const 0x8000000000000000)) (i32.const 0)) +(assert_return (invoke "le_u" (i64.const 0x8000000000000000) (i64.const 0x7fffffffffffffff)) (i32.const 0)) +(assert_return (invoke "le_u" (i64.const 0x7fffffffffffffff) (i64.const 0x8000000000000000)) (i32.const 1)) + +(assert_return (invoke "gt_s" (i64.const 0) (i64.const 0)) (i32.const 0)) +(assert_return (invoke "gt_s" (i64.const 1) (i64.const 1)) (i32.const 0)) +(assert_return (invoke "gt_s" (i64.const -1) (i64.const 1)) (i32.const 0)) +(assert_return (invoke "gt_s" (i64.const 0x8000000000000000) (i64.const 0x8000000000000000)) (i32.const 0)) +(assert_return (invoke "gt_s" (i64.const 0x7fffffffffffffff) (i64.const 0x7fffffffffffffff)) (i32.const 0)) +(assert_return (invoke "gt_s" (i64.const -1) (i64.const -1)) (i32.const 0)) +(assert_return (invoke "gt_s" (i64.const 1) (i64.const 0)) (i32.const 1)) +(assert_return (invoke "gt_s" (i64.const 0) (i64.const 1)) (i32.const 0)) +(assert_return (invoke "gt_s" (i64.const 0x8000000000000000) (i64.const 0)) (i32.const 0)) +(assert_return (invoke "gt_s" (i64.const 0) (i64.const 0x8000000000000000)) (i32.const 1)) +(assert_return (invoke "gt_s" (i64.const 0x8000000000000000) (i64.const -1)) (i32.const 0)) +(assert_return (invoke "gt_s" (i64.const -1) (i64.const 0x8000000000000000)) (i32.const 1)) +(assert_return (invoke "gt_s" (i64.const 0x8000000000000000) (i64.const 0x7fffffffffffffff)) (i32.const 0)) +(assert_return (invoke "gt_s" (i64.const 0x7fffffffffffffff) (i64.const 0x8000000000000000)) (i32.const 1)) + +(assert_return (invoke "gt_u" (i64.const 0) (i64.const 0)) (i32.const 0)) +(assert_return (invoke "gt_u" (i64.const 1) (i64.const 1)) (i32.const 0)) +(assert_return (invoke "gt_u" (i64.const -1) (i64.const 1)) (i32.const 1)) +(assert_return (invoke "gt_u" (i64.const 0x8000000000000000) (i64.const 0x8000000000000000)) (i32.const 0)) +(assert_return (invoke "gt_u" (i64.const 0x7fffffffffffffff) (i64.const 0x7fffffffffffffff)) (i32.const 0)) +(assert_return (invoke "gt_u" (i64.const -1) (i64.const -1)) (i32.const 0)) +(assert_return (invoke "gt_u" (i64.const 1) (i64.const 0)) (i32.const 1)) +(assert_return (invoke "gt_u" (i64.const 0) (i64.const 1)) (i32.const 0)) +(assert_return (invoke "gt_u" (i64.const 0x8000000000000000) (i64.const 0)) (i32.const 1)) +(assert_return (invoke "gt_u" (i64.const 0) (i64.const 0x8000000000000000)) (i32.const 0)) +(assert_return (invoke "gt_u" (i64.const 0x8000000000000000) (i64.const -1)) (i32.const 0)) +(assert_return (invoke "gt_u" (i64.const -1) (i64.const 0x8000000000000000)) (i32.const 1)) +(assert_return (invoke "gt_u" (i64.const 0x8000000000000000) (i64.const 0x7fffffffffffffff)) (i32.const 1)) +(assert_return (invoke "gt_u" (i64.const 0x7fffffffffffffff) (i64.const 0x8000000000000000)) (i32.const 0)) + +(assert_return (invoke "ge_s" (i64.const 0) (i64.const 0)) (i32.const 1)) +(assert_return (invoke "ge_s" (i64.const 1) (i64.const 1)) (i32.const 1)) +(assert_return (invoke "ge_s" (i64.const -1) (i64.const 1)) (i32.const 0)) +(assert_return (invoke "ge_s" (i64.const 0x8000000000000000) (i64.const 0x8000000000000000)) (i32.const 1)) +(assert_return (invoke "ge_s" (i64.const 0x7fffffffffffffff) (i64.const 0x7fffffffffffffff)) (i32.const 1)) +(assert_return (invoke "ge_s" (i64.const -1) (i64.const -1)) (i32.const 1)) +(assert_return (invoke "ge_s" (i64.const 1) (i64.const 0)) (i32.const 1)) +(assert_return (invoke "ge_s" (i64.const 0) (i64.const 1)) (i32.const 0)) +(assert_return (invoke "ge_s" (i64.const 0x8000000000000000) (i64.const 0)) (i32.const 0)) +(assert_return (invoke "ge_s" (i64.const 0) (i64.const 0x8000000000000000)) (i32.const 1)) +(assert_return (invoke "ge_s" (i64.const 0x8000000000000000) (i64.const -1)) (i32.const 0)) +(assert_return (invoke "ge_s" (i64.const -1) (i64.const 0x8000000000000000)) (i32.const 1)) +(assert_return (invoke "ge_s" (i64.const 0x8000000000000000) (i64.const 0x7fffffffffffffff)) (i32.const 0)) +(assert_return (invoke "ge_s" (i64.const 0x7fffffffffffffff) (i64.const 0x8000000000000000)) (i32.const 1)) + +(assert_return (invoke "ge_u" (i64.const 0) (i64.const 0)) (i32.const 1)) +(assert_return (invoke "ge_u" (i64.const 1) (i64.const 1)) (i32.const 1)) +(assert_return (invoke "ge_u" (i64.const -1) (i64.const 1)) (i32.const 1)) +(assert_return (invoke "ge_u" (i64.const 0x8000000000000000) (i64.const 0x8000000000000000)) (i32.const 1)) +(assert_return (invoke "ge_u" (i64.const 0x7fffffffffffffff) (i64.const 0x7fffffffffffffff)) (i32.const 1)) +(assert_return (invoke "ge_u" (i64.const -1) (i64.const -1)) (i32.const 1)) +(assert_return (invoke "ge_u" (i64.const 1) (i64.const 0)) (i32.const 1)) +(assert_return (invoke "ge_u" (i64.const 0) (i64.const 1)) (i32.const 0)) +(assert_return (invoke "ge_u" (i64.const 0x8000000000000000) (i64.const 0)) (i32.const 1)) +(assert_return (invoke "ge_u" (i64.const 0) (i64.const 0x8000000000000000)) (i32.const 0)) +(assert_return (invoke "ge_u" (i64.const 0x8000000000000000) (i64.const -1)) (i32.const 0)) +(assert_return (invoke "ge_u" (i64.const -1) (i64.const 0x8000000000000000)) (i32.const 1)) +(assert_return (invoke "ge_u" (i64.const 0x8000000000000000) (i64.const 0x7fffffffffffffff)) (i32.const 1)) +(assert_return (invoke "ge_u" (i64.const 0x7fffffffffffffff) (i64.const 0x8000000000000000)) (i32.const 0)) + + +;; Type check + +(assert_invalid (module (func (result i64) (i64.add (i32.const 0) (f32.const 0)))) "type mismatch") +(assert_invalid (module (func (result i64) (i64.and (i32.const 0) (f32.const 0)))) "type mismatch") +(assert_invalid (module (func (result i64) (i64.div_s (i32.const 0) (f32.const 0)))) "type mismatch") +(assert_invalid (module (func (result i64) (i64.div_u (i32.const 0) (f32.const 0)))) "type mismatch") +(assert_invalid (module (func (result i64) (i64.mul (i32.const 0) (f32.const 0)))) "type mismatch") +(assert_invalid (module (func (result i64) (i64.or (i32.const 0) (f32.const 0)))) "type mismatch") +(assert_invalid (module (func (result i64) (i64.rem_s (i32.const 0) (f32.const 0)))) "type mismatch") +(assert_invalid (module (func (result i64) (i64.rem_u (i32.const 0) (f32.const 0)))) "type mismatch") +(assert_invalid (module (func (result i64) (i64.rotl (i32.const 0) (f32.const 0)))) "type mismatch") +(assert_invalid (module (func (result i64) (i64.rotr (i32.const 0) (f32.const 0)))) "type mismatch") +(assert_invalid (module (func (result i64) (i64.shl (i32.const 0) (f32.const 0)))) "type mismatch") +(assert_invalid (module (func (result i64) (i64.shr_s (i32.const 0) (f32.const 0)))) "type mismatch") +(assert_invalid (module (func (result i64) (i64.shr_u (i32.const 0) (f32.const 0)))) "type mismatch") +(assert_invalid (module (func (result i64) (i64.sub (i32.const 0) (f32.const 0)))) "type mismatch") +(assert_invalid (module (func (result i64) (i64.xor (i32.const 0) (f32.const 0)))) "type mismatch") +(assert_invalid (module (func (result i64) (i64.eqz (i32.const 0)))) "type mismatch") +(assert_invalid (module (func (result i64) (i64.clz (i32.const 0)))) "type mismatch") +(assert_invalid (module (func (result i64) (i64.ctz (i32.const 0)))) "type mismatch") +(assert_invalid (module (func (result i64) (i64.popcnt (i32.const 0)))) "type mismatch") +(assert_invalid (module (func (result i64) (i64.eq (i32.const 0) (f32.const 0)))) "type mismatch") +(assert_invalid (module (func (result i64) (i64.ge_s (i32.const 0) (f32.const 0)))) "type mismatch") +(assert_invalid (module (func (result i64) (i64.ge_u (i32.const 0) (f32.const 0)))) "type mismatch") +(assert_invalid (module (func (result i64) (i64.gt_s (i32.const 0) (f32.const 0)))) "type mismatch") +(assert_invalid (module (func (result i64) (i64.gt_u (i32.const 0) (f32.const 0)))) "type mismatch") +(assert_invalid (module (func (result i64) (i64.le_s (i32.const 0) (f32.const 0)))) "type mismatch") +(assert_invalid (module (func (result i64) (i64.le_u (i32.const 0) (f32.const 0)))) "type mismatch") +(assert_invalid (module (func (result i64) (i64.lt_s (i32.const 0) (f32.const 0)))) "type mismatch") +(assert_invalid (module (func (result i64) (i64.lt_u (i32.const 0) (f32.const 0)))) "type mismatch") +(assert_invalid (module (func (result i64) (i64.ne (i32.const 0) (f32.const 0)))) "type mismatch") diff --git a/runtime/near-vm/tests/wast/spec/if.wast b/runtime/near-vm/tests/wast/spec/if.wast new file mode 100644 index 00000000000..1cbb617a7fa --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/if.wast @@ -0,0 +1,1550 @@ +;; Test `if` operator + +(module + ;; Auxiliary definition + (memory 1) + + (func $dummy) + + (func (export "empty") (param i32) + (if (local.get 0) (then)) + (if (local.get 0) (then) (else)) + (if $l (local.get 0) (then)) + (if $l (local.get 0) (then) (else)) + ) + + (func (export "singular") (param i32) (result i32) + (if (local.get 0) (then (nop))) + (if (local.get 0) (then (nop)) (else (nop))) + (if (result i32) (local.get 0) (then (i32.const 7)) (else (i32.const 8))) + ) + + (func (export "multi") (param i32) (result i32 i32) + (if (local.get 0) (then (call $dummy) (call $dummy) (call $dummy))) + (if (local.get 0) (then) (else (call $dummy) (call $dummy) (call $dummy))) + (if (result i32) (local.get 0) + (then (call $dummy) (call $dummy) (i32.const 8) (call $dummy)) + (else (call $dummy) (call $dummy) (i32.const 9) (call $dummy)) + ) + (if (result i32 i64 i32) (local.get 0) + (then + (call $dummy) (call $dummy) (i32.const 1) (call $dummy) + (call $dummy) (call $dummy) (i64.const 2) (call $dummy) + (call $dummy) (call $dummy) (i32.const 3) (call $dummy) + ) + (else + (call $dummy) (call $dummy) (i32.const -1) (call $dummy) + (call $dummy) (call $dummy) (i64.const -2) (call $dummy) + (call $dummy) (call $dummy) (i32.const -3) (call $dummy) + ) + ) + (drop) (drop) + ) + + (func (export "nested") (param i32 i32) (result i32) + (if (result i32) (local.get 0) + (then + (if (local.get 1) (then (call $dummy) (block) (nop))) + (if (local.get 1) (then) (else (call $dummy) (block) (nop))) + (if (result i32) (local.get 1) + (then (call $dummy) (i32.const 9)) + (else (call $dummy) (i32.const 10)) + ) + ) + (else + (if (local.get 1) (then (call $dummy) (block) (nop))) + (if (local.get 1) (then) (else (call $dummy) (block) (nop))) + (if (result i32) (local.get 1) + (then (call $dummy) (i32.const 10)) + (else (call $dummy) (i32.const 11)) + ) + ) + ) + ) + + (func (export "as-select-first") (param i32) (result i32) + (select + (if (result i32) (local.get 0) + (then (call $dummy) (i32.const 1)) + (else (call $dummy) (i32.const 0)) + ) + (i32.const 2) (i32.const 3) + ) + ) + (func (export "as-select-mid") (param i32) (result i32) + (select + (i32.const 2) + (if (result i32) (local.get 0) + (then (call $dummy) (i32.const 1)) + (else (call $dummy) (i32.const 0)) + ) + (i32.const 3) + ) + ) + (func (export "as-select-last") (param i32) (result i32) + (select + (i32.const 2) (i32.const 3) + (if (result i32) (local.get 0) + (then (call $dummy) (i32.const 1)) + (else (call $dummy) (i32.const 0)) + ) + ) + ) + + (func (export "as-loop-first") (param i32) (result i32) + (loop (result i32) + (if (result i32) (local.get 0) + (then (call $dummy) (i32.const 1)) + (else (call $dummy) (i32.const 0)) + ) + (call $dummy) (call $dummy) + ) + ) + (func (export "as-loop-mid") (param i32) (result i32) + (loop (result i32) + (call $dummy) + (if (result i32) (local.get 0) + (then (call $dummy) (i32.const 1)) + (else (call $dummy) (i32.const 0)) + ) + (call $dummy) + ) + ) + (func (export "as-loop-last") (param i32) (result i32) + (loop (result i32) + (call $dummy) (call $dummy) + (if (result i32) (local.get 0) + (then (call $dummy) (i32.const 1)) + (else (call $dummy) (i32.const 0)) + ) + ) + ) + + (func (export "as-if-condition") (param i32) (result i32) + (if (result i32) + (if (result i32) (local.get 0) + (then (i32.const 1)) (else (i32.const 0)) + ) + (then (call $dummy) (i32.const 2)) + (else (call $dummy) (i32.const 3)) + ) + ) + + (func (export "as-br_if-first") (param i32) (result i32) + (block (result i32) + (br_if 0 + (if (result i32) (local.get 0) + (then (call $dummy) (i32.const 1)) + (else (call $dummy) (i32.const 0)) + ) + (i32.const 2) + ) + (return (i32.const 3)) + ) + ) + (func (export "as-br_if-last") (param i32) (result i32) + (block (result i32) + (br_if 0 + (i32.const 2) + (if (result i32) (local.get 0) + (then (call $dummy) (i32.const 1)) + (else (call $dummy) (i32.const 0)) + ) + ) + (return (i32.const 3)) + ) + ) + + (func (export "as-br_table-first") (param i32) (result i32) + (block (result i32) + (if (result i32) (local.get 0) + (then (call $dummy) (i32.const 1)) + (else (call $dummy) (i32.const 0)) + ) + (i32.const 2) + (br_table 0 0) + ) + ) + (func (export "as-br_table-last") (param i32) (result i32) + (block (result i32) + (i32.const 2) + (if (result i32) (local.get 0) + (then (call $dummy) (i32.const 1)) + (else (call $dummy) (i32.const 0)) + ) + (br_table 0 0) + ) + ) + + (func $func (param i32 i32) (result i32) (local.get 0)) + (type $check (func (param i32 i32) (result i32))) + (table funcref (elem $func)) + (func (export "as-call_indirect-first") (param i32) (result i32) + (block (result i32) + (call_indirect (type $check) + (if (result i32) (local.get 0) + (then (call $dummy) (i32.const 1)) + (else (call $dummy) (i32.const 0)) + ) + (i32.const 2) (i32.const 0) + ) + ) + ) + (func (export "as-call_indirect-mid") (param i32) (result i32) + (block (result i32) + (call_indirect (type $check) + (i32.const 2) + (if (result i32) (local.get 0) + (then (call $dummy) (i32.const 1)) + (else (call $dummy) (i32.const 0)) + ) + (i32.const 0) + ) + ) + ) + (func (export "as-call_indirect-last") (param i32) (result i32) + (block (result i32) + (call_indirect (type $check) + (i32.const 2) (i32.const 0) + (if (result i32) (local.get 0) + (then (call $dummy) (i32.const 1)) + (else (call $dummy) (i32.const 0)) + ) + ) + ) + ) + + (func (export "as-store-first") (param i32) + (if (result i32) (local.get 0) + (then (call $dummy) (i32.const 1)) + (else (call $dummy) (i32.const 0)) + ) + (i32.const 2) + (i32.store) + ) + (func (export "as-store-last") (param i32) + (i32.const 2) + (if (result i32) (local.get 0) + (then (call $dummy) (i32.const 1)) + (else (call $dummy) (i32.const 0)) + ) + (i32.store) + ) + + (func (export "as-memory.grow-value") (param i32) (result i32) + (memory.grow + (if (result i32) (local.get 0) + (then (i32.const 1)) + (else (i32.const 0)) + ) + ) + ) + + (func $f (param i32) (result i32) (local.get 0)) + + (func (export "as-call-value") (param i32) (result i32) + (call $f + (if (result i32) (local.get 0) + (then (i32.const 1)) + (else (i32.const 0)) + ) + ) + ) + (func (export "as-return-value") (param i32) (result i32) + (if (result i32) (local.get 0) + (then (i32.const 1)) + (else (i32.const 0))) + (return) + ) + (func (export "as-drop-operand") (param i32) + (drop + (if (result i32) (local.get 0) + (then (i32.const 1)) + (else (i32.const 0)) + ) + ) + ) + (func (export "as-br-value") (param i32) (result i32) + (block (result i32) + (br 0 + (if (result i32) (local.get 0) + (then (i32.const 1)) + (else (i32.const 0)) + ) + ) + ) + ) + (func (export "as-local.set-value") (param i32) (result i32) + (local i32) + (local.set 0 + (if (result i32) (local.get 0) + (then (i32.const 1)) + (else (i32.const 0)) + ) + ) + (local.get 0) + ) + (func (export "as-local.tee-value") (param i32) (result i32) + (local.tee 0 + (if (result i32) (local.get 0) + (then (i32.const 1)) + (else (i32.const 0)) + ) + ) + ) + (global $a (mut i32) (i32.const 10)) + (func (export "as-global.set-value") (param i32) (result i32) + (global.set $a + (if (result i32) (local.get 0) + (then (i32.const 1)) + (else (i32.const 0)) + ) + ) (global.get $a) + ) + (func (export "as-load-operand") (param i32) (result i32) + (i32.load + (if (result i32) (local.get 0) + (then (i32.const 11)) + (else (i32.const 10)) + ) + ) + ) + + (func (export "as-unary-operand") (param i32) (result i32) + (i32.ctz + (if (result i32) (local.get 0) + (then (call $dummy) (i32.const 13)) + (else (call $dummy) (i32.const -13)) + ) + ) + ) + (func (export "as-binary-operand") (param i32 i32) (result i32) + (i32.mul + (if (result i32) (local.get 0) + (then (call $dummy) (i32.const 3)) + (else (call $dummy) (i32.const -3)) + ) + (if (result i32) (local.get 1) + (then (call $dummy) (i32.const 4)) + (else (call $dummy) (i32.const -5)) + ) + ) + ) + (func (export "as-test-operand") (param i32) (result i32) + (i32.eqz + (if (result i32) (local.get 0) + (then (call $dummy) (i32.const 13)) + (else (call $dummy) (i32.const 0)) + ) + ) + ) + (func (export "as-compare-operand") (param i32 i32) (result i32) + (f32.gt + (if (result f32) (local.get 0) + (then (call $dummy) (f32.const 3)) + (else (call $dummy) (f32.const -3)) + ) + (if (result f32) (local.get 1) + (then (call $dummy) (f32.const 4)) + (else (call $dummy) (f32.const -4)) + ) + ) + ) + (func (export "as-binary-operands") (param i32) (result i32) + (i32.mul + (if (result i32 i32) (local.get 0) + (then (call $dummy) (i32.const 3) (call $dummy) (i32.const 4)) + (else (call $dummy) (i32.const 3) (call $dummy) (i32.const -4)) + ) + ) + ) + (func (export "as-compare-operands") (param i32) (result i32) + (f32.gt + (if (result f32 f32) (local.get 0) + (then (call $dummy) (f32.const 3) (call $dummy) (f32.const 3)) + (else (call $dummy) (f32.const -2) (call $dummy) (f32.const -3)) + ) + ) + ) + (func (export "as-mixed-operands") (param i32) (result i32) + (if (result i32 i32) (local.get 0) + (then (call $dummy) (i32.const 3) (call $dummy) (i32.const 4)) + (else (call $dummy) (i32.const -3) (call $dummy) (i32.const -4)) + ) + (i32.const 5) + (i32.add) + (i32.mul) + ) + + (func (export "break-bare") (result i32) + (if (i32.const 1) (then (br 0) (unreachable))) + (if (i32.const 1) (then (br 0) (unreachable)) (else (unreachable))) + (if (i32.const 0) (then (unreachable)) (else (br 0) (unreachable))) + (if (i32.const 1) (then (br_if 0 (i32.const 1)) (unreachable))) + (if (i32.const 1) (then (br_if 0 (i32.const 1)) (unreachable)) (else (unreachable))) + (if (i32.const 0) (then (unreachable)) (else (br_if 0 (i32.const 1)) (unreachable))) + (if (i32.const 1) (then (br_table 0 (i32.const 0)) (unreachable))) + (if (i32.const 1) (then (br_table 0 (i32.const 0)) (unreachable)) (else (unreachable))) + (if (i32.const 0) (then (unreachable)) (else (br_table 0 (i32.const 0)) (unreachable))) + (i32.const 19) + ) + + (func (export "break-value") (param i32) (result i32) + (if (result i32) (local.get 0) + (then (br 0 (i32.const 18)) (i32.const 19)) + (else (br 0 (i32.const 21)) (i32.const 20)) + ) + ) + (func (export "break-multi-value") (param i32) (result i32 i32 i64) + (if (result i32 i32 i64) (local.get 0) + (then + (br 0 (i32.const 18) (i32.const -18) (i64.const 18)) + (i32.const 19) (i32.const -19) (i64.const 19) + ) + (else + (br 0 (i32.const -18) (i32.const 18) (i64.const -18)) + (i32.const -19) (i32.const 19) (i64.const -19) + ) + ) + ) + + (func (export "param") (param i32) (result i32) + (i32.const 1) + (if (param i32) (result i32) (local.get 0) + (then (i32.const 2) (i32.add)) + (else (i32.const -2) (i32.add)) + ) + ) + (func (export "params") (param i32) (result i32) + (i32.const 1) + (i32.const 2) + (if (param i32 i32) (result i32) (local.get 0) + (then (i32.add)) + (else (i32.sub)) + ) + ) + (func (export "params-id") (param i32) (result i32) + (i32.const 1) + (i32.const 2) + (if (param i32 i32) (result i32 i32) (local.get 0) (then)) + (i32.add) + ) + (func (export "param-break") (param i32) (result i32) + (i32.const 1) + (if (param i32) (result i32) (local.get 0) + (then (i32.const 2) (i32.add) (br 0)) + (else (i32.const -2) (i32.add) (br 0)) + ) + ) + (func (export "params-break") (param i32) (result i32) + (i32.const 1) + (i32.const 2) + (if (param i32 i32) (result i32) (local.get 0) + (then (i32.add) (br 0)) + (else (i32.sub) (br 0)) + ) + ) + (func (export "params-id-break") (param i32) (result i32) + (i32.const 1) + (i32.const 2) + (if (param i32 i32) (result i32 i32) (local.get 0) (then (br 0))) + (i32.add) + ) + + (func (export "effects") (param i32) (result i32) + (local i32) + (if + (block (result i32) (local.set 1 (i32.const 1)) (local.get 0)) + (then + (local.set 1 (i32.mul (local.get 1) (i32.const 3))) + (local.set 1 (i32.sub (local.get 1) (i32.const 5))) + (local.set 1 (i32.mul (local.get 1) (i32.const 7))) + (br 0) + (local.set 1 (i32.mul (local.get 1) (i32.const 100))) + ) + (else + (local.set 1 (i32.mul (local.get 1) (i32.const 5))) + (local.set 1 (i32.sub (local.get 1) (i32.const 7))) + (local.set 1 (i32.mul (local.get 1) (i32.const 3))) + (br 0) + (local.set 1 (i32.mul (local.get 1) (i32.const 1000))) + ) + ) + (local.get 1) + ) + + ;; Examples + + (func $add64_u_with_carry (export "add64_u_with_carry") + (param $i i64) (param $j i64) (param $c i32) (result i64 i32) + (local $k i64) + (local.set $k + (i64.add + (i64.add (local.get $i) (local.get $j)) + (i64.extend_i32_u (local.get $c)) + ) + ) + (return (local.get $k) (i64.lt_u (local.get $k) (local.get $i))) + ) + + (func $add64_u_saturated (export "add64_u_saturated") + (param i64 i64) (result i64) + (call $add64_u_with_carry (local.get 0) (local.get 1) (i32.const 0)) + (if (param i64) (result i64) + (then (drop) (i64.const -1)) + ) + ) + + ;; Block signature syntax + + (type $block-sig-1 (func)) + (type $block-sig-2 (func (result i32))) + (type $block-sig-3 (func (param $x i32))) + (type $block-sig-4 (func (param i32 f64 i32) (result i32 f64 i32))) + + (func (export "type-use") + (if (type $block-sig-1) (i32.const 1) (then)) + (if (type $block-sig-2) (i32.const 1) + (then (i32.const 0)) (else (i32.const 2)) + ) + (if (type $block-sig-3) (i32.const 1) (then (drop)) (else (drop))) + (i32.const 0) (f64.const 0) (i32.const 0) + (if (type $block-sig-4) (i32.const 1) (then)) + (drop) (drop) (drop) + (if (type $block-sig-2) (result i32) (i32.const 1) + (then (i32.const 0)) (else (i32.const 2)) + ) + (if (type $block-sig-3) (param i32) (i32.const 1) + (then (drop)) (else (drop)) + ) + (i32.const 0) (f64.const 0) (i32.const 0) + (if (type $block-sig-4) + (param i32) (param f64 i32) (result i32 f64) (result i32) + (i32.const 1) (then) + ) + (drop) (drop) (drop) + ) +) + +(assert_return (invoke "empty" (i32.const 0))) +(assert_return (invoke "empty" (i32.const 1))) +(assert_return (invoke "empty" (i32.const 100))) +(assert_return (invoke "empty" (i32.const -2))) + +(assert_return (invoke "singular" (i32.const 0)) (i32.const 8)) +(assert_return (invoke "singular" (i32.const 1)) (i32.const 7)) +(assert_return (invoke "singular" (i32.const 10)) (i32.const 7)) +(assert_return (invoke "singular" (i32.const -10)) (i32.const 7)) + +(assert_return (invoke "multi" (i32.const 0)) (i32.const 9) (i32.const -1)) +(assert_return (invoke "multi" (i32.const 1)) (i32.const 8) (i32.const 1)) +(assert_return (invoke "multi" (i32.const 13)) (i32.const 8) (i32.const 1)) +(assert_return (invoke "multi" (i32.const -5)) (i32.const 8) (i32.const 1)) + +(assert_return (invoke "nested" (i32.const 0) (i32.const 0)) (i32.const 11)) +(assert_return (invoke "nested" (i32.const 1) (i32.const 0)) (i32.const 10)) +(assert_return (invoke "nested" (i32.const 0) (i32.const 1)) (i32.const 10)) +(assert_return (invoke "nested" (i32.const 3) (i32.const 2)) (i32.const 9)) +(assert_return (invoke "nested" (i32.const 0) (i32.const -100)) (i32.const 10)) +(assert_return (invoke "nested" (i32.const 10) (i32.const 10)) (i32.const 9)) +(assert_return (invoke "nested" (i32.const 0) (i32.const -1)) (i32.const 10)) +(assert_return (invoke "nested" (i32.const -111) (i32.const -2)) (i32.const 9)) + +(assert_return (invoke "as-select-first" (i32.const 0)) (i32.const 0)) +(assert_return (invoke "as-select-first" (i32.const 1)) (i32.const 1)) +(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 3)) +(assert_return (invoke "as-select-last" (i32.const 1)) (i32.const 2)) + +(assert_return (invoke "as-loop-first" (i32.const 0)) (i32.const 0)) +(assert_return (invoke "as-loop-first" (i32.const 1)) (i32.const 1)) +(assert_return (invoke "as-loop-mid" (i32.const 0)) (i32.const 0)) +(assert_return (invoke "as-loop-mid" (i32.const 1)) (i32.const 1)) +(assert_return (invoke "as-loop-last" (i32.const 0)) (i32.const 0)) +(assert_return (invoke "as-loop-last" (i32.const 1)) (i32.const 1)) + +(assert_return (invoke "as-if-condition" (i32.const 0)) (i32.const 3)) +(assert_return (invoke "as-if-condition" (i32.const 1)) (i32.const 2)) + +(assert_return (invoke "as-br_if-first" (i32.const 0)) (i32.const 0)) +(assert_return (invoke "as-br_if-first" (i32.const 1)) (i32.const 1)) +(assert_return (invoke "as-br_if-last" (i32.const 0)) (i32.const 3)) +(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 0)) +(assert_return (invoke "as-br_table-first" (i32.const 1)) (i32.const 1)) +(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 0)) +(assert_return (invoke "as-call_indirect-first" (i32.const 1)) (i32.const 1)) +(assert_return (invoke "as-call_indirect-mid" (i32.const 0)) (i32.const 2)) +(assert_return (invoke "as-call_indirect-mid" (i32.const 1)) (i32.const 2)) +(assert_return (invoke "as-call_indirect-last" (i32.const 0)) (i32.const 2)) +(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 1)) + +(assert_return (invoke "as-call-value" (i32.const 0)) (i32.const 0)) +(assert_return (invoke "as-call-value" (i32.const 1)) (i32.const 1)) + +(assert_return (invoke "as-return-value" (i32.const 0)) (i32.const 0)) +(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 0)) +(assert_return (invoke "as-br-value" (i32.const 1)) (i32.const 1)) + +(assert_return (invoke "as-local.set-value" (i32.const 0)) (i32.const 0)) +(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 0)) +(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 0)) +(assert_return (invoke "as-global.set-value" (i32.const 1)) (i32.const 1)) + +(assert_return (invoke "as-load-operand" (i32.const 0)) (i32.const 0)) +(assert_return (invoke "as-load-operand" (i32.const 1)) (i32.const 0)) + +(assert_return (invoke "as-unary-operand" (i32.const 0)) (i32.const 0)) +(assert_return (invoke "as-unary-operand" (i32.const 1)) (i32.const 0)) +(assert_return (invoke "as-unary-operand" (i32.const -1)) (i32.const 0)) + +(assert_return (invoke "as-binary-operand" (i32.const 0) (i32.const 0)) (i32.const 15)) +(assert_return (invoke "as-binary-operand" (i32.const 0) (i32.const 1)) (i32.const -12)) +(assert_return (invoke "as-binary-operand" (i32.const 1) (i32.const 0)) (i32.const -15)) +(assert_return (invoke "as-binary-operand" (i32.const 1) (i32.const 1)) (i32.const 12)) + +(assert_return (invoke "as-test-operand" (i32.const 0)) (i32.const 1)) +(assert_return (invoke "as-test-operand" (i32.const 1)) (i32.const 0)) + +(assert_return (invoke "as-compare-operand" (i32.const 0) (i32.const 0)) (i32.const 1)) +(assert_return (invoke "as-compare-operand" (i32.const 0) (i32.const 1)) (i32.const 0)) +(assert_return (invoke "as-compare-operand" (i32.const 1) (i32.const 0)) (i32.const 1)) +(assert_return (invoke "as-compare-operand" (i32.const 1) (i32.const 1)) (i32.const 0)) + +(assert_return (invoke "as-binary-operands" (i32.const 0)) (i32.const -12)) +(assert_return (invoke "as-binary-operands" (i32.const 1)) (i32.const 12)) + +(assert_return (invoke "as-compare-operands" (i32.const 0)) (i32.const 1)) +(assert_return (invoke "as-compare-operands" (i32.const 1)) (i32.const 0)) + +(assert_return (invoke "as-mixed-operands" (i32.const 0)) (i32.const -3)) +(assert_return (invoke "as-mixed-operands" (i32.const 1)) (i32.const 27)) + +(assert_return (invoke "break-bare") (i32.const 19)) +(assert_return (invoke "break-value" (i32.const 1)) (i32.const 18)) +(assert_return (invoke "break-value" (i32.const 0)) (i32.const 21)) +(assert_return (invoke "break-multi-value" (i32.const 0)) + (i32.const -18) (i32.const 18) (i64.const -18) +) +(assert_return (invoke "break-multi-value" (i32.const 1)) + (i32.const 18) (i32.const -18) (i64.const 18) +) + +(assert_return (invoke "param" (i32.const 0)) (i32.const -1)) +(assert_return (invoke "param" (i32.const 1)) (i32.const 3)) +(assert_return (invoke "params" (i32.const 0)) (i32.const -1)) +(assert_return (invoke "params" (i32.const 1)) (i32.const 3)) +(assert_return (invoke "params-id" (i32.const 0)) (i32.const 3)) +(assert_return (invoke "params-id" (i32.const 1)) (i32.const 3)) +(assert_return (invoke "param-break" (i32.const 0)) (i32.const -1)) +(assert_return (invoke "param-break" (i32.const 1)) (i32.const 3)) +(assert_return (invoke "params-break" (i32.const 0)) (i32.const -1)) +(assert_return (invoke "params-break" (i32.const 1)) (i32.const 3)) +(assert_return (invoke "params-id-break" (i32.const 0)) (i32.const 3)) +(assert_return (invoke "params-id-break" (i32.const 1)) (i32.const 3)) + +(assert_return (invoke "effects" (i32.const 1)) (i32.const -14)) +(assert_return (invoke "effects" (i32.const 0)) (i32.const -6)) + +(assert_return + (invoke "add64_u_with_carry" (i64.const 0) (i64.const 0) (i32.const 0)) + (i64.const 0) (i32.const 0) +) +(assert_return + (invoke "add64_u_with_carry" (i64.const 100) (i64.const 124) (i32.const 0)) + (i64.const 224) (i32.const 0) +) +(assert_return + (invoke "add64_u_with_carry" (i64.const -1) (i64.const 0) (i32.const 0)) + (i64.const -1) (i32.const 0) +) +(assert_return + (invoke "add64_u_with_carry" (i64.const -1) (i64.const 1) (i32.const 0)) + (i64.const 0) (i32.const 1) +) +(assert_return + (invoke "add64_u_with_carry" (i64.const -1) (i64.const -1) (i32.const 0)) + (i64.const -2) (i32.const 1) +) +(assert_return + (invoke "add64_u_with_carry" (i64.const -1) (i64.const 0) (i32.const 1)) + (i64.const 0) (i32.const 1) +) +(assert_return + (invoke "add64_u_with_carry" (i64.const -1) (i64.const 1) (i32.const 1)) + (i64.const 1) (i32.const 1) +) +(assert_return + (invoke "add64_u_with_carry" (i64.const 0x8000000000000000) (i64.const 0x8000000000000000) (i32.const 0)) + (i64.const 0) (i32.const 1) +) + +(assert_return + (invoke "add64_u_saturated" (i64.const 0) (i64.const 0)) (i64.const 0) +) +(assert_return + (invoke "add64_u_saturated" (i64.const 1230) (i64.const 23)) (i64.const 1253) +) +(assert_return + (invoke "add64_u_saturated" (i64.const -1) (i64.const 0)) (i64.const -1) +) +(assert_return + (invoke "add64_u_saturated" (i64.const -1) (i64.const 1)) (i64.const -1) +) +(assert_return + (invoke "add64_u_saturated" (i64.const -1) (i64.const -1)) (i64.const -1) +) +(assert_return + (invoke "add64_u_saturated" (i64.const 0x8000000000000000) (i64.const 0x8000000000000000)) (i64.const -1) +) + +(assert_return (invoke "type-use")) + +(assert_malformed + (module quote + "(type $sig (func (param i32) (result i32)))" + "(func (i32.const 0)" + " (if (type $sig) (result i32) (param i32) (i32.const 1) (then))" + ")" + ) + "unexpected token" +) +(assert_malformed + (module quote + "(type $sig (func (param i32) (result i32)))" + "(func (i32.const 0)" + " (if (param i32) (type $sig) (result i32) (i32.const 1) (then))" + ")" + ) + "unexpected token" +) +(assert_malformed + (module quote + "(type $sig (func (param i32) (result i32)))" + "(func (i32.const 0)" + " (if (param i32) (result i32) (type $sig) (i32.const 1) (then))" + ")" + ) + "unexpected token" +) +(assert_malformed + (module quote + "(type $sig (func (param i32) (result i32)))" + "(func (i32.const 0)" + " (if (result i32) (type $sig) (param i32) (i32.const 1) (then))" + ")" + ) + "unexpected token" +) +(assert_malformed + (module quote + "(type $sig (func (param i32) (result i32)))" + "(func (i32.const 0)" + " (if (result i32) (param i32) (type $sig) (i32.const 1) (then))" + ")" + ) + "unexpected token" +) +(assert_malformed + (module quote + "(func (i32.const 0) (if (result i32) (param i32) (i32.const 1) (then)))" + ) + "unexpected token" +) + +(assert_malformed + (module quote + "(func (i32.const 0) (i32.const 1)" + " (if (param $x i32) (then (drop)) (else (drop)))" + ")" + ) + "unexpected token" +) +(assert_malformed + (module quote + "(type $sig (func))" + "(func (i32.const 1)" + " (if (type $sig) (result i32) (then (i32.const 0)) (else (i32.const 2)))" + " (unreachable)" + ")" + ) + "inline function type" +) +(assert_malformed + (module quote + "(type $sig (func (param i32) (result i32)))" + "(func (i32.const 1)" + " (if (type $sig) (result i32) (then (i32.const 0)) (else (i32.const 2)))" + " (unreachable)" + ")" + ) + "inline function type" +) +(assert_malformed + (module quote + "(type $sig (func (param i32) (result i32)))" + "(func (i32.const 0) (i32.const 1)" + " (if (type $sig) (param i32) (then (drop)) (else (drop)))" + " (unreachable)" + ")" + ) + "inline function type" +) +(assert_malformed + (module quote + "(type $sig (func (param i32 i32) (result i32)))" + "(func (i32.const 0) (i32.const 1)" + " (if (type $sig) (param i32) (result i32) (then)) (unreachable)" + ")" + ) + "inline function type" +) + +(assert_invalid + (module + (type $sig (func)) + (func (i32.const 1) (if (type $sig) (i32.const 0) (then))) + ) + "type mismatch" +) + +(assert_invalid + (module (func $type-empty-i32 (result i32) (if (i32.const 0) (then)))) + "type mismatch" +) +(assert_invalid + (module (func $type-empty-i64 (result i64) (if (i32.const 0) (then)))) + "type mismatch" +) +(assert_invalid + (module (func $type-empty-f32 (result f32) (if (i32.const 0) (then)))) + "type mismatch" +) +(assert_invalid + (module (func $type-empty-f64 (result f64) (if (i32.const 0) (then)))) + "type mismatch" +) + +(assert_invalid + (module (func $type-empty-i32 (result i32) (if (i32.const 0) (then) (else)))) + "type mismatch" +) +(assert_invalid + (module (func $type-empty-i64 (result i64) (if (i32.const 0) (then) (else)))) + "type mismatch" +) +(assert_invalid + (module (func $type-empty-f32 (result f32) (if (i32.const 0) (then) (else)))) + "type mismatch" +) +(assert_invalid + (module (func $type-empty-f64 (result f64) (if (i32.const 0) (then) (else)))) + "type mismatch" +) + +(assert_invalid + (module (func $type-then-value-num-vs-void + (if (i32.const 1) (then (i32.const 1))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-then-value-num-vs-void-else + (if (i32.const 1) (then (i32.const 1)) (else)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-else-value-num-vs-void + (if (i32.const 1) (then) (else (i32.const 1))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-both-value-num-vs-void + (if (i32.const 1) (then (i32.const 1)) (else (i32.const 1))) + )) + "type mismatch" +) + +(assert_invalid + (module (func $type-then-value-nums-vs-void + (if (i32.const 1) (then (i32.const 1) (i32.const 2))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-then-value-nums-vs-void-else + (if (i32.const 1) (then (i32.const 1) (i32.const 2)) (else)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-else-value-nums-vs-void + (if (i32.const 1) (then) (else (i32.const 1) (i32.const 2))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-both-value-nums-vs-void + (if (i32.const 1) (then (i32.const 1) (i32.const 2)) (else (i32.const 2) (i32.const 1))) + )) + "type mismatch" +) + +(assert_invalid + (module (func $type-then-value-empty-vs-num (result i32) + (if (result i32) (i32.const 1) (then) (else (i32.const 0))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-else-value-empty-vs-num (result i32) + (if (result i32) (i32.const 1) (then (i32.const 0)) (else)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-both-value-empty-vs-num (result i32) + (if (result i32) (i32.const 1) (then) (else)) + )) + "type mismatch" +) + +(assert_invalid + (module (func $type-then-value-empty-vs-nums (result i32 i32) + (if (result i32 i32) (i32.const 1) (then) (else (i32.const 0) (i32.const 2))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-else-value-empty-vs-nums (result i32 i32) + (if (result i32 i32) (i32.const 1) (then (i32.const 0) (i32.const 1)) (else)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-both-value-empty-vs-nums (result i32 i32) + (if (result i32 i32) (i32.const 1) (then) (else)) + )) + "type mismatch" +) + +(assert_invalid + (module (func $type-no-else-vs-num (result i32) + (if (result i32) (i32.const 1) (then (i32.const 1))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-no-else-vs-nums (result i32 i32) + (if (result i32 i32) (i32.const 1) (then (i32.const 1) (i32.const 1))) + )) + "type mismatch" +) + +(assert_invalid + (module (func $type-then-value-void-vs-num (result i32) + (if (result i32) (i32.const 1) (then (nop)) (else (i32.const 0))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-else-value-void-vs-num (result i32) + (if (result i32) (i32.const 1) (then (i32.const 0)) (else (nop))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-both-value-void-vs-num (result i32) + (if (result i32) (i32.const 1) (then (nop)) (else (nop))) + )) + "type mismatch" +) + +(assert_invalid + (module (func $type-then-value-void-vs-nums (result i32 i32) + (if (result i32 i32) (i32.const 1) (then (nop)) (else (i32.const 0) (i32.const 0))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-else-value-void-vs-nums (result i32 i32) + (if (result i32 i32) (i32.const 1) (then (i32.const 0) (i32.const 0)) (else (nop))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-both-value-void-vs-nums (result i32 i32) + (if (result i32 i32) (i32.const 1) (then (nop)) (else (nop))) + )) + "type mismatch" +) + +(assert_invalid + (module (func $type-then-value-num-vs-num (result i32) + (if (result i32) (i32.const 1) (then (i64.const 1)) (else (i32.const 1))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-else-value-num-vs-num (result i32) + (if (result i32) (i32.const 1) (then (i32.const 1)) (else (i64.const 1))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-both-value-num-vs-num (result i32) + (if (result i32) (i32.const 1) (then (i64.const 1)) (else (i64.const 1))) + )) + "type mismatch" +) + +(assert_invalid + (module (func $type-then-value-num-vs-nums (result i32 i32) + (if (result i32 i32) (i32.const 1) (then (i32.const 1)) (else (i32.const 1) (i32.const 1))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-else-value-num-vs-nums (result i32 i32) + (if (result i32 i32) (i32.const 1) (then (i32.const 1) (i32.const 1)) (else (i32.const 1))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-both-value-num-vs-nums (result i32 i32) + (if (result i32 i32) (i32.const 1) (then (i32.const 1)) (else (i32.const 1))) + )) + "type mismatch" +) + +(assert_invalid + (module (func $type-then-value-partial-vs-nums (result i32 i32) + (i32.const 0) + (if (result i32 i32) (i32.const 1) (then (i32.const 1)) (else (i32.const 1) (i32.const 1))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-else-value-partial-vs-nums (result i32 i32) + (i32.const 0) + (if (result i32 i32) (i32.const 1) (then (i32.const 1) (i32.const 1)) (else (i32.const 1))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-both-value-partial-vs-nums (result i32 i32) + (i32.const 0) + (if (result i32 i32) (i32.const 1) (then (i32.const 1)) (else (i32.const 1))) + )) + "type mismatch" +) + +(assert_invalid + (module (func $type-then-value-nums-vs-num (result i32) + (if (result i32) (i32.const 1) (then (i32.const 1) (i32.const 1)) (else (i32.const 1))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-else-value-nums-vs-num (result i32) + (if (result i32) (i32.const 1) (then (i32.const 1)) (else (i32.const 1) (i32.const 1))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-both-value-nums-vs-num (result i32) + (if (result i32) (i32.const 1) (then (i32.const 1) (i32.const 1)) (else (i32.const 1) (i32.const 1))) + )) + "type mismatch" +) + +(assert_invalid + (module (func $type-both-different-value-num-vs-num (result i32) + (if (result i32) (i32.const 1) (then (i64.const 1)) (else (f64.const 1))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-both-different-value-nums-vs-nums (result i32 i32) + (if (result i32 i32) (i32.const 1) (then (i32.const 1) (i32.const 1) (i32.const 1)) (else (i32.const 1))) + )) + "type mismatch" +) + +(assert_invalid + (module (func $type-then-value-unreached-select (result i32) + (if (result i64) + (i32.const 0) + (then (select (unreachable) (unreachable) (unreachable))) + (else (i64.const 0)) + ) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-else-value-unreached-select (result i32) + (if (result i64) + (i32.const 1) + (then (i64.const 0)) + (else (select (unreachable) (unreachable) (unreachable))) + ) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-else-value-unreached-select (result i32) + (if (result i64) + (i32.const 1) + (then (select (unreachable) (unreachable) (unreachable))) + (else (select (unreachable) (unreachable) (unreachable))) + ) + )) + "type mismatch" +) + +(assert_invalid + (module (func $type-then-break-last-void-vs-num (result i32) + (if (result i32) (i32.const 1) (then (br 0)) (else (i32.const 1))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-else-break-last-void-vs-num (result i32) + (if (result i32) (i32.const 1) (then (i32.const 1)) (else (br 0))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-then-break-last-void-vs-nums (result i32 i32) + (if (result i32 i32) (i32.const 1) (then (br 0)) (else (i32.const 1) (i32.const 1))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-else-break-last-void-vs-nums (result i32 i32) + (if (result i32 i32) (i32.const 1) (then (i32.const 1) (i32.const 1)) (else (br 0))) + )) + "type mismatch" +) + +(assert_invalid + (module (func $type-then-break-empty-vs-num (result i32) + (if (result i32) (i32.const 1) + (then (br 0) (i32.const 1)) + (else (i32.const 1)) + ) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-else-break-empty-vs-num (result i32) + (if (result i32) (i32.const 1) + (then (i32.const 1)) + (else (br 0) (i32.const 1)) + ) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-then-break-empty-vs-nums (result i32 i32) + (if (result i32 i32) (i32.const 1) + (then (br 0) (i32.const 1) (i32.const 1)) + (else (i32.const 1) (i32.const 1)) + ) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-else-break-empty-vs-nums (result i32 i32) + (if (result i32 i32) (i32.const 1) + (then (i32.const 1) (i32.const 1)) + (else (br 0) (i32.const 1) (i32.const 1)) + ) + )) + "type mismatch" +) + +(assert_invalid + (module (func $type-then-break-void-vs-num (result i32) + (if (result i32) (i32.const 1) + (then (br 0 (nop)) (i32.const 1)) + (else (i32.const 1)) + ) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-else-break-void-vs-num (result i32) + (if (result i32) (i32.const 1) + (then (i32.const 1)) + (else (br 0 (nop)) (i32.const 1)) + ) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-then-break-void-vs-nums (result i32 i32) + (if (result i32 i32) (i32.const 1) + (then (br 0 (nop)) (i32.const 1) (i32.const 1)) + (else (i32.const 1) (i32.const 1)) + ) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-else-break-void-vs-nums (result i32 i32) + (if (result i32 i32) (i32.const 1) + (then (i32.const 1) (i32.const 1)) + (else (br 0 (nop)) (i32.const 1) (i32.const 1)) + ) + )) + "type mismatch" +) + +(assert_invalid + (module (func $type-then-break-num-vs-num (result i32) + (if (result i32) (i32.const 1) + (then (br 0 (i64.const 1)) (i32.const 1)) + (else (i32.const 1)) + ) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-else-break-num-vs-num (result i32) + (if (result i32) (i32.const 1) + (then (i32.const 1)) + (else (br 0 (i64.const 1)) (i32.const 1)) + ) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-then-break-num-vs-nums (result i32 i32) + (if (result i32 i32) (i32.const 1) + (then (br 0 (i64.const 1)) (i32.const 1) (i32.const 1)) + (else (i32.const 1) (i32.const 1)) + ) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-else-break-num-vs-nums (result i32 i32) + (if (result i32 i32) (i32.const 1) + (then (i32.const 1) (i32.const 1)) + (else (br 0 (i64.const 1)) (i32.const 1) (i32.const 1)) + ) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-then-break-partial-vs-nums (result i32 i32) + (i32.const 1) + (if (result i32 i32) (i32.const 1) + (then (br 0 (i64.const 1)) (i32.const 1)) + (else (i32.const 1)) + ) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-else-break-partial-vs-nums (result i32 i32) + (i32.const 1) + (if (result i32 i32) (i32.const 1) + (then (i32.const 1)) + (else (br 0 (i64.const 1)) (i32.const 1)) + ) + )) + "type mismatch" +) + +(assert_invalid + (module + (func $type-condition-empty + (if (then)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-condition-empty-in-block + (i32.const 0) + (block (if (then))) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-condition-empty-in-loop + (i32.const 0) + (loop (if (then))) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-condition-empty-in-then + (i32.const 0) (i32.const 0) + (if (then (if (then)))) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-condition-empty-in-else + (i32.const 0) (i32.const 0) + (if (result i32) (then (i32.const 0)) (else (if (then)) (i32.const 0))) + (drop) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-condition-empty-in-br + (i32.const 0) + (block (br 0 (if(then))) (drop)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-condition-empty-in-br_if + (i32.const 0) + (block (br_if 0 (if(then)) (i32.const 1)) (drop)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-condition-empty-in-br_table + (i32.const 0) + (block (br_table 0 (if(then))) (drop)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-condition-empty-in-return + (return (if(then))) (drop) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-condition-empty-in-select + (select (if(then)) (i32.const 1) (i32.const 2)) (drop) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-condition-empty-in-call + (call 1 (if(then))) (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-condition-empty-in-call_indirect + (block (result i32) + (call_indirect (type $sig) + (if(then)) (i32.const 0) + ) + (drop) + ) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-condition-empty-in-local.set + (local i32) + (local.set 0 (if(then))) (local.get 0) (drop) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-condition-empty-in-local.tee + (local i32) + (local.tee 0 (if(then))) (drop) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (global $x (mut i32) (i32.const 0)) + (func $type-condition-empty-in-global.set + (global.set $x (if(then))) (global.get $x) (drop) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (memory 0) + (func $type-condition-empty-in-memory.grow + (memory.grow (if(then))) (drop) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (memory 0) + (func $type-condition-empty-in-load + (i32.load (if(then))) (drop) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (memory 1) + (func $type-condition-empty-in-store + (i32.store (if(then)) (i32.const 1)) + ) + ) + "type mismatch" +) + +(assert_invalid + (module (func $type-param-void-vs-num + (if (param i32) (i32.const 1) (then (drop))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-param-void-vs-nums + (if (param i32 f64) (i32.const 1) (then (drop) (drop))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-param-num-vs-num + (f32.const 0) (if (param i32) (i32.const 1) (then (drop))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-param-num-vs-nums + (f32.const 0) (if (param f32 i32) (i32.const 1) (then (drop) (drop))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-param-nested-void-vs-num + (block (if (param i32) (i32.const 1) (then (drop)))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-param-void-vs-nums + (block (if (param i32 f64) (i32.const 1) (then (drop) (drop)))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-param-num-vs-num + (block (f32.const 0) (if (param i32) (i32.const 1) (then (drop)))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-param-num-vs-nums + (block (f32.const 0) (if (param f32 i32) (i32.const 1) (then (drop) (drop)))) + )) + "type mismatch" +) + +(assert_malformed + (module quote "(func (param i32) (result i32) if (param $x i32) end)") + "unexpected token" +) +(assert_malformed + (module quote "(func (param i32) (result i32) (if (param $x i32) (then)))") + "unexpected token" +) + +(assert_malformed + (module quote "(func i32.const 0 if end $l)") + "mismatching label" +) +(assert_malformed + (module quote "(func i32.const 0 if $a end $l)") + "mismatching label" +) +(assert_malformed + (module quote "(func i32.const 0 if else $l end)") + "mismatching label" +) +(assert_malformed + (module quote "(func i32.const 0 if $a else $l end)") + "mismatching label" +) +(assert_malformed + (module quote "(func i32.const 0 if else end $l)") + "mismatching label" +) +(assert_malformed + (module quote "(func i32.const 0 if else $l end $l)") + "mismatching label" +) +(assert_malformed + (module quote "(func i32.const 0 if else $l1 end $l2)") + "mismatching label" +) +(assert_malformed + (module quote "(func i32.const 0 if $a else end $l)") + "mismatching label" +) +(assert_malformed + (module quote "(func i32.const 0 if $a else $a end $l)") + "mismatching label" +) +(assert_malformed + (module quote "(func i32.const 0 if $a else $l end $l)") + "mismatching label" +) \ No newline at end of file diff --git a/runtime/near-vm/tests/wast/spec/imports.wast b/runtime/near-vm/tests/wast/spec/imports.wast new file mode 100644 index 00000000000..35e8c917f4b --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/imports.wast @@ -0,0 +1,696 @@ +;; Auxiliary module to import from + +(module + (func (export "func")) + (func (export "func-i32") (param i32)) + (func (export "func-f32") (param f32)) + (func (export "func->i32") (result i32) (i32.const 22)) + (func (export "func->f32") (result f32) (f32.const 11)) + (func (export "func-i32->i32") (param i32) (result i32) (local.get 0)) + (func (export "func-i64->i64") (param i64) (result i64) (local.get 0)) + (global (export "global-i32") i32 (i32.const 55)) + (global (export "global-f32") f32 (f32.const 44)) + (global (export "global-mut-i64") (mut i64) (i64.const 66)) + (table (export "table-10-inf") 10 funcref) + (table (export "table-10-20") 10 20 funcref) + (memory (export "memory-2-inf") 2) + ;; Multiple memories are not yet supported + ;; (memory (export "memory-2-4") 2 4) +) + +(register "test") + + +;; Functions + +(module + (type $func_i32 (func (param i32))) + (type $func_i64 (func (param i64))) + (type $func_f32 (func (param f32))) + (type $func_f64 (func (param f64))) + + (import "spectest" "print_i32" (func (param i32))) + ;; JavaScript can't handle i64 yet. + ;; (func (import "spectest" "print_i64") (param i64)) + (import "spectest" "print_i32" (func $print_i32 (param i32))) + ;; JavaScript can't handle i64 yet. + ;; (import "spectest" "print_i64" (func $print_i64 (param i64))) + (import "spectest" "print_f32" (func $print_f32 (param f32))) + (import "spectest" "print_f64" (func $print_f64 (param f64))) + (import "spectest" "print_i32_f32" (func $print_i32_f32 (param i32 f32))) + (import "spectest" "print_f64_f64" (func $print_f64_f64 (param f64 f64))) + (func $print_i32-2 (import "spectest" "print_i32") (param i32)) + (func $print_f64-2 (import "spectest" "print_f64") (param f64)) + (import "test" "func-i64->i64" (func $i64->i64 (param i64) (result i64))) + + (func (export "p1") (import "spectest" "print_i32") (param i32)) + (func $p (export "p2") (import "spectest" "print_i32") (param i32)) + (func (export "p3") (export "p4") (import "spectest" "print_i32") (param i32)) + (func (export "p5") (import "spectest" "print_i32") (type 0)) + (func (export "p6") (import "spectest" "print_i32") (type 0) (param i32) (result)) + + (import "spectest" "print_i32" (func (type $forward))) + (func (import "spectest" "print_i32") (type $forward)) + (type $forward (func (param i32))) + + (table funcref (elem $print_i32 $print_f64)) + + (func (export "print32") (param $i i32) + (local $x f32) + (local.set $x (f32.convert_i32_s (local.get $i))) + (call 0 (local.get $i)) + (call $print_i32_f32 + (i32.add (local.get $i) (i32.const 1)) + (f32.const 42) + ) + (call $print_i32 (local.get $i)) + (call $print_i32-2 (local.get $i)) + (call $print_f32 (local.get $x)) + (call_indirect (type $func_i32) (local.get $i) (i32.const 0)) + ) + + (func (export "print64") (param $i i64) + (local $x f64) + (local.set $x (f64.convert_i64_s (call $i64->i64 (local.get $i)))) + ;; JavaScript can't handle i64 yet. + ;; (call 1 (local.get $i)) + (call $print_f64_f64 + (f64.add (local.get $x) (f64.const 1)) + (f64.const 53) + ) + ;; JavaScript can't handle i64 yet. + ;; (call $print_i64 (local.get $i)) + (call $print_f64 (local.get $x)) + (call $print_f64-2 (local.get $x)) + (call_indirect (type $func_f64) (local.get $x) (i32.const 1)) + ) +) + +(assert_return (invoke "print32" (i32.const 13))) +(assert_return (invoke "print64" (i64.const 24))) + +(assert_invalid + (module + (type (func (result i32))) + (import "test" "func" (func (type 1))) + ) + "unknown type" +) + +;; Export sharing name with import +(module + (import "spectest" "print_i32" (func $imported_print (param i32))) + (func (export "print_i32") (param $i i32) + (call $imported_print (local.get $i)) + ) +) + +(assert_return (invoke "print_i32" (i32.const 13))) + +;; Export sharing name with import +(module + (import "spectest" "print_i32" (func $imported_print (param i32))) + (func (export "print_i32") (param $i i32) (param $j i32) (result i32) + (i32.add (local.get $i) (local.get $j)) + ) +) + +(assert_return (invoke "print_i32" (i32.const 5) (i32.const 11)) (i32.const 16)) + +(module (import "test" "func" (func))) +(module (import "test" "func-i32" (func (param i32)))) +(module (import "test" "func-f32" (func (param f32)))) +(module (import "test" "func->i32" (func (result i32)))) +(module (import "test" "func->f32" (func (result f32)))) +(module (import "test" "func-i32->i32" (func (param i32) (result i32)))) +(module (import "test" "func-i64->i64" (func (param i64) (result i64)))) + +(assert_unlinkable + (module (import "test" "unknown" (func))) + "unknown import" +) +(assert_unlinkable + (module (import "spectest" "unknown" (func))) + "unknown import" +) + +(assert_unlinkable + (module (import "test" "func" (func (param i32)))) + "incompatible import type" +) +(assert_unlinkable + (module (import "test" "func" (func (result i32)))) + "incompatible import type" +) +(assert_unlinkable + (module (import "test" "func" (func (param i32) (result i32)))) + "incompatible import type" +) +(assert_unlinkable + (module (import "test" "func-i32" (func))) + "incompatible import type" +) +(assert_unlinkable + (module (import "test" "func-i32" (func (result i32)))) + "incompatible import type" +) +(assert_unlinkable + (module (import "test" "func-i32" (func (param f32)))) + "incompatible import type" +) +(assert_unlinkable + (module (import "test" "func-i32" (func (param i64)))) + "incompatible import type" +) +(assert_unlinkable + (module (import "test" "func-i32" (func (param i32) (result i32)))) + "incompatible import type" +) +(assert_unlinkable + (module (import "test" "func->i32" (func))) + "incompatible import type" +) +(assert_unlinkable + (module (import "test" "func->i32" (func (param i32)))) + "incompatible import type" +) +(assert_unlinkable + (module (import "test" "func->i32" (func (result f32)))) + "incompatible import type" +) +(assert_unlinkable + (module (import "test" "func->i32" (func (result i64)))) + "incompatible import type" +) +(assert_unlinkable + (module (import "test" "func->i32" (func (param i32) (result i32)))) + "incompatible import type" +) +(assert_unlinkable + (module (import "test" "func-i32->i32" (func))) + "incompatible import type" +) +(assert_unlinkable + (module (import "test" "func-i32->i32" (func (param i32)))) + "incompatible import type" +) +(assert_unlinkable + (module (import "test" "func-i32->i32" (func (result i32)))) + "incompatible import type" +) + +(assert_unlinkable + (module (import "test" "global-i32" (func (result i32)))) + "incompatible import type" +) +(assert_unlinkable + (module (import "test" "table-10-inf" (func))) + "incompatible import type" +) +(assert_unlinkable + (module (import "test" "memory-2-inf" (func))) + "incompatible import type" +) +(assert_unlinkable + (module (import "spectest" "global_i32" (func))) + "incompatible import type" +) +(assert_unlinkable + (module (import "spectest" "table" (func))) + "incompatible import type" +) +(assert_unlinkable + (module (import "spectest" "memory" (func))) + "incompatible import type" +) + + +;; Globals + +(module + (import "spectest" "global_i32" (global i32)) + (global (import "spectest" "global_i32") i32) + + (import "spectest" "global_i32" (global $x i32)) + (global $y (import "spectest" "global_i32") i32) + + ;; JavaScript can't handle i64 yet. + ;; (import "spectest" "global_i64" (global i64)) + (import "spectest" "global_f32" (global f32)) + (import "spectest" "global_f64" (global f64)) + + (func (export "get-0") (result i32) (global.get 0)) + (func (export "get-1") (result i32) (global.get 1)) + (func (export "get-x") (result i32) (global.get $x)) + (func (export "get-y") (result i32) (global.get $y)) +) + +(assert_return (invoke "get-0") (i32.const 666)) +(assert_return (invoke "get-1") (i32.const 666)) +(assert_return (invoke "get-x") (i32.const 666)) +(assert_return (invoke "get-y") (i32.const 666)) + +(module (import "test" "global-i32" (global i32))) +(module (import "test" "global-f32" (global f32))) +(module (import "test" "global-mut-i64" (global (mut i64)))) + +(assert_unlinkable + (module (import "test" "unknown" (global i32))) + "unknown import" +) +(assert_unlinkable + (module (import "spectest" "unknown" (global i32))) + "unknown import" +) + +(assert_unlinkable + (module (import "test" "global-i32" (global i64))) + "incompatible import type" +) +(assert_unlinkable + (module (import "test" "global-i32" (global f32))) + "incompatible import type" +) +(assert_unlinkable + (module (import "test" "global-i32" (global f64))) + "incompatible import type" +) +(assert_unlinkable + (module (import "test" "global-i32" (global (mut i32)))) + "incompatible import type" +) +(assert_unlinkable + (module (import "test" "global-f32" (global i32))) + "incompatible import type" +) +(assert_unlinkable + (module (import "test" "global-f32" (global i64))) + "incompatible import type" +) +(assert_unlinkable + (module (import "test" "global-f32" (global f64))) + "incompatible import type" +) +(assert_unlinkable + (module (import "test" "global-f32" (global (mut f32)))) + "incompatible import type" +) +(assert_unlinkable + (module (import "test" "global-mut-i64" (global (mut i32)))) + "incompatible import type" +) +(assert_unlinkable + (module (import "test" "global-mut-i64" (global (mut f32)))) + "incompatible import type" +) +(assert_unlinkable + (module (import "test" "global-mut-i64" (global (mut f64)))) + "incompatible import type" +) +(assert_unlinkable + (module (import "test" "global-mut-i64" (global i64))) + "incompatible import type" +) + +(assert_unlinkable + (module (import "test" "func" (global i32))) + "incompatible import type" +) +(assert_unlinkable + (module (import "test" "table-10-inf" (global i32))) + "incompatible import type" +) +(assert_unlinkable + (module (import "test" "memory-2-inf" (global i32))) + "incompatible import type" +) +(assert_unlinkable + (module (import "spectest" "print_i32" (global i32))) + "incompatible import type" +) +(assert_unlinkable + (module (import "spectest" "table" (global i32))) + "incompatible import type" +) +(assert_unlinkable + (module (import "spectest" "memory" (global i32))) + "incompatible import type" +) + + +;; Tables + +(module + (type (func (result i32))) + (import "spectest" "table" (table $tab 10 20 funcref)) + (elem (table $tab) (i32.const 1) func $f $g) + + (func (export "call") (param i32) (result i32) + (call_indirect $tab (type 0) (local.get 0)) + ) + (func $f (result i32) (i32.const 11)) + (func $g (result i32) (i32.const 22)) +) + +(assert_trap (invoke "call" (i32.const 0)) "uninitialized element") +(assert_return (invoke "call" (i32.const 1)) (i32.const 11)) +(assert_return (invoke "call" (i32.const 2)) (i32.const 22)) +(assert_trap (invoke "call" (i32.const 3)) "uninitialized element") +(assert_trap (invoke "call" (i32.const 100)) "undefined element") + + +(module + (type (func (result i32))) + (table $tab (import "spectest" "table") 10 20 funcref) + (elem (table $tab) (i32.const 1) func $f $g) + + (func (export "call") (param i32) (result i32) + (call_indirect $tab (type 0) (local.get 0)) + ) + (func $f (result i32) (i32.const 11)) + (func $g (result i32) (i32.const 22)) +) + +(assert_trap (invoke "call" (i32.const 0)) "uninitialized element") +(assert_return (invoke "call" (i32.const 1)) (i32.const 11)) +(assert_return (invoke "call" (i32.const 2)) (i32.const 22)) +(assert_trap (invoke "call" (i32.const 3)) "uninitialized element") +(assert_trap (invoke "call" (i32.const 100)) "undefined element") + + +(module + (import "spectest" "table" (table 0 funcref)) + (import "spectest" "table" (table 0 funcref)) + (table 10 funcref) + (table 10 funcref) +) + +(module (import "test" "table-10-inf" (table 10 funcref))) +(module (import "test" "table-10-inf" (table 5 funcref))) +(module (import "test" "table-10-inf" (table 0 funcref))) +(module (import "test" "table-10-20" (table 10 funcref))) +(module (import "test" "table-10-20" (table 5 funcref))) +(module (import "test" "table-10-20" (table 0 funcref))) +(module (import "test" "table-10-20" (table 10 20 funcref))) +(module (import "test" "table-10-20" (table 5 20 funcref))) +(module (import "test" "table-10-20" (table 0 20 funcref))) +(module (import "test" "table-10-20" (table 10 25 funcref))) +(module (import "test" "table-10-20" (table 5 25 funcref))) +(module (import "test" "table-10-20" (table 0 25 funcref))) +(module (import "spectest" "table" (table 10 funcref))) +(module (import "spectest" "table" (table 5 funcref))) +(module (import "spectest" "table" (table 0 funcref))) +(module (import "spectest" "table" (table 10 20 funcref))) +(module (import "spectest" "table" (table 5 20 funcref))) +(module (import "spectest" "table" (table 0 20 funcref))) +(module (import "spectest" "table" (table 10 25 funcref))) +(module (import "spectest" "table" (table 5 25 funcref))) + +(assert_unlinkable + (module (import "test" "unknown" (table 10 funcref))) + "unknown import" +) +(assert_unlinkable + (module (import "spectest" "unknown" (table 10 funcref))) + "unknown import" +) + +(assert_unlinkable + (module (import "test" "table-10-inf" (table 12 funcref))) + "incompatible import type" +) +(assert_unlinkable + (module (import "test" "table-10-inf" (table 10 20 funcref))) + "incompatible import type" +) +(assert_unlinkable + (module (import "test" "table-10-20" (table 12 20 funcref))) + "incompatible import type" +) +(assert_unlinkable + (module (import "test" "table-10-20" (table 10 18 funcref))) + "incompatible import type" +) +(assert_unlinkable + (module (import "spectest" "table" (table 12 funcref))) + "incompatible import type" +) +(assert_unlinkable + (module (import "spectest" "table" (table 10 15 funcref))) + "incompatible import type" +) + +(assert_unlinkable + (module (import "test" "func" (table 10 funcref))) + "incompatible import type" +) +(assert_unlinkable + (module (import "test" "global-i32" (table 10 funcref))) + "incompatible import type" +) +(assert_unlinkable + (module (import "test" "memory-2-inf" (table 10 funcref))) + "incompatible import type" +) +(assert_unlinkable + (module (import "spectest" "print_i32" (table 10 funcref))) + "incompatible import type" +) + + + +;; Memories + +(module + (import "spectest" "memory" (memory 1 2)) + (data (memory 0) (i32.const 10) "\10") + + (func (export "load") (param i32) (result i32) (i32.load (local.get 0))) +) + +(assert_return (invoke "load" (i32.const 0)) (i32.const 0)) +(assert_return (invoke "load" (i32.const 10)) (i32.const 16)) +(assert_return (invoke "load" (i32.const 8)) (i32.const 0x100000)) +(assert_trap (invoke "load" (i32.const 1000000)) "out of bounds memory access") + +(module + (memory (import "spectest" "memory") 1 2) + (data (memory 0) (i32.const 10) "\10") + + (func (export "load") (param i32) (result i32) (i32.load (local.get 0))) +) +(assert_return (invoke "load" (i32.const 0)) (i32.const 0)) +(assert_return (invoke "load" (i32.const 10)) (i32.const 16)) +(assert_return (invoke "load" (i32.const 8)) (i32.const 0x100000)) +(assert_trap (invoke "load" (i32.const 1000000)) "out of bounds memory access") + +(assert_invalid + (module (import "" "" (memory 1)) (import "" "" (memory 1))) + "multiple memories" +) +(assert_invalid + (module (import "" "" (memory 1)) (memory 0)) + "multiple memories" +) +(assert_invalid + (module (memory 0) (memory 0)) + "multiple memories" +) + +(module (import "test" "memory-2-inf" (memory 2))) +(module (import "test" "memory-2-inf" (memory 1))) +(module (import "test" "memory-2-inf" (memory 0))) +(module (import "spectest" "memory" (memory 1))) +(module (import "spectest" "memory" (memory 0))) +(module (import "spectest" "memory" (memory 1 2))) +(module (import "spectest" "memory" (memory 0 2))) +(module (import "spectest" "memory" (memory 1 3))) +(module (import "spectest" "memory" (memory 0 3))) + +(assert_unlinkable + (module (import "test" "unknown" (memory 1))) + "unknown import" +) +(assert_unlinkable + (module (import "spectest" "unknown" (memory 1))) + "unknown import" +) + +(assert_unlinkable + (module (import "test" "memory-2-inf" (memory 3))) + "incompatible import type" +) +(assert_unlinkable + (module (import "test" "memory-2-inf" (memory 2 3))) + "incompatible import type" +) +(assert_unlinkable + (module (import "spectest" "memory" (memory 2))) + "incompatible import type" +) +(assert_unlinkable + (module (import "spectest" "memory" (memory 1 1))) + "incompatible import type" +) + +(assert_unlinkable + (module (import "test" "func-i32" (memory 1))) + "incompatible import type" +) +(assert_unlinkable + (module (import "test" "global-i32" (memory 1))) + "incompatible import type" +) +(assert_unlinkable + (module (import "test" "table-10-inf" (memory 1))) + "incompatible import type" +) +(assert_unlinkable + (module (import "spectest" "print_i32" (memory 1))) + "incompatible import type" +) +(assert_unlinkable + (module (import "spectest" "global_i32" (memory 1))) + "incompatible import type" +) +(assert_unlinkable + (module (import "spectest" "table" (memory 1))) + "incompatible import type" +) + +(assert_unlinkable + (module (import "spectest" "memory" (memory 2))) + "incompatible import type" +) +(assert_unlinkable + (module (import "spectest" "memory" (memory 1 1))) + "incompatible import type" +) + +(module + (import "spectest" "memory" (memory 0 3)) ;; actual has max size 2 + (func (export "grow") (param i32) (result i32) (memory.grow (local.get 0))) +) +(assert_return (invoke "grow" (i32.const 0)) (i32.const 1)) +(assert_return (invoke "grow" (i32.const 1)) (i32.const 1)) +(assert_return (invoke "grow" (i32.const 0)) (i32.const 2)) +(assert_return (invoke "grow" (i32.const 1)) (i32.const -1)) +(assert_return (invoke "grow" (i32.const 0)) (i32.const 2)) + +(module $Mgm + (memory (export "memory") 1) ;; initial size is 1 + (func (export "grow") (result i32) (memory.grow (i32.const 1))) +) +(register "grown-memory" $Mgm) +(assert_return (invoke $Mgm "grow") (i32.const 1)) ;; now size is 2 +(module $Mgim1 + ;; imported memory limits should match, because external memory size is 2 now + (memory (export "memory") (import "grown-memory" "memory") 2) + (func (export "grow") (result i32) (memory.grow (i32.const 1))) +) +(register "grown-imported-memory" $Mgim1) +(assert_return (invoke $Mgim1 "grow") (i32.const 2)) ;; now size is 3 +(module $Mgim2 + ;; imported memory limits should match, because external memory size is 3 now + (import "grown-imported-memory" "memory" (memory 3)) + (func (export "size") (result i32) (memory.size)) +) +(assert_return (invoke $Mgim2 "size") (i32.const 3)) + + +;; Syntax errors + +(assert_malformed + (module quote "(func) (import \"\" \"\" (func))") + "import after function" +) +(assert_malformed + (module quote "(func) (import \"\" \"\" (global i64))") + "import after function" +) +(assert_malformed + (module quote "(func) (import \"\" \"\" (table 0 funcref))") + "import after function" +) +(assert_malformed + (module quote "(func) (import \"\" \"\" (memory 0))") + "import after function" +) + +(assert_malformed + (module quote "(global i64 (i64.const 0)) (import \"\" \"\" (func))") + "import after global" +) +(assert_malformed + (module quote "(global i64 (i64.const 0)) (import \"\" \"\" (global f32))") + "import after global" +) +(assert_malformed + (module quote "(global i64 (i64.const 0)) (import \"\" \"\" (table 0 funcref))") + "import after global" +) +(assert_malformed + (module quote "(global i64 (i64.const 0)) (import \"\" \"\" (memory 0))") + "import after global" +) + +(assert_malformed + (module quote "(table 0 funcref) (import \"\" \"\" (func))") + "import after table" +) +(assert_malformed + (module quote "(table 0 funcref) (import \"\" \"\" (global i32))") + "import after table" +) +(assert_malformed + (module quote "(table 0 funcref) (import \"\" \"\" (table 0 funcref))") + "import after table" +) +(assert_malformed + (module quote "(table 0 funcref) (import \"\" \"\" (memory 0))") + "import after table" +) + +(assert_malformed + (module quote "(memory 0) (import \"\" \"\" (func))") + "import after memory" +) +(assert_malformed + (module quote "(memory 0) (import \"\" \"\" (global i32))") + "import after memory" +) +(assert_malformed + (module quote "(memory 0) (import \"\" \"\" (table 1 3 funcref))") + "import after memory" +) +(assert_malformed + (module quote "(memory 0) (import \"\" \"\" (memory 1 2))") + "import after memory" +) + +;; This module is required to validate, regardless of whether it can be +;; linked. Overloading is not possible in wasm itself, but it is possible +;; in modules from which wasm can import. +(module) +(register "not wasm") +(assert_unlinkable + (module + (import "not wasm" "overloaded" (func)) + (import "not wasm" "overloaded" (func (param i32))) + (import "not wasm" "overloaded" (func (param i32 i32))) + (import "not wasm" "overloaded" (func (param i64))) + (import "not wasm" "overloaded" (func (param f32))) + (import "not wasm" "overloaded" (func (param f64))) + (import "not wasm" "overloaded" (func (result i32))) + (import "not wasm" "overloaded" (func (result i64))) + (import "not wasm" "overloaded" (func (result f32))) + (import "not wasm" "overloaded" (func (result f64))) + (import "not wasm" "overloaded" (global i32)) + (import "not wasm" "overloaded" (global i64)) + (import "not wasm" "overloaded" (global f32)) + (import "not wasm" "overloaded" (global f64)) + (import "not wasm" "overloaded" (table 0 funcref)) + (import "not wasm" "overloaded" (memory 0)) + ) + "unknown import" +) diff --git a/runtime/near-vm/tests/wast/spec/inline-module.wast b/runtime/near-vm/tests/wast/spec/inline-module.wast new file mode 100644 index 00000000000..dc7ead7767f --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/inline-module.wast @@ -0,0 +1 @@ +(func) (memory 0) (func (export "f")) diff --git a/runtime/near-vm/tests/wast/spec/int_exprs.wast b/runtime/near-vm/tests/wast/spec/int_exprs.wast new file mode 100644 index 00000000000..22e1fbcb5c9 --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/int_exprs.wast @@ -0,0 +1,350 @@ +;; Test interesting integer "expressions". These tests contain code +;; patterns which tempt common value-changing optimizations. + +;; Test that x+1>n is not folded to x. + +(module + (func (export "i32.no_fold_shl_shr_s") (param $x i32) (result i32) + (i32.shr_s (i32.shl (local.get $x) (i32.const 1)) (i32.const 1))) + (func (export "i32.no_fold_shl_shr_u") (param $x i32) (result i32) + (i32.shr_u (i32.shl (local.get $x) (i32.const 1)) (i32.const 1))) + + (func (export "i64.no_fold_shl_shr_s") (param $x i64) (result i64) + (i64.shr_s (i64.shl (local.get $x) (i64.const 1)) (i64.const 1))) + (func (export "i64.no_fold_shl_shr_u") (param $x i64) (result i64) + (i64.shr_u (i64.shl (local.get $x) (i64.const 1)) (i64.const 1))) +) + +(assert_return (invoke "i32.no_fold_shl_shr_s" (i32.const 0x80000000)) (i32.const 0)) +(assert_return (invoke "i32.no_fold_shl_shr_u" (i32.const 0x80000000)) (i32.const 0)) +(assert_return (invoke "i64.no_fold_shl_shr_s" (i64.const 0x8000000000000000)) (i64.const 0)) +(assert_return (invoke "i64.no_fold_shl_shr_u" (i64.const 0x8000000000000000)) (i64.const 0)) + +;; Test that x>>n<?,./ ") (result i32) (i32.const 6)) + + ;; Test that we can use names that have special meaning in JS. + (func (export "NaN") (result i32) (i32.const 7)) + (func (export "Infinity") (result i32) (i32.const 8)) + (func (export "if") (result i32) (i32.const 9)) + + ;; Test that we can use common libc names without conflict. + (func (export "malloc") (result i32) (i32.const 10)) + + ;; Test that we can use some libc hidden names without conflict. + (func (export "_malloc") (result i32) (i32.const 11)) + (func (export "__malloc") (result i32) (i32.const 12)) + + ;; Test that names are case-sensitive. + (func (export "a") (result i32) (i32.const 13)) + (func (export "A") (result i32) (i32.const 14)) + + ;; Test that UTF-8 BOM code points can appear in identifiers. + (func (export "") (result i32) (i32.const 15)) + + ;; Test that Unicode normalization is not applied. These function names + ;; contain different codepoints which normalize to the same thing under + ;; NFC or NFD. + (func (export "Å") (result i32) (i32.const 16)) + (func (export "Å") (result i32) (i32.const 17)) + (func (export "Å") (result i32) (i32.const 18)) + + ;; Test that Unicode compatibility normalization is not applied. These + ;; function names contain different codepoints which normalize to the + ;; same thing under NFKC or NFKD. + (func (export "ffi") (result i32) (i32.const 19)) + (func (export "ffi") (result i32) (i32.const 20)) + (func (export "ffi") (result i32) (i32.const 21)) + + ;; Test the C0 control codes. + (func (export "\00\01\02\03\04\05\06\07\08\09\0a\0b\0c\0d\0e\0f") (result i32) (i32.const 22)) + (func (export "\10\11\12\13\14\15\16\17\18\19\1a\1b\1c\1d\1e\1f") (result i32) (i32.const 23)) + ;; Test miscellaneous control codes. + (func (export " \7f") (result i32) (i32.const 24)) + ;; Test the C1 control codes. + (func (export "\c2\80\c2\81\c2\82\c2\83\c2\84\c2\85\c2\86\c2\87\c2\88\c2\89\c2\8a\c2\8b\c2\8c\c2\8d\c2\8e\c2\8f") (result i32) (i32.const 25)) + (func (export "\c2\90\c2\91\c2\92\c2\93\c2\94\c2\95\c2\96\c2\97\c2\98\c2\99\c2\9a\c2\9b\c2\9c\c2\9d\c2\9e\c2\9f") (result i32) (i32.const 26)) + ;; Test the Unicode Specials. + (func (export "\ef\bf\b0\ef\bf\b1\ef\bf\b2\ef\bf\b3\ef\bf\b4\ef\bf\b5\ef\bf\b6\ef\bf\b7") (result i32) (i32.const 27)) + (func (export "\ef\bf\b8\ef\bf\b9\ef\bf\ba\ef\bf\bb\ef\bf\bc\ef\bf\bd\ef\bf\be\ef\bf\bf") (result i32) (i32.const 28)) + + ;; Test that the control pictures are distinct from the control codes they + ;; depict. These correspond to the C0 and miscellaneous control code tests + ;; above. + (func (export "␀␁␂␃␄␅␆␇␈␉␊␋␌␍␎␏") (result i32) (i32.const 29)) + (func (export "␐␑␒␓␔␕␖␗␘␙␚␛␜␝␞␟") (result i32) (i32.const 30)) + (func (export "␠␡") (result i32) (i32.const 31)) + + ;; Test the Unicode Specials in non-escaped form (excluding U+FFFE and + ;; U+FFFF, so that generic tools don't detect this file as non-UTF-8). + (func (export "￰￱￲￳￴￵￶￷￸�") (result i32) (i32.const 32)) + + ;; Test a bare ZWJ code point. + (func (export "‍") (result i32) (i32.const 33)) + ;; Test a bare ZWNJ code point. + (func (export "‌") (result i32) (i32.const 34)) + + ;; Test various bare joiner code points. + (func (export "͏") (result i32) (i32.const 35)) + (func (export "⁠") (result i32) (i32.const 36)) + (func (export "⵿") (result i32) (i32.const 37)) + (func (export "𑁿") (result i32) (i32.const 38)) + (func (export "᠎") (result i32) (i32.const 39)) + + ;; Test various interesting code points: reverse BOM, zero-width space, + ;; no-break space, soft hyphen, word joiner, ogham space mark, + ;; right-to-left override, left-to-right override. + (func (export "￯​ ­⁠ ‮‭") (result i32) (i32.const 40)) + + ;; Test more interesting code points: left-to-right mark, right-to-left mark, + ;; non-breaking hyphen, line separator, paragraph separator, + ;; left-to-right embedding, right-to-left embedding, + ;; pop directional formatting, narrow no-break space, left-to-right isolate, + ;; right-to-left isolate, first strong isolate, pop directional isolate. + (func (export "‎‏‑

‪‫‬ ⁦⁧⁨⁩") (result i32) (i32.const 41)) + + ;; Test some deprecated code points: inhibit symmetric swapping, + ;; activate symmetric swapping, inhibit arabic form shaping, + ;; activate arabic form shaping, national digit shapes, nominal digit shapes. + (func (export "") (result i32) (i32.const 42)) + + ;; Test "invisible" operator code points. + (func (export "⁡⁢⁣⁤") (result i32) (i32.const 43)) + + ;; Test that code points outside the BMP are supported. + (func (export "𐀀󟿿􏿿") (result i32) (i32.const 44)) + + ;; Test that WebAssembly implementations cope in the presence of Zalgo. + (func (export "Z̴͇̫̥̪͓͈͔͎̗̞̺̯̱̞̙̱̜̖̠̏͆̆͛͌͘͞ḁ̶̰̳̭͙̲̱̹̝͎̼͗ͨ̎̄̆͗̿̀́͟͡l̶̷͉̩̹̫̝͖̙̲̼͇͚͍̮͎̥̞̈́͊͗ͦ̈́ͫ̇́̚ͅͅg̶͕͔͚̩̓̐̅ͮ̔̐̎̂̏̾͊̍͋͊ͧ́̆ͦ͞o̡͋̔͐ͪͩ͏̢̧̫̙̤̮͖͙͓̺̜̩̼̘̠́") (result i32) (i32.const 45)) + + ;; Test Hangul filler code points. + (func (export "ᅟᅠㅤﾠ") (result i32) (i32.const 46)) + + ;; Test variation selectors (which are also ID_Continue code points). + (func (export "︀") (result i32) (i32.const 47)) + (func (export "︄") (result i32) (i32.const 48)) + (func (export "󠄀") (result i32) (i32.const 49)) + (func (export "󠇯") (result i32) (i32.const 50)) + + ;; Test an uncombined combining code point. + (func (export "̈") (result i32) (i32.const 51)) + + ;; Test that numerous different present and historical representations of the + ;; "newline" concept are distinct. Tests largely inspired by: + ;; https://en.wikipedia.org/wiki/Newline#Representations + ;; https://en.wikipedia.org/wiki/Newline#Unicode and + ;; https://en.wikipedia.org/wiki/Newline#Reverse_and_partial_line_feeds + (func (export "\0a") (result i32) (i32.const 52)) + (func (export "␤") (result i32) (i32.const 53)) + (func (export "
") (result i32) (i32.const 54)) + (func (export "\0d") (result i32) (i32.const 55)) + (func (export "\0d\0a") (result i32) (i32.const 56)) + (func (export "\0a\0d") (result i32) (i32.const 57)) + (func (export "\1e") (result i32) (i32.const 58)) + (func (export "\0b") (result i32) (i32.const 59)) + (func (export "\0c") (result i32) (i32.const 60)) + (func (export "\c2\85") (result i32) (i32.const 61)) + (func (export "
") (result i32) (i32.const 62)) + (func (export "…") (result i32) (i32.const 63)) + (func (export "⏎") (result i32) (i32.const 64)) + (func (export "\c2\8b") (result i32) (i32.const 65)) + (func (export "\c2\8c") (result i32) (i32.const 66)) + (func (export "\c2\8d") (result i32) (i32.const 67)) + (func (export "↵") (result i32) (i32.const 68)) + (func (export "↩") (result i32) (i32.const 69)) + (func (export "⌤") (result i32) (i32.const 70)) + (func (export "⤶") (result i32) (i32.const 71)) + (func (export "↲") (result i32) (i32.const 72)) + (func (export "⮨") (result i32) (i32.const 73)) + (func (export "⮰") (result i32) (i32.const 74)) + + ;; Test that non-characters are not replaced by the replacement character. + (func (export "�") (result i32) (i32.const 75)) + (func (export "\ef\b7\90") (result i32) (i32.const 76)) + (func (export "\ef\b7\91") (result i32) (i32.const 77)) + (func (export "\ef\b7\92") (result i32) (i32.const 78)) + (func (export "\ef\b7\93") (result i32) (i32.const 79)) + (func (export "\ef\b7\94") (result i32) (i32.const 80)) + (func (export "\ef\b7\95") (result i32) (i32.const 81)) + (func (export "\ef\b7\96") (result i32) (i32.const 82)) + (func (export "\ef\b7\97") (result i32) (i32.const 83)) + (func (export "\ef\b7\98") (result i32) (i32.const 84)) + (func (export "\ef\b7\99") (result i32) (i32.const 85)) + (func (export "\ef\b7\9a") (result i32) (i32.const 86)) + (func (export "\ef\b7\9b") (result i32) (i32.const 87)) + (func (export "\ef\b7\9c") (result i32) (i32.const 88)) + (func (export "\ef\b7\9d") (result i32) (i32.const 89)) + (func (export "\ef\b7\9e") (result i32) (i32.const 90)) + (func (export "\ef\b7\9f") (result i32) (i32.const 91)) + (func (export "\ef\b7\a0") (result i32) (i32.const 92)) + (func (export "\ef\b7\a1") (result i32) (i32.const 93)) + (func (export "\ef\b7\a2") (result i32) (i32.const 94)) + (func (export "\ef\b7\a3") (result i32) (i32.const 95)) + (func (export "\ef\b7\a4") (result i32) (i32.const 96)) + (func (export "\ef\b7\a5") (result i32) (i32.const 97)) + (func (export "\ef\b7\a6") (result i32) (i32.const 98)) + (func (export "\ef\b7\a7") (result i32) (i32.const 99)) + (func (export "\ef\b7\a8") (result i32) (i32.const 100)) + (func (export "\ef\b7\a9") (result i32) (i32.const 101)) + (func (export "\ef\b7\aa") (result i32) (i32.const 102)) + (func (export "\ef\b7\ab") (result i32) (i32.const 103)) + (func (export "\ef\b7\ac") (result i32) (i32.const 104)) + (func (export "\ef\b7\ad") (result i32) (i32.const 105)) + (func (export "\ef\b7\ae") (result i32) (i32.const 106)) + (func (export "\ef\b7\af") (result i32) (i32.const 107)) + (func (export "\ef\bf\be") (result i32) (i32.const 108)) + (func (export "\ef\bf\bf") (result i32) (i32.const 109)) + (func (export "\f0\9f\bf\be") (result i32) (i32.const 110)) + (func (export "\f0\9f\bf\bf") (result i32) (i32.const 111)) + (func (export "\f0\af\bf\be") (result i32) (i32.const 112)) + (func (export "\f0\af\bf\bf") (result i32) (i32.const 113)) + (func (export "\f0\bf\bf\be") (result i32) (i32.const 114)) + (func (export "\f0\bf\bf\bf") (result i32) (i32.const 115)) + (func (export "\f1\8f\bf\be") (result i32) (i32.const 116)) + (func (export "\f1\8f\bf\bf") (result i32) (i32.const 117)) + (func (export "\f1\9f\bf\be") (result i32) (i32.const 118)) + (func (export "\f1\9f\bf\bf") (result i32) (i32.const 119)) + (func (export "\f1\af\bf\be") (result i32) (i32.const 120)) + (func (export "\f1\af\bf\bf") (result i32) (i32.const 121)) + (func (export "\f1\bf\bf\be") (result i32) (i32.const 122)) + (func (export "\f1\bf\bf\bf") (result i32) (i32.const 123)) + (func (export "\f2\8f\bf\be") (result i32) (i32.const 124)) + (func (export "\f2\8f\bf\bf") (result i32) (i32.const 125)) + (func (export "\f2\9f\bf\be") (result i32) (i32.const 126)) + (func (export "\f2\9f\bf\bf") (result i32) (i32.const 127)) + (func (export "\f2\af\bf\be") (result i32) (i32.const 128)) + (func (export "\f2\af\bf\bf") (result i32) (i32.const 129)) + (func (export "\f2\bf\bf\be") (result i32) (i32.const 130)) + (func (export "\f2\bf\bf\bf") (result i32) (i32.const 131)) + (func (export "\f3\8f\bf\be") (result i32) (i32.const 132)) + (func (export "\f3\8f\bf\bf") (result i32) (i32.const 133)) + (func (export "\f3\9f\bf\be") (result i32) (i32.const 134)) + (func (export "\f3\9f\bf\bf") (result i32) (i32.const 135)) + (func (export "\f3\af\bf\be") (result i32) (i32.const 136)) + (func (export "\f3\af\bf\bf") (result i32) (i32.const 137)) + (func (export "\f3\bf\bf\be") (result i32) (i32.const 138)) + (func (export "\f3\bf\bf\bf") (result i32) (i32.const 139)) + (func (export "\f4\8f\bf\be") (result i32) (i32.const 140)) + (func (export "\f4\8f\bf\bf") (result i32) (i32.const 141)) + + ;; Test an interrobang with combining diacritical marks above. + ;; https://xkcd.com/1209/ + (func (export "̈‽̈̉") (result i32) (i32.const 142)) + + ;; Test that RLM/LRM don't change the logical byte order. + (func (export "abc") (result i32) (i32.const 143)) + (func (export "‭abc") (result i32) (i32.const 144)) + (func (export "‮cba") (result i32) (i32.const 145)) + (func (export "‭abc‮") (result i32) (i32.const 146)) + (func (export "‮cba‭") (result i32) (i32.const 147)) + + ;; Test that Unicode font variations are preserved. + (func (export "𝑨") (result i32) (i32.const 148)) + (func (export "𝐴") (result i32) (i32.const 149)) + (func (export "𝘈") (result i32) (i32.const 150)) + (func (export "𝘼") (result i32) (i32.const 151)) + (func (export "𝐀") (result i32) (i32.const 152)) + (func (export "𝓐") (result i32) (i32.const 153)) + (func (export "𝕬") (result i32) (i32.const 154)) + (func (export "𝗔") (result i32) (i32.const 155)) + (func (export "𝒜") (result i32) (i32.const 156)) + (func (export "𝔄") (result i32) (i32.const 157)) + (func (export "𝔸") (result i32) (i32.const 158)) + (func (export "𝖠") (result i32) (i32.const 159)) + (func (export "𝙰") (result i32) (i32.const 160)) + (func (export "ᴀ") (result i32) (i32.const 161)) + + ;; Test that various additional letter variations are preserved. + ;; (U+0040, U+0061, U+0041, U+00C5, U+0041 U+030A, U+212B, and the font + ;; variations are covered above.) + (func (export "ᴬ") (result i32) (i32.const 162)) + (func (export "Ⓐ") (result i32) (i32.const 163)) + (func (export "Ａ") (result i32) (i32.const 164)) + (func (export "🄐") (result i32) (i32.const 165)) + (func (export "🄰") (result i32) (i32.const 166)) + (func (export "󠁁") (result i32) (i32.const 167)) + (func (export "U+0041") (result i32) (i32.const 168)) + (func (export "A​") (result i32) (i32.const 169)) + (func (export "А") (result i32) (i32.const 170)) + (func (export "Ꙗ") (result i32) (i32.const 171)) + (func (export "ⷼ") (result i32) (i32.const 172)) + (func (export "ⷶ") (result i32) (i32.const 173)) + (func (export "Ɐ") (result i32) (i32.const 174)) + (func (export "🅐") (result i32) (i32.const 175)) + (func (export "🅰") (result i32) (i32.const 176)) + (func (export "Ⱝ") (result i32) (i32.const 177)) + (func (export "𐐂") (result i32) (i32.const 178)) + (func (export "𐐈") (result i32) (i32.const 179)) + (func (export "𐒰") (result i32) (i32.const 180)) + (func (export "À") (result i32) (i32.const 181)) + (func (export "Á") (result i32) (i32.const 182)) + (func (export "Â") (result i32) (i32.const 183)) + (func (export "Ã") (result i32) (i32.const 184)) + (func (export "Ä") (result i32) (i32.const 185)) + (func (export "Ā") (result i32) (i32.const 186)) + (func (export "Ă") (result i32) (i32.const 187)) + (func (export "Ą") (result i32) (i32.const 188)) + (func (export "Ǎ") (result i32) (i32.const 189)) + (func (export "Ǟ") (result i32) (i32.const 190)) + (func (export "Ǡ") (result i32) (i32.const 191)) + (func (export "Ǻ") (result i32) (i32.const 192)) + (func (export "Ȁ") (result i32) (i32.const 193)) + (func (export "Ȃ") (result i32) (i32.const 194)) + (func (export "Ȧ") (result i32) (i32.const 195)) + (func (export "Ⱥ") (result i32) (i32.const 196)) + (func (export "Ӑ") (result i32) (i32.const 197)) + (func (export "Ӓ") (result i32) (i32.const 198)) + (func (export "ߊ") (result i32) (i32.const 199)) + (func (export "ࠡ") (result i32) (i32.const 200)) + (func (export "ࠢ") (result i32) (i32.const 201)) + (func (export "ࠣ") (result i32) (i32.const 202)) + (func (export "ࠤ") (result i32) (i32.const 203)) + (func (export "ࠥ") (result i32) (i32.const 204)) + (func (export "ऄ") (result i32) (i32.const 205)) + (func (export "अ") (result i32) (i32.const 206)) + (func (export "ॲ") (result i32) (i32.const 207)) + (func (export "অ") (result i32) (i32.const 208)) + (func (export "ਅ") (result i32) (i32.const 209)) + (func (export "અ") (result i32) (i32.const 210)) + (func (export "ଅ") (result i32) (i32.const 211)) + (func (export "அ") (result i32) (i32.const 212)) + (func (export "అ") (result i32) (i32.const 213)) + (func (export "ಅ") (result i32) (i32.const 214)) + (func (export "അ") (result i32) (i32.const 215)) + (func (export "ะ") (result i32) (i32.const 216)) + (func (export "ະ") (result i32) (i32.const 217)) + (func (export "༁") (result i32) (i32.const 218)) + (func (export "ཨ") (result i32) (i32.const 219)) + (func (export "ྸ") (result i32) (i32.const 220)) + (func (export "အ") (result i32) (i32.const 221)) + (func (export "ဢ") (result i32) (i32.const 222)) + (func (export "ႜ") (result i32) (i32.const 223)) + (func (export "ᅡ") (result i32) (i32.const 224)) + (func (export "አ") (result i32) (i32.const 225)) + (func (export "ዐ") (result i32) (i32.const 226)) + (func (export "Ꭰ") (result i32) (i32.const 227)) + (func (export "ᐊ") (result i32) (i32.const 228)) + (func (export "ᖳ") (result i32) (i32.const 229)) + (func (export "ᚨ") (result i32) (i32.const 230)) + (func (export "ᚪ") (result i32) (i32.const 231)) + (func (export "ᛆ") (result i32) (i32.const 232)) + (func (export "ᜀ") (result i32) (i32.const 233)) + (func (export "ᜠ") (result i32) (i32.const 234)) + (func (export "ᝀ") (result i32) (i32.const 235)) + (func (export "ᝠ") (result i32) (i32.const 236)) + (func (export "ᠠ") (result i32) (i32.const 237)) + (func (export "ᢇ") (result i32) (i32.const 238)) + (func (export "ᤠ") (result i32) (i32.const 239)) + (func (export "ᥣ") (result i32) (i32.const 240)) + (func (export "ᨕ") (result i32) (i32.const 241)) + (func (export "ᩋ") (result i32) (i32.const 242)) + (func (export "ᩡ") (result i32) (i32.const 243)) + (func (export "ᮃ") (result i32) (i32.const 244)) + (func (export "ᯀ") (result i32) (i32.const 245)) + (func (export "ᯁ") (result i32) (i32.const 246)) + (func (export "ᰣ") (result i32) (i32.const 247)) + (func (export "Ḁ") (result i32) (i32.const 248)) + (func (export "Ạ") (result i32) (i32.const 249)) + (func (export "Ả") (result i32) (i32.const 250)) + (func (export "Ấ") (result i32) (i32.const 251)) + (func (export "Ầ") (result i32) (i32.const 252)) + (func (export "Ẩ") (result i32) (i32.const 253)) + (func (export "Ẫ") (result i32) (i32.const 254)) + (func (export "Ậ") (result i32) (i32.const 255)) + (func (export "Ắ") (result i32) (i32.const 256)) + (func (export "Ằ") (result i32) (i32.const 257)) + (func (export "Ẳ") (result i32) (i32.const 258)) + (func (export "Ẵ") (result i32) (i32.const 259)) + (func (export "Ặ") (result i32) (i32.const 260)) + (func (export "あ") (result i32) (i32.const 261)) + (func (export "ア") (result i32) (i32.const 262)) + (func (export "ㄚ") (result i32) (i32.const 263)) + (func (export "ㅏ") (result i32) (i32.const 264)) + (func (export "㈎") (result i32) (i32.const 265)) + (func (export "㈏") (result i32) (i32.const 266)) + (func (export "㈐") (result i32) (i32.const 267)) + (func (export "㈑") (result i32) (i32.const 268)) + (func (export "㈒") (result i32) (i32.const 269)) + (func (export "㈓") (result i32) (i32.const 270)) + (func (export "㈔") (result i32) (i32.const 271)) + (func (export "㈕") (result i32) (i32.const 272)) + (func (export "㈖") (result i32) (i32.const 273)) + (func (export "㈗") (result i32) (i32.const 274)) + (func (export "㈘") (result i32) (i32.const 275)) + (func (export "㈙") (result i32) (i32.const 276)) + (func (export "㈚") (result i32) (i32.const 277)) + (func (export "㈛") (result i32) (i32.const 278)) + (func (export "㉮") (result i32) (i32.const 279)) + (func (export "㉯") (result i32) (i32.const 280)) + (func (export "㉰") (result i32) (i32.const 281)) + (func (export "㉱") (result i32) (i32.const 282)) + (func (export "㉲") (result i32) (i32.const 283)) + (func (export "㉳") (result i32) (i32.const 284)) + (func (export "㉴") (result i32) (i32.const 285)) + (func (export "㉵") (result i32) (i32.const 286)) + (func (export "㉶") (result i32) (i32.const 287)) + (func (export "㉷") (result i32) (i32.const 288)) + (func (export "㉸") (result i32) (i32.const 289)) + (func (export "㉹") (result i32) (i32.const 290)) + (func (export "㉺") (result i32) (i32.const 291)) + (func (export "㉻") (result i32) (i32.const 292)) + (func (export "㋐") (result i32) (i32.const 293)) + (func (export "ꀊ") (result i32) (i32.const 294)) + (func (export "ꓮ") (result i32) (i32.const 295)) + (func (export "ꕉ") (result i32) (i32.const 296)) + (func (export "ꚠ") (result i32) (i32.const 297)) + (func (export "ꠀ") (result i32) (i32.const 298)) + (func (export "ꠣ") (result i32) (i32.const 299)) + (func (export "ꡝ") (result i32) (i32.const 300)) + (func (export "ꢂ") (result i32) (i32.const 301)) + (func (export "꣪") (result i32) (i32.const 302)) + (func (export "ꤢ") (result i32) (i32.const 303)) + (func (export "ꥆ") (result i32) (i32.const 304)) + (func (export "ꦄ") (result i32) (i32.const 305)) + (func (export "ꨀ") (result i32) (i32.const 306)) + (func (export "ｱ") (result i32) (i32.const 307)) + (func (export "ￂ") (result i32) (i32.const 308)) + (func (export "𐀀") (result i32) (i32.const 309)) + (func (export "𐊀") (result i32) (i32.const 310)) + (func (export "𐊠") (result i32) (i32.const 311)) + (func (export "𐌀") (result i32) (i32.const 312)) + (func (export "𐎠") (result i32) (i32.const 313)) + (func (export "𐒖") (result i32) (i32.const 314)) + (func (export "𐔀") (result i32) (i32.const 315)) + (func (export "𐝀") (result i32) (i32.const 316)) + (func (export "𐠀") (result i32) (i32.const 317)) + (func (export "𐤠") (result i32) (i32.const 318)) + (func (export "𐦀") (result i32) (i32.const 319)) + (func (export "𐦠") (result i32) (i32.const 320)) + (func (export "𐨀") (result i32) (i32.const 321)) + (func (export "𐬀") (result i32) (i32.const 322)) + (func (export "𐰀") (result i32) (i32.const 323)) + (func (export "𐰁") (result i32) (i32.const 324)) + (func (export "𐲀") (result i32) (i32.const 325)) + (func (export "𑀅") (result i32) (i32.const 326)) + (func (export "𑂃") (result i32) (i32.const 327)) + (func (export "𑄧") (result i32) (i32.const 328)) + (func (export "𑅐") (result i32) (i32.const 329)) + (func (export "𑆃") (result i32) (i32.const 330)) + (func (export "𑈀") (result i32) (i32.const 331)) + (func (export "𑊀") (result i32) (i32.const 332)) + (func (export "𑊰") (result i32) (i32.const 333)) + (func (export "𑌅") (result i32) (i32.const 334)) + (func (export "𑍰") (result i32) (i32.const 335)) + (func (export "𑐀") (result i32) (i32.const 336)) + (func (export "𑒁") (result i32) (i32.const 337)) + (func (export "𑖀") (result i32) (i32.const 338)) + (func (export "𑘀") (result i32) (i32.const 339)) + (func (export "𑚀") (result i32) (i32.const 340)) + (func (export "𑜒") (result i32) (i32.const 341)) + (func (export "𑜠") (result i32) (i32.const 342)) + (func (export "𑢡") (result i32) (i32.const 343)) + (func (export "𑫕") (result i32) (i32.const 344)) + (func (export "𑰀") (result i32) (i32.const 345)) + (func (export "𑲏") (result i32) (i32.const 346)) + (func (export "𑲯") (result i32) (i32.const 347)) + (func (export "𒀀") (result i32) (i32.const 348)) + (func (export "𖧕") (result i32) (i32.const 349)) + (func (export "𖩆") (result i32) (i32.const 350)) + (func (export "𖫧") (result i32) (i32.const 351)) + (func (export "𖽔") (result i32) (i32.const 352)) + (func (export "𛱁") (result i32) (i32.const 353)) + (func (export "𛱤") (result i32) (i32.const 354)) + (func (export "𞠣") (result i32) (i32.const 355)) + (func (export "🇦") (result i32) (i32.const 356)) + (func (export "Ɑ") (result i32) (i32.const 357)) + (func (export "Λ") (result i32) (i32.const 358)) + (func (export "Ɒ") (result i32) (i32.const 359)) + (func (export "ª") (result i32) (i32.const 360)) + (func (export "∀") (result i32) (i32.const 361)) + (func (export "₳") (result i32) (i32.const 362)) + (func (export "𐤀") (result i32) (i32.const 363)) + (func (export "Ⲁ") (result i32) (i32.const 364)) + (func (export "𐌰") (result i32) (i32.const 365)) + (func (export "Ά") (result i32) (i32.const 366)) + (func (export "Α") (result i32) (i32.const 367)) + (func (export "Ἀ") (result i32) (i32.const 368)) + (func (export "Ἁ") (result i32) (i32.const 369)) + (func (export "Ἂ") (result i32) (i32.const 370)) + (func (export "Ἃ") (result i32) (i32.const 371)) + (func (export "Ἄ") (result i32) (i32.const 372)) + (func (export "Ἅ") (result i32) (i32.const 373)) + (func (export "Ἆ") (result i32) (i32.const 374)) + (func (export "Ἇ") (result i32) (i32.const 375)) + (func (export "ᾈ") (result i32) (i32.const 376)) + (func (export "ᾉ") (result i32) (i32.const 377)) + (func (export "ᾊ") (result i32) (i32.const 378)) + (func (export "ᾋ") (result i32) (i32.const 379)) + (func (export "ᾌ") (result i32) (i32.const 380)) + (func (export "ᾍ") (result i32) (i32.const 381)) + (func (export "ᾎ") (result i32) (i32.const 382)) + (func (export "ᾏ") (result i32) (i32.const 383)) + (func (export "Ᾰ") (result i32) (i32.const 384)) + (func (export "Ᾱ") (result i32) (i32.const 385)) + (func (export "Ὰ") (result i32) (i32.const 386)) + (func (export "Ά") (result i32) (i32.const 387)) + (func (export "ᾼ") (result i32) (i32.const 388)) + (func (export "𝚨") (result i32) (i32.const 389)) + (func (export "𝛢") (result i32) (i32.const 390)) + (func (export "𝜜") (result i32) (i32.const 391)) + (func (export "𝝖") (result i32) (i32.const 392)) + (func (export "𝞐") (result i32) (i32.const 393)) + (func (export "⍶") (result i32) (i32.const 394)) + (func (export "⍺") (result i32) (i32.const 395)) + (func (export "⩜") (result i32) (i32.const 396)) + (func (export "ᗅ") (result i32) (i32.const 397)) + (func (export "Ꭺ") (result i32) (i32.const 398)) + + ;; Test unmatched "closing" and "opening" code points. + (func (export ")˺˼𔗏𝅴𝅶𝅸𝅺⁾₎❩❫⟯﴿︶﹚）｠󠀩❳❵⟧⟩⟫⟭⦈⦊⦖⸣⸥︘︸︺︼︾﹀﹂﹄﹈﹜﹞］｝｣󠁝󠁽»’”›❯") (result i32) (i32.const 399)) + (func (export "(˹˻𔗎𝅳𝅵𝅷𝅹⁽₍❨❪⟮﴾︵﹙（｟󠀨❲❴⟦⟨⟪⟬⦇⦉⦕⸢⸤︗︷︹︻︽︿﹁﹃﹇﹛﹝［｛｢󠁛󠁻«‘“‹❮") (result i32) (i32.const 400)) + (func (export "𝪋𝪤") (result i32) (i32.const 401)) + (func (export "𝪋") (result i32) (i32.const 402)) + + ;; Test that Unicode fraction normalization is not applied. + (func (export "½") (result i32) (i32.const 403)) + (func (export "1⁄2") (result i32) (i32.const 404)) + (func (export "1/2") (result i32) (i32.const 405)) + (func (export "୳") (result i32) (i32.const 406)) + (func (export "൴") (result i32) (i32.const 407)) + (func (export "⳽") (result i32) (i32.const 408)) + (func (export "꠱") (result i32) (i32.const 409)) + (func (export "𐅁") (result i32) (i32.const 410)) + (func (export "𐅵") (result i32) (i32.const 411)) + (func (export "𐅶") (result i32) (i32.const 412)) + (func (export "𐦽") (result i32) (i32.const 413)) + (func (export "𐹻") (result i32) (i32.const 414)) + + ;; Test a full-width quote. + (func (export "＂") (result i32) (i32.const 415)) + + ;; Test that different present and historical representations of the "delete" + ;; concept are distinct. + (func (export "\7f") (result i32) (i32.const 416)) + (func (export "\08") (result i32) (i32.const 417)) + (func (export "⌫") (result i32) (i32.const 418)) + (func (export "⌦") (result i32) (i32.const 419)) + (func (export "␈") (result i32) (i32.const 420)) + (func (export "␡") (result i32) (i32.const 421)) + (func (export "᷻") (result i32) (i32.const 422)) + (func (export "\0f") (result i32) (i32.const 423)) + (func (export "←") (result i32) (i32.const 424)) + (func (export "⌧") (result i32) (i32.const 425)) + (func (export "⍒") (result i32) (i32.const 426)) + (func (export "⍔") (result i32) (i32.const 427)) + (func (export "⍢") (result i32) (i32.const 428)) + (func (export "⍫") (result i32) (i32.const 429)) + + ;; Test that different representations of the "substitute" concept are + ;; distinct. (U+FFFD is covered above.) + (func (export "\1a") (result i32) (i32.const 430)) + (func (export "␦") (result i32) (i32.const 431)) + (func (export "␚") (result i32) (i32.const 432)) + (func (export "") (result i32) (i32.const 433)) + (func (export "?") (result i32) (i32.const 434)) + (func (export "¿") (result i32) (i32.const 435)) + (func (export "᥅") (result i32) (i32.const 436)) + (func (export ";") (result i32) (i32.const 437)) + (func (export "՞") (result i32) (i32.const 438)) + (func (export "؟") (result i32) (i32.const 439)) + (func (export "፧") (result i32) (i32.const 440)) + (func (export "⁇") (result i32) (i32.const 441)) + (func (export "⍰") (result i32) (i32.const 442)) + (func (export "❓") (result i32) (i32.const 443)) + (func (export "❔") (result i32) (i32.const 444)) + (func (export "⳺") (result i32) (i32.const 445)) + (func (export "⳻") (result i32) (i32.const 446)) + (func (export "⸮") (result i32) (i32.const 447)) + (func (export "㉄") (result i32) (i32.const 448)) + (func (export "꘏") (result i32) (i32.const 449)) + (func (export "꛷") (result i32) (i32.const 450)) + (func (export "︖") (result i32) (i32.const 451)) + (func (export "﹖") (result i32) (i32.const 452)) + (func (export "？") (result i32) (i32.const 453)) + (func (export "𑅃") (result i32) (i32.const 454)) + (func (export "𞥟") (result i32) (i32.const 455)) + (func (export "󠀿") (result i32) (i32.const 456)) + (func (export "𖡄") (result i32) (i32.const 457)) + (func (export "⯑") (result i32) (i32.const 458)) + + ;; Test that different present and historical representations of the + ;; "paragraph" concept are distinct. (U+2029 is covered above). + (func (export "¶") (result i32) (i32.const 459)) + (func (export "⁋") (result i32) (i32.const 460)) + (func (export "܀") (result i32) (i32.const 461)) + (func (export "჻") (result i32) (i32.const 462)) + (func (export "፨") (result i32) (i32.const 463)) + (func (export "〷") (result i32) (i32.const 464)) + (func (export "❡") (result i32) (i32.const 465)) + (func (export "⸏") (result i32) (i32.const 466)) + (func (export "⸐") (result i32) (i32.const 467)) + (func (export "⸑") (result i32) (i32.const 468)) + (func (export "⸎") (result i32) (i32.const 469)) + (func (export "\14") (result i32) (i32.const 470)) ;; ¶ in CP437 + (func (export "☙") (result i32) (i32.const 471)) + (func (export "⸿") (result i32) (i32.const 472)) + (func (export "〇") (result i32) (i32.const 473)) + (func (export "๛") (result i32) (i32.const 474)) + + ;; Test an unusual character. + (func (export "ꙮ") (result i32) (i32.const 475)) + + ;; Test the three characters whose normalization forms under NFC, NFD, NFKC, + ;; and NFKD are all different. + ;; http://unicode.org/faq/normalization.html#6 + (func (export "ϓ") (result i32) (i32.const 476)) + (func (export "ϔ") (result i32) (i32.const 477)) + (func (export "ẛ") (result i32) (i32.const 478)) +) + +(assert_return (invoke "") (i32.const 0)) +(assert_return (invoke "0") (i32.const 1)) +(assert_return (invoke "-0") (i32.const 2)) +(assert_return (invoke "_") (i32.const 3)) +(assert_return (invoke "$") (i32.const 4)) +(assert_return (invoke "@") (i32.const 5)) +(assert_return (invoke "~!@#$%^&*()_+`-={}|[]\\:\";'<>?,./ ") (i32.const 6)) +(assert_return (invoke "NaN") (i32.const 7)) +(assert_return (invoke "Infinity") (i32.const 8)) +(assert_return (invoke "if") (i32.const 9)) +(assert_return (invoke "malloc") (i32.const 10)) +(assert_return (invoke "_malloc") (i32.const 11)) +(assert_return (invoke "__malloc") (i32.const 12)) +(assert_return (invoke "a") (i32.const 13)) +(assert_return (invoke "A") (i32.const 14)) +(assert_return (invoke "") (i32.const 15)) +(assert_return (invoke "Å") (i32.const 16)) +(assert_return (invoke "Å") (i32.const 17)) +(assert_return (invoke "Å") (i32.const 18)) +(assert_return (invoke "ffi") (i32.const 19)) +(assert_return (invoke "ffi") (i32.const 20)) +(assert_return (invoke "ffi") (i32.const 21)) +(assert_return (invoke "\00\01\02\03\04\05\06\07\08\09\0a\0b\0c\0d\0e\0f") (i32.const 22)) +(assert_return (invoke "\10\11\12\13\14\15\16\17\18\19\1a\1b\1c\1d\1e\1f") (i32.const 23)) +(assert_return (invoke " \7f") (i32.const 24)) +(assert_return (invoke "\c2\80\c2\81\c2\82\c2\83\c2\84\c2\85\c2\86\c2\87\c2\88\c2\89\c2\8a\c2\8b\c2\8c\c2\8d\c2\8e\c2\8f") (i32.const 25)) +(assert_return (invoke "\c2\90\c2\91\c2\92\c2\93\c2\94\c2\95\c2\96\c2\97\c2\98\c2\99\c2\9a\c2\9b\c2\9c\c2\9d\c2\9e\c2\9f") (i32.const 26)) +(assert_return (invoke "\ef\bf\b0\ef\bf\b1\ef\bf\b2\ef\bf\b3\ef\bf\b4\ef\bf\b5\ef\bf\b6\ef\bf\b7") (i32.const 27)) +(assert_return (invoke "\ef\bf\b8\ef\bf\b9\ef\bf\ba\ef\bf\bb\ef\bf\bc\ef\bf\bd\ef\bf\be\ef\bf\bf") (i32.const 28)) +(assert_return (invoke "␀␁␂␃␄␅␆␇␈␉␊␋␌␍␎␏") (i32.const 29)) +(assert_return (invoke "␐␑␒␓␔␕␖␗␘␙␚␛␜␝␞␟") (i32.const 30)) +(assert_return (invoke "␠␡") (i32.const 31)) +(assert_return (invoke "￰￱￲￳￴￵￶￷￸�") (i32.const 32)) +(assert_return (invoke "‍") (i32.const 33)) +(assert_return (invoke "‌") (i32.const 34)) +(assert_return (invoke "͏") (i32.const 35)) +(assert_return (invoke "⁠") (i32.const 36)) +(assert_return (invoke "⵿") (i32.const 37)) +(assert_return (invoke "𑁿") (i32.const 38)) +(assert_return (invoke "᠎") (i32.const 39)) +(assert_return (invoke "￯​ ­⁠ ‮‭") (i32.const 40)) +(assert_return (invoke "‎‏‑

‪‫‬ ⁦⁧⁨⁩") (i32.const 41)) +(assert_return (invoke "") (i32.const 42)) +(assert_return (invoke "⁡⁢⁣⁤") (i32.const 43)) +(assert_return (invoke "𐀀󟿿􏿿") (i32.const 44)) +(assert_return (invoke "Z̴͇̫̥̪͓͈͔͎̗̞̺̯̱̞̙̱̜̖̠̏͆̆͛͌͘͞ḁ̶̰̳̭͙̲̱̹̝͎̼͗ͨ̎̄̆͗̿̀́͟͡l̶̷͉̩̹̫̝͖̙̲̼͇͚͍̮͎̥̞̈́͊͗ͦ̈́ͫ̇́̚ͅͅg̶͕͔͚̩̓̐̅ͮ̔̐̎̂̏̾͊̍͋͊ͧ́̆ͦ͞o̡͋̔͐ͪͩ͏̢̧̫̙̤̮͖͙͓̺̜̩̼̘̠́") (i32.const 45)) +(assert_return (invoke "ᅟᅠㅤﾠ") (i32.const 46)) +(assert_return (invoke "︀") (i32.const 47)) +(assert_return (invoke "︄") (i32.const 48)) +(assert_return (invoke "󠄀") (i32.const 49)) +(assert_return (invoke "󠇯") (i32.const 50)) +(assert_return (invoke "̈") (i32.const 51)) +(assert_return (invoke "\0a") (i32.const 52)) +(assert_return (invoke "␤") (i32.const 53)) +(assert_return (invoke "
") (i32.const 54)) +(assert_return (invoke "\0d") (i32.const 55)) +(assert_return (invoke "\0d\0a") (i32.const 56)) +(assert_return (invoke "\0a\0d") (i32.const 57)) +(assert_return (invoke "\1e") (i32.const 58)) +(assert_return (invoke "\0b") (i32.const 59)) +(assert_return (invoke "\0c") (i32.const 60)) +(assert_return (invoke "\c2\85") (i32.const 61)) +(assert_return (invoke "
") (i32.const 62)) +(assert_return (invoke "…") (i32.const 63)) +(assert_return (invoke "⏎") (i32.const 64)) +(assert_return (invoke "\c2\8b") (i32.const 65)) +(assert_return (invoke "\c2\8c") (i32.const 66)) +(assert_return (invoke "\c2\8d") (i32.const 67)) +(assert_return (invoke "↵") (i32.const 68)) +(assert_return (invoke "↩") (i32.const 69)) +(assert_return (invoke "⌤") (i32.const 70)) +(assert_return (invoke "⤶") (i32.const 71)) +(assert_return (invoke "↲") (i32.const 72)) +(assert_return (invoke "⮨") (i32.const 73)) +(assert_return (invoke "⮰") (i32.const 74)) +(assert_return (invoke "�") (i32.const 75)) +(assert_return (invoke "\ef\b7\90") (i32.const 76)) +(assert_return (invoke "\ef\b7\91") (i32.const 77)) +(assert_return (invoke "\ef\b7\92") (i32.const 78)) +(assert_return (invoke "\ef\b7\93") (i32.const 79)) +(assert_return (invoke "\ef\b7\94") (i32.const 80)) +(assert_return (invoke "\ef\b7\95") (i32.const 81)) +(assert_return (invoke "\ef\b7\96") (i32.const 82)) +(assert_return (invoke "\ef\b7\97") (i32.const 83)) +(assert_return (invoke "\ef\b7\98") (i32.const 84)) +(assert_return (invoke "\ef\b7\99") (i32.const 85)) +(assert_return (invoke "\ef\b7\9a") (i32.const 86)) +(assert_return (invoke "\ef\b7\9b") (i32.const 87)) +(assert_return (invoke "\ef\b7\9c") (i32.const 88)) +(assert_return (invoke "\ef\b7\9d") (i32.const 89)) +(assert_return (invoke "\ef\b7\9e") (i32.const 90)) +(assert_return (invoke "\ef\b7\9f") (i32.const 91)) +(assert_return (invoke "\ef\b7\a0") (i32.const 92)) +(assert_return (invoke "\ef\b7\a1") (i32.const 93)) +(assert_return (invoke "\ef\b7\a2") (i32.const 94)) +(assert_return (invoke "\ef\b7\a3") (i32.const 95)) +(assert_return (invoke "\ef\b7\a4") (i32.const 96)) +(assert_return (invoke "\ef\b7\a5") (i32.const 97)) +(assert_return (invoke "\ef\b7\a6") (i32.const 98)) +(assert_return (invoke "\ef\b7\a7") (i32.const 99)) +(assert_return (invoke "\ef\b7\a8") (i32.const 100)) +(assert_return (invoke "\ef\b7\a9") (i32.const 101)) +(assert_return (invoke "\ef\b7\aa") (i32.const 102)) +(assert_return (invoke "\ef\b7\ab") (i32.const 103)) +(assert_return (invoke "\ef\b7\ac") (i32.const 104)) +(assert_return (invoke "\ef\b7\ad") (i32.const 105)) +(assert_return (invoke "\ef\b7\ae") (i32.const 106)) +(assert_return (invoke "\ef\b7\af") (i32.const 107)) +(assert_return (invoke "\ef\bf\be") (i32.const 108)) +(assert_return (invoke "\ef\bf\bf") (i32.const 109)) +(assert_return (invoke "\f0\9f\bf\be") (i32.const 110)) +(assert_return (invoke "\f0\9f\bf\bf") (i32.const 111)) +(assert_return (invoke "\f0\af\bf\be") (i32.const 112)) +(assert_return (invoke "\f0\af\bf\bf") (i32.const 113)) +(assert_return (invoke "\f0\bf\bf\be") (i32.const 114)) +(assert_return (invoke "\f0\bf\bf\bf") (i32.const 115)) +(assert_return (invoke "\f1\8f\bf\be") (i32.const 116)) +(assert_return (invoke "\f1\8f\bf\bf") (i32.const 117)) +(assert_return (invoke "\f1\9f\bf\be") (i32.const 118)) +(assert_return (invoke "\f1\9f\bf\bf") (i32.const 119)) +(assert_return (invoke "\f1\af\bf\be") (i32.const 120)) +(assert_return (invoke "\f1\af\bf\bf") (i32.const 121)) +(assert_return (invoke "\f1\bf\bf\be") (i32.const 122)) +(assert_return (invoke "\f1\bf\bf\bf") (i32.const 123)) +(assert_return (invoke "\f2\8f\bf\be") (i32.const 124)) +(assert_return (invoke "\f2\8f\bf\bf") (i32.const 125)) +(assert_return (invoke "\f2\9f\bf\be") (i32.const 126)) +(assert_return (invoke "\f2\9f\bf\bf") (i32.const 127)) +(assert_return (invoke "\f2\af\bf\be") (i32.const 128)) +(assert_return (invoke "\f2\af\bf\bf") (i32.const 129)) +(assert_return (invoke "\f2\bf\bf\be") (i32.const 130)) +(assert_return (invoke "\f2\bf\bf\bf") (i32.const 131)) +(assert_return (invoke "\f3\8f\bf\be") (i32.const 132)) +(assert_return (invoke "\f3\8f\bf\bf") (i32.const 133)) +(assert_return (invoke "\f3\9f\bf\be") (i32.const 134)) +(assert_return (invoke "\f3\9f\bf\bf") (i32.const 135)) +(assert_return (invoke "\f3\af\bf\be") (i32.const 136)) +(assert_return (invoke "\f3\af\bf\bf") (i32.const 137)) +(assert_return (invoke "\f3\bf\bf\be") (i32.const 138)) +(assert_return (invoke "\f3\bf\bf\bf") (i32.const 139)) +(assert_return (invoke "\f4\8f\bf\be") (i32.const 140)) +(assert_return (invoke "\f4\8f\bf\bf") (i32.const 141)) +(assert_return (invoke "̈‽̈̉") (i32.const 142)) +(assert_return (invoke "abc") (i32.const 143)) +(assert_return (invoke "‭abc") (i32.const 144)) +(assert_return (invoke "‮cba") (i32.const 145)) +(assert_return (invoke "‭abc‮") (i32.const 146)) +(assert_return (invoke "‮cba‭") (i32.const 147)) +(assert_return (invoke "𝑨") (i32.const 148)) +(assert_return (invoke "𝐴") (i32.const 149)) +(assert_return (invoke "𝘈") (i32.const 150)) +(assert_return (invoke "𝘼") (i32.const 151)) +(assert_return (invoke "𝐀") (i32.const 152)) +(assert_return (invoke "𝓐") (i32.const 153)) +(assert_return (invoke "𝕬") (i32.const 154)) +(assert_return (invoke "𝗔") (i32.const 155)) +(assert_return (invoke "𝒜") (i32.const 156)) +(assert_return (invoke "𝔄") (i32.const 157)) +(assert_return (invoke "𝔸") (i32.const 158)) +(assert_return (invoke "𝖠") (i32.const 159)) +(assert_return (invoke "𝙰") (i32.const 160)) +(assert_return (invoke "ᴀ") (i32.const 161)) +(assert_return (invoke "ᴬ") (i32.const 162)) +(assert_return (invoke "Ⓐ") (i32.const 163)) +(assert_return (invoke "Ａ") (i32.const 164)) +(assert_return (invoke "🄐") (i32.const 165)) +(assert_return (invoke "🄰") (i32.const 166)) +(assert_return (invoke "󠁁") (i32.const 167)) +(assert_return (invoke "U+0041") (i32.const 168)) +(assert_return (invoke "A​") (i32.const 169)) +(assert_return (invoke "А") (i32.const 170)) +(assert_return (invoke "Ꙗ") (i32.const 171)) +(assert_return (invoke "ⷼ") (i32.const 172)) +(assert_return (invoke "ⷶ") (i32.const 173)) +(assert_return (invoke "Ɐ") (i32.const 174)) +(assert_return (invoke "🅐") (i32.const 175)) +(assert_return (invoke "🅰") (i32.const 176)) +(assert_return (invoke "Ⱝ") (i32.const 177)) +(assert_return (invoke "𐐂") (i32.const 178)) +(assert_return (invoke "𐐈") (i32.const 179)) +(assert_return (invoke "𐒰") (i32.const 180)) +(assert_return (invoke "À") (i32.const 181)) +(assert_return (invoke "Á") (i32.const 182)) +(assert_return (invoke "Â") (i32.const 183)) +(assert_return (invoke "Ã") (i32.const 184)) +(assert_return (invoke "Ä") (i32.const 185)) +(assert_return (invoke "Ā") (i32.const 186)) +(assert_return (invoke "Ă") (i32.const 187)) +(assert_return (invoke "Ą") (i32.const 188)) +(assert_return (invoke "Ǎ") (i32.const 189)) +(assert_return (invoke "Ǟ") (i32.const 190)) +(assert_return (invoke "Ǡ") (i32.const 191)) +(assert_return (invoke "Ǻ") (i32.const 192)) +(assert_return (invoke "Ȁ") (i32.const 193)) +(assert_return (invoke "Ȃ") (i32.const 194)) +(assert_return (invoke "Ȧ") (i32.const 195)) +(assert_return (invoke "Ⱥ") (i32.const 196)) +(assert_return (invoke "Ӑ") (i32.const 197)) +(assert_return (invoke "Ӓ") (i32.const 198)) +(assert_return (invoke "ߊ") (i32.const 199)) +(assert_return (invoke "ࠡ") (i32.const 200)) +(assert_return (invoke "ࠢ") (i32.const 201)) +(assert_return (invoke "ࠣ") (i32.const 202)) +(assert_return (invoke "ࠤ") (i32.const 203)) +(assert_return (invoke "ࠥ") (i32.const 204)) +(assert_return (invoke "ऄ") (i32.const 205)) +(assert_return (invoke "अ") (i32.const 206)) +(assert_return (invoke "ॲ") (i32.const 207)) +(assert_return (invoke "অ") (i32.const 208)) +(assert_return (invoke "ਅ") (i32.const 209)) +(assert_return (invoke "અ") (i32.const 210)) +(assert_return (invoke "ଅ") (i32.const 211)) +(assert_return (invoke "அ") (i32.const 212)) +(assert_return (invoke "అ") (i32.const 213)) +(assert_return (invoke "ಅ") (i32.const 214)) +(assert_return (invoke "അ") (i32.const 215)) +(assert_return (invoke "ะ") (i32.const 216)) +(assert_return (invoke "ະ") (i32.const 217)) +(assert_return (invoke "༁") (i32.const 218)) +(assert_return (invoke "ཨ") (i32.const 219)) +(assert_return (invoke "ྸ") (i32.const 220)) +(assert_return (invoke "အ") (i32.const 221)) +(assert_return (invoke "ဢ") (i32.const 222)) +(assert_return (invoke "ႜ") (i32.const 223)) +(assert_return (invoke "ᅡ") (i32.const 224)) +(assert_return (invoke "አ") (i32.const 225)) +(assert_return (invoke "ዐ") (i32.const 226)) +(assert_return (invoke "Ꭰ") (i32.const 227)) +(assert_return (invoke "ᐊ") (i32.const 228)) +(assert_return (invoke "ᖳ") (i32.const 229)) +(assert_return (invoke "ᚨ") (i32.const 230)) +(assert_return (invoke "ᚪ") (i32.const 231)) +(assert_return (invoke "ᛆ") (i32.const 232)) +(assert_return (invoke "ᜀ") (i32.const 233)) +(assert_return (invoke "ᜠ") (i32.const 234)) +(assert_return (invoke "ᝀ") (i32.const 235)) +(assert_return (invoke "ᝠ") (i32.const 236)) +(assert_return (invoke "ᠠ") (i32.const 237)) +(assert_return (invoke "ᢇ") (i32.const 238)) +(assert_return (invoke "ᤠ") (i32.const 239)) +(assert_return (invoke "ᥣ") (i32.const 240)) +(assert_return (invoke "ᨕ") (i32.const 241)) +(assert_return (invoke "ᩋ") (i32.const 242)) +(assert_return (invoke "ᩡ") (i32.const 243)) +(assert_return (invoke "ᮃ") (i32.const 244)) +(assert_return (invoke "ᯀ") (i32.const 245)) +(assert_return (invoke "ᯁ") (i32.const 246)) +(assert_return (invoke "ᰣ") (i32.const 247)) +(assert_return (invoke "Ḁ") (i32.const 248)) +(assert_return (invoke "Ạ") (i32.const 249)) +(assert_return (invoke "Ả") (i32.const 250)) +(assert_return (invoke "Ấ") (i32.const 251)) +(assert_return (invoke "Ầ") (i32.const 252)) +(assert_return (invoke "Ẩ") (i32.const 253)) +(assert_return (invoke "Ẫ") (i32.const 254)) +(assert_return (invoke "Ậ") (i32.const 255)) +(assert_return (invoke "Ắ") (i32.const 256)) +(assert_return (invoke "Ằ") (i32.const 257)) +(assert_return (invoke "Ẳ") (i32.const 258)) +(assert_return (invoke "Ẵ") (i32.const 259)) +(assert_return (invoke "Ặ") (i32.const 260)) +(assert_return (invoke "あ") (i32.const 261)) +(assert_return (invoke "ア") (i32.const 262)) +(assert_return (invoke "ㄚ") (i32.const 263)) +(assert_return (invoke "ㅏ") (i32.const 264)) +(assert_return (invoke "㈎") (i32.const 265)) +(assert_return (invoke "㈏") (i32.const 266)) +(assert_return (invoke "㈐") (i32.const 267)) +(assert_return (invoke "㈑") (i32.const 268)) +(assert_return (invoke "㈒") (i32.const 269)) +(assert_return (invoke "㈓") (i32.const 270)) +(assert_return (invoke "㈔") (i32.const 271)) +(assert_return (invoke "㈕") (i32.const 272)) +(assert_return (invoke "㈖") (i32.const 273)) +(assert_return (invoke "㈗") (i32.const 274)) +(assert_return (invoke "㈘") (i32.const 275)) +(assert_return (invoke "㈙") (i32.const 276)) +(assert_return (invoke "㈚") (i32.const 277)) +(assert_return (invoke "㈛") (i32.const 278)) +(assert_return (invoke "㉮") (i32.const 279)) +(assert_return (invoke "㉯") (i32.const 280)) +(assert_return (invoke "㉰") (i32.const 281)) +(assert_return (invoke "㉱") (i32.const 282)) +(assert_return (invoke "㉲") (i32.const 283)) +(assert_return (invoke "㉳") (i32.const 284)) +(assert_return (invoke "㉴") (i32.const 285)) +(assert_return (invoke "㉵") (i32.const 286)) +(assert_return (invoke "㉶") (i32.const 287)) +(assert_return (invoke "㉷") (i32.const 288)) +(assert_return (invoke "㉸") (i32.const 289)) +(assert_return (invoke "㉹") (i32.const 290)) +(assert_return (invoke "㉺") (i32.const 291)) +(assert_return (invoke "㉻") (i32.const 292)) +(assert_return (invoke "㋐") (i32.const 293)) +(assert_return (invoke "ꀊ") (i32.const 294)) +(assert_return (invoke "ꓮ") (i32.const 295)) +(assert_return (invoke "ꕉ") (i32.const 296)) +(assert_return (invoke "ꚠ") (i32.const 297)) +(assert_return (invoke "ꠀ") (i32.const 298)) +(assert_return (invoke "ꠣ") (i32.const 299)) +(assert_return (invoke "ꡝ") (i32.const 300)) +(assert_return (invoke "ꢂ") (i32.const 301)) +(assert_return (invoke "꣪") (i32.const 302)) +(assert_return (invoke "ꤢ") (i32.const 303)) +(assert_return (invoke "ꥆ") (i32.const 304)) +(assert_return (invoke "ꦄ") (i32.const 305)) +(assert_return (invoke "ꨀ") (i32.const 306)) +(assert_return (invoke "ｱ") (i32.const 307)) +(assert_return (invoke "ￂ") (i32.const 308)) +(assert_return (invoke "𐀀") (i32.const 309)) +(assert_return (invoke "𐊀") (i32.const 310)) +(assert_return (invoke "𐊠") (i32.const 311)) +(assert_return (invoke "𐌀") (i32.const 312)) +(assert_return (invoke "𐎠") (i32.const 313)) +(assert_return (invoke "𐒖") (i32.const 314)) +(assert_return (invoke "𐔀") (i32.const 315)) +(assert_return (invoke "𐝀") (i32.const 316)) +(assert_return (invoke "𐠀") (i32.const 317)) +(assert_return (invoke "𐤠") (i32.const 318)) +(assert_return (invoke "𐦀") (i32.const 319)) +(assert_return (invoke "𐦠") (i32.const 320)) +(assert_return (invoke "𐨀") (i32.const 321)) +(assert_return (invoke "𐬀") (i32.const 322)) +(assert_return (invoke "𐰀") (i32.const 323)) +(assert_return (invoke "𐰁") (i32.const 324)) +(assert_return (invoke "𐲀") (i32.const 325)) +(assert_return (invoke "𑀅") (i32.const 326)) +(assert_return (invoke "𑂃") (i32.const 327)) +(assert_return (invoke "𑄧") (i32.const 328)) +(assert_return (invoke "𑅐") (i32.const 329)) +(assert_return (invoke "𑆃") (i32.const 330)) +(assert_return (invoke "𑈀") (i32.const 331)) +(assert_return (invoke "𑊀") (i32.const 332)) +(assert_return (invoke "𑊰") (i32.const 333)) +(assert_return (invoke "𑌅") (i32.const 334)) +(assert_return (invoke "𑍰") (i32.const 335)) +(assert_return (invoke "𑐀") (i32.const 336)) +(assert_return (invoke "𑒁") (i32.const 337)) +(assert_return (invoke "𑖀") (i32.const 338)) +(assert_return (invoke "𑘀") (i32.const 339)) +(assert_return (invoke "𑚀") (i32.const 340)) +(assert_return (invoke "𑜒") (i32.const 341)) +(assert_return (invoke "𑜠") (i32.const 342)) +(assert_return (invoke "𑢡") (i32.const 343)) +(assert_return (invoke "𑫕") (i32.const 344)) +(assert_return (invoke "𑰀") (i32.const 345)) +(assert_return (invoke "𑲏") (i32.const 346)) +(assert_return (invoke "𑲯") (i32.const 347)) +(assert_return (invoke "𒀀") (i32.const 348)) +(assert_return (invoke "𖧕") (i32.const 349)) +(assert_return (invoke "𖩆") (i32.const 350)) +(assert_return (invoke "𖫧") (i32.const 351)) +(assert_return (invoke "𖽔") (i32.const 352)) +(assert_return (invoke "𛱁") (i32.const 353)) +(assert_return (invoke "𛱤") (i32.const 354)) +(assert_return (invoke "𞠣") (i32.const 355)) +(assert_return (invoke "🇦") (i32.const 356)) +(assert_return (invoke "Ɑ") (i32.const 357)) +(assert_return (invoke "Λ") (i32.const 358)) +(assert_return (invoke "Ɒ") (i32.const 359)) +(assert_return (invoke "ª") (i32.const 360)) +(assert_return (invoke "∀") (i32.const 361)) +(assert_return (invoke "₳") (i32.const 362)) +(assert_return (invoke "𐤀") (i32.const 363)) +(assert_return (invoke "Ⲁ") (i32.const 364)) +(assert_return (invoke "𐌰") (i32.const 365)) +(assert_return (invoke "Ά") (i32.const 366)) +(assert_return (invoke "Α") (i32.const 367)) +(assert_return (invoke "Ἀ") (i32.const 368)) +(assert_return (invoke "Ἁ") (i32.const 369)) +(assert_return (invoke "Ἂ") (i32.const 370)) +(assert_return (invoke "Ἃ") (i32.const 371)) +(assert_return (invoke "Ἄ") (i32.const 372)) +(assert_return (invoke "Ἅ") (i32.const 373)) +(assert_return (invoke "Ἆ") (i32.const 374)) +(assert_return (invoke "Ἇ") (i32.const 375)) +(assert_return (invoke "ᾈ") (i32.const 376)) +(assert_return (invoke "ᾉ") (i32.const 377)) +(assert_return (invoke "ᾊ") (i32.const 378)) +(assert_return (invoke "ᾋ") (i32.const 379)) +(assert_return (invoke "ᾌ") (i32.const 380)) +(assert_return (invoke "ᾍ") (i32.const 381)) +(assert_return (invoke "ᾎ") (i32.const 382)) +(assert_return (invoke "ᾏ") (i32.const 383)) +(assert_return (invoke "Ᾰ") (i32.const 384)) +(assert_return (invoke "Ᾱ") (i32.const 385)) +(assert_return (invoke "Ὰ") (i32.const 386)) +(assert_return (invoke "Ά") (i32.const 387)) +(assert_return (invoke "ᾼ") (i32.const 388)) +(assert_return (invoke "𝚨") (i32.const 389)) +(assert_return (invoke "𝛢") (i32.const 390)) +(assert_return (invoke "𝜜") (i32.const 391)) +(assert_return (invoke "𝝖") (i32.const 392)) +(assert_return (invoke "𝞐") (i32.const 393)) +(assert_return (invoke "⍶") (i32.const 394)) +(assert_return (invoke "⍺") (i32.const 395)) +(assert_return (invoke "⩜") (i32.const 396)) +(assert_return (invoke "ᗅ") (i32.const 397)) +(assert_return (invoke "Ꭺ") (i32.const 398)) +(assert_return (invoke ")˺˼𔗏𝅴𝅶𝅸𝅺⁾₎❩❫⟯﴿︶﹚）｠󠀩❳❵⟧⟩⟫⟭⦈⦊⦖⸣⸥︘︸︺︼︾﹀﹂﹄﹈﹜﹞］｝｣󠁝󠁽»’”›❯") (i32.const 399)) +(assert_return (invoke "(˹˻𔗎𝅳𝅵𝅷𝅹⁽₍❨❪⟮﴾︵﹙（｟󠀨❲❴⟦⟨⟪⟬⦇⦉⦕⸢⸤︗︷︹︻︽︿﹁﹃﹇﹛﹝［｛｢󠁛󠁻«‘“‹❮") (i32.const 400)) +(assert_return (invoke "𝪋𝪤") (i32.const 401)) +(assert_return (invoke "𝪋") (i32.const 402)) +(assert_return (invoke "½") (i32.const 403)) +(assert_return (invoke "1⁄2") (i32.const 404)) +(assert_return (invoke "1/2") (i32.const 405)) +(assert_return (invoke "୳") (i32.const 406)) +(assert_return (invoke "൴") (i32.const 407)) +(assert_return (invoke "⳽") (i32.const 408)) +(assert_return (invoke "꠱") (i32.const 409)) +(assert_return (invoke "𐅁") (i32.const 410)) +(assert_return (invoke "𐅵") (i32.const 411)) +(assert_return (invoke "𐅶") (i32.const 412)) +(assert_return (invoke "𐦽") (i32.const 413)) +(assert_return (invoke "𐹻") (i32.const 414)) +(assert_return (invoke "＂") (i32.const 415)) +(assert_return (invoke "\7f") (i32.const 416)) +(assert_return (invoke "\08") (i32.const 417)) +(assert_return (invoke "⌫") (i32.const 418)) +(assert_return (invoke "⌦") (i32.const 419)) +(assert_return (invoke "␈") (i32.const 420)) +(assert_return (invoke "␡") (i32.const 421)) +(assert_return (invoke "᷻") (i32.const 422)) +(assert_return (invoke "\0f") (i32.const 423)) +(assert_return (invoke "←") (i32.const 424)) +(assert_return (invoke "⌧") (i32.const 425)) +(assert_return (invoke "⍒") (i32.const 426)) +(assert_return (invoke "⍔") (i32.const 427)) +(assert_return (invoke "⍢") (i32.const 428)) +(assert_return (invoke "⍫") (i32.const 429)) +(assert_return (invoke "\1a") (i32.const 430)) +(assert_return (invoke "␦") (i32.const 431)) +(assert_return (invoke "␚") (i32.const 432)) +(assert_return (invoke "") (i32.const 433)) +(assert_return (invoke "?") (i32.const 434)) +(assert_return (invoke "¿") (i32.const 435)) +(assert_return (invoke "᥅") (i32.const 436)) +(assert_return (invoke ";") (i32.const 437)) +(assert_return (invoke "՞") (i32.const 438)) +(assert_return (invoke "؟") (i32.const 439)) +(assert_return (invoke "፧") (i32.const 440)) +(assert_return (invoke "⁇") (i32.const 441)) +(assert_return (invoke "⍰") (i32.const 442)) +(assert_return (invoke "❓") (i32.const 443)) +(assert_return (invoke "❔") (i32.const 444)) +(assert_return (invoke "⳺") (i32.const 445)) +(assert_return (invoke "⳻") (i32.const 446)) +(assert_return (invoke "⸮") (i32.const 447)) +(assert_return (invoke "㉄") (i32.const 448)) +(assert_return (invoke "꘏") (i32.const 449)) +(assert_return (invoke "꛷") (i32.const 450)) +(assert_return (invoke "︖") (i32.const 451)) +(assert_return (invoke "﹖") (i32.const 452)) +(assert_return (invoke "？") (i32.const 453)) +(assert_return (invoke "𑅃") (i32.const 454)) +(assert_return (invoke "𞥟") (i32.const 455)) +(assert_return (invoke "󠀿") (i32.const 456)) +(assert_return (invoke "𖡄") (i32.const 457)) +(assert_return (invoke "⯑") (i32.const 458)) +(assert_return (invoke "¶") (i32.const 459)) +(assert_return (invoke "⁋") (i32.const 460)) +(assert_return (invoke "܀") (i32.const 461)) +(assert_return (invoke "჻") (i32.const 462)) +(assert_return (invoke "፨") (i32.const 463)) +(assert_return (invoke "〷") (i32.const 464)) +(assert_return (invoke "❡") (i32.const 465)) +(assert_return (invoke "⸏") (i32.const 466)) +(assert_return (invoke "⸐") (i32.const 467)) +(assert_return (invoke "⸑") (i32.const 468)) +(assert_return (invoke "⸎") (i32.const 469)) +(assert_return (invoke "\14") (i32.const 470)) +(assert_return (invoke "☙") (i32.const 471)) +(assert_return (invoke "⸿") (i32.const 472)) +(assert_return (invoke "〇") (i32.const 473)) +(assert_return (invoke "๛") (i32.const 474)) +(assert_return (invoke "ꙮ") (i32.const 475)) +(assert_return (invoke "ϓ") (i32.const 476)) +(assert_return (invoke "ϔ") (i32.const 477)) +(assert_return (invoke "ẛ") (i32.const 478)) + +(module + ;; Test that we can use indices instead of names to reference imports, + ;; exports, functions and parameters. + (import "spectest" "print_i32" (func (param i32))) + (func (import "spectest" "print_i32") (param i32)) + (func (param i32) (param i32) + (call 0 (local.get 0)) + (call 1 (local.get 1)) + ) + (export "print32" (func 2)) +) + +(assert_return (invoke "print32" (i32.const 42) (i32.const 123))) diff --git a/runtime/near-vm/tests/wast/spec/nop.wast b/runtime/near-vm/tests/wast/spec/nop.wast new file mode 100644 index 00000000000..e8fe2de4b5f --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/nop.wast @@ -0,0 +1,426 @@ +;; Test `nop` operator. + +(module + ;; Auxiliary definitions + (func $dummy) + (func $3-ary (param i32 i32 i32) (result i32) + local.get 0 local.get 1 local.get 2 i32.sub i32.add + ) + (memory 1) + + (func (export "as-func-first") (result i32) + (nop) (i32.const 1) + ) + (func (export "as-func-mid") (result i32) + (call $dummy) (nop) (i32.const 2) + ) + (func (export "as-func-last") (result i32) + (call $dummy) (i32.const 3) (nop) + ) + (func (export "as-func-everywhere") (result i32) + (nop) (nop) (call $dummy) (nop) (i32.const 4) (nop) (nop) + ) + + (func (export "as-drop-first") (param i32) + (nop) (local.get 0) (drop) + ) + (func (export "as-drop-last") (param i32) + (local.get 0) (nop) (drop) + ) + (func (export "as-drop-everywhere") (param i32) + (nop) (nop) (local.get 0) (nop) (nop) (drop) + ) + + (func (export "as-select-first") (param i32) (result i32) + (nop) (local.get 0) (local.get 0) (local.get 0) (select) + ) + (func (export "as-select-mid1") (param i32) (result i32) + (local.get 0) (nop) (local.get 0) (local.get 0) (select) + ) + (func (export "as-select-mid2") (param i32) (result i32) + (local.get 0) (local.get 0) (nop) (local.get 0) (select) + ) + (func (export "as-select-last") (param i32) (result i32) + (local.get 0) (local.get 0) (local.get 0) (nop) (select) + ) + (func (export "as-select-everywhere") (param i32) (result i32) + (nop) (local.get 0) (nop) (nop) (local.get 0) + (nop) (nop) (local.get 0) (nop) (nop) (select) + ) + + (func (export "as-block-first") (result i32) + (block (result i32) (nop) (i32.const 2)) + ) + (func (export "as-block-mid") (result i32) + (block (result i32) (call $dummy) (nop) (i32.const 2)) + ) + (func (export "as-block-last") (result i32) + (block (result i32) (nop) (call $dummy) (i32.const 3) (nop)) + ) + (func (export "as-block-everywhere") (result i32) + (block (result i32) + (nop) (nop) (call $dummy) (nop) (i32.const 4) (nop) (nop) + ) + ) + + (func (export "as-loop-first") (result i32) + (loop (result i32) (nop) (i32.const 2)) + ) + (func (export "as-loop-mid") (result i32) + (loop (result i32) (call $dummy) (nop) (i32.const 2)) + ) + (func (export "as-loop-last") (result i32) + (loop (result i32) (call $dummy) (i32.const 3) (nop)) + ) + (func (export "as-loop-everywhere") (result i32) + (loop (result i32) + (nop) (nop) (call $dummy) (nop) (i32.const 4) (nop) (nop) + ) + ) + + (func (export "as-if-condition") (param i32) + (local.get 0) (nop) (if (then (call $dummy))) + ) + (func (export "as-if-then") (param i32) + (if (local.get 0) (then (nop)) (else (call $dummy))) + ) + (func (export "as-if-else") (param i32) + (if (local.get 0) (then (call $dummy)) (else (nop))) + ) + + (func (export "as-br-first") (param i32) (result i32) + (block (result i32) (nop) (local.get 0) (br 0)) + ) + (func (export "as-br-last") (param i32) (result i32) + (block (result i32) (local.get 0) (nop) (br 0)) + ) + (func (export "as-br-everywhere") (param i32) (result i32) + (block (result i32) (nop) (nop) (local.get 0) (nop) (nop) (br 0)) + ) + + (func (export "as-br_if-first") (param i32) (result i32) + (block (result i32) (nop) (local.get 0) (local.get 0) (br_if 0)) + ) + (func (export "as-br_if-mid") (param i32) (result i32) + (block (result i32) (local.get 0) (nop) (local.get 0) (br_if 0)) + ) + (func (export "as-br_if-last") (param i32) (result i32) + (block (result i32) (local.get 0) (local.get 0) (nop) (br_if 0)) + ) + (func (export "as-br_if-everywhere") (param i32) (result i32) + (block (result i32) + (nop) (nop) (local.get 0) (nop) (nop) (local.get 0) (nop) (nop) + (br_if 0) + ) + ) + + (func (export "as-br_table-first") (param i32) (result i32) + (block (result i32) (nop) (local.get 0) (local.get 0) (br_table 0 0)) + ) + (func (export "as-br_table-mid") (param i32) (result i32) + (block (result i32) (local.get 0) (nop) (local.get 0) (br_table 0 0)) + ) + (func (export "as-br_table-last") (param i32) (result i32) + (block (result i32) (local.get 0) (local.get 0) (nop) (br_table 0 0)) + ) + (func (export "as-br_table-everywhere") (param i32) (result i32) + (block (result i32) + (nop) (nop) (local.get 0) (nop) (nop) (local.get 0) (nop) (nop) + (br_table 0 0) + ) + ) + + (func (export "as-return-first") (param i32) (result i32) + (nop) (local.get 0) (return) + ) + (func (export "as-return-last") (param i32) (result i32) + (local.get 0) (nop) (return) + ) + (func (export "as-return-everywhere") (param i32) (result i32) + (nop) (nop) (local.get 0) (nop) (nop) (return) + ) + + (func (export "as-call-first") (param i32 i32 i32) (result i32) + (nop) (local.get 0) (local.get 1) (local.get 2) (call $3-ary) + ) + (func (export "as-call-mid1") (param i32 i32 i32) (result i32) + (local.get 0) (nop) (local.get 1) (local.get 2) (call $3-ary) + ) + (func (export "as-call-mid2") (param i32 i32 i32) (result i32) + (local.get 0) (local.get 1) (nop) (local.get 2) (call $3-ary) + ) + (func (export "as-call-last") (param i32 i32 i32) (result i32) + (local.get 0) (local.get 1) (local.get 2) (nop) (call $3-ary) + ) + (func (export "as-call-everywhere") (param i32 i32 i32) (result i32) + (nop) (nop) (local.get 0) (nop) (nop) (local.get 1) + (nop) (nop) (local.get 2) (nop) (nop) (call $3-ary) + ) + + (func (export "as-unary-first") (param i32) (result i32) + (nop) (local.get 0) (i32.ctz) + ) + (func (export "as-unary-last") (param i32) (result i32) + (local.get 0) (nop) (i32.ctz) + ) + (func (export "as-unary-everywhere") (param i32) (result i32) + (nop) (nop) (local.get 0) (nop) (nop) (i32.ctz) + ) + + (func (export "as-binary-first") (param i32) (result i32) + (nop) (local.get 0) (local.get 0) (i32.add) + ) + (func (export "as-binary-mid") (param i32) (result i32) + (local.get 0) (nop) (local.get 0) (i32.add) + ) + (func (export "as-binary-last") (param i32) (result i32) + (local.get 0) (local.get 0) (nop) (i32.add) + ) + (func (export "as-binary-everywhere") (param i32) (result i32) + (nop) (local.get 0) (nop) (nop) (local.get 0) (nop) (nop) (i32.add) + ) + + (func (export "as-test-first") (param i32) (result i32) + (nop) (local.get 0) (i32.eqz) + ) + (func (export "as-test-last") (param i32) (result i32) + (local.get 0) (nop) (i32.eqz) + ) + (func (export "as-test-everywhere") (param i32) (result i32) + (nop) (nop) (local.get 0) (nop) (nop) i32.eqz + ) + + (func (export "as-compare-first") (param i32) (result i32) + (nop) (local.get 0) (local.get 0) (i32.ne) + ) + (func (export "as-compare-mid") (param i32) (result i32) + (local.get 0) (nop) (local.get 0) (i32.ne) + ) + (func (export "as-compare-last") (param i32) (result i32) + (local.get 0) (local.get 0) (nop) (i32.lt_u) + ) + (func (export "as-compare-everywhere") (param i32) (result i32) + (nop) (local.get 0) (nop) (nop) (local.get 0) (nop) (nop) (i32.le_s) + ) + + (func (export "as-memory.grow-first") (param i32) (result i32) + (nop) (local.get 0) (memory.grow) + ) + (func (export "as-memory.grow-last") (param i32) (result i32) + (local.get 0) (nop) (memory.grow) + ) + (func (export "as-memory.grow-everywhere") (param i32) (result i32) + (nop) (nop) (local.get 0) (nop) (nop) (memory.grow) + ) + + (func $func (param i32 i32) (result i32) (local.get 0)) + (type $check (func (param i32 i32) (result i32))) + (table funcref (elem $func)) + (func (export "as-call_indirect-first") (result i32) + (block (result i32) + (nop) (i32.const 1) (i32.const 2) (i32.const 0) + (call_indirect (type $check)) + ) + ) + (func (export "as-call_indirect-mid1") (result i32) + (block (result i32) + (i32.const 1) (nop) (i32.const 2) (i32.const 0) + (call_indirect (type $check)) + ) + ) + (func (export "as-call_indirect-mid2") (result i32) + (block (result i32) + (i32.const 1) (i32.const 2) (nop) (i32.const 0) + (call_indirect (type $check)) + ) + ) + (func (export "as-call_indirect-last") (result i32) + (block (result i32) + (i32.const 1) (i32.const 2) (i32.const 0) (nop) + (call_indirect (type $check)) + ) + ) + (func (export "as-call_indirect-everywhere") (result i32) + (block (result i32) + (nop) (nop) (i32.const 1) (nop) (nop) (i32.const 2) (nop) (nop) (i32.const 0) (nop) (nop) + (call_indirect (type $check)) + ) + ) + + (func (export "as-local.set-first") (param i32) (result i32) + (nop) (i32.const 2) (local.set 0) (local.get 0) + ) + (func (export "as-local.set-last") (param i32) (result i32) + (i32.const 2) (nop) (local.set 0) (local.get 0) + ) + (func (export "as-local.set-everywhere") (param i32) (result i32) + (nop) (nop) (i32.const 2) (nop) (nop) (local.set 0) (local.get 0) + ) + + (func (export "as-local.tee-first") (param i32) (result i32) + (nop) (i32.const 2) (local.tee 0) + ) + (func (export "as-local.tee-last") (param i32) (result i32) + (i32.const 2) (nop) (local.tee 0) + ) + (func (export "as-local.tee-everywhere") (param i32) (result i32) + (nop) (nop) (i32.const 2) (nop) (nop) (local.tee 0) + ) + + (global $a (mut i32) (i32.const 0)) + (func (export "as-global.set-first") (result i32) + (nop) (i32.const 2) (global.set $a) (global.get $a) + ) + (func (export "as-global.set-last") (result i32) + (i32.const 2) (nop) (global.set $a) (global.get $a) + ) + (func (export "as-global.set-everywhere") (result i32) + (nop) (nop) (i32.const 2) (nop) (nop) (global.set 0) + (global.get $a) + ) + + (func (export "as-load-first") (param i32) (result i32) + (nop) (local.get 0) (i32.load) + ) + (func (export "as-load-last") (param i32) (result i32) + (local.get 0) (nop) (i32.load) + ) + (func (export "as-load-everywhere") (param i32) (result i32) + (nop) (nop) (local.get 0) (nop) (nop) (i32.load) + ) + + (func (export "as-store-first") (param i32 i32) + (nop) (local.get 0) (local.get 1) (i32.store) + ) + (func (export "as-store-mid") (param i32 i32) + (local.get 0) (nop) (local.get 1) (i32.store) + ) + (func (export "as-store-last") (param i32 i32) + (local.get 0) (local.get 1) (nop) (i32.store) + ) + (func (export "as-store-everywhere") (param i32 i32) + (nop) (nop) (local.get 0) (nop) (nop) (local.get 1) (nop) (nop) (i32.store) + ) +) + +(assert_return (invoke "as-func-first") (i32.const 1)) +(assert_return (invoke "as-func-mid") (i32.const 2)) +(assert_return (invoke "as-func-last") (i32.const 3)) +(assert_return (invoke "as-func-everywhere") (i32.const 4)) + +(assert_return (invoke "as-drop-first" (i32.const 0))) +(assert_return (invoke "as-drop-last" (i32.const 0))) +(assert_return (invoke "as-drop-everywhere" (i32.const 0))) + +(assert_return (invoke "as-select-first" (i32.const 3)) (i32.const 3)) +(assert_return (invoke "as-select-mid1" (i32.const 3)) (i32.const 3)) +(assert_return (invoke "as-select-mid2" (i32.const 3)) (i32.const 3)) +(assert_return (invoke "as-select-last" (i32.const 3)) (i32.const 3)) +(assert_return (invoke "as-select-everywhere" (i32.const 3)) (i32.const 3)) + +(assert_return (invoke "as-block-first") (i32.const 2)) +(assert_return (invoke "as-block-mid") (i32.const 2)) +(assert_return (invoke "as-block-last") (i32.const 3)) +(assert_return (invoke "as-block-everywhere") (i32.const 4)) + +(assert_return (invoke "as-loop-first") (i32.const 2)) +(assert_return (invoke "as-loop-mid") (i32.const 2)) +(assert_return (invoke "as-loop-last") (i32.const 3)) +(assert_return (invoke "as-loop-everywhere") (i32.const 4)) + +(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))) +(assert_return (invoke "as-if-then" (i32.const 4))) +(assert_return (invoke "as-if-else" (i32.const 0))) +(assert_return (invoke "as-if-else" (i32.const 3))) + +(assert_return (invoke "as-br-first" (i32.const 5)) (i32.const 5)) +(assert_return (invoke "as-br-last" (i32.const 6)) (i32.const 6)) +(assert_return (invoke "as-br-everywhere" (i32.const 7)) (i32.const 7)) + +(assert_return (invoke "as-br_if-first" (i32.const 4)) (i32.const 4)) +(assert_return (invoke "as-br_if-mid" (i32.const 5)) (i32.const 5)) +(assert_return (invoke "as-br_if-last" (i32.const 6)) (i32.const 6)) +(assert_return (invoke "as-br_if-everywhere" (i32.const 7)) (i32.const 7)) + +(assert_return (invoke "as-br_table-first" (i32.const 4)) (i32.const 4)) +(assert_return (invoke "as-br_table-mid" (i32.const 5)) (i32.const 5)) +(assert_return (invoke "as-br_table-last" (i32.const 6)) (i32.const 6)) +(assert_return (invoke "as-br_table-everywhere" (i32.const 7)) (i32.const 7)) + +(assert_return (invoke "as-return-first" (i32.const 5)) (i32.const 5)) +(assert_return (invoke "as-return-last" (i32.const 6)) (i32.const 6)) +(assert_return (invoke "as-return-everywhere" (i32.const 7)) (i32.const 7)) + +(assert_return (invoke "as-call-first" (i32.const 3) (i32.const 1) (i32.const 2)) (i32.const 2)) +(assert_return (invoke "as-call-mid1" (i32.const 3) (i32.const 1) (i32.const 2)) (i32.const 2)) +(assert_return (invoke "as-call-mid2" (i32.const 0) (i32.const 3) (i32.const 1)) (i32.const 2)) +(assert_return (invoke "as-call-last" (i32.const 10) (i32.const 9) (i32.const -1)) (i32.const 20)) +(assert_return (invoke "as-call-everywhere" (i32.const 2) (i32.const 1) (i32.const 5)) (i32.const -2)) + +(assert_return (invoke "as-unary-first" (i32.const 30)) (i32.const 1)) +(assert_return (invoke "as-unary-last" (i32.const 30)) (i32.const 1)) +(assert_return (invoke "as-unary-everywhere" (i32.const 12)) (i32.const 2)) + +(assert_return (invoke "as-binary-first" (i32.const 3)) (i32.const 6)) +(assert_return (invoke "as-binary-mid" (i32.const 3)) (i32.const 6)) +(assert_return (invoke "as-binary-last" (i32.const 3)) (i32.const 6)) +(assert_return (invoke "as-binary-everywhere" (i32.const 3)) (i32.const 6)) + +(assert_return (invoke "as-test-first" (i32.const 0)) (i32.const 1)) +(assert_return (invoke "as-test-last" (i32.const 0)) (i32.const 1)) +(assert_return (invoke "as-test-everywhere" (i32.const 0)) (i32.const 1)) + +(assert_return (invoke "as-compare-first" (i32.const 3)) (i32.const 0)) +(assert_return (invoke "as-compare-mid" (i32.const 3)) (i32.const 0)) +(assert_return (invoke "as-compare-last" (i32.const 3)) (i32.const 0)) +(assert_return (invoke "as-compare-everywhere" (i32.const 3)) (i32.const 1)) + +(assert_return (invoke "as-memory.grow-first" (i32.const 0)) (i32.const 1)) +(assert_return (invoke "as-memory.grow-last" (i32.const 2)) (i32.const 1)) +(assert_return (invoke "as-memory.grow-everywhere" (i32.const 12)) (i32.const 3)) + +(assert_return (invoke "as-call_indirect-first") (i32.const 1)) +(assert_return (invoke "as-call_indirect-mid1") (i32.const 1)) +(assert_return (invoke "as-call_indirect-mid2") (i32.const 1)) +(assert_return (invoke "as-call_indirect-last") (i32.const 1)) +(assert_return (invoke "as-call_indirect-everywhere") (i32.const 1)) + +(assert_return (invoke "as-local.set-first" (i32.const 1)) (i32.const 2)) +(assert_return (invoke "as-local.set-last" (i32.const 1)) (i32.const 2)) +(assert_return (invoke "as-local.set-everywhere" (i32.const 1)) (i32.const 2)) + +(assert_return (invoke "as-local.tee-first" (i32.const 1)) (i32.const 2)) +(assert_return (invoke "as-local.tee-last" (i32.const 1)) (i32.const 2)) +(assert_return (invoke "as-local.tee-everywhere" (i32.const 1)) (i32.const 2)) + +(assert_return (invoke "as-global.set-first") (i32.const 2)) +(assert_return (invoke "as-global.set-last") (i32.const 2)) +(assert_return (invoke "as-global.set-everywhere") (i32.const 2)) + +(assert_return (invoke "as-load-first" (i32.const 100)) (i32.const 0)) +(assert_return (invoke "as-load-last" (i32.const 100)) (i32.const 0)) +(assert_return (invoke "as-load-everywhere" (i32.const 100)) (i32.const 0)) + +(assert_return (invoke "as-store-first" (i32.const 0) (i32.const 1))) +(assert_return (invoke "as-store-mid" (i32.const 0) (i32.const 2))) +(assert_return (invoke "as-store-last" (i32.const 0) (i32.const 3))) +(assert_return (invoke "as-store-everywhere" (i32.const 0) (i32.const 4))) + +(assert_invalid + (module (func $type-i32 (result i32) (nop))) + "type mismatch" +) +(assert_invalid + (module (func $type-i64 (result i64) (nop))) + "type mismatch" +) +(assert_invalid + (module (func $type-f32 (result f32) (nop))) + "type mismatch" +) +(assert_invalid + (module (func $type-f64 (result f64) (nop))) + "type mismatch" +) diff --git a/runtime/near-vm/tests/wast/spec/proposals/annotations/annotations.wast b/runtime/near-vm/tests/wast/spec/proposals/annotations/annotations.wast new file mode 100644 index 00000000000..ce538d9371b --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/proposals/annotations/annotations.wast @@ -0,0 +1,195 @@ +(@a) + +(@aas-3!@$d-@#4) +(@@) (@$) (@+) (@0) (@.) (@!$@#$23414@#$) +(@a x y z) +(@a x-y $yz "aa" -2 0.3 0x3) +(@a x-y$yz"aa"-2) +(@a block func module i32.add) +(@a 0x 8q 0xfa #4g0-.@f#^&@#$*0sf -- @#) +(@a , ; ] [ }} }x{ ({) ,{{};}] ;) +(@a (bla) () (5-g) ("aa" a) ($x) (bla bla) (x (y)) ")" "(" x")"y) +(@a @ @x (@x) (@x y) (@) (@ x) (@(@(@(@))))) +(@a (;bla;) (; ) ;) + ;; bla) + ;; bla (@x +) + +(assert_malformed (module quote "(@a \00)") "illegal character") +(assert_malformed (module quote "(@a \01)") "illegal character") +(assert_malformed (module quote "(@a \02)") "illegal character") +(assert_malformed (module quote "(@a \03)") "illegal character") +(assert_malformed (module quote "(@a \04)") "illegal character") +(assert_malformed (module quote "(@a \05)") "illegal character") +(assert_malformed (module quote "(@a \06)") "illegal character") +(assert_malformed (module quote "(@a \07)") "illegal character") +(assert_malformed (module quote "(@a \08)") "illegal character") +(module quote "(@a \09)") ;; \t +(module quote "(@a \0a)") ;; \n +(assert_malformed (module quote "(@a \0b)") "illegal character") +(assert_malformed (module quote "(@a \0c)") "illegal character") +(module quote "(@a \0d)") ;; \r +(assert_malformed (module quote "(@a \0e)") "illegal character") +(assert_malformed (module quote "(@a \0f)") "illegal character") +(assert_malformed (module quote "(@a \10)") "illegal character") +(assert_malformed (module quote "(@a \11)") "illegal character") +(assert_malformed (module quote "(@a \12)") "illegal character") +(assert_malformed (module quote "(@a \13)") "illegal character") +(assert_malformed (module quote "(@a \14)") "illegal character") +(assert_malformed (module quote "(@a \15)") "illegal character") +(assert_malformed (module quote "(@a \16)") "illegal character") +(assert_malformed (module quote "(@a \17)") "illegal character") +(assert_malformed (module quote "(@a \18)") "illegal character") +(assert_malformed (module quote "(@a \19)") "illegal character") +(assert_malformed (module quote "(@a \1a)") "illegal character") +(assert_malformed (module quote "(@a \1b)") "illegal character") +(assert_malformed (module quote "(@a \1c)") "illegal character") +(assert_malformed (module quote "(@a \1d)") "illegal character") +(assert_malformed (module quote "(@a \1e)") "illegal character") +(assert_malformed (module quote "(@a \1f)") "illegal character") +(module quote "(@a \20)") ;; space +(assert_malformed (module quote "(@a \7f)") "illegal character") +(assert_malformed (module quote "(@a \80)") "malformed UTF-8 encoding") +(assert_malformed (module quote "(@a \81)") "malformed UTF-8 encoding") +(assert_malformed (module quote "(@a \90)") "malformed UTF-8 encoding") +(assert_malformed (module quote "(@a \a0)") "malformed UTF-8 encoding") +(assert_malformed (module quote "(@a \b0)") "malformed UTF-8 encoding") +(assert_malformed (module quote "(@a \c0)") "malformed UTF-8 encoding") +(assert_malformed (module quote "(@a \d0)") "malformed UTF-8 encoding") +(assert_malformed (module quote "(@a \e0)") "malformed UTF-8 encoding") +(assert_malformed (module quote "(@a \f0)") "malformed UTF-8 encoding") +(assert_malformed (module quote "(@a \ff)") "malformed UTF-8 encoding") +(assert_malformed (module quote "(@a Heiße Würstchen)") "illegal character") +(assert_malformed (module quote "(@a )") "illegal character") + +(assert_malformed (module quote "( @a)") "unknown operator") + +(assert_malformed (module quote "(@)") "malformed annotation id") +(assert_malformed (module quote "(@ )") "malformed annotation id") +(assert_malformed (module quote "(@ x)") "malformed annotation id") +(assert_malformed (module quote "(@(@a)x)") "malformed annotation id") + +(assert_malformed (module quote "(@x ") "unclosed annotation") +(assert_malformed (module quote "(@x ()") "unclosed annotation") +(assert_malformed (module quote "(@x (y (z))") "unclosed annotation") +(assert_malformed (module quote "(@x (@y )") "unclosed annotation") + +(assert_malformed (module quote "(@x))") "unexpected token") +(assert_malformed (module quote "(@x ()))") "unexpected token") +(assert_malformed (module quote "(@x (y (z))))") "unexpected token") +(assert_malformed (module quote "(@x (@y )))") "unexpected token") + +(assert_malformed (module quote "(@x \"") "unclosed string") +(assert_malformed (module quote "(@x \")") "unclosed string") + +(assert_malformed (module quote "((@a)@b)") "unknown operator") +(assert_malformed (module quote "(func $(@a))") "unknown operator") +(assert_malformed (module quote "(func $(@a)f)") "unknown operator") + +((@a) module (@a) $m (@a) (@a) + ((@a) import (@a) "spectest" (@a) "global_i32" (@a) + ((@a) global (@a) $g (@a) i32 (@a)) (@a) + ) (@a) + ((@a) import (@a) "spectest" (@a) "table" (@a) + ((@a) table (@a) $t (@a) 10 (@a) 20 (@a) funcref (@a)) (@a) + ) (@a) + ((@a) import (@a) "spectest" (@a) "memory" (@a) + ((@a) memory (@a) $m (@a) 1 (@a) 2 (@a)) (@a) + ) (@a) + ((@a) import (@a) "spectest" (@a) "print_i32_f32" (@a) + ((@a) func (@a) $f (@a) + ((@a) param (@a) i32 (@a) f32 (@a)) (@a) + ((@a) result (@a)) (@a) + ) (@a) + ) (@a) + + ((@a) export (@a) "g" (@a) + ((@a) global (@a) $g (@a)) (@a) + ) (@a) + ((@a) export (@a) "t" (@a) + ((@a) table (@a) $t (@a)) (@a) + ) (@a) + ((@a) export (@a) "m" (@a) + ((@a) memory (@a) $m (@a)) (@a) + ) (@a) + ((@a) export (@a) "f" (@a) + ((@a) func (@a) $f (@a)) (@a) + ) (@a) +) (@a) + +((@a) module (@a) $m (@a) (@a) + ((@a) global (@a) $g (@a) + ((@a) export (@a) "g" (@a)) (@a) + ((@a) import (@a) "spectest" (@a) "global_i32" (@a)) (@a) + i32 (@a) + ) (@a) + ((@a) table (@a) $t (@a) + ((@a) export (@a) "t" (@a)) (@a) + ((@a) import (@a) "spectest" (@a) "table" (@a)) (@a) + 10 (@a) 20 (@a) + funcref (@a) + ) (@a) + ((@a) memory (@a) $m (@a) + ((@a) export (@a) "m" (@a)) (@a) + ((@a) import (@a) "spectest" (@a) "memory" (@a)) (@a) + 1 (@a) 2 (@a) + ) (@a) + ((@a) func (@a) $f (@a) + ((@a) export (@a) "f" (@a)) (@a) + ((@a) import (@a) "spectest" (@a) "print_i32_f32" (@a)) (@a) + ((@a) param (@a) i32 (@a) f32 (@a)) (@a) + ((@a) result (@a)) (@a) + ) (@a) +) (@a) + +((@a) module (@a) $m (@a) (@a) + ((@a) type (@a) $T (@a) + ((@a) func (@a) + ((@a) param (@a) i32 (@a) i64 (@a)) (@a) + ((@a) param (@a) $x (@a) i32 (@a)) (@a) + ((@a) result (@a) i32 (@a)) (@a) + ) (@a) + ) (@a) + + ((@a) global (@a) $g (@a) + ((@a) export (@a) "g" (@a)) (@a) + i32 (@a) + ((@a) i32.const (@a) 42 (@a)) (@a) + ) (@a) + ((@a) table (@a) $t (@a) + ((@a) export (@a) "t" (@a)) (@a) + 10 (@a) 20 (@a) + funcref (@a) + ) (@a) + ((@a) memory (@a) $m (@a) + ((@a) export (@a) "m" (@a)) (@a) + 1 (@a) 2 (@a) + ) (@a) + ((@a) func (@a) $f (@a) + ((@a) export (@a) "f" (@a)) (@a) + ((@a) param (@a) i32 (@a) i64 (@a)) (@a) + ((@a) param (@a) $x (@a) i32 (@a)) (@a) + ((@a) result (@a) i32 (@a)) (@a) + ((@a) local (@a) i32 (@a) i32 (@a)) (@a) + ((@a) local (@a) $y (@a) i32 (@a)) (@a) + ((@a) block (@a) + ((@a) result (@a) i32 (@a)) (@a) + ((@a) i32.add (@a) + ((@a) local.get (@a) $x (@a)) (@a) + ((@a) local.get (@a) 0 (@a)) (@a) + ) + ) + ) (@a) + + ((@a) elem (@a) + ((@a) offset (@a) ((@a) i32.const (@a) 0 (@a)) (@a)) (@a) + $f (@a) $f (@a) (@a) $f (@a) + ) (@a) + ((@a) data (@a) + ((@a) offset (@a) ((@a) i32.const (@a) 0 (@a)) (@a)) (@a) + "bla" (@a) "\43" (@a) (@a) "" (@a) + ) (@a) + + (func $s) + ((@a) start (@a) $s (@a)) (@a) +) (@a) diff --git a/runtime/near-vm/tests/wast/spec/proposals/bulk-memory-operations/binary.wast b/runtime/near-vm/tests/wast/spec/proposals/bulk-memory-operations/binary.wast new file mode 100644 index 00000000000..8385826390b --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/proposals/bulk-memory-operations/binary.wast @@ -0,0 +1,1218 @@ +(module binary "\00asm\01\00\00\00") +(module binary "\00asm" "\01\00\00\00") +(module $M1 binary "\00asm\01\00\00\00") +(module $M2 binary "\00asm" "\01\00\00\00") + +(assert_malformed (module binary "") "unexpected end") +(assert_malformed (module binary "\01") "unexpected end") +(assert_malformed (module binary "\00as") "unexpected end") +(assert_malformed (module binary "asm\00") "magic header not detected") +(assert_malformed (module binary "msa\00") "magic header not detected") +(assert_malformed (module binary "msa\00\01\00\00\00") "magic header not detected") +(assert_malformed (module binary "msa\00\00\00\00\01") "magic header not detected") +(assert_malformed (module binary "asm\01\00\00\00\00") "magic header not detected") +(assert_malformed (module binary "wasm\01\00\00\00") "magic header not detected") +(assert_malformed (module binary "\7fasm\01\00\00\00") "magic header not detected") +(assert_malformed (module binary "\80asm\01\00\00\00") "magic header not detected") +(assert_malformed (module binary "\82asm\01\00\00\00") "magic header not detected") +(assert_malformed (module binary "\ffasm\01\00\00\00") "magic header not detected") + +;; 8-byte endian-reversed. +(assert_malformed (module binary "\00\00\00\01msa\00") "magic header not detected") + +;; Middle-endian byte orderings. +(assert_malformed (module binary "a\00ms\00\01\00\00") "magic header not detected") +(assert_malformed (module binary "sm\00a\00\00\01\00") "magic header not detected") + +;; Upper-cased. +(assert_malformed (module binary "\00ASM\01\00\00\00") "magic header not detected") + +;; EBCDIC-encoded magic. +(assert_malformed (module binary "\00\81\a2\94\01\00\00\00") "magic header not detected") + +;; Leading UTF-8 BOM. +(assert_malformed (module binary "\ef\bb\bf\00asm\01\00\00\00") "magic header not detected") + +;; Malformed binary version. +(assert_malformed (module binary "\00asm") "unexpected end") +(assert_malformed (module binary "\00asm\01") "unexpected end") +(assert_malformed (module binary "\00asm\01\00\00") "unexpected end") +(assert_malformed (module binary "\00asm\00\00\00\00") "unknown binary version") +(assert_malformed (module binary "\00asm\0d\00\00\00") "unknown binary version") +(assert_malformed (module binary "\00asm\0e\00\00\00") "unknown binary version") +(assert_malformed (module binary "\00asm\00\01\00\00") "unknown binary version") +(assert_malformed (module binary "\00asm\00\00\01\00") "unknown binary version") +(assert_malformed (module binary "\00asm\00\00\00\01") "unknown binary version") + +;; Unsigned LEB128 can have non-minimal length +(module binary + "\00asm" "\01\00\00\00" + "\05\04\01" ;; Memory section with 1 entry + "\00\82\00" ;; no max, minimum 2 +) +(module binary + "\00asm" "\01\00\00\00" + "\05\07\01" ;; Memory section with 1 entry + "\00\82\80\80\80\00" ;; no max, minimum 2 +) + +;; Signed LEB128 can have non-minimal length +(module binary + "\00asm" "\01\00\00\00" + "\06\07\01" ;; Global section with 1 entry + "\7f\00" ;; i32, immutable + "\41\80\00" ;; i32.const 0 + "\0b" ;; end +) +(module binary + "\00asm" "\01\00\00\00" + "\06\07\01" ;; Global section with 1 entry + "\7f\00" ;; i32, immutable + "\41\ff\7f" ;; i32.const -1 + "\0b" ;; end +) +(module binary + "\00asm" "\01\00\00\00" + "\06\0a\01" ;; Global section with 1 entry + "\7f\00" ;; i32, immutable + "\41\80\80\80\80\00" ;; i32.const 0 + "\0b" ;; end +) +(module binary + "\00asm" "\01\00\00\00" + "\06\0a\01" ;; Global section with 1 entry + "\7f\00" ;; i32, immutable + "\41\ff\ff\ff\ff\7f" ;; i32.const -1 + "\0b" ;; end +) + +(module binary + "\00asm" "\01\00\00\00" + "\06\07\01" ;; Global section with 1 entry + "\7e\00" ;; i64, immutable + "\42\80\00" ;; i64.const 0 with unused bits set + "\0b" ;; end +) +(module binary + "\00asm" "\01\00\00\00" + "\06\07\01" ;; Global section with 1 entry + "\7e\00" ;; i64, immutable + "\42\ff\7f" ;; i64.const -1 with unused bits unset + "\0b" ;; end +) +(module binary + "\00asm" "\01\00\00\00" + "\06\0f\01" ;; Global section with 1 entry + "\7e\00" ;; i64, immutable + "\42\80\80\80\80\80\80\80\80\80\00" ;; i64.const 0 with unused bits set + "\0b" ;; end +) +(module binary + "\00asm" "\01\00\00\00" + "\06\0f\01" ;; Global section with 1 entry + "\7e\00" ;; i64, immutable + "\42\ff\ff\ff\ff\ff\ff\ff\ff\ff\7f" ;; i64.const -1 with unused bits unset + "\0b" ;; end +) + +;; Data segment memory index can have non-minimal length +(module binary + "\00asm" "\01\00\00\00" + "\05\03\01" ;; Memory section with 1 entry + "\00\00" ;; no max, minimum 0 + "\0b\07\01" ;; Data section with 1 entry + "\80\00" ;; Memory index 0, encoded with 2 bytes + "\41\00\0b\00" ;; (i32.const 0) with contents "" +) + +;; Element segment table index can have non-minimal length +(module binary + "\00asm" "\01\00\00\00" + "\04\04\01" ;; Table section with 1 entry + "\70\00\00" ;; no max, minimum 0, funcref + "\09\09\01" ;; Element section with 1 entry + "\02\80\00" ;; Table index 0, encoded with 2 bytes + "\41\00\0b\00\00" ;; (i32.const 0) with no elements +) + +;; Unsigned LEB128 must not be overlong +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\05\08\01" ;; Memory section with 1 entry + "\00\82\80\80\80\80\00" ;; no max, minimum 2 with one byte too many + ) + "integer representation too long" +) + +;; Signed LEB128 must not be overlong +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\06\0b\01" ;; Global section with 1 entry + "\7f\00" ;; i32, immutable + "\41\80\80\80\80\80\00" ;; i32.const 0 with one byte too many + "\0b" ;; end + ) + "integer representation too long" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\06\0b\01" ;; Global section with 1 entry + "\7f\00" ;; i32, immutable + "\41\ff\ff\ff\ff\ff\7f" ;; i32.const -1 with one byte too many + "\0b" ;; end + ) + "integer representation too long" +) + +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\06\10\01" ;; Global section with 1 entry + "\7e\00" ;; i64, immutable + "\42\80\80\80\80\80\80\80\80\80\80\00" ;; i64.const 0 with one byte too many + "\0b" ;; end + ) + "integer representation too long" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\06\10\01" ;; Global section with 1 entry + "\7e\00" ;; i64, immutable + "\42\ff\ff\ff\ff\ff\ff\ff\ff\ff\ff\7f" ;; i64.const -1 with one byte too many + "\0b" ;; end + ) + "integer representation too long" +) + +;; Unsigned LEB128s zero-extend +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\05\07\01" ;; Memory section with 1 entry + "\00\82\80\80\80\70" ;; no max, minimum 2 with unused bits set + ) + "integer too large" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\05\07\01" ;; Memory section with 1 entry + "\00\82\80\80\80\40" ;; no max, minimum 2 with some unused bits set + ) + "integer too large" +) + +;; Signed LEB128s sign-extend +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\06\0a\01" ;; Global section with 1 entry + "\7f\00" ;; i32, immutable + "\41\80\80\80\80\70" ;; i32.const 0 with unused bits set + "\0b" ;; end + ) + "integer too large" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\06\0a\01" ;; Global section with 1 entry + "\7f\00" ;; i32, immutable + "\41\ff\ff\ff\ff\0f" ;; i32.const -1 with unused bits unset + "\0b" ;; end + ) + "integer too large" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\06\0a\01" ;; Global section with 1 entry + "\7f\00" ;; i32, immutable + "\41\80\80\80\80\1f" ;; i32.const 0 with some unused bits set + "\0b" ;; end + ) + "integer too large" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\06\0a\01" ;; Global section with 1 entry + "\7f\00" ;; i32, immutable + "\41\ff\ff\ff\ff\4f" ;; i32.const -1 with some unused bits unset + "\0b" ;; end + ) + "integer too large" +) + +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\06\0f\01" ;; Global section with 1 entry + "\7e\00" ;; i64, immutable + "\42\80\80\80\80\80\80\80\80\80\7e" ;; i64.const 0 with unused bits set + "\0b" ;; end + ) + "integer too large" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\06\0f\01" ;; Global section with 1 entry + "\7e\00" ;; i64, immutable + "\42\ff\ff\ff\ff\ff\ff\ff\ff\ff\01" ;; i64.const -1 with unused bits unset + "\0b" ;; end + ) + "integer too large" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\06\0f\01" ;; Global section with 1 entry + "\7e\00" ;; i64, immutable + "\42\80\80\80\80\80\80\80\80\80\02" ;; i64.const 0 with some unused bits set + "\0b" ;; end + ) + "integer too large" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\06\0f\01" ;; Global section with 1 entry + "\7e\00" ;; i64, immutable + "\42\ff\ff\ff\ff\ff\ff\ff\ff\ff\41" ;; i64.const -1 with some unused bits unset + "\0b" ;; end + ) + "integer too large" +) + + +;; call_indirect reserved byte equal to zero. +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01\60\00\00" ;; Type section + "\03\02\01\00" ;; Function section + "\04\04\01\70\00\00" ;; Table section + "\0a\09\01" ;; Code section + + ;; function 0 + "\07\00" + "\41\00" ;; i32.const 0 + "\11\00" ;; call_indirect (type 0) + "\01" ;; call_indirect reserved byte is not equal to zero! + "\0b" ;; end + ) + "zero flag expected" +) + +;; call_indirect reserved byte should not be a "long" LEB128 zero. +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01\60\00\00" ;; Type section + "\03\02\01\00" ;; Function section + "\04\04\01\70\00\00" ;; Table section + "\0a\0a\01" ;; Code section + + ;; function 0 + "\07\00" + "\41\00" ;; i32.const 0 + "\11\00" ;; call_indirect (type 0) + "\80\00" ;; call_indirect reserved byte + "\0b" ;; end + ) + "zero flag expected" +) + +;; Same as above for 3, 4, and 5-byte zero encodings. +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01\60\00\00" ;; Type section + "\03\02\01\00" ;; Function section + "\04\04\01\70\00\00" ;; Table section + "\0a\0b\01" ;; Code section + + ;; function 0 + "\08\00" + "\41\00" ;; i32.const 0 + "\11\00" ;; call_indirect (type 0) + "\80\80\00" ;; call_indirect reserved byte + "\0b" ;; end + ) + "zero flag expected" +) + +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01\60\00\00" ;; Type section + "\03\02\01\00" ;; Function section + "\04\04\01\70\00\00" ;; Table section + "\0a\0c\01" ;; Code section + + ;; function 0 + "\09\00" + "\41\00" ;; i32.const 0 + "\11\00" ;; call_indirect (type 0) + "\80\80\80\00" ;; call_indirect reserved byte + "\0b" ;; end + ) + "zero flag expected" +) + +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01\60\00\00" ;; Type section + "\03\02\01\00" ;; Function section + "\04\04\01\70\00\00" ;; Table section + "\0a\0d\01" ;; Code section + + ;; function 0 + "\0a\00" + "\41\00" ;; i32.const 0 + "\11\00" ;; call_indirect (type 0) + "\80\80\80\80\00" ;; call_indirect reserved byte + "\0b" ;; end + ) + "zero flag expected" +) + +;; memory.grow reserved byte equal to zero. +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01\60\00\00" ;; Type section + "\03\02\01\00" ;; Function section + "\05\03\01\00\00" ;; Memory section + "\0a\09\01" ;; Code section + + ;; function 0 + "\07\00" + "\41\00" ;; i32.const 0 + "\40" ;; memory.grow + "\01" ;; memory.grow reserved byte is not equal to zero! + "\1a" ;; drop + "\0b" ;; end + ) + "zero flag expected" +) + +;; memory.grow reserved byte should not be a "long" LEB128 zero. +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01\60\00\00" ;; Type section + "\03\02\01\00" ;; Function section + "\05\03\01\00\00" ;; Memory section + "\0a\0a\01" ;; Code section + + ;; function 0 + "\08\00" + "\41\00" ;; i32.const 0 + "\40" ;; memory.grow + "\80\00" ;; memory.grow reserved byte + "\1a" ;; drop + "\0b" ;; end + ) + "zero flag expected" +) + +;; Same as above for 3, 4, and 5-byte zero encodings. +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01\60\00\00" ;; Type section + "\03\02\01\00" ;; Function section + "\05\03\01\00\00" ;; Memory section + "\0a\0b\01" ;; Code section + + ;; function 0 + "\09\00" + "\41\00" ;; i32.const 0 + "\40" ;; memory.grow + "\80\80\00" ;; memory.grow reserved byte + "\1a" ;; drop + "\0b" ;; end + ) + "zero flag expected" +) + +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01\60\00\00" ;; Type section + "\03\02\01\00" ;; Function section + "\05\03\01\00\00" ;; Memory section + "\0a\0c\01" ;; Code section + + ;; function 0 + "\0a\00" + "\41\00" ;; i32.const 0 + "\40" ;; memory.grow + "\80\80\80\00" ;; memory.grow reserved byte + "\1a" ;; drop + "\0b" ;; end + ) + "zero flag expected" +) + +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01\60\00\00" ;; Type section + "\03\02\01\00" ;; Function section + "\05\03\01\00\00" ;; Memory section + "\0a\0d\01" ;; Code section + + ;; function 0 + "\0b\00" + "\41\00" ;; i32.const 0 + "\40" ;; memory.grow + "\80\80\80\80\00" ;; memory.grow reserved byte + "\1a" ;; drop + "\0b" ;; end + ) + "zero flag expected" +) + +;; memory.size reserved byte equal to zero. +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01\60\00\00" ;; Type section + "\03\02\01\00" ;; Function section + "\05\03\01\00\00" ;; Memory section + "\0a\07\01" ;; Code section + + ;; function 0 + "\05\00" + "\3f" ;; memory.size + "\01" ;; memory.size reserved byte is not equal to zero! + "\1a" ;; drop + "\0b" ;; end + ) + "zero flag expected" +) + +;; memory.size reserved byte should not be a "long" LEB128 zero. +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01\60\00\00" ;; Type section + "\03\02\01\00" ;; Function section + "\05\03\01\00\00" ;; Memory section + "\0a\08\01" ;; Code section + + ;; function 0 + "\06\00" + "\3f" ;; memory.size + "\80\00" ;; memory.size reserved byte + "\1a" ;; drop + "\0b" ;; end + ) + "zero flag expected" +) + +;; Same as above for 3, 4, and 5-byte zero encodings. +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01\60\00\00" ;; Type section + "\03\02\01\00" ;; Function section + "\05\03\01\00\00" ;; Memory section + "\0a\09\01" ;; Code section + + ;; function 0 + "\07\00" + "\3f" ;; memory.size + "\80\80\00" ;; memory.size reserved byte + "\1a" ;; drop + "\0b" ;; end + ) + "zero flag expected" +) + +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01\60\00\00" ;; Type section + "\03\02\01\00" ;; Function section + "\05\03\01\00\00" ;; Memory section + "\0a\0a\01" ;; Code section + + ;; function 0 + "\08\00" + "\3f" ;; memory.size + "\80\80\80\00" ;; memory.size reserved byte + "\1a" ;; drop + "\0b" ;; end + ) + "zero flag expected" +) + +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01\60\00\00" ;; Type section + "\03\02\01\00" ;; Function section + "\05\03\01\00\00" ;; Memory section + "\0a\0b\01" ;; Code section + + ;; function 0 + "\09\00" + "\3f" ;; memory.size + "\80\80\80\80\00" ;; memory.size reserved byte + "\1a" ;; drop + "\0b" ;; end + ) + "zero flag expected" +) + +;; No more than 2^32 locals. +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01\60\00\00" ;; Type section + "\03\02\01\00" ;; Function section + "\0a\0c\01" ;; Code section + + ;; function 0 + "\0a\02" + "\ff\ff\ff\ff\0f\7f" ;; 0xFFFFFFFF i32 + "\02\7e" ;; 0x00000002 i64 + "\0b" ;; end + ) + "too many locals" +) + +;; Local count can be 0. +(module binary + "\00asm" "\01\00\00\00" + "\01\04\01\60\00\00" ;; Type section + "\03\02\01\00" ;; Function section + "\0a\0a\01" ;; Code section + + ;; function 0 + "\08\03" + "\00\7f" ;; 0 i32 + "\00\7e" ;; 0 i64 + "\02\7d" ;; 2 f32 + "\0b" ;; end +) + +;; Function section has non-zero count, but code section is absent. +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01\60\00\00" ;; Type section + "\03\03\02\00\00" ;; Function section with 2 functions + ) + "function and code section have inconsistent lengths" +) + +;; Code section has non-zero count, but function section is absent. +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\0a\04\01\02\00\0b" ;; Code section with 1 empty function + ) + "function and code section have inconsistent lengths" +) + +;; Function section count > code section count +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01\60\00\00" ;; Type section + "\03\03\02\00\00" ;; Function section with 2 functions + "\0a\04\01\02\00\0b" ;; Code section with 1 empty function + ) + "function and code section have inconsistent lengths" +) + +;; Function section count < code section count +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01\60\00\00" ;; Type section + "\03\02\01\00" ;; Function section with 1 function + "\0a\07\02\02\00\0b\02\00\0b" ;; Code section with 2 empty functions + ) + "function and code section have inconsistent lengths" +) + +;; Function section has zero count, and code section is absent. +(module binary + "\00asm" "\01\00\00\00" + "\03\01\00" ;; Function section with 0 functions +) + +;; Code section has zero count, and function section is absent. +(module binary + "\00asm" "\01\00\00\00" + "\0a\01\00" ;; Code section with 0 functions +) + +;; Fewer passive segments than datacount +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\0c\01\03" ;; Datacount section with value "3" + "\0b\05\02" ;; Data section with two entries + "\01\00" ;; Passive data section + "\01\00") ;; Passive data section + "data count and data section have inconsistent lengths") + +;; More passive segments than datacount +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\0c\01\01" ;; Datacount section with value "1" + "\0b\05\02" ;; Data section with two entries + "\01\00" ;; Passive data section + "\01\00") ;; Passive data section + "data count and data section have inconsistent lengths") + +;; memory.init requires a datacount section +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + + "\01\04\01\60\00\00" ;; Type section + "\03\02\01\00" ;; Function section + "\05\03\01\00\00" ;; Memory section + "\0a\0e\01" ;; Code section + + ;; function 0 + "\0c\00" + "\41\00" ;; zero args + "\41\00" + "\41\00" + "\fc\08\00\00" ;; memory.init + "\0b" + + "\0b\03\01\01\00" ;; Data section + ) ;; end + "data count section required") + +;; data.drop requires a datacount section +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + + "\01\04\01\60\00\00" ;; Type section + "\03\02\01\00" ;; Function section + "\05\03\01\00\00" ;; Memory section + "\0a\07\01" ;; Code section + + ;; function 0 + "\05\00" + "\fc\09\00" ;; data.drop + "\0b" + + "\0b\03\01\01\00" ;; Data section + ) ;; end + "data count section required") + +;; passive element segment containing opcode other than ref.func or ref.null +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + + "\01\04\01\60\00\00" ;; Type section + + "\03\02\01\00" ;; Function section + + "\04\04\01" ;; Table section with 1 entry + "\70\00\00" ;; no max, minimum 0, funcref + + "\05\03\01\00\00" ;; Memory section + + "\09\07\01" ;; Element section with one segment + "\05\70" ;; Passive, funcref + "\01" ;; 1 element + "\d3\00\0b" ;; bad opcode, index 0, end + + "\0a\04\01" ;; Code section + + ;; function 0 + "\02\00" + "\0b") ;; end + "invalid elem") + +;; passive element segment containing type other than funcref +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + + "\01\04\01\60\00\00" ;; Type section + + "\03\02\01\00" ;; Function section + + "\04\04\01" ;; Table section with 1 entry + "\70\00\00" ;; no max, minimum 0, funcref + + "\05\03\01\00\00" ;; Memory section + + "\09\07\01" ;; Element section with one segment + "\05\7f" ;; Passive, i32 + "\01" ;; 1 element + "\d2\00\0b" ;; ref.func, index 0, end + + "\0a\04\01" ;; Code section + + ;; function 0 + "\02\00" + "\0b") ;; end + "malformed element type") + +;; passive element segment containing opcode ref.func +(module binary + "\00asm" "\01\00\00\00" + + "\01\04\01\60\00\00" ;; Type section + + "\03\02\01\00" ;; Function section + + "\04\04\01" ;; Table section with 1 entry + "\70\00\00" ;; no max, minimum 0, funcref + + "\05\03\01\00\00" ;; Memory section + + "\09\07\01" ;; Element section with one segment + "\05\70" ;; Passive, funcref + "\01" ;; 1 element + "\d2\00\0b" ;; ref.func, index 0, end + + "\0a\04\01" ;; Code section + + ;; function 0 + "\02\00" + "\0b") ;; end + +;; passive element segment containing opcode ref.null +(module binary + "\00asm" "\01\00\00\00" + + "\01\04\01\60\00\00" ;; Type section + + "\03\02\01\00" ;; Function section + + "\04\04\01" ;; Table section with 1 entry + "\70\00\00" ;; no max, minimum 0, funcref + + "\05\03\01\00\00" ;; Memory section + + "\09\06\01" ;; Element section with one segment + "\05\70" ;; Passive, funcref + "\01" ;; 1 element + "\d0\0b" ;; ref.null, end + + "\0a\04\01" ;; Code section + + ;; function 0 + "\02\00" + "\0b") ;; end + + +;; Type count can be zero +(module binary + "\00asm" "\01\00\00\00" + "\01\01\00" ;; type count can be zero +) + +;; 2 type declared, 1 given +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\07\02" ;; type section with inconsistent count (2 declared, 1 given) + "\60\00\00" ;; 1st type + ;; "\60\00\00" ;; 2nd type (missed) + ) + "unexpected end of section or function" +) + +;; 1 type declared, 2 given +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\07\01" ;; type section with inconsistent count (1 declared, 2 given) + "\60\00\00" ;; 1st type + "\60\00\00" ;; 2nd type (redundant) + ) + "section size mismatch" +) + +;; Import count can be zero +(module binary + "\00asm" "\01\00\00\00" + "\01\05\01" ;; type section + "\60\01\7f\00" ;; type 0 + "\02\01\00" ;; import count can be zero +) + +;; 2 import declared, 1 given +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\05\01" ;; type section + "\60\01\7f\00" ;; type 0 + "\02\16\02" ;; import section with inconsistent count (2 declared, 1 given) + ;; 1st import + "\08" ;; string length + "\73\70\65\63\74\65\73\74" ;; spectest + "\09" ;; string length + "\70\72\69\6e\74\5f\69\33\32" ;; print_i32 + "\00\00" ;; import kind, import signature index + ;; 2nd import + ;; (missed) + ) + "unexpected end of section or function" +) + +;; 1 import declared, 2 given +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\09\02" ;; type section + "\60\01\7f\00" ;; type 0 + "\60\01\7d\00" ;; type 1 + "\02\2b\01" ;; import section with inconsistent count (1 declared, 2 given) + ;; 1st import + "\08" ;; string length + "\73\70\65\63\74\65\73\74" ;; spectest + "\09" ;; string length + "\70\72\69\6e\74\5f\69\33\32" ;; print_i32 + "\00\00" ;; import kind, import signature index + ;; 2nd import + ;; (redundant) + "\08" ;; string length + "\73\70\65\63\74\65\73\74" ;; spectest + "\09" ;; string length + "\70\72\69\6e\74\5f\66\33\32" ;; print_f32 + "\00\01" ;; import kind, import signature index + ) + "section size mismatch" +) + +;; Table count can be zero +(module binary + "\00asm" "\01\00\00\00" + "\04\01\00" ;; table count can be zero +) + +;; 1 table declared, 0 given +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\04\01\01" ;; table section with inconsistent count (1 declared, 0 given) + ;; "\70\01\00\00" ;; table entity + ) + "unexpected end of section or function" +) + +;; Memory count can be zero +(module binary + "\00asm" "\01\00\00\00" + "\05\01\00" ;; memory count can be zero +) + +;; 1 memory declared, 0 given +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\05\01\01" ;; memory section with inconsistent count (1 declared, 0 given) + ;; "\00\00" ;; memory 0 (missed) + ) + "unexpected end of section or function" +) + +;; Global count can be zero +(module binary + "\00asm" "\01\00\00\00" + "\06\01\00" ;; global count can be zero +) + +;; 2 global declared, 1 given +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\06\06\02" ;; global section with inconsistent count (2 declared, 1 given) + "\7f\00\41\00\0b" ;; global 0 + ;; "\7f\00\41\00\0b" ;; global 1 (missed) + ) + "unexpected end of section or function" +) + +;; 1 global declared, 2 given +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\06\0b\01" ;; global section with inconsistent count (1 declared, 2 given) + "\7f\00\41\00\0b" ;; global 0 + "\7f\00\41\00\0b" ;; global 1 (redundant) + ) + "section size mismatch" +) + +;; Export count can be 0 +(module binary + "\00asm" "\01\00\00\00" + "\01\04\01" ;; type section + "\60\00\00" ;; type 0 + "\03\03\02\00\00" ;; func section + "\07\01\00" ;; export count can be zero + "\0a\07\02" ;; code section + "\02\00\0b" ;; function body 0 + "\02\00\0b" ;; function body 1 +) + +;; 2 export declared, 1 given +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01" ;; type section + "\60\00\00" ;; type 0 + "\03\03\02\00\00" ;; func section + "\07\06\02" ;; export section with inconsistent count (2 declared, 1 given) + "\02" ;; export 0 + "\66\31" ;; export name + "\00\00" ;; export kind, export func index + ;; "\02" ;; export 1 (missed) + ;; "\66\32" ;; export name + ;; "\00\01" ;; export kind, export func index + "\0a\07\02" ;; code section + "\02\00\0b" ;; function body 0 + "\02\00\0b" ;; function body 1 + ) + "unexpected end of section or function" +) + +;; 1 export declared, 2 given +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01" ;; type section + "\60\00\00" ;; type 0 + "\03\03\02\00\00" ;; func section + "\07\0b\01" ;; export section with inconsistent count (1 declared, 2 given) + "\02" ;; export 0 + "\66\31" ;; export name + "\00\00" ;; export kind, export func index + "\02" ;; export 1 (redundant) + "\66\32" ;; export name + "\00\01" ;; export kind, export func index + "\0a\07\02" ;; code section + "\02\00\0b" ;; function body 0 + "\02\00\0b" ;; function body 1 + ) + "section size mismatch" +) + +;; elem segment count can be zero +(module binary + "\00asm" "\01\00\00\00" + "\01\04\01" ;; type section + "\60\00\00" ;; type 0 + "\03\02\01\00" ;; func section + "\04\04\01" ;; table section + "\70\00\01" ;; table 0 + "\09\01\00" ;; elem segment count can be zero + "\0a\04\01" ;; code section + "\02\00\0b" ;; function body +) + +;; 2 elem segment declared, 1 given +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01" ;; type section + "\60\00\00" ;; type 0 + "\03\02\01\00" ;; func section + "\04\04\01" ;; table section + "\70\00\01" ;; table 0 + "\09\07\02" ;; elem with inconsistent segment count (2 declared, 1 given) + "\00\41\00\0b\01\00" ;; elem 0 + ;; "\00\41\00\0b\01\00" ;; elem 1 (missed) + "\0a\04\01" ;; code section + "\02\00\0b" ;; function body + ) + "invalid elements segment kind" +) + +;; 1 elem segment declared, 2 given +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01" ;; type section + "\60\00\00" ;; type 0 + "\03\02\01\00" ;; func section + "\04\04\01" ;; table section + "\70\00\01" ;; table 0 + "\09\0d\01" ;; elem with inconsistent segment count (1 declared, 2 given) + "\00\41\00\0b\01\00" ;; elem 0 + "\00\41\00\0b\01\00" ;; elem 1 (redundant) + "\0a\04\01" ;; code section + "\02\00\0b" ;; function body + ) + "section size mismatch" +) + +;; data segment count can be zero +(module binary + "\00asm" "\01\00\00\00" + "\05\03\01" ;; memory section + "\00\01" ;; memory 0 + "\0b\01\00" ;; data segment count can be zero +) + +;; 2 data segment declared, 1 given +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\05\03\01" ;; memory section + "\00\01" ;; memory 0 + "\0b\07\02" ;; data with inconsistent segment count (2 declared, 1 given) + "\00\41\00\0b\01\61" ;; data 0 + ;; "\00\41\01\0b\01\62" ;; data 1 (missed) + ) + "unexpected end of section or function" +) + +;; 1 data segment declared, 2 given +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\05\03\01" ;; memory section + "\00\01" ;; memory 0 + "\0b\0d\01" ;; data with inconsistent segment count (1 declared, 2 given) + "\00\41\00\0b\01\61" ;; data 0 + "\00\41\01\0b\01\62" ;; data 1 (redundant) + ) + "section size mismatch" +) + +;; data segment has 7 bytes declared, but 6 bytes given +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\05\03\01" ;; memory section + "\00\01" ;; memory 0 + "\0b\0c\01" ;; data section + "\00\41\03\0b" ;; data segment 0 + "\07" ;; data segment size with inconsistent lengths (7 declared, 6 given) + "\61\62\63\64\65\66" ;; 6 bytes given + ) + "unexpected end of section or function" +) + +;; data segment has 5 bytes declared, but 6 bytes given +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\05\03\01" ;; memory section + "\00\01" ;; memory 0 + "\0b\0c\01" ;; data section + "\00\41\00\0b" ;; data segment 0 + "\05" ;; data segment size with inconsistent lengths (5 declared, 6 given) + "\61\62\63\64\65\66" ;; 6 bytes given + ) + "section size mismatch" +) + +;; br_table target count can be zero +(module binary + "\00asm" "\01\00\00\00" + "\01\04\01" ;; type section + "\60\00\00" ;; type 0 + "\03\02\01\00" ;; func section + "\0a\11\01" ;; code section + "\0f\00" ;; func 0 + "\02\40" ;; block 0 + "\41\01" ;; condition of if 0 + "\04\40" ;; if 0 + "\41\01" ;; index of br_table element + "\0e\00" ;; br_table target count can be zero + "\02" ;; break depth for default + "\0b\0b\0b" ;; end +) + +;; 2 br_table target declared, 1 given +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01" ;; type section + "\60\00\00" ;; type 0 + "\03\02\01\00" ;; func section + "\0a\12\01" ;; code section + "\10\00" ;; func 0 + "\02\40" ;; block 0 + "\41\01" ;; condition of if 0 + "\04\40" ;; if 0 + "\41\01" ;; index of br_table element + "\0e\02" ;; br_table with inconsistent target count (2 declared, 1 given) + "\00" ;; break depth 0 + ;; "\01" ;; break depth 1 (missed) + "\02" ;; break depth for default + "\0b\0b\0b" ;; end + ) + "unexpected end of section or function" +) + +;; 1 br_table target declared, 2 given +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01" ;; type section + "\60\00\00" ;; type 0 + "\03\02\01\00" ;; func section + "\0a\12\01" ;; code section + "\11\00" ;; func 0 + "\02\40" ;; block 0 + "\41\01" ;; condition of if 0 + "\04\40" ;; if 0 + "\41\01" ;; index of br_table element + "\0e\01" ;; br_table with inconsistent target count (1 declared, 2 given) + "\00" ;; break depth 0 + "\01" ;; break depth 1 + "\02" ;; break depth for default + "\0b\0b\0b" ;; end + ) + "malformed value type" +) + +;; Start section +(module binary + "\00asm" "\01\00\00\00" + "\01\04\01\60\00\00" ;; Type section + "\03\02\01\00" ;; Function section + "\08\01\00" ;; Start section: function 0 + + "\0a\04\01" ;; Code section + ;; function 0 + "\02\00" + "\0b" ;; end +) + +;; Multiple start sections +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01\60\00\00" ;; Type section + "\03\02\01\00" ;; Function section + "\08\01\00" ;; Start section: function 0 + "\08\01\00" ;; Start section: function 0 + + "\0a\04\01" ;; Code section + ;; function 0 + "\02\00" + "\0b" ;; end + ) + "junk after last section" +) diff --git a/runtime/near-vm/tests/wast/spec/proposals/bulk-memory-operations/bulk.wast b/runtime/near-vm/tests/wast/spec/proposals/bulk-memory-operations/bulk.wast new file mode 100644 index 00000000000..6fb1f0deccd --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/proposals/bulk-memory-operations/bulk.wast @@ -0,0 +1,351 @@ +;; segment syntax +(module + (memory 1) + (data "foo")) + +(module + (table 3 funcref) + (elem funcref (ref.func 0) (ref.null) (ref.func 1)) + (func) + (func)) + +;; memory.fill +(module + (memory 1) + + (func (export "fill") (param i32 i32 i32) + (memory.fill + (local.get 0) + (local.get 1) + (local.get 2))) + + (func (export "load8_u") (param i32) (result i32) + (i32.load8_u (local.get 0))) +) + +;; Basic fill test. +(invoke "fill" (i32.const 1) (i32.const 0xff) (i32.const 3)) +(assert_return (invoke "load8_u" (i32.const 0)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 1)) (i32.const 0xff)) +(assert_return (invoke "load8_u" (i32.const 2)) (i32.const 0xff)) +(assert_return (invoke "load8_u" (i32.const 3)) (i32.const 0xff)) +(assert_return (invoke "load8_u" (i32.const 4)) (i32.const 0)) + +;; Fill value is stored as a byte. +(invoke "fill" (i32.const 0) (i32.const 0xbbaa) (i32.const 2)) +(assert_return (invoke "load8_u" (i32.const 0)) (i32.const 0xaa)) +(assert_return (invoke "load8_u" (i32.const 1)) (i32.const 0xaa)) + +;; Fill all of memory +(invoke "fill" (i32.const 0) (i32.const 0) (i32.const 0x10000)) + +;; Out-of-bounds writes trap, and nothing is written +(assert_trap (invoke "fill" (i32.const 0xff00) (i32.const 1) (i32.const 0x101)) + "out of bounds memory access") +(assert_return (invoke "load8_u" (i32.const 0xff00)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 0xffff)) (i32.const 0)) + +;; Succeed when writing 0 bytes at the end of the region. +(invoke "fill" (i32.const 0x10000) (i32.const 0) (i32.const 0)) + +;; Writing 0 bytes outside the memory traps. +(assert_trap (invoke "fill" (i32.const 0x10001) (i32.const 0) (i32.const 0)) + "out of bounds memory access") + + +;; memory.copy +(module + (memory (data "\aa\bb\cc\dd")) + + (func (export "copy") (param i32 i32 i32) + (memory.copy + (local.get 0) + (local.get 1) + (local.get 2))) + + (func (export "load8_u") (param i32) (result i32) + (i32.load8_u (local.get 0))) +) + +;; Non-overlapping copy. +(invoke "copy" (i32.const 10) (i32.const 0) (i32.const 4)) + +(assert_return (invoke "load8_u" (i32.const 9)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 10)) (i32.const 0xaa)) +(assert_return (invoke "load8_u" (i32.const 11)) (i32.const 0xbb)) +(assert_return (invoke "load8_u" (i32.const 12)) (i32.const 0xcc)) +(assert_return (invoke "load8_u" (i32.const 13)) (i32.const 0xdd)) +(assert_return (invoke "load8_u" (i32.const 14)) (i32.const 0)) + +;; Overlap, source > dest +(invoke "copy" (i32.const 8) (i32.const 10) (i32.const 4)) +(assert_return (invoke "load8_u" (i32.const 8)) (i32.const 0xaa)) +(assert_return (invoke "load8_u" (i32.const 9)) (i32.const 0xbb)) +(assert_return (invoke "load8_u" (i32.const 10)) (i32.const 0xcc)) +(assert_return (invoke "load8_u" (i32.const 11)) (i32.const 0xdd)) +(assert_return (invoke "load8_u" (i32.const 12)) (i32.const 0xcc)) +(assert_return (invoke "load8_u" (i32.const 13)) (i32.const 0xdd)) + +;; Overlap, source < dest +(invoke "copy" (i32.const 10) (i32.const 7) (i32.const 6)) +(assert_return (invoke "load8_u" (i32.const 10)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 11)) (i32.const 0xaa)) +(assert_return (invoke "load8_u" (i32.const 12)) (i32.const 0xbb)) +(assert_return (invoke "load8_u" (i32.const 13)) (i32.const 0xcc)) +(assert_return (invoke "load8_u" (i32.const 14)) (i32.const 0xdd)) +(assert_return (invoke "load8_u" (i32.const 15)) (i32.const 0xcc)) +(assert_return (invoke "load8_u" (i32.const 16)) (i32.const 0)) + +;; Copy ending at memory limit is ok. +(invoke "copy" (i32.const 0xff00) (i32.const 0) (i32.const 0x100)) +(invoke "copy" (i32.const 0xfe00) (i32.const 0xff00) (i32.const 0x100)) + +;; Succeed when copying 0 bytes at the end of the region. +(invoke "copy" (i32.const 0x10000) (i32.const 0) (i32.const 0)) +(invoke "copy" (i32.const 0) (i32.const 0x10000) (i32.const 0)) + +;; Copying 0 bytes outside the memory traps. +(assert_trap (invoke "copy" (i32.const 0x10001) (i32.const 0) (i32.const 0)) + "out of bounds memory access") +(assert_trap (invoke "copy" (i32.const 0) (i32.const 0x10001) (i32.const 0)) + "out of bounds memory access") + + +;; memory.init +(module + (memory 1) + (data "\aa\bb\cc\dd") + + (func (export "init") (param i32 i32 i32) + (memory.init 0 + (local.get 0) + (local.get 1) + (local.get 2))) + + (func (export "load8_u") (param i32) (result i32) + (i32.load8_u (local.get 0))) +) + +(invoke "init" (i32.const 0) (i32.const 1) (i32.const 2)) +(assert_return (invoke "load8_u" (i32.const 0)) (i32.const 0xbb)) +(assert_return (invoke "load8_u" (i32.const 1)) (i32.const 0xcc)) +(assert_return (invoke "load8_u" (i32.const 2)) (i32.const 0)) + +;; Init ending at memory limit and segment limit is ok. +(invoke "init" (i32.const 0xfffc) (i32.const 0) (i32.const 4)) + +;; Out-of-bounds writes trap, and nothing is written. +(assert_trap (invoke "init" (i32.const 0xfffe) (i32.const 0) (i32.const 3)) + "out of bounds memory access") +(assert_return (invoke "load8_u" (i32.const 0xfffe)) (i32.const 0xcc)) +(assert_return (invoke "load8_u" (i32.const 0xffff)) (i32.const 0xdd)) + +;; Succeed when writing 0 bytes at the end of either region. +(invoke "init" (i32.const 0x10000) (i32.const 0) (i32.const 0)) +(invoke "init" (i32.const 0) (i32.const 4) (i32.const 0)) + +;; Writing 0 bytes outside the memory traps. +(assert_trap (invoke "init" (i32.const 0x10001) (i32.const 0) (i32.const 0)) + "out of bounds memory access") +(assert_trap (invoke "init" (i32.const 0) (i32.const 5) (i32.const 0)) + "out of bounds memory access") + +;; data.drop +(module + (memory 1) + (data $p "x") + (data $a (memory 0) (i32.const 0) "x") + + (func (export "drop_passive") (data.drop $p)) + (func (export "init_passive") (param $len i32) + (memory.init $p (i32.const 0) (i32.const 0) (local.get $len))) + + (func (export "drop_active") (data.drop $a)) + (func (export "init_active") (param $len i32) + (memory.init $a (i32.const 0) (i32.const 0) (local.get $len))) +) + +(invoke "init_passive" (i32.const 1)) +(invoke "drop_passive") +(invoke "drop_passive") +(assert_return (invoke "init_passive" (i32.const 0))) +(assert_trap (invoke "init_passive" (i32.const 1)) "out of bounds") +(invoke "init_passive" (i32.const 0)) +(invoke "drop_active") +(assert_return (invoke "init_active" (i32.const 0))) +(assert_trap (invoke "init_active" (i32.const 1)) "out of bounds") +(invoke "init_active" (i32.const 0)) + +;; Test that the data segment index is properly encoded as an unsigned (not +;; signed) LEB. +(module + ;; 65 data segments. 64 is the smallest positive number that is encoded + ;; differently as a signed LEB. + (data "") (data "") (data "") (data "") (data "") (data "") (data "") (data "") + (data "") (data "") (data "") (data "") (data "") (data "") (data "") (data "") + (data "") (data "") (data "") (data "") (data "") (data "") (data "") (data "") + (data "") (data "") (data "") (data "") (data "") (data "") (data "") (data "") + (data "") (data "") (data "") (data "") (data "") (data "") (data "") (data "") + (data "") (data "") (data "") (data "") (data "") (data "") (data "") (data "") + (data "") (data "") (data "") (data "") (data "") (data "") (data "") (data "") + (data "") (data "") (data "") (data "") (data "") (data "") (data "") (data "") + (data "") + (func (data.drop 64))) + +;; No memory is required for the data.drop instruction. +(module (data "goodbye") (func (data.drop 0))) + +;; table.init +(module + (table 3 funcref) + (elem funcref + (ref.func $zero) (ref.func $one) (ref.func $zero) (ref.func $one)) + + (func $zero (result i32) (i32.const 0)) + (func $one (result i32) (i32.const 1)) + + (func (export "init") (param i32 i32 i32) + (table.init 0 + (local.get 0) + (local.get 1) + (local.get 2))) + + (func (export "call") (param i32) (result i32) + (call_indirect (result i32) + (local.get 0))) +) + +;; Out-of-bounds stores trap, and nothing is written. +(assert_trap (invoke "init" (i32.const 2) (i32.const 0) (i32.const 2)) + "out of bounds table access") +(assert_trap (invoke "call" (i32.const 2)) + "uninitialized element 2") + +(invoke "init" (i32.const 0) (i32.const 1) (i32.const 2)) +(assert_return (invoke "call" (i32.const 0)) (i32.const 1)) +(assert_return (invoke "call" (i32.const 1)) (i32.const 0)) +(assert_trap (invoke "call" (i32.const 2)) "uninitialized element") + +;; Init ending at table limit and segment limit is ok. +(invoke "init" (i32.const 1) (i32.const 2) (i32.const 2)) + +;; Succeed when storing 0 elements at the end of either region. +(invoke "init" (i32.const 3) (i32.const 0) (i32.const 0)) +(invoke "init" (i32.const 0) (i32.const 4) (i32.const 0)) + +;; Writing 0 elements outside the table traps. +(assert_trap (invoke "init" (i32.const 4) (i32.const 0) (i32.const 0)) + "out of bounds table access") +(assert_trap (invoke "init" (i32.const 0) (i32.const 5) (i32.const 0)) + "out of bounds table access") + + +;; elem.drop +(module + (table 1 funcref) + (func $f) + (elem $p funcref (ref.func $f)) + (elem $a (table 0) (i32.const 0) func $f) + + (func (export "drop_passive") (elem.drop $p)) + (func (export "init_passive") (param $len i32) + (table.init $p (i32.const 0) (i32.const 0) (local.get $len)) + ) + + (func (export "drop_active") (elem.drop $a)) + (func (export "init_active") (param $len i32) + (table.init $a (i32.const 0) (i32.const 0) (local.get $len)) + ) +) + +(invoke "init_passive" (i32.const 1)) +(invoke "drop_passive") +(invoke "drop_passive") +(assert_return (invoke "init_passive" (i32.const 0))) +(assert_trap (invoke "init_passive" (i32.const 1)) "out of bounds") +(invoke "init_passive" (i32.const 0)) +(invoke "drop_active") +(assert_return (invoke "init_active" (i32.const 0))) +(assert_trap (invoke "init_active" (i32.const 1)) "out of bounds") +(invoke "init_active" (i32.const 0)) + +;; Test that the elem segment index is properly encoded as an unsigned (not +;; signed) LEB. +(module + ;; 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 (elem.drop 64))) + +;; No table is required for the elem.drop instruction. +(module (elem funcref (ref.func 0)) (func (elem.drop 0))) + +;; table.copy +(module + (table 10 funcref) + (elem (i32.const 0) $zero $one $two) + (func $zero (result i32) (i32.const 0)) + (func $one (result i32) (i32.const 1)) + (func $two (result i32) (i32.const 2)) + + (func (export "copy") (param i32 i32 i32) + (table.copy + (local.get 0) + (local.get 1) + (local.get 2))) + + (func (export "call") (param i32) (result i32) + (call_indirect (result i32) + (local.get 0))) +) + +;; Non-overlapping copy. +(invoke "copy" (i32.const 3) (i32.const 0) (i32.const 3)) +;; Now [$zero, $one, $two, $zero, $one, $two, ...] +(assert_return (invoke "call" (i32.const 3)) (i32.const 0)) +(assert_return (invoke "call" (i32.const 4)) (i32.const 1)) +(assert_return (invoke "call" (i32.const 5)) (i32.const 2)) + +;; Overlap, source > dest +(invoke "copy" (i32.const 0) (i32.const 1) (i32.const 3)) +;; Now [$one, $two, $zero, $zero, $one, $two, ...] +(assert_return (invoke "call" (i32.const 0)) (i32.const 1)) +(assert_return (invoke "call" (i32.const 1)) (i32.const 2)) +(assert_return (invoke "call" (i32.const 2)) (i32.const 0)) + +;; Overlap, source < dest +(invoke "copy" (i32.const 2) (i32.const 0) (i32.const 3)) +;; Now [$one, $two, $one, $two, $zero, $two, ...] +(assert_return (invoke "call" (i32.const 2)) (i32.const 1)) +(assert_return (invoke "call" (i32.const 3)) (i32.const 2)) +(assert_return (invoke "call" (i32.const 4)) (i32.const 0)) + +;; Copy ending at table limit is ok. +(invoke "copy" (i32.const 6) (i32.const 8) (i32.const 2)) +(invoke "copy" (i32.const 8) (i32.const 6) (i32.const 2)) + +;; Succeed when copying 0 elements at the end of the region. +(invoke "copy" (i32.const 10) (i32.const 0) (i32.const 0)) +(invoke "copy" (i32.const 0) (i32.const 10) (i32.const 0)) + +;; Fail on out-of-bounds when copying 0 elements outside of table. +(assert_trap (invoke "copy" (i32.const 11) (i32.const 0) (i32.const 0)) + "out of bounds") +(assert_trap (invoke "copy" (i32.const 0) (i32.const 11) (i32.const 0)) + "out of bounds") diff --git a/runtime/near-vm/tests/wast/spec/proposals/bulk-memory-operations/custom.wast b/runtime/near-vm/tests/wast/spec/proposals/bulk-memory-operations/custom.wast new file mode 100644 index 00000000000..b2394f5e3ba --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/proposals/bulk-memory-operations/custom.wast @@ -0,0 +1,130 @@ +(module binary + "\00asm" "\01\00\00\00" + "\00\24\10" "a custom section" "this is the payload" + "\00\20\10" "a custom section" "this is payload" + "\00\11\10" "a custom section" "" + "\00\10\00" "" "this is payload" + "\00\01\00" "" "" + "\00\24\10" "\00\00custom sectio\00" "this is the payload" + "\00\24\10" "\ef\bb\bfa custom sect" "this is the payload" + "\00\24\10" "a custom sect\e2\8c\a3" "this is the payload" + "\00\1f\16" "module within a module" "\00asm" "\01\00\00\00" +) + +(module binary + "\00asm" "\01\00\00\00" + "\00\0e\06" "custom" "payload" + "\00\0e\06" "custom" "payload" + "\01\01\00" ;; type section + "\00\0e\06" "custom" "payload" + "\00\0e\06" "custom" "payload" + "\02\01\00" ;; import section + "\00\0e\06" "custom" "payload" + "\00\0e\06" "custom" "payload" + "\03\01\00" ;; function section + "\00\0e\06" "custom" "payload" + "\00\0e\06" "custom" "payload" + "\04\01\00" ;; table section + "\00\0e\06" "custom" "payload" + "\00\0e\06" "custom" "payload" + "\05\01\00" ;; memory section + "\00\0e\06" "custom" "payload" + "\00\0e\06" "custom" "payload" + "\06\01\00" ;; global section + "\00\0e\06" "custom" "payload" + "\00\0e\06" "custom" "payload" + "\07\01\00" ;; export section + "\00\0e\06" "custom" "payload" + "\00\0e\06" "custom" "payload" + "\09\01\00" ;; element section + "\00\0e\06" "custom" "payload" + "\00\0e\06" "custom" "payload" + "\0a\01\00" ;; code section + "\00\0e\06" "custom" "payload" + "\00\0e\06" "custom" "payload" + "\0b\01\00" ;; data section + "\00\0e\06" "custom" "payload" + "\00\0e\06" "custom" "payload" +) + +(module binary + "\00asm" "\01\00\00\00" + "\01\07\01\60\02\7f\7f\01\7f" ;; type section + "\00\1a\06" "custom" "this is the payload" ;; custom section + "\03\02\01\00" ;; function section + "\07\0a\01\06\61\64\64\54\77\6f\00\00" ;; export section + "\0a\09\01\07\00\20\00\20\01\6a\0b" ;; code section + "\00\1b\07" "custom2" "this is the payload" ;; custom section +) + +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00" + ) + "unexpected end" +) + +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\00" + ) + "unexpected end" +) + +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\00\00\05\01\00\07\00\00" + ) + "unexpected end" +) + +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\26\10" "a custom section" "this is the payload" + ) + "unexpected end" +) + +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\25\10" "a custom section" "this is the payload" + "\00\24\10" "a custom section" "this is the payload" + ) + "malformed section id" +) + +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\07\01\60\02\7f\7f\01\7f" ;; type section + "\00\25\10" "a custom section" "this is the payload" ;; wrong length! + "\03\02\01\00" ;; function section + "\0a\09\01\07\00\20\00\20\01\6a\0b" ;; code section + "\00\1b\07" "custom2" "this is the payload" ;; custom section + ) + "function and code section have inconsistent lengths" +) + +;; Test concatenated modules. +(assert_malformed + (module binary + "\00asm\01\00\00\00" + "\00asm\01\00\00\00" + ) + "length out of bounds" +) + +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\05\03\01\00\01" ;; memory section + "\0c\01\02" ;; data count section (2 segments) + "\0b\06\01\00\41\00\0b\00" ;; data section (1 segment) + ) + "data count and data section have inconsistent lengths" +) diff --git a/runtime/near-vm/tests/wast/spec/proposals/bulk-memory-operations/data.wast b/runtime/near-vm/tests/wast/spec/proposals/bulk-memory-operations/data.wast new file mode 100644 index 00000000000..aabe1021b23 --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/proposals/bulk-memory-operations/data.wast @@ -0,0 +1,345 @@ +;; Test the data section + +;; Syntax + +(module + (memory $m 1) + (data (i32.const 0)) + (data (i32.const 1) "a" "" "bcd") + (data (offset (i32.const 0))) + (data (offset (i32.const 0)) "" "a" "bc" "") + (data (memory 0) (i32.const 0)) + (data (memory 0x0) (i32.const 1) "a" "" "bcd") + (data (memory 0x000) (offset (i32.const 0))) + (data (memory 0) (offset (i32.const 0)) "" "a" "bc" "") + (data (memory $m) (i32.const 0)) + (data (memory $m) (i32.const 1) "a" "" "bcd") + (data (memory $m) (offset (i32.const 0))) + (data (memory $m) (offset (i32.const 0)) "" "a" "bc" "") + (data $d1 (i32.const 0)) + (data $d2 (i32.const 1) "a" "" "bcd") + (data $d3 (offset (i32.const 0))) + (data $d4 (offset (i32.const 0)) "" "a" "bc" "") + (data $d5 (memory 0) (i32.const 0)) + (data $d6 (memory 0x0) (i32.const 1) "a" "" "bcd") + (data $d7 (memory 0x000) (offset (i32.const 0))) + (data $d8 (memory 0) (offset (i32.const 0)) "" "a" "bc" "") + (data $d9 (memory $m) (i32.const 0)) + (data $d10 (memory $m) (i32.const 1) "a" "" "bcd") + (data $d11 (memory $m) (offset (i32.const 0))) + (data $d12 (memory $m) (offset (i32.const 0)) "" "a" "bc" "") +) + +;; Basic use + +(module + (memory 1) + (data (i32.const 0) "a") +) +(module + (import "spectest" "memory" (memory 1)) + (data (i32.const 0) "a") +) + +(module + (memory 1) + (data (i32.const 0) "a") + (data (i32.const 3) "b") + (data (i32.const 100) "cde") + (data (i32.const 5) "x") + (data (i32.const 3) "c") +) +(module + (import "spectest" "memory" (memory 1)) + (data (i32.const 0) "a") + (data (i32.const 1) "b") + (data (i32.const 2) "cde") + (data (i32.const 3) "f") + (data (i32.const 2) "g") + (data (i32.const 1) "h") +) + +(module + (global (import "spectest" "global_i32") i32) + (memory 1) + (data (global.get 0) "a") +) +(module + (global (import "spectest" "global_i32") i32) + (import "spectest" "memory" (memory 1)) + (data (global.get 0) "a") +) + +(module + (global $g (import "spectest" "global_i32") i32) + (memory 1) + (data (global.get $g) "a") +) +(module + (global $g (import "spectest" "global_i32") i32) + (import "spectest" "memory" (memory 1)) + (data (global.get $g) "a") +) + +;; Use of internal globals in constant expressions is not allowed in MVP. +;; (module (memory 1) (data (global.get 0) "a") (global i32 (i32.const 0))) +;; (module (memory 1) (data (global.get $g) "a") (global $g i32 (i32.const 0))) + +;; Corner cases + +(module + (memory 1) + (data (i32.const 0) "a") + (data (i32.const 0xffff) "b") +) +(module + (import "spectest" "memory" (memory 1)) + (data (i32.const 0) "a") + (data (i32.const 0xffff) "b") +) + +(module + (memory 2) + (data (i32.const 0x1_ffff) "a") +) + +(module + (memory 0) + (data (i32.const 0)) +) +(module + (import "spectest" "memory" (memory 0)) + (data (i32.const 0)) +) + +(module + (memory 0 0) + (data (i32.const 0)) +) + +(module + (memory 1) + (data (i32.const 0x1_0000) "") +) + +(module + (memory 0) + (data (i32.const 0) "" "") +) +(module + (import "spectest" "memory" (memory 0)) + (data (i32.const 0) "" "") +) + +(module + (memory 0 0) + (data (i32.const 0) "" "") +) + +(module + (import "spectest" "memory" (memory 0)) + (data (i32.const 0) "a") +) + +(module + (import "spectest" "memory" (memory 0 3)) + (data (i32.const 0) "a") +) + +(module + (global (import "spectest" "global_i32") i32) + (import "spectest" "memory" (memory 0)) + (data (global.get 0) "a") +) + +(module + (global (import "spectest" "global_i32") i32) + (import "spectest" "memory" (memory 0 3)) + (data (global.get 0) "a") +) + +(module + (import "spectest" "memory" (memory 0)) + (data (i32.const 1) "a") +) + +(module + (import "spectest" "memory" (memory 0 3)) + (data (i32.const 1) "a") +) + +;; Invalid bounds for data + +(assert_trap + (module + (memory 0) + (data (i32.const 0) "a") + ) + "out of bounds" +) + +(assert_trap + (module + (memory 0 0) + (data (i32.const 0) "a") + ) + "out of bounds" +) + +(assert_trap + (module + (memory 0 1) + (data (i32.const 0) "a") + ) + "out of bounds" +) +(assert_trap + (module + (memory 0) + (data (i32.const 1)) + ) + "out of bounds" +) +(assert_trap + (module + (memory 0 1) + (data (i32.const 1)) + ) + "out of bounds" +) + +;; This seems to cause a time-out on Travis. +(;assert_unlinkable + (module + (memory 0x10000) + (data (i32.const 0xffffffff) "ab") + ) + "" ;; either out of memory or out of bounds +;) + +(assert_trap + (module + (global (import "spectest" "global_i32") i32) + (memory 0) + (data (global.get 0) "a") + ) + "out of bounds" +) + +(assert_trap + (module + (memory 1 2) + (data (i32.const 0x1_0000) "a") + ) + "out of bounds" +) +(assert_trap + (module + (import "spectest" "memory" (memory 1)) + (data (i32.const 0x1_0000) "a") + ) + "out of bounds" +) + +(assert_trap + (module + (memory 2) + (data (i32.const 0x2_0000) "a") + ) + "out of bounds" +) + +(assert_trap + (module + (memory 2 3) + (data (i32.const 0x2_0000) "a") + ) + "out of bounds" +) + +(assert_trap + (module + (memory 1) + (data (i32.const -1) "a") + ) + "out of bounds" +) +(assert_trap + (module + (import "spectest" "memory" (memory 1)) + (data (i32.const -1) "a") + ) + "out of bounds" +) + +(assert_trap + (module + (memory 2) + (data (i32.const -100) "a") + ) + "out of bounds" +) +(assert_trap + (module + (import "spectest" "memory" (memory 1)) + (data (i32.const -100) "a") + ) + "out of bounds" +) + +;; Data without memory + +(assert_invalid + (module + (data (i32.const 0) "") + ) + "unknown memory" +) + +;; Invalid offsets + +(assert_invalid + (module + (memory 1) + (data (i64.const 0)) + ) + "type mismatch" +) + +(assert_invalid + (module + (memory 1) + (data (i32.ctz (i32.const 0))) + ) + "constant expression required" +) + +(assert_invalid + (module + (memory 1) + (data (nop)) + ) + "constant expression required" +) + +(assert_invalid + (module + (memory 1) + (data (offset (nop) (i32.const 0))) + ) + "constant expression required" +) + +(assert_invalid + (module + (memory 1) + (data (offset (i32.const 0) (nop))) + ) + "constant expression required" +) + +;; Use of internal globals in constant expressions is not allowed in MVP. +;; (assert_invalid +;; (module (memory 1) (data (global.get $g)) (global $g (mut i32) (i32.const 0))) +;; "constant expression required" +;; ) diff --git a/runtime/near-vm/tests/wast/spec/proposals/bulk-memory-operations/elem.wast b/runtime/near-vm/tests/wast/spec/proposals/bulk-memory-operations/elem.wast new file mode 100644 index 00000000000..bb622ee662b --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/proposals/bulk-memory-operations/elem.wast @@ -0,0 +1,433 @@ +;; Test the element section + +;; Syntax +(module + (table $t 10 funcref) + (func $f) + (func $g) + + ;; Passive + (elem funcref) + (elem funcref (ref.func $f) (ref.func $f) (ref.null) (ref.func $g)) + (elem func) + (elem func $f $f $g $g) + + (elem $p1 funcref) + (elem $p2 funcref (ref.func $f) (ref.func $f) (ref.null) (ref.func $g)) + (elem $p3 func) + (elem $p4 func $f $f $g $g) + + ;; Active + (elem (table $t) (i32.const 0) funcref) + (elem (table $t) (i32.const 0) funcref (ref.func $f) (ref.null)) + (elem (table $t) (i32.const 0) func) + (elem (table $t) (i32.const 0) func $f $g) + (elem (table $t) (offset (i32.const 0)) funcref) + (elem (table $t) (offset (i32.const 0)) func $f $g) + (elem (table 0) (i32.const 0) func) + (elem (table 0x0) (i32.const 0) func $f $f) + (elem (table 0x000) (offset (i32.const 0)) func) + (elem (table 0) (offset (i32.const 0)) func $f $f) + (elem (table $t) (i32.const 0) func) + (elem (table $t) (i32.const 0) func $f $f) + (elem (table $t) (offset (i32.const 0)) func) + (elem (table $t) (offset (i32.const 0)) func $f $f) + (elem (offset (i32.const 0))) + (elem (offset (i32.const 0)) funcref (ref.func $f) (ref.null)) + (elem (offset (i32.const 0)) func $f $f) + (elem (offset (i32.const 0)) $f $f) + (elem (i32.const 0)) + (elem (i32.const 0) funcref (ref.func $f) (ref.null)) + (elem (i32.const 0) func $f $f) + (elem (i32.const 0) $f $f) + + (elem $a1 (table $t) (i32.const 0) funcref) + (elem $a2 (table $t) (i32.const 0) funcref (ref.func $f) (ref.null)) + (elem $a3 (table $t) (i32.const 0) func) + (elem $a4 (table $t) (i32.const 0) func $f $g) + (elem $a9 (table $t) (offset (i32.const 0)) funcref) + (elem $a10 (table $t) (offset (i32.const 0)) func $f $g) + (elem $a11 (table 0) (i32.const 0) func) + (elem $a12 (table 0x0) (i32.const 0) func $f $f) + (elem $a13 (table 0x000) (offset (i32.const 0)) func) + (elem $a14 (table 0) (offset (i32.const 0)) func $f $f) + (elem $a15 (table $t) (i32.const 0) func) + (elem $a16 (table $t) (i32.const 0) func $f $f) + (elem $a17 (table $t) (offset (i32.const 0)) func) + (elem $a18 (table $t) (offset (i32.const 0)) func $f $f) + (elem $a19 (offset (i32.const 0))) + (elem $a20 (offset (i32.const 0)) funcref (ref.func $f) (ref.null)) + (elem $a21 (offset (i32.const 0)) func $f $f) + (elem $a22 (offset (i32.const 0)) $f $f) + (elem $a23 (i32.const 0)) + (elem $a24 (i32.const 0) funcref (ref.func $f) (ref.null)) + (elem $a25 (i32.const 0) func $f $f) + (elem $a26 (i32.const 0) $f $f) +) + +(module + (func $f) + (func $g) + + (table $t funcref (elem (ref.func $f) (ref.null) (ref.func $g))) +) +;; Basic use + +(module + (table 10 funcref) + (func $f) + (elem (i32.const 0) $f) +) +(module + (import "spectest" "table" (table 10 funcref)) + (func $f) + (elem (i32.const 0) $f) +) + +(module + (table 10 funcref) + (func $f) + (elem (i32.const 0) $f) + (elem (i32.const 3) $f) + (elem (i32.const 7) $f) + (elem (i32.const 5) $f) + (elem (i32.const 3) $f) +) +(module + (import "spectest" "table" (table 10 funcref)) + (func $f) + (elem (i32.const 9) $f) + (elem (i32.const 3) $f) + (elem (i32.const 7) $f) + (elem (i32.const 3) $f) + (elem (i32.const 5) $f) +) + +(module + (global (import "spectest" "global_i32") i32) + (table 1000 funcref) + (func $f) + (elem (global.get 0) $f) +) + +(module + (global $g (import "spectest" "global_i32") i32) + (table 1000 funcref) + (func $f) + (elem (global.get $g) $f) +) + +(module + (type $out-i32 (func (result i32))) + (table 10 funcref) + (elem (i32.const 7) $const-i32-a) + (elem (i32.const 9) $const-i32-b) + (func $const-i32-a (type $out-i32) (i32.const 65)) + (func $const-i32-b (type $out-i32) (i32.const 66)) + (func (export "call-7") (type $out-i32) + (call_indirect (type $out-i32) (i32.const 7)) + ) + (func (export "call-9") (type $out-i32) + (call_indirect (type $out-i32) (i32.const 9)) + ) +) +(assert_return (invoke "call-7") (i32.const 65)) +(assert_return (invoke "call-9") (i32.const 66)) + +;; Corner cases + +(module + (table 10 funcref) + (func $f) + (elem (i32.const 9) $f) +) +(module + (import "spectest" "table" (table 10 funcref)) + (func $f) + (elem (i32.const 9) $f) +) + +(module + (table 0 funcref) + (elem (i32.const 0)) +) +(module + (import "spectest" "table" (table 0 funcref)) + (elem (i32.const 0)) +) + +(module + (table 0 0 funcref) + (elem (i32.const 0)) +) + +(module + (table 20 funcref) + (elem (i32.const 20)) +) + +(module + (import "spectest" "table" (table 0 funcref)) + (func $f) + (elem (i32.const 0) $f) +) + +(module + (import "spectest" "table" (table 0 100 funcref)) + (func $f) + (elem (i32.const 0) $f) +) + +(module + (import "spectest" "table" (table 0 funcref)) + (func $f) + (elem (i32.const 1) $f) +) + +(module + (import "spectest" "table" (table 0 30 funcref)) + (func $f) + (elem (i32.const 1) $f) +) + +;; Invalid bounds for elements + +(assert_trap + (module + (table 0 funcref) + (func $f) + (elem (i32.const 0) $f) + ) + "out of bounds" +) + +(assert_trap + (module + (table 0 0 funcref) + (func $f) + (elem (i32.const 0) $f) + ) + "out of bounds" +) + +(assert_trap + (module + (table 0 1 funcref) + (func $f) + (elem (i32.const 0) $f) + ) + "out of bounds" +) + +(assert_trap + (module + (table 0 funcref) + (elem (i32.const 1)) + ) + "out of bounds" +) +(assert_trap + (module + (table 10 funcref) + (func $f) + (elem (i32.const 10) $f) + ) + "out of bounds" +) +(assert_trap + (module + (import "spectest" "table" (table 10 funcref)) + (func $f) + (elem (i32.const 10) $f) + ) + "out of bounds" +) + +(assert_trap + (module + (table 10 20 funcref) + (func $f) + (elem (i32.const 10) $f) + ) + "out of bounds" +) +(assert_trap + (module + (import "spectest" "table" (table 10 funcref)) + (func $f) + (elem (i32.const 10) $f) + ) + "out of bounds" +) + +(assert_trap + (module + (table 10 funcref) + (func $f) + (elem (i32.const -1) $f) + ) + "out of bounds" +) +(assert_trap + (module + (import "spectest" "table" (table 10 funcref)) + (func $f) + (elem (i32.const -1) $f) + ) + "out of bounds" +) + +(assert_trap + (module + (table 10 funcref) + (func $f) + (elem (i32.const -10) $f) + ) + "out of bounds" +) +(assert_trap + (module + (import "spectest" "table" (table 10 funcref)) + (func $f) + (elem (i32.const -10) $f) + ) + "out of bounds" +) + +;; Element without table + +(assert_invalid + (module + (func $f) + (elem (i32.const 0) $f) + ) + "unknown table" +) + +;; Invalid offsets + +(assert_invalid + (module + (table 1 funcref) + (elem (i64.const 0)) + ) + "type mismatch" +) + +(assert_invalid + (module + (table 1 funcref) + (elem (i32.ctz (i32.const 0))) + ) + "constant expression required" +) + +(assert_invalid + (module + (table 1 funcref) + (elem (nop)) + ) + "constant expression required" +) + +(assert_invalid + (module + (table 1 funcref) + (elem (offset (nop) (i32.const 0))) + ) + "constant expression required" +) + +(assert_invalid + (module + (table 1 funcref) + (elem (offset (i32.const 0) (nop))) + ) + "constant expression required" +) + +;; Use of internal globals in constant expressions is not allowed in MVP. +;; (assert_invalid +;; (module (memory 1) (data (global.get $g)) (global $g (mut i32) (i32.const 0))) +;; "constant expression required" +;; ) + +;; Two elements target the same slot + +(module + (type $out-i32 (func (result i32))) + (table 10 funcref) + (elem (i32.const 9) $const-i32-a) + (elem (i32.const 9) $const-i32-b) + (func $const-i32-a (type $out-i32) (i32.const 65)) + (func $const-i32-b (type $out-i32) (i32.const 66)) + (func (export "call-overwritten") (type $out-i32) + (call_indirect (type $out-i32) (i32.const 9)) + ) +) +(assert_return (invoke "call-overwritten") (i32.const 66)) + +(module + (type $out-i32 (func (result i32))) + (import "spectest" "table" (table 10 funcref)) + (elem (i32.const 9) $const-i32-a) + (elem (i32.const 9) $const-i32-b) + (func $const-i32-a (type $out-i32) (i32.const 65)) + (func $const-i32-b (type $out-i32) (i32.const 66)) + (func (export "call-overwritten-element") (type $out-i32) + (call_indirect (type $out-i32) (i32.const 9)) + ) +) +(assert_return (invoke "call-overwritten-element") (i32.const 66)) + +;; Element sections across multiple modules change the same table + +(module $module1 + (type $out-i32 (func (result i32))) + (table (export "shared-table") 10 funcref) + (elem (i32.const 8) $const-i32-a) + (elem (i32.const 9) $const-i32-b) + (func $const-i32-a (type $out-i32) (i32.const 65)) + (func $const-i32-b (type $out-i32) (i32.const 66)) + (func (export "call-7") (type $out-i32) + (call_indirect (type $out-i32) (i32.const 7)) + ) + (func (export "call-8") (type $out-i32) + (call_indirect (type $out-i32) (i32.const 8)) + ) + (func (export "call-9") (type $out-i32) + (call_indirect (type $out-i32) (i32.const 9)) + ) +) + +(register "module1" $module1) + +(assert_trap (invoke $module1 "call-7") "uninitialized element") +(assert_return (invoke $module1 "call-8") (i32.const 65)) +(assert_return (invoke $module1 "call-9") (i32.const 66)) + +(module $module2 + (type $out-i32 (func (result i32))) + (import "module1" "shared-table" (table 10 funcref)) + (elem (i32.const 7) $const-i32-c) + (elem (i32.const 8) $const-i32-d) + (func $const-i32-c (type $out-i32) (i32.const 67)) + (func $const-i32-d (type $out-i32) (i32.const 68)) +) + +(assert_return (invoke $module1 "call-7") (i32.const 67)) +(assert_return (invoke $module1 "call-8") (i32.const 68)) +(assert_return (invoke $module1 "call-9") (i32.const 66)) + +(module $module3 + (type $out-i32 (func (result i32))) + (import "module1" "shared-table" (table 10 funcref)) + (elem (i32.const 8) $const-i32-e) + (elem (i32.const 9) $const-i32-f) + (func $const-i32-e (type $out-i32) (i32.const 69)) + (func $const-i32-f (type $out-i32) (i32.const 70)) +) + +(assert_return (invoke $module1 "call-7") (i32.const 67)) +(assert_return (invoke $module1 "call-8") (i32.const 69)) +(assert_return (invoke $module1 "call-9") (i32.const 70)) diff --git a/runtime/near-vm/tests/wast/spec/proposals/bulk-memory-operations/imports.wast b/runtime/near-vm/tests/wast/spec/proposals/bulk-memory-operations/imports.wast new file mode 100644 index 00000000000..d987775ecb6 --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/proposals/bulk-memory-operations/imports.wast @@ -0,0 +1,593 @@ +;; Auxiliary module to import from + +(module + (func (export "func")) + (func (export "func-i32") (param i32)) + (func (export "func-f32") (param f32)) + (func (export "func->i32") (result i32) (i32.const 22)) + (func (export "func->f32") (result f32) (f32.const 11)) + (func (export "func-i32->i32") (param i32) (result i32) (local.get 0)) + (func (export "func-i64->i64") (param i64) (result i64) (local.get 0)) + (global (export "global-i32") i32 (i32.const 55)) + (global (export "global-f32") f32 (f32.const 44)) + (table (export "table-10-inf") 10 funcref) + ;; (table (export "table-10-20") 10 20 funcref) + (memory (export "memory-2-inf") 2) + ;; (memory (export "memory-2-4") 2 4) +) + +(register "test") + + +;; Functions + +(module + (type $func_i32 (func (param i32))) + (type $func_i64 (func (param i64))) + (type $func_f32 (func (param f32))) + (type $func_f64 (func (param f64))) + + (import "spectest" "print_i32" (func (param i32))) + ;; JavaScript can't handle i64 yet. + ;; (func (import "spectest" "print_i64") (param i64)) + (import "spectest" "print_i32" (func $print_i32 (param i32))) + ;; JavaScript can't handle i64 yet. + ;; (import "spectest" "print_i64" (func $print_i64 (param i64))) + (import "spectest" "print_f32" (func $print_f32 (param f32))) + (import "spectest" "print_f64" (func $print_f64 (param f64))) + (import "spectest" "print_i32_f32" (func $print_i32_f32 (param i32 f32))) + (import "spectest" "print_f64_f64" (func $print_f64_f64 (param f64 f64))) + (func $print_i32-2 (import "spectest" "print_i32") (param i32)) + (func $print_f64-2 (import "spectest" "print_f64") (param f64)) + (import "test" "func-i64->i64" (func $i64->i64 (param i64) (result i64))) + + (func (export "p1") (import "spectest" "print_i32") (param i32)) + (func $p (export "p2") (import "spectest" "print_i32") (param i32)) + (func (export "p3") (export "p4") (import "spectest" "print_i32") (param i32)) + (func (export "p5") (import "spectest" "print_i32") (type 0)) + (func (export "p6") (import "spectest" "print_i32") (type 0) (param i32) (result)) + + (import "spectest" "print_i32" (func (type $forward))) + (func (import "spectest" "print_i32") (type $forward)) + (type $forward (func (param i32))) + + (table funcref (elem $print_i32 $print_f64)) + + (func (export "print32") (param $i i32) + (local $x f32) + (local.set $x (f32.convert_i32_s (local.get $i))) + (call 0 (local.get $i)) + (call $print_i32_f32 + (i32.add (local.get $i) (i32.const 1)) + (f32.const 42) + ) + (call $print_i32 (local.get $i)) + (call $print_i32-2 (local.get $i)) + (call $print_f32 (local.get $x)) + (call_indirect (type $func_i32) (local.get $i) (i32.const 0)) + ) + + (func (export "print64") (param $i i64) + (local $x f64) + (local.set $x (f64.convert_i64_s (call $i64->i64 (local.get $i)))) + ;; JavaScript can't handle i64 yet. + ;; (call 1 (local.get $i)) + (call $print_f64_f64 + (f64.add (local.get $x) (f64.const 1)) + (f64.const 53) + ) + ;; JavaScript can't handle i64 yet. + ;; (call $print_i64 (local.get $i)) + (call $print_f64 (local.get $x)) + (call $print_f64-2 (local.get $x)) + (call_indirect (type $func_f64) (local.get $x) (i32.const 1)) + ) +) + +(assert_return (invoke "print32" (i32.const 13))) +(assert_return (invoke "print64" (i64.const 24))) + +(assert_invalid + (module + (type (func (result i32))) + (import "test" "func" (func (type 1))) + ) + "unknown type" +) + +(module (import "test" "func" (func))) +(module (import "test" "func-i32" (func (param i32)))) +(module (import "test" "func-f32" (func (param f32)))) +(module (import "test" "func->i32" (func (result i32)))) +(module (import "test" "func->f32" (func (result f32)))) +(module (import "test" "func-i32->i32" (func (param i32) (result i32)))) +(module (import "test" "func-i64->i64" (func (param i64) (result i64)))) + +(assert_unlinkable + (module (import "test" "unknown" (func))) + "unknown import" +) +(assert_unlinkable + (module (import "spectest" "unknown" (func))) + "unknown import" +) + +(assert_unlinkable + (module (import "test" "func" (func (param i32)))) + "incompatible import type" +) +(assert_unlinkable + (module (import "test" "func" (func (result i32)))) + "incompatible import type" +) +(assert_unlinkable + (module (import "test" "func" (func (param i32) (result i32)))) + "incompatible import type" +) +(assert_unlinkable + (module (import "test" "func-i32" (func))) + "incompatible import type" +) +(assert_unlinkable + (module (import "test" "func-i32" (func (result i32)))) + "incompatible import type" +) +(assert_unlinkable + (module (import "test" "func-i32" (func (param f32)))) + "incompatible import type" +) +(assert_unlinkable + (module (import "test" "func-i32" (func (param i64)))) + "incompatible import type" +) +(assert_unlinkable + (module (import "test" "func-i32" (func (param i32) (result i32)))) + "incompatible import type" +) +(assert_unlinkable + (module (import "test" "func->i32" (func))) + "incompatible import type" +) +(assert_unlinkable + (module (import "test" "func->i32" (func (param i32)))) + "incompatible import type" +) +(assert_unlinkable + (module (import "test" "func->i32" (func (result f32)))) + "incompatible import type" +) +(assert_unlinkable + (module (import "test" "func->i32" (func (result i64)))) + "incompatible import type" +) +(assert_unlinkable + (module (import "test" "func->i32" (func (param i32) (result i32)))) + "incompatible import type" +) +(assert_unlinkable + (module (import "test" "func-i32->i32" (func))) + "incompatible import type" +) +(assert_unlinkable + (module (import "test" "func-i32->i32" (func (param i32)))) + "incompatible import type" +) +(assert_unlinkable + (module (import "test" "func-i32->i32" (func (result i32)))) + "incompatible import type" +) + +(assert_unlinkable + (module (import "test" "global-i32" (func (result i32)))) + "incompatible import type" +) +(assert_unlinkable + (module (import "test" "table-10-inf" (func))) + "incompatible import type" +) +(assert_unlinkable + (module (import "test" "memory-2-inf" (func))) + "incompatible import type" +) +(assert_unlinkable + (module (import "spectest" "global_i32" (func))) + "incompatible import type" +) +(assert_unlinkable + (module (import "spectest" "table" (func))) + "incompatible import type" +) +(assert_unlinkable + (module (import "spectest" "memory" (func))) + "incompatible import type" +) + + +;; Globals + +(module + (import "spectest" "global_i32" (global i32)) + (global (import "spectest" "global_i32") i32) + + (import "spectest" "global_i32" (global $x i32)) + (global $y (import "spectest" "global_i32") i32) + + ;; JavaScript can't handle i64 yet. + ;; (import "spectest" "global_i64" (global i64)) + (import "spectest" "global_f32" (global f32)) + (import "spectest" "global_f64" (global f64)) + + (func (export "get-0") (result i32) (global.get 0)) + (func (export "get-1") (result i32) (global.get 1)) + (func (export "get-x") (result i32) (global.get $x)) + (func (export "get-y") (result i32) (global.get $y)) +) + +(assert_return (invoke "get-0") (i32.const 666)) +(assert_return (invoke "get-1") (i32.const 666)) +(assert_return (invoke "get-x") (i32.const 666)) +(assert_return (invoke "get-y") (i32.const 666)) + +(module (import "test" "global-i32" (global i32))) +(module (import "test" "global-f32" (global f32))) + +(assert_unlinkable + (module (import "test" "unknown" (global i32))) + "unknown import" +) +(assert_unlinkable + (module (import "spectest" "unknown" (global i32))) + "unknown import" +) + +(assert_unlinkable + (module (import "test" "func" (global i32))) + "incompatible import type" +) +(assert_unlinkable + (module (import "test" "table-10-inf" (global i32))) + "incompatible import type" +) +(assert_unlinkable + (module (import "test" "memory-2-inf" (global i32))) + "incompatible import type" +) +(assert_unlinkable + (module (import "spectest" "print_i32" (global i32))) + "incompatible import type" +) +(assert_unlinkable + (module (import "spectest" "table" (global i32))) + "incompatible import type" +) +(assert_unlinkable + (module (import "spectest" "memory" (global i32))) + "incompatible import type" +) + + +;; Tables + +(module + (type (func (result i32))) + (import "spectest" "table" (table 10 20 funcref)) + (elem (table 0) (i32.const 1) func $f $g) + + (func (export "call") (param i32) (result i32) + (call_indirect (type 0) (local.get 0)) + ) + (func $f (result i32) (i32.const 11)) + (func $g (result i32) (i32.const 22)) +) + +(assert_trap (invoke "call" (i32.const 0)) "uninitialized element") +(assert_return (invoke "call" (i32.const 1)) (i32.const 11)) +(assert_return (invoke "call" (i32.const 2)) (i32.const 22)) +(assert_trap (invoke "call" (i32.const 3)) "uninitialized element") +(assert_trap (invoke "call" (i32.const 100)) "undefined element") + + +(module + (type (func (result i32))) + (table (import "spectest" "table") 10 20 funcref) + (elem (table 0) (i32.const 1) func $f $g) + + (func (export "call") (param i32) (result i32) + (call_indirect (type 0) (local.get 0)) + ) + (func $f (result i32) (i32.const 11)) + (func $g (result i32) (i32.const 22)) +) + +(assert_trap (invoke "call" (i32.const 0)) "uninitialized element") +(assert_return (invoke "call" (i32.const 1)) (i32.const 11)) +(assert_return (invoke "call" (i32.const 2)) (i32.const 22)) +(assert_trap (invoke "call" (i32.const 3)) "uninitialized element") +(assert_trap (invoke "call" (i32.const 100)) "undefined element") + + +(assert_invalid + (module (import "" "" (table 10 funcref)) (import "" "" (table 10 funcref))) + "multiple tables" +) +(assert_invalid + (module (import "" "" (table 10 funcref)) (table 10 funcref)) + "multiple tables" +) +(assert_invalid + (module (table 10 funcref) (table 10 funcref)) + "multiple tables" +) + +(module (import "test" "table-10-inf" (table 10 funcref))) +(module (import "test" "table-10-inf" (table 5 funcref))) +(module (import "test" "table-10-inf" (table 0 funcref))) +(module (import "spectest" "table" (table 10 funcref))) +(module (import "spectest" "table" (table 5 funcref))) +(module (import "spectest" "table" (table 0 funcref))) +(module (import "spectest" "table" (table 10 20 funcref))) +(module (import "spectest" "table" (table 5 20 funcref))) +(module (import "spectest" "table" (table 0 20 funcref))) +(module (import "spectest" "table" (table 10 25 funcref))) +(module (import "spectest" "table" (table 5 25 funcref))) + +(assert_unlinkable + (module (import "test" "unknown" (table 10 funcref))) + "unknown import" +) +(assert_unlinkable + (module (import "spectest" "unknown" (table 10 funcref))) + "unknown import" +) + +(assert_unlinkable + (module (import "test" "table-10-inf" (table 12 funcref))) + "incompatible import type" +) +(assert_unlinkable + (module (import "test" "table-10-inf" (table 10 20 funcref))) + "incompatible import type" +) +(assert_unlinkable + (module (import "spectest" "table" (table 12 funcref))) + "incompatible import type" +) +(assert_unlinkable + (module (import "spectest" "table" (table 10 15 funcref))) + "incompatible import type" +) + +(assert_unlinkable + (module (import "test" "func" (table 10 funcref))) + "incompatible import type" +) +(assert_unlinkable + (module (import "test" "global-i32" (table 10 funcref))) + "incompatible import type" +) +(assert_unlinkable + (module (import "test" "memory-2-inf" (table 10 funcref))) + "incompatible import type" +) +(assert_unlinkable + (module (import "spectest" "print_i32" (table 10 funcref))) + "incompatible import type" +) + + + +;; Memories + +(module + (import "spectest" "memory" (memory 1 2)) + (data (memory 0) (i32.const 10) "\10") + + (func (export "load") (param i32) (result i32) (i32.load (local.get 0))) +) + +(assert_return (invoke "load" (i32.const 0)) (i32.const 0)) +(assert_return (invoke "load" (i32.const 10)) (i32.const 16)) +(assert_return (invoke "load" (i32.const 8)) (i32.const 0x100000)) +(assert_trap (invoke "load" (i32.const 1000000)) "out of bounds memory access") + +(module + (memory (import "spectest" "memory") 1 2) + (data (memory 0) (i32.const 10) "\10") + + (func (export "load") (param i32) (result i32) (i32.load (local.get 0))) +) +(assert_return (invoke "load" (i32.const 0)) (i32.const 0)) +(assert_return (invoke "load" (i32.const 10)) (i32.const 16)) +(assert_return (invoke "load" (i32.const 8)) (i32.const 0x100000)) +(assert_trap (invoke "load" (i32.const 1000000)) "out of bounds memory access") + +(assert_invalid + (module (import "" "" (memory 1)) (import "" "" (memory 1))) + "multiple memories" +) +(assert_invalid + (module (import "" "" (memory 1)) (memory 0)) + "multiple memories" +) +(assert_invalid + (module (memory 0) (memory 0)) + "multiple memories" +) + +(module (import "test" "memory-2-inf" (memory 2))) +(module (import "test" "memory-2-inf" (memory 1))) +(module (import "test" "memory-2-inf" (memory 0))) +(module (import "spectest" "memory" (memory 1))) +(module (import "spectest" "memory" (memory 0))) +(module (import "spectest" "memory" (memory 1 2))) +(module (import "spectest" "memory" (memory 0 2))) +(module (import "spectest" "memory" (memory 1 3))) +(module (import "spectest" "memory" (memory 0 3))) + +(assert_unlinkable + (module (import "test" "unknown" (memory 1))) + "unknown import" +) +(assert_unlinkable + (module (import "spectest" "unknown" (memory 1))) + "unknown import" +) + +(assert_unlinkable + (module (import "test" "memory-2-inf" (memory 3))) + "incompatible import type" +) +(assert_unlinkable + (module (import "test" "memory-2-inf" (memory 2 3))) + "incompatible import type" +) +(assert_unlinkable + (module (import "spectest" "memory" (memory 2))) + "incompatible import type" +) +(assert_unlinkable + (module (import "spectest" "memory" (memory 1 1))) + "incompatible import type" +) + +(assert_unlinkable + (module (import "test" "func-i32" (memory 1))) + "incompatible import type" +) +(assert_unlinkable + (module (import "test" "global-i32" (memory 1))) + "incompatible import type" +) +(assert_unlinkable + (module (import "test" "table-10-inf" (memory 1))) + "incompatible import type" +) +(assert_unlinkable + (module (import "spectest" "print_i32" (memory 1))) + "incompatible import type" +) +(assert_unlinkable + (module (import "spectest" "global_i32" (memory 1))) + "incompatible import type" +) +(assert_unlinkable + (module (import "spectest" "table" (memory 1))) + "incompatible import type" +) + +(assert_unlinkable + (module (import "spectest" "memory" (memory 2))) + "incompatible import type" +) +(assert_unlinkable + (module (import "spectest" "memory" (memory 1 1))) + "incompatible import type" +) + +(module + (import "spectest" "memory" (memory 0 3)) ;; actual has max size 2 + (func (export "grow") (param i32) (result i32) (memory.grow (local.get 0))) +) +(assert_return (invoke "grow" (i32.const 0)) (i32.const 1)) +(assert_return (invoke "grow" (i32.const 1)) (i32.const 1)) +(assert_return (invoke "grow" (i32.const 0)) (i32.const 2)) +(assert_return (invoke "grow" (i32.const 1)) (i32.const -1)) +(assert_return (invoke "grow" (i32.const 0)) (i32.const 2)) + + +;; Syntax errors + +(assert_malformed + (module quote "(func) (import \"\" \"\" (func))") + "import after function" +) +(assert_malformed + (module quote "(func) (import \"\" \"\" (global i64))") + "import after function" +) +(assert_malformed + (module quote "(func) (import \"\" \"\" (table 0 funcref))") + "import after function" +) +(assert_malformed + (module quote "(func) (import \"\" \"\" (memory 0))") + "import after function" +) + +(assert_malformed + (module quote "(global i64 (i64.const 0)) (import \"\" \"\" (func))") + "import after global" +) +(assert_malformed + (module quote "(global i64 (i64.const 0)) (import \"\" \"\" (global f32))") + "import after global" +) +(assert_malformed + (module quote "(global i64 (i64.const 0)) (import \"\" \"\" (table 0 funcref))") + "import after global" +) +(assert_malformed + (module quote "(global i64 (i64.const 0)) (import \"\" \"\" (memory 0))") + "import after global" +) + +(assert_malformed + (module quote "(table 0 funcref) (import \"\" \"\" (func))") + "import after table" +) +(assert_malformed + (module quote "(table 0 funcref) (import \"\" \"\" (global i32))") + "import after table" +) +(assert_malformed + (module quote "(table 0 funcref) (import \"\" \"\" (table 0 funcref))") + "import after table" +) +(assert_malformed + (module quote "(table 0 funcref) (import \"\" \"\" (memory 0))") + "import after table" +) + +(assert_malformed + (module quote "(memory 0) (import \"\" \"\" (func))") + "import after memory" +) +(assert_malformed + (module quote "(memory 0) (import \"\" \"\" (global i32))") + "import after memory" +) +(assert_malformed + (module quote "(memory 0) (import \"\" \"\" (table 1 3 funcref))") + "import after memory" +) +(assert_malformed + (module quote "(memory 0) (import \"\" \"\" (memory 1 2))") + "import after memory" +) + +;; This module is required to validate, regardless of whether it can be +;; linked. Overloading is not possible in wasm itself, but it is possible +;; in modules from which wasm can import. +(module) +(register "not wasm") +(assert_unlinkable + (module + (import "not wasm" "overloaded" (func)) + (import "not wasm" "overloaded" (func (param i32))) + (import "not wasm" "overloaded" (func (param i32 i32))) + (import "not wasm" "overloaded" (func (param i64))) + (import "not wasm" "overloaded" (func (param f32))) + (import "not wasm" "overloaded" (func (param f64))) + (import "not wasm" "overloaded" (func (result i32))) + (import "not wasm" "overloaded" (func (result i64))) + (import "not wasm" "overloaded" (func (result f32))) + (import "not wasm" "overloaded" (func (result f64))) + (import "not wasm" "overloaded" (global i32)) + (import "not wasm" "overloaded" (global i64)) + (import "not wasm" "overloaded" (global f32)) + (import "not wasm" "overloaded" (global f64)) + (import "not wasm" "overloaded" (table 0 funcref)) + (import "not wasm" "overloaded" (memory 0)) + ) + "unknown import" +) diff --git a/runtime/near-vm/tests/wast/spec/proposals/bulk-memory-operations/linking.wast b/runtime/near-vm/tests/wast/spec/proposals/bulk-memory-operations/linking.wast new file mode 100644 index 00000000000..2d92078f9a2 --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/proposals/bulk-memory-operations/linking.wast @@ -0,0 +1,392 @@ +;; Functions + +(module $Mf + (func (export "call") (result i32) (call $g)) + (func $g (result i32) (i32.const 2)) +) +(register "Mf" $Mf) + +(module $Nf + (func $f (import "Mf" "call") (result i32)) + (export "Mf.call" (func $f)) + (func (export "call Mf.call") (result i32) (call $f)) + (func (export "call") (result i32) (call $g)) + (func $g (result i32) (i32.const 3)) +) + +(assert_return (invoke $Mf "call") (i32.const 2)) +(assert_return (invoke $Nf "Mf.call") (i32.const 2)) +(assert_return (invoke $Nf "call") (i32.const 3)) +(assert_return (invoke $Nf "call Mf.call") (i32.const 2)) + +(module + (import "spectest" "print_i32" (func $f (param i32))) + (export "print" (func $f)) +) +(register "reexport_f") +(assert_unlinkable + (module (import "reexport_f" "print" (func (param i64)))) + "incompatible import type" +) +(assert_unlinkable + (module (import "reexport_f" "print" (func (param i32) (result i32)))) + "incompatible import type" +) + + +;; Globals + +(module $Mg + (global $glob (export "glob") i32 (i32.const 42)) + (func (export "get") (result i32) (global.get $glob)) + + ;; export mutable globals + (global $mut_glob (export "mut_glob") (mut i32) (i32.const 142)) + (func (export "get_mut") (result i32) (global.get $mut_glob)) + (func (export "set_mut") (param i32) (global.set $mut_glob (local.get 0))) +) +(register "Mg" $Mg) + +(module $Ng + (global $x (import "Mg" "glob") i32) + (global $mut_glob (import "Mg" "mut_glob") (mut i32)) + (func $f (import "Mg" "get") (result i32)) + (func $get_mut (import "Mg" "get_mut") (result i32)) + (func $set_mut (import "Mg" "set_mut") (param i32)) + + (export "Mg.glob" (global $x)) + (export "Mg.get" (func $f)) + (global $glob (export "glob") i32 (i32.const 43)) + (func (export "get") (result i32) (global.get $glob)) + + (export "Mg.mut_glob" (global $mut_glob)) + (export "Mg.get_mut" (func $get_mut)) + (export "Mg.set_mut" (func $set_mut)) +) + +(assert_return (get $Mg "glob") (i32.const 42)) +(assert_return (get $Ng "Mg.glob") (i32.const 42)) +(assert_return (get $Ng "glob") (i32.const 43)) +(assert_return (invoke $Mg "get") (i32.const 42)) +(assert_return (invoke $Ng "Mg.get") (i32.const 42)) +(assert_return (invoke $Ng "get") (i32.const 43)) + +(assert_return (get $Mg "mut_glob") (i32.const 142)) +(assert_return (get $Ng "Mg.mut_glob") (i32.const 142)) +(assert_return (invoke $Mg "get_mut") (i32.const 142)) +(assert_return (invoke $Ng "Mg.get_mut") (i32.const 142)) + +(assert_return (invoke $Mg "set_mut" (i32.const 241))) +(assert_return (get $Mg "mut_glob") (i32.const 241)) +(assert_return (get $Ng "Mg.mut_glob") (i32.const 241)) +(assert_return (invoke $Mg "get_mut") (i32.const 241)) +(assert_return (invoke $Ng "Mg.get_mut") (i32.const 241)) + + +(assert_unlinkable + (module (import "Mg" "mut_glob" (global i32))) + "incompatible import type" +) +(assert_unlinkable + (module (import "Mg" "glob" (global (mut i32)))) + "incompatible import type" +) + +;; Tables + +(module $Mt + (type (func (result i32))) + (type (func)) + + (table (export "tab") 10 funcref) + (elem (i32.const 2) $g $g $g $g) + (func $g (result i32) (i32.const 4)) + (func (export "h") (result i32) (i32.const -4)) + + (func (export "call") (param i32) (result i32) + (call_indirect (type 0) (local.get 0)) + ) +) +(register "Mt" $Mt) + +(module $Nt + (type (func)) + (type (func (result i32))) + + (func $f (import "Mt" "call") (param i32) (result i32)) + (func $h (import "Mt" "h") (result i32)) + + (table funcref (elem $g $g $g $h $f)) + (func $g (result i32) (i32.const 5)) + + (export "Mt.call" (func $f)) + (func (export "call Mt.call") (param i32) (result i32) + (call $f (local.get 0)) + ) + (func (export "call") (param i32) (result i32) + (call_indirect (type 1) (local.get 0)) + ) +) + +(assert_return (invoke $Mt "call" (i32.const 2)) (i32.const 4)) +(assert_return (invoke $Nt "Mt.call" (i32.const 2)) (i32.const 4)) +(assert_return (invoke $Nt "call" (i32.const 2)) (i32.const 5)) +(assert_return (invoke $Nt "call Mt.call" (i32.const 2)) (i32.const 4)) + +(assert_trap (invoke $Mt "call" (i32.const 1)) "uninitialized") +(assert_trap (invoke $Nt "Mt.call" (i32.const 1)) "uninitialized") +(assert_return (invoke $Nt "call" (i32.const 1)) (i32.const 5)) +(assert_trap (invoke $Nt "call Mt.call" (i32.const 1)) "uninitialized") + +(assert_trap (invoke $Mt "call" (i32.const 0)) "uninitialized") +(assert_trap (invoke $Nt "Mt.call" (i32.const 0)) "uninitialized") +(assert_return (invoke $Nt "call" (i32.const 0)) (i32.const 5)) +(assert_trap (invoke $Nt "call Mt.call" (i32.const 0)) "uninitialized") + +(assert_trap (invoke $Mt "call" (i32.const 20)) "undefined") +(assert_trap (invoke $Nt "Mt.call" (i32.const 20)) "undefined") +(assert_trap (invoke $Nt "call" (i32.const 7)) "undefined") +(assert_trap (invoke $Nt "call Mt.call" (i32.const 20)) "undefined") + +(assert_return (invoke $Nt "call" (i32.const 3)) (i32.const -4)) +(assert_trap (invoke $Nt "call" (i32.const 4)) "indirect call") + +(module $Ot + (type (func (result i32))) + + (func $h (import "Mt" "h") (result i32)) + (table (import "Mt" "tab") 5 funcref) + (elem (i32.const 1) $i $h) + (func $i (result i32) (i32.const 6)) + + (func (export "call") (param i32) (result i32) + (call_indirect (type 0) (local.get 0)) + ) +) + +(assert_return (invoke $Mt "call" (i32.const 3)) (i32.const 4)) +(assert_return (invoke $Nt "Mt.call" (i32.const 3)) (i32.const 4)) +(assert_return (invoke $Nt "call Mt.call" (i32.const 3)) (i32.const 4)) +(assert_return (invoke $Ot "call" (i32.const 3)) (i32.const 4)) + +(assert_return (invoke $Mt "call" (i32.const 2)) (i32.const -4)) +(assert_return (invoke $Nt "Mt.call" (i32.const 2)) (i32.const -4)) +(assert_return (invoke $Nt "call" (i32.const 2)) (i32.const 5)) +(assert_return (invoke $Nt "call Mt.call" (i32.const 2)) (i32.const -4)) +(assert_return (invoke $Ot "call" (i32.const 2)) (i32.const -4)) + +(assert_return (invoke $Mt "call" (i32.const 1)) (i32.const 6)) +(assert_return (invoke $Nt "Mt.call" (i32.const 1)) (i32.const 6)) +(assert_return (invoke $Nt "call" (i32.const 1)) (i32.const 5)) +(assert_return (invoke $Nt "call Mt.call" (i32.const 1)) (i32.const 6)) +(assert_return (invoke $Ot "call" (i32.const 1)) (i32.const 6)) + +(assert_trap (invoke $Mt "call" (i32.const 0)) "uninitialized") +(assert_trap (invoke $Nt "Mt.call" (i32.const 0)) "uninitialized") +(assert_return (invoke $Nt "call" (i32.const 0)) (i32.const 5)) +(assert_trap (invoke $Nt "call Mt.call" (i32.const 0)) "uninitialized") +(assert_trap (invoke $Ot "call" (i32.const 0)) "uninitialized") + +(assert_trap (invoke $Ot "call" (i32.const 20)) "undefined") + +(module + (table (import "Mt" "tab") 0 funcref) + (elem (i32.const 9) $f) + (func $f) +) + +(module $G1 (global (export "g") i32 (i32.const 5))) +(register "G1" $G1) +(module $G2 + (global (import "G1" "g") i32) + (global (export "g") i32 (global.get 0)) +) +(assert_return (get $G2 "g") (i32.const 5)) + +(assert_trap + (module + (table (import "Mt" "tab") 0 funcref) + (elem (i32.const 10) $f) + (func $f) + ) + "out of bounds" +) + +(assert_unlinkable + (module + (table (import "Mt" "tab") 10 funcref) + (memory (import "Mt" "mem") 1) ;; does not exist + (func $f (result i32) (i32.const 0)) + (elem (i32.const 7) $f) + (elem (i32.const 9) $f) + ) + "unknown import" +) +(assert_trap (invoke $Mt "call" (i32.const 7)) "uninitialized") + +;; Unlike in the v1 spec, the elements stored before an out-of-bounds access +;; persist after the instantiation failure. +(assert_trap + (module + (table (import "Mt" "tab") 10 funcref) + (func $f (result i32) (i32.const 0)) + (elem (i32.const 7) $f) + (elem (i32.const 12) $f) ;; out of bounds + ) + "out of bounds" +) +(assert_return (invoke $Mt "call" (i32.const 7)) (i32.const 0)) + +(assert_trap + (module + (table (import "Mt" "tab") 10 funcref) + (func $f (result i32) (i32.const 0)) + (elem (i32.const 7) $f) + (memory 1) + (data (i32.const 0x10000) "d") ;; out of bounds + ) + "out of bounds" +) +(assert_return (invoke $Mt "call" (i32.const 7)) (i32.const 0)) + + +;; Memories + +(module $Mm + (memory (export "mem") 1 5) + (data (i32.const 10) "\00\01\02\03\04\05\06\07\08\09") + + (func (export "load") (param $a i32) (result i32) + (i32.load8_u (local.get 0)) + ) +) +(register "Mm" $Mm) + +(module $Nm + (func $loadM (import "Mm" "load") (param i32) (result i32)) + + (memory 1) + (data (i32.const 10) "\f0\f1\f2\f3\f4\f5") + + (export "Mm.load" (func $loadM)) + (func (export "load") (param $a i32) (result i32) + (i32.load8_u (local.get 0)) + ) +) + +(assert_return (invoke $Mm "load" (i32.const 12)) (i32.const 2)) +(assert_return (invoke $Nm "Mm.load" (i32.const 12)) (i32.const 2)) +(assert_return (invoke $Nm "load" (i32.const 12)) (i32.const 0xf2)) + +(module $Om + (memory (import "Mm" "mem") 1) + (data (i32.const 5) "\a0\a1\a2\a3\a4\a5\a6\a7") + + (func (export "load") (param $a i32) (result i32) + (i32.load8_u (local.get 0)) + ) +) + +(assert_return (invoke $Mm "load" (i32.const 12)) (i32.const 0xa7)) +(assert_return (invoke $Nm "Mm.load" (i32.const 12)) (i32.const 0xa7)) +(assert_return (invoke $Nm "load" (i32.const 12)) (i32.const 0xf2)) +(assert_return (invoke $Om "load" (i32.const 12)) (i32.const 0xa7)) + +(module + (memory (import "Mm" "mem") 0) + (data (i32.const 0xffff) "a") +) + +(assert_trap + (module + (memory (import "Mm" "mem") 0) + (data (i32.const 0x10000) "a") + ) + "out of bounds" +) + +(module $Pm + (memory (import "Mm" "mem") 1 8) + + (func (export "grow") (param $a i32) (result i32) + (memory.grow (local.get 0)) + ) +) + +(assert_return (invoke $Pm "grow" (i32.const 0)) (i32.const 1)) +(assert_return (invoke $Pm "grow" (i32.const 2)) (i32.const 1)) +(assert_return (invoke $Pm "grow" (i32.const 0)) (i32.const 3)) +(assert_return (invoke $Pm "grow" (i32.const 1)) (i32.const 3)) +(assert_return (invoke $Pm "grow" (i32.const 1)) (i32.const 4)) +(assert_return (invoke $Pm "grow" (i32.const 0)) (i32.const 5)) +(assert_return (invoke $Pm "grow" (i32.const 1)) (i32.const -1)) +(assert_return (invoke $Pm "grow" (i32.const 0)) (i32.const 5)) + +(assert_unlinkable + (module + (func $host (import "spectest" "print")) + (memory (import "Mm" "mem") 1) + (table (import "Mm" "tab") 0 funcref) ;; does not exist + (data (i32.const 0) "abc") + ) + "unknown import" +) +(assert_return (invoke $Mm "load" (i32.const 0)) (i32.const 0)) + +;; Unlike in v1 spec, bytes written before an out-of-bounds access persist +;; after the instantiation failure. +(assert_trap + (module + (memory (import "Mm" "mem") 1) + (data (i32.const 0) "abc") + (data (i32.const 0x50000) "d") ;; out of bounds + ) + "out of bounds" +) +(assert_return (invoke $Mm "load" (i32.const 0)) (i32.const 97)) + +(assert_trap + (module + (memory (import "Mm" "mem") 1) + (data (i32.const 0) "abc") + (table 0 funcref) + (func) + (elem (i32.const 0) 0) ;; out of bounds + ) + "out of bounds" +) +(assert_return (invoke $Mm "load" (i32.const 0)) (i32.const 97)) + +;; Store is modified if the start function traps. +(module $Ms + (type $t (func (result i32))) + (memory (export "memory") 1) + (table (export "table") 1 funcref) + (func (export "get memory[0]") (type $t) + (i32.load8_u (i32.const 0)) + ) + (func (export "get table[0]") (type $t) + (call_indirect (type $t) (i32.const 0)) + ) +) +(register "Ms" $Ms) + +(assert_trap + (module + (import "Ms" "memory" (memory 1)) + (import "Ms" "table" (table 1 funcref)) + (data (i32.const 0) "hello") + (elem (i32.const 0) $f) + (func $f (result i32) + (i32.const 0xdead) + ) + (func $main + (unreachable) + ) + (start $main) + ) + "unreachable" +) + +(assert_return (invoke $Ms "get memory[0]") (i32.const 104)) ;; 'h' +(assert_return (invoke $Ms "get table[0]") (i32.const 0xdead)) diff --git a/runtime/near-vm/tests/wast/spec/proposals/bulk-memory-operations/memory_copy.wast b/runtime/near-vm/tests/wast/spec/proposals/bulk-memory-operations/memory_copy.wast new file mode 100644 index 00000000000..692e1ad85fb --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/proposals/bulk-memory-operations/memory_copy.wast @@ -0,0 +1,5577 @@ +;; +;; Generated by ../meta/generate_memory_copy.js +;; + +(module + (memory (export "memory0") 1 1) + (data (i32.const 2) "\03\01\04\01") + (data (i32.const 12) "\07\05\02\03\06") + (func (export "test") + (nop)) + (func (export "load8_u") (param i32) (result i32) + (i32.load8_u (local.get 0)))) + +(invoke "test") + +(assert_return (invoke "load8_u" (i32.const 0)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 1)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 2)) (i32.const 3)) +(assert_return (invoke "load8_u" (i32.const 3)) (i32.const 1)) +(assert_return (invoke "load8_u" (i32.const 4)) (i32.const 4)) +(assert_return (invoke "load8_u" (i32.const 5)) (i32.const 1)) +(assert_return (invoke "load8_u" (i32.const 6)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 7)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 8)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 9)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 10)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 11)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 12)) (i32.const 7)) +(assert_return (invoke "load8_u" (i32.const 13)) (i32.const 5)) +(assert_return (invoke "load8_u" (i32.const 14)) (i32.const 2)) +(assert_return (invoke "load8_u" (i32.const 15)) (i32.const 3)) +(assert_return (invoke "load8_u" (i32.const 16)) (i32.const 6)) +(assert_return (invoke "load8_u" (i32.const 17)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 18)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 19)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 20)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 21)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 22)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 23)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 24)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 25)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 26)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 27)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 28)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 29)) (i32.const 0)) + +(module + (memory (export "memory0") 1 1) + (data (i32.const 2) "\03\01\04\01") + (data (i32.const 12) "\07\05\02\03\06") + (func (export "test") + (memory.copy (i32.const 13) (i32.const 2) (i32.const 3))) + (func (export "load8_u") (param i32) (result i32) + (i32.load8_u (local.get 0)))) + +(invoke "test") + +(assert_return (invoke "load8_u" (i32.const 0)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 1)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 2)) (i32.const 3)) +(assert_return (invoke "load8_u" (i32.const 3)) (i32.const 1)) +(assert_return (invoke "load8_u" (i32.const 4)) (i32.const 4)) +(assert_return (invoke "load8_u" (i32.const 5)) (i32.const 1)) +(assert_return (invoke "load8_u" (i32.const 6)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 7)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 8)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 9)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 10)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 11)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 12)) (i32.const 7)) +(assert_return (invoke "load8_u" (i32.const 13)) (i32.const 3)) +(assert_return (invoke "load8_u" (i32.const 14)) (i32.const 1)) +(assert_return (invoke "load8_u" (i32.const 15)) (i32.const 4)) +(assert_return (invoke "load8_u" (i32.const 16)) (i32.const 6)) +(assert_return (invoke "load8_u" (i32.const 17)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 18)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 19)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 20)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 21)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 22)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 23)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 24)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 25)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 26)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 27)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 28)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 29)) (i32.const 0)) + +(module + (memory (export "memory0") 1 1) + (data (i32.const 2) "\03\01\04\01") + (data (i32.const 12) "\07\05\02\03\06") + (func (export "test") + (memory.copy (i32.const 25) (i32.const 15) (i32.const 2))) + (func (export "load8_u") (param i32) (result i32) + (i32.load8_u (local.get 0)))) + +(invoke "test") + +(assert_return (invoke "load8_u" (i32.const 0)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 1)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 2)) (i32.const 3)) +(assert_return (invoke "load8_u" (i32.const 3)) (i32.const 1)) +(assert_return (invoke "load8_u" (i32.const 4)) (i32.const 4)) +(assert_return (invoke "load8_u" (i32.const 5)) (i32.const 1)) +(assert_return (invoke "load8_u" (i32.const 6)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 7)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 8)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 9)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 10)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 11)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 12)) (i32.const 7)) +(assert_return (invoke "load8_u" (i32.const 13)) (i32.const 5)) +(assert_return (invoke "load8_u" (i32.const 14)) (i32.const 2)) +(assert_return (invoke "load8_u" (i32.const 15)) (i32.const 3)) +(assert_return (invoke "load8_u" (i32.const 16)) (i32.const 6)) +(assert_return (invoke "load8_u" (i32.const 17)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 18)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 19)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 20)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 21)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 22)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 23)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 24)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 25)) (i32.const 3)) +(assert_return (invoke "load8_u" (i32.const 26)) (i32.const 6)) +(assert_return (invoke "load8_u" (i32.const 27)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 28)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 29)) (i32.const 0)) + +(module + (memory (export "memory0") 1 1) + (data (i32.const 2) "\03\01\04\01") + (data (i32.const 12) "\07\05\02\03\06") + (func (export "test") + (memory.copy (i32.const 13) (i32.const 25) (i32.const 3))) + (func (export "load8_u") (param i32) (result i32) + (i32.load8_u (local.get 0)))) + +(invoke "test") + +(assert_return (invoke "load8_u" (i32.const 0)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 1)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 2)) (i32.const 3)) +(assert_return (invoke "load8_u" (i32.const 3)) (i32.const 1)) +(assert_return (invoke "load8_u" (i32.const 4)) (i32.const 4)) +(assert_return (invoke "load8_u" (i32.const 5)) (i32.const 1)) +(assert_return (invoke "load8_u" (i32.const 6)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 7)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 8)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 9)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 10)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 11)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 12)) (i32.const 7)) +(assert_return (invoke "load8_u" (i32.const 13)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 14)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 15)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 16)) (i32.const 6)) +(assert_return (invoke "load8_u" (i32.const 17)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 18)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 19)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 20)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 21)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 22)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 23)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 24)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 25)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 26)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 27)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 28)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 29)) (i32.const 0)) + +(module + (memory (export "memory0") 1 1) + (data (i32.const 2) "\03\01\04\01") + (data (i32.const 12) "\07\05\02\03\06") + (func (export "test") + (memory.copy (i32.const 20) (i32.const 22) (i32.const 4))) + (func (export "load8_u") (param i32) (result i32) + (i32.load8_u (local.get 0)))) + +(invoke "test") + +(assert_return (invoke "load8_u" (i32.const 0)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 1)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 2)) (i32.const 3)) +(assert_return (invoke "load8_u" (i32.const 3)) (i32.const 1)) +(assert_return (invoke "load8_u" (i32.const 4)) (i32.const 4)) +(assert_return (invoke "load8_u" (i32.const 5)) (i32.const 1)) +(assert_return (invoke "load8_u" (i32.const 6)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 7)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 8)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 9)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 10)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 11)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 12)) (i32.const 7)) +(assert_return (invoke "load8_u" (i32.const 13)) (i32.const 5)) +(assert_return (invoke "load8_u" (i32.const 14)) (i32.const 2)) +(assert_return (invoke "load8_u" (i32.const 15)) (i32.const 3)) +(assert_return (invoke "load8_u" (i32.const 16)) (i32.const 6)) +(assert_return (invoke "load8_u" (i32.const 17)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 18)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 19)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 20)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 21)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 22)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 23)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 24)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 25)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 26)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 27)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 28)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 29)) (i32.const 0)) + +(module + (memory (export "memory0") 1 1) + (data (i32.const 2) "\03\01\04\01") + (data (i32.const 12) "\07\05\02\03\06") + (func (export "test") + (memory.copy (i32.const 25) (i32.const 1) (i32.const 3))) + (func (export "load8_u") (param i32) (result i32) + (i32.load8_u (local.get 0)))) + +(invoke "test") + +(assert_return (invoke "load8_u" (i32.const 0)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 1)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 2)) (i32.const 3)) +(assert_return (invoke "load8_u" (i32.const 3)) (i32.const 1)) +(assert_return (invoke "load8_u" (i32.const 4)) (i32.const 4)) +(assert_return (invoke "load8_u" (i32.const 5)) (i32.const 1)) +(assert_return (invoke "load8_u" (i32.const 6)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 7)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 8)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 9)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 10)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 11)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 12)) (i32.const 7)) +(assert_return (invoke "load8_u" (i32.const 13)) (i32.const 5)) +(assert_return (invoke "load8_u" (i32.const 14)) (i32.const 2)) +(assert_return (invoke "load8_u" (i32.const 15)) (i32.const 3)) +(assert_return (invoke "load8_u" (i32.const 16)) (i32.const 6)) +(assert_return (invoke "load8_u" (i32.const 17)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 18)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 19)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 20)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 21)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 22)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 23)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 24)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 25)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 26)) (i32.const 3)) +(assert_return (invoke "load8_u" (i32.const 27)) (i32.const 1)) +(assert_return (invoke "load8_u" (i32.const 28)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 29)) (i32.const 0)) + +(module + (memory (export "memory0") 1 1) + (data (i32.const 2) "\03\01\04\01") + (data (i32.const 12) "\07\05\02\03\06") + (func (export "test") + (memory.copy (i32.const 10) (i32.const 12) (i32.const 7))) + (func (export "load8_u") (param i32) (result i32) + (i32.load8_u (local.get 0)))) + +(invoke "test") + +(assert_return (invoke "load8_u" (i32.const 0)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 1)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 2)) (i32.const 3)) +(assert_return (invoke "load8_u" (i32.const 3)) (i32.const 1)) +(assert_return (invoke "load8_u" (i32.const 4)) (i32.const 4)) +(assert_return (invoke "load8_u" (i32.const 5)) (i32.const 1)) +(assert_return (invoke "load8_u" (i32.const 6)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 7)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 8)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 9)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 10)) (i32.const 7)) +(assert_return (invoke "load8_u" (i32.const 11)) (i32.const 5)) +(assert_return (invoke "load8_u" (i32.const 12)) (i32.const 2)) +(assert_return (invoke "load8_u" (i32.const 13)) (i32.const 3)) +(assert_return (invoke "load8_u" (i32.const 14)) (i32.const 6)) +(assert_return (invoke "load8_u" (i32.const 15)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 16)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 17)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 18)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 19)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 20)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 21)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 22)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 23)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 24)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 25)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 26)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 27)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 28)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 29)) (i32.const 0)) + +(module + (memory (export "memory0") 1 1) + (data (i32.const 2) "\03\01\04\01") + (data (i32.const 12) "\07\05\02\03\06") + (func (export "test") + (memory.copy (i32.const 12) (i32.const 10) (i32.const 7))) + (func (export "load8_u") (param i32) (result i32) + (i32.load8_u (local.get 0)))) + +(invoke "test") + +(assert_return (invoke "load8_u" (i32.const 0)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 1)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 2)) (i32.const 3)) +(assert_return (invoke "load8_u" (i32.const 3)) (i32.const 1)) +(assert_return (invoke "load8_u" (i32.const 4)) (i32.const 4)) +(assert_return (invoke "load8_u" (i32.const 5)) (i32.const 1)) +(assert_return (invoke "load8_u" (i32.const 6)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 7)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 8)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 9)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 10)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 11)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 12)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 13)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 14)) (i32.const 7)) +(assert_return (invoke "load8_u" (i32.const 15)) (i32.const 5)) +(assert_return (invoke "load8_u" (i32.const 16)) (i32.const 2)) +(assert_return (invoke "load8_u" (i32.const 17)) (i32.const 3)) +(assert_return (invoke "load8_u" (i32.const 18)) (i32.const 6)) +(assert_return (invoke "load8_u" (i32.const 19)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 20)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 21)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 22)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 23)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 24)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 25)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 26)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 27)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 28)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 29)) (i32.const 0)) + +(module + (memory (export "mem") 1 1 ) + (data (i32.const 0) "\00\01\02\03\04\05\06\07\08\09\0a\0b\0c\0d\0e\0f\10\11\12\13") + (func (export "run") (param $targetOffs i32) (param $srcOffs i32) (param $len i32) + (memory.copy (local.get $targetOffs) (local.get $srcOffs) (local.get $len))) + (func (export "load8_u") (param i32) (result i32) + (i32.load8_u (local.get 0)))) + +(assert_trap (invoke "run" (i32.const 65516) (i32.const 0) (i32.const 40)) + "out of bounds") + +(assert_return (invoke "load8_u" (i32.const 0)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 1)) (i32.const 1)) +(assert_return (invoke "load8_u" (i32.const 2)) (i32.const 2)) +(assert_return (invoke "load8_u" (i32.const 3)) (i32.const 3)) +(assert_return (invoke "load8_u" (i32.const 4)) (i32.const 4)) +(assert_return (invoke "load8_u" (i32.const 5)) (i32.const 5)) +(assert_return (invoke "load8_u" (i32.const 6)) (i32.const 6)) +(assert_return (invoke "load8_u" (i32.const 7)) (i32.const 7)) +(assert_return (invoke "load8_u" (i32.const 8)) (i32.const 8)) +(assert_return (invoke "load8_u" (i32.const 9)) (i32.const 9)) +(assert_return (invoke "load8_u" (i32.const 10)) (i32.const 10)) +(assert_return (invoke "load8_u" (i32.const 11)) (i32.const 11)) +(assert_return (invoke "load8_u" (i32.const 12)) (i32.const 12)) +(assert_return (invoke "load8_u" (i32.const 13)) (i32.const 13)) +(assert_return (invoke "load8_u" (i32.const 14)) (i32.const 14)) +(assert_return (invoke "load8_u" (i32.const 15)) (i32.const 15)) +(assert_return (invoke "load8_u" (i32.const 16)) (i32.const 16)) +(assert_return (invoke "load8_u" (i32.const 17)) (i32.const 17)) +(assert_return (invoke "load8_u" (i32.const 18)) (i32.const 18)) +(assert_return (invoke "load8_u" (i32.const 19)) (i32.const 19)) +(assert_return (invoke "load8_u" (i32.const 218)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 417)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 616)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 815)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 1014)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 1213)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 1412)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 1611)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 1810)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 2009)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 2208)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 2407)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 2606)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 2805)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 3004)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 3203)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 3402)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 3601)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 3800)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 3999)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 4198)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 4397)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 4596)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 4795)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 4994)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 5193)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 5392)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 5591)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 5790)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 5989)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 6188)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 6387)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 6586)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 6785)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 6984)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 7183)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 7382)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 7581)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 7780)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 7979)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 8178)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 8377)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 8576)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 8775)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 8974)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 9173)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 9372)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 9571)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 9770)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 9969)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 10168)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 10367)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 10566)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 10765)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 10964)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 11163)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 11362)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 11561)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 11760)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 11959)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 12158)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 12357)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 12556)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 12755)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 12954)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 13153)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 13352)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 13551)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 13750)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 13949)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 14148)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 14347)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 14546)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 14745)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 14944)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 15143)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 15342)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 15541)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 15740)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 15939)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 16138)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 16337)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 16536)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 16735)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 16934)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 17133)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 17332)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 17531)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 17730)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 17929)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 18128)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 18327)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 18526)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 18725)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 18924)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 19123)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 19322)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 19521)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 19720)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 19919)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 20118)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 20317)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 20516)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 20715)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 20914)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 21113)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 21312)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 21511)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 21710)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 21909)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 22108)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 22307)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 22506)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 22705)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 22904)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 23103)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 23302)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 23501)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 23700)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 23899)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 24098)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 24297)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 24496)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 24695)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 24894)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 25093)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 25292)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 25491)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 25690)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 25889)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 26088)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 26287)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 26486)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 26685)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 26884)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 27083)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 27282)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 27481)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 27680)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 27879)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 28078)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 28277)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 28476)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 28675)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 28874)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 29073)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 29272)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 29471)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 29670)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 29869)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 30068)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 30267)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 30466)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 30665)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 30864)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 31063)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 31262)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 31461)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 31660)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 31859)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 32058)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 32257)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 32456)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 32655)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 32854)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 33053)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 33252)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 33451)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 33650)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 33849)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 34048)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 34247)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 34446)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 34645)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 34844)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 35043)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 35242)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 35441)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 35640)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 35839)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 36038)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 36237)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 36436)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 36635)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 36834)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 37033)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 37232)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 37431)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 37630)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 37829)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 38028)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 38227)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 38426)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 38625)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 38824)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 39023)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 39222)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 39421)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 39620)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 39819)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 40018)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 40217)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 40416)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 40615)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 40814)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 41013)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 41212)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 41411)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 41610)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 41809)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 42008)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 42207)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 42406)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 42605)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 42804)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 43003)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 43202)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 43401)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 43600)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 43799)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 43998)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 44197)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 44396)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 44595)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 44794)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 44993)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 45192)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 45391)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 45590)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 45789)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 45988)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 46187)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 46386)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 46585)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 46784)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 46983)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 47182)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 47381)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 47580)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 47779)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 47978)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 48177)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 48376)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 48575)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 48774)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 48973)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 49172)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 49371)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 49570)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 49769)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 49968)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 50167)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 50366)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 50565)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 50764)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 50963)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 51162)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 51361)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 51560)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 51759)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 51958)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 52157)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 52356)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 52555)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 52754)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 52953)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 53152)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 53351)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 53550)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 53749)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 53948)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 54147)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 54346)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 54545)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 54744)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 54943)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 55142)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 55341)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 55540)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 55739)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 55938)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 56137)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 56336)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 56535)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 56734)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 56933)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 57132)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 57331)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 57530)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 57729)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 57928)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 58127)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 58326)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 58525)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 58724)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 58923)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 59122)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 59321)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 59520)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 59719)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 59918)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 60117)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 60316)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 60515)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 60714)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 60913)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 61112)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 61311)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 61510)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 61709)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 61908)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 62107)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 62306)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 62505)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 62704)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 62903)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 63102)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 63301)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 63500)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 63699)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 63898)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 64097)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 64296)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 64495)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 64694)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 64893)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 65092)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 65291)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 65490)) (i32.const 0)) + +(module + (memory (export "mem") 1 1 ) + (data (i32.const 0) "\00\01\02\03\04\05\06\07\08\09\0a\0b\0c\0d\0e\0f\10\11\12\13\14") + (func (export "run") (param $targetOffs i32) (param $srcOffs i32) (param $len i32) + (memory.copy (local.get $targetOffs) (local.get $srcOffs) (local.get $len))) + (func (export "load8_u") (param i32) (result i32) + (i32.load8_u (local.get 0)))) + +(assert_trap (invoke "run" (i32.const 65515) (i32.const 0) (i32.const 39)) + "out of bounds") + +(assert_return (invoke "load8_u" (i32.const 0)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 1)) (i32.const 1)) +(assert_return (invoke "load8_u" (i32.const 2)) (i32.const 2)) +(assert_return (invoke "load8_u" (i32.const 3)) (i32.const 3)) +(assert_return (invoke "load8_u" (i32.const 4)) (i32.const 4)) +(assert_return (invoke "load8_u" (i32.const 5)) (i32.const 5)) +(assert_return (invoke "load8_u" (i32.const 6)) (i32.const 6)) +(assert_return (invoke "load8_u" (i32.const 7)) (i32.const 7)) +(assert_return (invoke "load8_u" (i32.const 8)) (i32.const 8)) +(assert_return (invoke "load8_u" (i32.const 9)) (i32.const 9)) +(assert_return (invoke "load8_u" (i32.const 10)) (i32.const 10)) +(assert_return (invoke "load8_u" (i32.const 11)) (i32.const 11)) +(assert_return (invoke "load8_u" (i32.const 12)) (i32.const 12)) +(assert_return (invoke "load8_u" (i32.const 13)) (i32.const 13)) +(assert_return (invoke "load8_u" (i32.const 14)) (i32.const 14)) +(assert_return (invoke "load8_u" (i32.const 15)) (i32.const 15)) +(assert_return (invoke "load8_u" (i32.const 16)) (i32.const 16)) +(assert_return (invoke "load8_u" (i32.const 17)) (i32.const 17)) +(assert_return (invoke "load8_u" (i32.const 18)) (i32.const 18)) +(assert_return (invoke "load8_u" (i32.const 19)) (i32.const 19)) +(assert_return (invoke "load8_u" (i32.const 20)) (i32.const 20)) +(assert_return (invoke "load8_u" (i32.const 219)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 418)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 617)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 816)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 1015)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 1214)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 1413)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 1612)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 1811)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 2010)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 2209)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 2408)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 2607)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 2806)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 3005)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 3204)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 3403)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 3602)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 3801)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 4000)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 4199)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 4398)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 4597)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 4796)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 4995)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 5194)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 5393)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 5592)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 5791)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 5990)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 6189)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 6388)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 6587)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 6786)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 6985)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 7184)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 7383)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 7582)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 7781)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 7980)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 8179)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 8378)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 8577)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 8776)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 8975)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 9174)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 9373)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 9572)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 9771)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 9970)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 10169)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 10368)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 10567)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 10766)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 10965)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 11164)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 11363)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 11562)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 11761)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 11960)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 12159)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 12358)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 12557)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 12756)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 12955)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 13154)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 13353)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 13552)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 13751)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 13950)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 14149)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 14348)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 14547)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 14746)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 14945)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 15144)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 15343)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 15542)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 15741)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 15940)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 16139)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 16338)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 16537)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 16736)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 16935)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 17134)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 17333)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 17532)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 17731)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 17930)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 18129)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 18328)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 18527)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 18726)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 18925)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 19124)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 19323)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 19522)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 19721)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 19920)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 20119)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 20318)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 20517)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 20716)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 20915)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 21114)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 21313)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 21512)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 21711)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 21910)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 22109)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 22308)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 22507)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 22706)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 22905)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 23104)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 23303)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 23502)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 23701)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 23900)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 24099)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 24298)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 24497)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 24696)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 24895)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 25094)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 25293)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 25492)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 25691)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 25890)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 26089)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 26288)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 26487)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 26686)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 26885)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 27084)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 27283)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 27482)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 27681)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 27880)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 28079)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 28278)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 28477)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 28676)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 28875)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 29074)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 29273)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 29472)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 29671)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 29870)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 30069)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 30268)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 30467)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 30666)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 30865)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 31064)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 31263)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 31462)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 31661)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 31860)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 32059)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 32258)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 32457)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 32656)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 32855)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 33054)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 33253)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 33452)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 33651)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 33850)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 34049)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 34248)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 34447)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 34646)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 34845)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 35044)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 35243)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 35442)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 35641)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 35840)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 36039)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 36238)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 36437)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 36636)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 36835)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 37034)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 37233)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 37432)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 37631)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 37830)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 38029)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 38228)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 38427)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 38626)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 38825)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 39024)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 39223)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 39422)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 39621)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 39820)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 40019)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 40218)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 40417)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 40616)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 40815)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 41014)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 41213)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 41412)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 41611)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 41810)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 42009)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 42208)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 42407)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 42606)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 42805)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 43004)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 43203)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 43402)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 43601)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 43800)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 43999)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 44198)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 44397)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 44596)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 44795)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 44994)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 45193)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 45392)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 45591)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 45790)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 45989)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 46188)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 46387)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 46586)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 46785)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 46984)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 47183)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 47382)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 47581)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 47780)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 47979)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 48178)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 48377)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 48576)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 48775)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 48974)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 49173)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 49372)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 49571)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 49770)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 49969)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 50168)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 50367)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 50566)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 50765)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 50964)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 51163)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 51362)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 51561)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 51760)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 51959)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 52158)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 52357)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 52556)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 52755)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 52954)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 53153)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 53352)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 53551)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 53750)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 53949)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 54148)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 54347)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 54546)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 54745)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 54944)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 55143)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 55342)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 55541)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 55740)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 55939)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 56138)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 56337)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 56536)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 56735)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 56934)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 57133)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 57332)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 57531)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 57730)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 57929)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 58128)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 58327)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 58526)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 58725)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 58924)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 59123)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 59322)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 59521)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 59720)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 59919)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 60118)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 60317)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 60516)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 60715)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 60914)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 61113)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 61312)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 61511)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 61710)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 61909)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 62108)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 62307)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 62506)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 62705)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 62904)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 63103)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 63302)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 63501)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 63700)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 63899)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 64098)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 64297)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 64496)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 64695)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 64894)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 65093)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 65292)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 65491)) (i32.const 0)) + +(module + (memory (export "mem") 1 1 ) + (data (i32.const 65516) "\00\01\02\03\04\05\06\07\08\09\0a\0b\0c\0d\0e\0f\10\11\12\13") + (func (export "run") (param $targetOffs i32) (param $srcOffs i32) (param $len i32) + (memory.copy (local.get $targetOffs) (local.get $srcOffs) (local.get $len))) + (func (export "load8_u") (param i32) (result i32) + (i32.load8_u (local.get 0)))) + +(assert_trap (invoke "run" (i32.const 0) (i32.const 65516) (i32.const 40)) + "out of bounds") + +(assert_return (invoke "load8_u" (i32.const 198)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 397)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 596)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 795)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 994)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 1193)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 1392)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 1591)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 1790)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 1989)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 2188)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 2387)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 2586)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 2785)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 2984)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 3183)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 3382)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 3581)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 3780)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 3979)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 4178)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 4377)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 4576)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 4775)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 4974)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 5173)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 5372)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 5571)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 5770)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 5969)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 6168)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 6367)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 6566)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 6765)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 6964)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 7163)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 7362)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 7561)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 7760)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 7959)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 8158)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 8357)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 8556)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 8755)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 8954)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 9153)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 9352)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 9551)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 9750)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 9949)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 10148)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 10347)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 10546)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 10745)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 10944)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 11143)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 11342)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 11541)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 11740)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 11939)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 12138)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 12337)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 12536)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 12735)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 12934)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 13133)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 13332)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 13531)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 13730)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 13929)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 14128)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 14327)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 14526)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 14725)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 14924)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 15123)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 15322)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 15521)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 15720)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 15919)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 16118)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 16317)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 16516)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 16715)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 16914)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 17113)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 17312)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 17511)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 17710)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 17909)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 18108)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 18307)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 18506)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 18705)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 18904)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 19103)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 19302)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 19501)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 19700)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 19899)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 20098)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 20297)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 20496)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 20695)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 20894)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 21093)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 21292)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 21491)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 21690)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 21889)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 22088)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 22287)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 22486)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 22685)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 22884)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 23083)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 23282)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 23481)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 23680)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 23879)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 24078)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 24277)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 24476)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 24675)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 24874)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 25073)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 25272)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 25471)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 25670)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 25869)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 26068)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 26267)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 26466)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 26665)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 26864)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 27063)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 27262)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 27461)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 27660)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 27859)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 28058)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 28257)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 28456)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 28655)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 28854)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 29053)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 29252)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 29451)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 29650)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 29849)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 30048)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 30247)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 30446)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 30645)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 30844)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 31043)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 31242)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 31441)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 31640)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 31839)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 32038)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 32237)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 32436)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 32635)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 32834)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 33033)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 33232)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 33431)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 33630)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 33829)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 34028)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 34227)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 34426)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 34625)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 34824)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 35023)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 35222)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 35421)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 35620)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 35819)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 36018)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 36217)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 36416)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 36615)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 36814)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 37013)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 37212)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 37411)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 37610)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 37809)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 38008)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 38207)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 38406)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 38605)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 38804)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 39003)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 39202)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 39401)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 39600)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 39799)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 39998)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 40197)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 40396)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 40595)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 40794)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 40993)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 41192)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 41391)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 41590)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 41789)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 41988)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 42187)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 42386)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 42585)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 42784)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 42983)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 43182)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 43381)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 43580)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 43779)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 43978)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 44177)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 44376)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 44575)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 44774)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 44973)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 45172)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 45371)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 45570)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 45769)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 45968)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 46167)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 46366)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 46565)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 46764)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 46963)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 47162)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 47361)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 47560)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 47759)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 47958)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 48157)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 48356)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 48555)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 48754)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 48953)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 49152)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 49351)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 49550)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 49749)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 49948)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 50147)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 50346)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 50545)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 50744)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 50943)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 51142)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 51341)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 51540)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 51739)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 51938)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 52137)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 52336)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 52535)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 52734)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 52933)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 53132)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 53331)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 53530)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 53729)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 53928)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 54127)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 54326)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 54525)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 54724)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 54923)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 55122)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 55321)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 55520)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 55719)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 55918)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 56117)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 56316)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 56515)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 56714)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 56913)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 57112)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 57311)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 57510)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 57709)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 57908)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 58107)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 58306)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 58505)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 58704)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 58903)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 59102)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 59301)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 59500)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 59699)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 59898)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 60097)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 60296)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 60495)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 60694)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 60893)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 61092)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 61291)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 61490)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 61689)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 61888)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 62087)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 62286)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 62485)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 62684)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 62883)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 63082)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 63281)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 63480)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 63679)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 63878)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 64077)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 64276)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 64475)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 64674)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 64873)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 65072)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 65271)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 65470)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 65516)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 65517)) (i32.const 1)) +(assert_return (invoke "load8_u" (i32.const 65518)) (i32.const 2)) +(assert_return (invoke "load8_u" (i32.const 65519)) (i32.const 3)) +(assert_return (invoke "load8_u" (i32.const 65520)) (i32.const 4)) +(assert_return (invoke "load8_u" (i32.const 65521)) (i32.const 5)) +(assert_return (invoke "load8_u" (i32.const 65522)) (i32.const 6)) +(assert_return (invoke "load8_u" (i32.const 65523)) (i32.const 7)) +(assert_return (invoke "load8_u" (i32.const 65524)) (i32.const 8)) +(assert_return (invoke "load8_u" (i32.const 65525)) (i32.const 9)) +(assert_return (invoke "load8_u" (i32.const 65526)) (i32.const 10)) +(assert_return (invoke "load8_u" (i32.const 65527)) (i32.const 11)) +(assert_return (invoke "load8_u" (i32.const 65528)) (i32.const 12)) +(assert_return (invoke "load8_u" (i32.const 65529)) (i32.const 13)) +(assert_return (invoke "load8_u" (i32.const 65530)) (i32.const 14)) +(assert_return (invoke "load8_u" (i32.const 65531)) (i32.const 15)) +(assert_return (invoke "load8_u" (i32.const 65532)) (i32.const 16)) +(assert_return (invoke "load8_u" (i32.const 65533)) (i32.const 17)) +(assert_return (invoke "load8_u" (i32.const 65534)) (i32.const 18)) +(assert_return (invoke "load8_u" (i32.const 65535)) (i32.const 19)) + +(module + (memory (export "mem") 1 1 ) + (data (i32.const 65515) "\00\01\02\03\04\05\06\07\08\09\0a\0b\0c\0d\0e\0f\10\11\12\13\14") + (func (export "run") (param $targetOffs i32) (param $srcOffs i32) (param $len i32) + (memory.copy (local.get $targetOffs) (local.get $srcOffs) (local.get $len))) + (func (export "load8_u") (param i32) (result i32) + (i32.load8_u (local.get 0)))) + +(assert_trap (invoke "run" (i32.const 0) (i32.const 65515) (i32.const 39)) + "out of bounds") + +(assert_return (invoke "load8_u" (i32.const 198)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 397)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 596)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 795)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 994)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 1193)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 1392)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 1591)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 1790)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 1989)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 2188)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 2387)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 2586)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 2785)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 2984)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 3183)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 3382)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 3581)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 3780)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 3979)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 4178)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 4377)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 4576)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 4775)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 4974)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 5173)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 5372)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 5571)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 5770)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 5969)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 6168)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 6367)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 6566)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 6765)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 6964)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 7163)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 7362)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 7561)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 7760)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 7959)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 8158)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 8357)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 8556)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 8755)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 8954)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 9153)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 9352)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 9551)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 9750)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 9949)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 10148)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 10347)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 10546)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 10745)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 10944)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 11143)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 11342)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 11541)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 11740)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 11939)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 12138)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 12337)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 12536)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 12735)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 12934)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 13133)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 13332)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 13531)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 13730)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 13929)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 14128)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 14327)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 14526)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 14725)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 14924)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 15123)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 15322)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 15521)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 15720)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 15919)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 16118)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 16317)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 16516)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 16715)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 16914)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 17113)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 17312)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 17511)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 17710)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 17909)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 18108)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 18307)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 18506)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 18705)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 18904)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 19103)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 19302)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 19501)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 19700)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 19899)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 20098)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 20297)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 20496)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 20695)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 20894)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 21093)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 21292)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 21491)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 21690)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 21889)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 22088)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 22287)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 22486)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 22685)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 22884)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 23083)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 23282)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 23481)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 23680)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 23879)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 24078)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 24277)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 24476)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 24675)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 24874)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 25073)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 25272)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 25471)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 25670)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 25869)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 26068)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 26267)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 26466)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 26665)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 26864)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 27063)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 27262)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 27461)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 27660)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 27859)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 28058)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 28257)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 28456)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 28655)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 28854)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 29053)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 29252)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 29451)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 29650)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 29849)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 30048)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 30247)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 30446)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 30645)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 30844)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 31043)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 31242)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 31441)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 31640)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 31839)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 32038)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 32237)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 32436)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 32635)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 32834)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 33033)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 33232)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 33431)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 33630)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 33829)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 34028)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 34227)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 34426)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 34625)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 34824)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 35023)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 35222)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 35421)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 35620)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 35819)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 36018)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 36217)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 36416)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 36615)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 36814)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 37013)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 37212)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 37411)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 37610)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 37809)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 38008)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 38207)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 38406)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 38605)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 38804)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 39003)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 39202)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 39401)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 39600)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 39799)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 39998)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 40197)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 40396)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 40595)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 40794)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 40993)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 41192)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 41391)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 41590)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 41789)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 41988)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 42187)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 42386)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 42585)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 42784)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 42983)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 43182)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 43381)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 43580)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 43779)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 43978)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 44177)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 44376)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 44575)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 44774)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 44973)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 45172)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 45371)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 45570)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 45769)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 45968)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 46167)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 46366)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 46565)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 46764)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 46963)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 47162)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 47361)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 47560)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 47759)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 47958)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 48157)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 48356)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 48555)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 48754)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 48953)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 49152)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 49351)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 49550)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 49749)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 49948)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 50147)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 50346)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 50545)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 50744)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 50943)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 51142)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 51341)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 51540)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 51739)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 51938)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 52137)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 52336)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 52535)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 52734)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 52933)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 53132)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 53331)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 53530)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 53729)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 53928)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 54127)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 54326)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 54525)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 54724)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 54923)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 55122)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 55321)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 55520)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 55719)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 55918)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 56117)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 56316)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 56515)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 56714)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 56913)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 57112)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 57311)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 57510)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 57709)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 57908)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 58107)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 58306)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 58505)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 58704)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 58903)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 59102)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 59301)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 59500)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 59699)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 59898)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 60097)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 60296)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 60495)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 60694)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 60893)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 61092)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 61291)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 61490)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 61689)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 61888)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 62087)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 62286)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 62485)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 62684)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 62883)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 63082)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 63281)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 63480)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 63679)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 63878)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 64077)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 64276)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 64475)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 64674)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 64873)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 65072)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 65271)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 65470)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 65515)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 65516)) (i32.const 1)) +(assert_return (invoke "load8_u" (i32.const 65517)) (i32.const 2)) +(assert_return (invoke "load8_u" (i32.const 65518)) (i32.const 3)) +(assert_return (invoke "load8_u" (i32.const 65519)) (i32.const 4)) +(assert_return (invoke "load8_u" (i32.const 65520)) (i32.const 5)) +(assert_return (invoke "load8_u" (i32.const 65521)) (i32.const 6)) +(assert_return (invoke "load8_u" (i32.const 65522)) (i32.const 7)) +(assert_return (invoke "load8_u" (i32.const 65523)) (i32.const 8)) +(assert_return (invoke "load8_u" (i32.const 65524)) (i32.const 9)) +(assert_return (invoke "load8_u" (i32.const 65525)) (i32.const 10)) +(assert_return (invoke "load8_u" (i32.const 65526)) (i32.const 11)) +(assert_return (invoke "load8_u" (i32.const 65527)) (i32.const 12)) +(assert_return (invoke "load8_u" (i32.const 65528)) (i32.const 13)) +(assert_return (invoke "load8_u" (i32.const 65529)) (i32.const 14)) +(assert_return (invoke "load8_u" (i32.const 65530)) (i32.const 15)) +(assert_return (invoke "load8_u" (i32.const 65531)) (i32.const 16)) +(assert_return (invoke "load8_u" (i32.const 65532)) (i32.const 17)) +(assert_return (invoke "load8_u" (i32.const 65533)) (i32.const 18)) +(assert_return (invoke "load8_u" (i32.const 65534)) (i32.const 19)) +(assert_return (invoke "load8_u" (i32.const 65535)) (i32.const 20)) + +(module + (memory (export "mem") 1 1 ) + (data (i32.const 65486) "\00\01\02\03\04\05\06\07\08\09\0a\0b\0c\0d\0e\0f\10\11\12\13") + (func (export "run") (param $targetOffs i32) (param $srcOffs i32) (param $len i32) + (memory.copy (local.get $targetOffs) (local.get $srcOffs) (local.get $len))) + (func (export "load8_u") (param i32) (result i32) + (i32.load8_u (local.get 0)))) + +(assert_trap (invoke "run" (i32.const 65516) (i32.const 65486) (i32.const 40)) + "out of bounds") + +(assert_return (invoke "load8_u" (i32.const 198)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 397)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 596)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 795)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 994)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 1193)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 1392)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 1591)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 1790)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 1989)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 2188)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 2387)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 2586)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 2785)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 2984)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 3183)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 3382)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 3581)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 3780)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 3979)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 4178)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 4377)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 4576)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 4775)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 4974)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 5173)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 5372)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 5571)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 5770)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 5969)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 6168)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 6367)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 6566)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 6765)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 6964)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 7163)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 7362)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 7561)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 7760)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 7959)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 8158)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 8357)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 8556)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 8755)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 8954)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 9153)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 9352)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 9551)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 9750)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 9949)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 10148)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 10347)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 10546)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 10745)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 10944)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 11143)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 11342)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 11541)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 11740)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 11939)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 12138)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 12337)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 12536)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 12735)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 12934)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 13133)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 13332)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 13531)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 13730)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 13929)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 14128)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 14327)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 14526)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 14725)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 14924)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 15123)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 15322)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 15521)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 15720)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 15919)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 16118)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 16317)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 16516)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 16715)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 16914)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 17113)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 17312)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 17511)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 17710)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 17909)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 18108)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 18307)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 18506)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 18705)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 18904)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 19103)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 19302)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 19501)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 19700)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 19899)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 20098)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 20297)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 20496)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 20695)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 20894)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 21093)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 21292)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 21491)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 21690)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 21889)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 22088)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 22287)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 22486)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 22685)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 22884)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 23083)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 23282)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 23481)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 23680)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 23879)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 24078)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 24277)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 24476)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 24675)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 24874)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 25073)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 25272)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 25471)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 25670)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 25869)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 26068)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 26267)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 26466)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 26665)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 26864)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 27063)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 27262)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 27461)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 27660)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 27859)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 28058)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 28257)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 28456)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 28655)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 28854)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 29053)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 29252)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 29451)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 29650)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 29849)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 30048)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 30247)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 30446)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 30645)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 30844)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 31043)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 31242)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 31441)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 31640)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 31839)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 32038)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 32237)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 32436)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 32635)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 32834)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 33033)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 33232)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 33431)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 33630)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 33829)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 34028)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 34227)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 34426)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 34625)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 34824)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 35023)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 35222)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 35421)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 35620)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 35819)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 36018)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 36217)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 36416)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 36615)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 36814)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 37013)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 37212)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 37411)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 37610)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 37809)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 38008)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 38207)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 38406)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 38605)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 38804)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 39003)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 39202)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 39401)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 39600)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 39799)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 39998)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 40197)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 40396)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 40595)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 40794)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 40993)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 41192)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 41391)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 41590)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 41789)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 41988)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 42187)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 42386)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 42585)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 42784)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 42983)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 43182)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 43381)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 43580)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 43779)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 43978)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 44177)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 44376)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 44575)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 44774)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 44973)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 45172)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 45371)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 45570)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 45769)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 45968)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 46167)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 46366)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 46565)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 46764)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 46963)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 47162)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 47361)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 47560)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 47759)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 47958)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 48157)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 48356)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 48555)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 48754)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 48953)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 49152)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 49351)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 49550)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 49749)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 49948)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 50147)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 50346)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 50545)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 50744)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 50943)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 51142)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 51341)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 51540)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 51739)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 51938)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 52137)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 52336)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 52535)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 52734)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 52933)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 53132)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 53331)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 53530)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 53729)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 53928)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 54127)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 54326)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 54525)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 54724)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 54923)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 55122)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 55321)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 55520)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 55719)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 55918)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 56117)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 56316)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 56515)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 56714)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 56913)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 57112)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 57311)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 57510)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 57709)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 57908)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 58107)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 58306)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 58505)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 58704)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 58903)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 59102)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 59301)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 59500)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 59699)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 59898)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 60097)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 60296)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 60495)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 60694)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 60893)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 61092)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 61291)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 61490)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 61689)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 61888)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 62087)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 62286)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 62485)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 62684)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 62883)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 63082)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 63281)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 63480)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 63679)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 63878)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 64077)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 64276)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 64475)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 64674)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 64873)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 65072)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 65271)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 65470)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 65486)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 65487)) (i32.const 1)) +(assert_return (invoke "load8_u" (i32.const 65488)) (i32.const 2)) +(assert_return (invoke "load8_u" (i32.const 65489)) (i32.const 3)) +(assert_return (invoke "load8_u" (i32.const 65490)) (i32.const 4)) +(assert_return (invoke "load8_u" (i32.const 65491)) (i32.const 5)) +(assert_return (invoke "load8_u" (i32.const 65492)) (i32.const 6)) +(assert_return (invoke "load8_u" (i32.const 65493)) (i32.const 7)) +(assert_return (invoke "load8_u" (i32.const 65494)) (i32.const 8)) +(assert_return (invoke "load8_u" (i32.const 65495)) (i32.const 9)) +(assert_return (invoke "load8_u" (i32.const 65496)) (i32.const 10)) +(assert_return (invoke "load8_u" (i32.const 65497)) (i32.const 11)) +(assert_return (invoke "load8_u" (i32.const 65498)) (i32.const 12)) +(assert_return (invoke "load8_u" (i32.const 65499)) (i32.const 13)) +(assert_return (invoke "load8_u" (i32.const 65500)) (i32.const 14)) +(assert_return (invoke "load8_u" (i32.const 65501)) (i32.const 15)) +(assert_return (invoke "load8_u" (i32.const 65502)) (i32.const 16)) +(assert_return (invoke "load8_u" (i32.const 65503)) (i32.const 17)) +(assert_return (invoke "load8_u" (i32.const 65504)) (i32.const 18)) +(assert_return (invoke "load8_u" (i32.const 65505)) (i32.const 19)) + +(module + (memory (export "mem") 1 1 ) + (data (i32.const 65516) "\00\01\02\03\04\05\06\07\08\09\0a\0b\0c\0d\0e\0f\10\11\12\13") + (func (export "run") (param $targetOffs i32) (param $srcOffs i32) (param $len i32) + (memory.copy (local.get $targetOffs) (local.get $srcOffs) (local.get $len))) + (func (export "load8_u") (param i32) (result i32) + (i32.load8_u (local.get 0)))) + +(assert_trap (invoke "run" (i32.const 65486) (i32.const 65516) (i32.const 40)) + "out of bounds") + +(assert_return (invoke "load8_u" (i32.const 198)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 397)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 596)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 795)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 994)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 1193)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 1392)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 1591)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 1790)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 1989)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 2188)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 2387)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 2586)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 2785)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 2984)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 3183)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 3382)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 3581)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 3780)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 3979)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 4178)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 4377)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 4576)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 4775)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 4974)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 5173)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 5372)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 5571)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 5770)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 5969)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 6168)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 6367)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 6566)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 6765)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 6964)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 7163)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 7362)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 7561)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 7760)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 7959)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 8158)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 8357)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 8556)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 8755)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 8954)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 9153)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 9352)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 9551)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 9750)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 9949)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 10148)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 10347)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 10546)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 10745)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 10944)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 11143)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 11342)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 11541)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 11740)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 11939)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 12138)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 12337)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 12536)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 12735)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 12934)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 13133)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 13332)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 13531)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 13730)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 13929)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 14128)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 14327)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 14526)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 14725)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 14924)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 15123)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 15322)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 15521)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 15720)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 15919)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 16118)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 16317)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 16516)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 16715)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 16914)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 17113)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 17312)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 17511)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 17710)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 17909)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 18108)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 18307)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 18506)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 18705)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 18904)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 19103)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 19302)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 19501)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 19700)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 19899)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 20098)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 20297)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 20496)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 20695)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 20894)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 21093)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 21292)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 21491)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 21690)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 21889)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 22088)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 22287)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 22486)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 22685)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 22884)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 23083)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 23282)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 23481)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 23680)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 23879)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 24078)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 24277)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 24476)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 24675)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 24874)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 25073)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 25272)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 25471)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 25670)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 25869)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 26068)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 26267)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 26466)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 26665)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 26864)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 27063)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 27262)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 27461)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 27660)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 27859)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 28058)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 28257)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 28456)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 28655)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 28854)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 29053)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 29252)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 29451)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 29650)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 29849)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 30048)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 30247)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 30446)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 30645)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 30844)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 31043)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 31242)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 31441)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 31640)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 31839)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 32038)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 32237)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 32436)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 32635)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 32834)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 33033)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 33232)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 33431)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 33630)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 33829)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 34028)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 34227)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 34426)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 34625)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 34824)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 35023)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 35222)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 35421)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 35620)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 35819)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 36018)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 36217)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 36416)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 36615)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 36814)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 37013)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 37212)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 37411)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 37610)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 37809)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 38008)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 38207)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 38406)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 38605)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 38804)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 39003)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 39202)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 39401)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 39600)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 39799)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 39998)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 40197)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 40396)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 40595)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 40794)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 40993)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 41192)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 41391)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 41590)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 41789)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 41988)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 42187)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 42386)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 42585)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 42784)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 42983)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 43182)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 43381)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 43580)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 43779)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 43978)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 44177)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 44376)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 44575)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 44774)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 44973)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 45172)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 45371)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 45570)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 45769)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 45968)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 46167)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 46366)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 46565)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 46764)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 46963)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 47162)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 47361)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 47560)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 47759)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 47958)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 48157)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 48356)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 48555)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 48754)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 48953)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 49152)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 49351)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 49550)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 49749)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 49948)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 50147)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 50346)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 50545)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 50744)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 50943)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 51142)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 51341)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 51540)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 51739)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 51938)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 52137)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 52336)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 52535)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 52734)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 52933)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 53132)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 53331)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 53530)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 53729)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 53928)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 54127)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 54326)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 54525)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 54724)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 54923)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 55122)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 55321)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 55520)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 55719)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 55918)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 56117)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 56316)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 56515)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 56714)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 56913)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 57112)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 57311)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 57510)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 57709)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 57908)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 58107)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 58306)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 58505)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 58704)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 58903)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 59102)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 59301)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 59500)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 59699)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 59898)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 60097)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 60296)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 60495)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 60694)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 60893)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 61092)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 61291)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 61490)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 61689)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 61888)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 62087)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 62286)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 62485)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 62684)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 62883)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 63082)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 63281)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 63480)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 63679)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 63878)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 64077)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 64276)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 64475)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 64674)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 64873)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 65072)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 65271)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 65470)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 65516)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 65517)) (i32.const 1)) +(assert_return (invoke "load8_u" (i32.const 65518)) (i32.const 2)) +(assert_return (invoke "load8_u" (i32.const 65519)) (i32.const 3)) +(assert_return (invoke "load8_u" (i32.const 65520)) (i32.const 4)) +(assert_return (invoke "load8_u" (i32.const 65521)) (i32.const 5)) +(assert_return (invoke "load8_u" (i32.const 65522)) (i32.const 6)) +(assert_return (invoke "load8_u" (i32.const 65523)) (i32.const 7)) +(assert_return (invoke "load8_u" (i32.const 65524)) (i32.const 8)) +(assert_return (invoke "load8_u" (i32.const 65525)) (i32.const 9)) +(assert_return (invoke "load8_u" (i32.const 65526)) (i32.const 10)) +(assert_return (invoke "load8_u" (i32.const 65527)) (i32.const 11)) +(assert_return (invoke "load8_u" (i32.const 65528)) (i32.const 12)) +(assert_return (invoke "load8_u" (i32.const 65529)) (i32.const 13)) +(assert_return (invoke "load8_u" (i32.const 65530)) (i32.const 14)) +(assert_return (invoke "load8_u" (i32.const 65531)) (i32.const 15)) +(assert_return (invoke "load8_u" (i32.const 65532)) (i32.const 16)) +(assert_return (invoke "load8_u" (i32.const 65533)) (i32.const 17)) +(assert_return (invoke "load8_u" (i32.const 65534)) (i32.const 18)) +(assert_return (invoke "load8_u" (i32.const 65535)) (i32.const 19)) + +(module + (memory (export "mem") 1 1 ) + (data (i32.const 65506) "\00\01\02\03\04\05\06\07\08\09\0a\0b\0c\0d\0e\0f\10\11\12\13") + (func (export "run") (param $targetOffs i32) (param $srcOffs i32) (param $len i32) + (memory.copy (local.get $targetOffs) (local.get $srcOffs) (local.get $len))) + (func (export "load8_u") (param i32) (result i32) + (i32.load8_u (local.get 0)))) + +(assert_trap (invoke "run" (i32.const 65516) (i32.const 65506) (i32.const 40)) + "out of bounds") + +(assert_return (invoke "load8_u" (i32.const 198)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 397)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 596)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 795)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 994)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 1193)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 1392)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 1591)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 1790)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 1989)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 2188)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 2387)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 2586)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 2785)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 2984)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 3183)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 3382)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 3581)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 3780)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 3979)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 4178)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 4377)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 4576)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 4775)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 4974)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 5173)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 5372)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 5571)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 5770)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 5969)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 6168)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 6367)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 6566)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 6765)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 6964)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 7163)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 7362)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 7561)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 7760)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 7959)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 8158)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 8357)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 8556)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 8755)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 8954)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 9153)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 9352)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 9551)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 9750)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 9949)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 10148)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 10347)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 10546)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 10745)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 10944)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 11143)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 11342)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 11541)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 11740)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 11939)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 12138)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 12337)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 12536)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 12735)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 12934)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 13133)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 13332)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 13531)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 13730)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 13929)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 14128)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 14327)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 14526)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 14725)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 14924)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 15123)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 15322)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 15521)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 15720)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 15919)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 16118)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 16317)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 16516)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 16715)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 16914)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 17113)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 17312)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 17511)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 17710)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 17909)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 18108)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 18307)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 18506)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 18705)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 18904)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 19103)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 19302)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 19501)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 19700)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 19899)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 20098)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 20297)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 20496)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 20695)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 20894)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 21093)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 21292)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 21491)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 21690)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 21889)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 22088)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 22287)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 22486)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 22685)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 22884)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 23083)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 23282)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 23481)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 23680)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 23879)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 24078)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 24277)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 24476)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 24675)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 24874)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 25073)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 25272)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 25471)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 25670)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 25869)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 26068)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 26267)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 26466)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 26665)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 26864)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 27063)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 27262)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 27461)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 27660)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 27859)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 28058)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 28257)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 28456)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 28655)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 28854)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 29053)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 29252)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 29451)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 29650)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 29849)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 30048)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 30247)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 30446)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 30645)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 30844)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 31043)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 31242)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 31441)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 31640)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 31839)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 32038)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 32237)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 32436)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 32635)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 32834)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 33033)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 33232)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 33431)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 33630)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 33829)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 34028)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 34227)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 34426)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 34625)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 34824)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 35023)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 35222)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 35421)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 35620)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 35819)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 36018)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 36217)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 36416)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 36615)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 36814)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 37013)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 37212)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 37411)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 37610)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 37809)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 38008)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 38207)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 38406)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 38605)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 38804)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 39003)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 39202)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 39401)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 39600)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 39799)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 39998)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 40197)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 40396)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 40595)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 40794)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 40993)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 41192)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 41391)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 41590)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 41789)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 41988)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 42187)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 42386)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 42585)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 42784)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 42983)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 43182)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 43381)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 43580)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 43779)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 43978)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 44177)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 44376)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 44575)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 44774)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 44973)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 45172)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 45371)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 45570)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 45769)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 45968)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 46167)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 46366)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 46565)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 46764)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 46963)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 47162)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 47361)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 47560)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 47759)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 47958)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 48157)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 48356)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 48555)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 48754)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 48953)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 49152)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 49351)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 49550)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 49749)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 49948)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 50147)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 50346)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 50545)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 50744)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 50943)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 51142)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 51341)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 51540)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 51739)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 51938)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 52137)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 52336)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 52535)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 52734)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 52933)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 53132)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 53331)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 53530)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 53729)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 53928)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 54127)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 54326)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 54525)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 54724)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 54923)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 55122)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 55321)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 55520)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 55719)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 55918)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 56117)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 56316)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 56515)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 56714)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 56913)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 57112)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 57311)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 57510)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 57709)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 57908)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 58107)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 58306)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 58505)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 58704)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 58903)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 59102)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 59301)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 59500)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 59699)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 59898)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 60097)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 60296)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 60495)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 60694)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 60893)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 61092)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 61291)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 61490)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 61689)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 61888)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 62087)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 62286)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 62485)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 62684)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 62883)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 63082)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 63281)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 63480)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 63679)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 63878)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 64077)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 64276)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 64475)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 64674)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 64873)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 65072)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 65271)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 65470)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 65506)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 65507)) (i32.const 1)) +(assert_return (invoke "load8_u" (i32.const 65508)) (i32.const 2)) +(assert_return (invoke "load8_u" (i32.const 65509)) (i32.const 3)) +(assert_return (invoke "load8_u" (i32.const 65510)) (i32.const 4)) +(assert_return (invoke "load8_u" (i32.const 65511)) (i32.const 5)) +(assert_return (invoke "load8_u" (i32.const 65512)) (i32.const 6)) +(assert_return (invoke "load8_u" (i32.const 65513)) (i32.const 7)) +(assert_return (invoke "load8_u" (i32.const 65514)) (i32.const 8)) +(assert_return (invoke "load8_u" (i32.const 65515)) (i32.const 9)) +(assert_return (invoke "load8_u" (i32.const 65516)) (i32.const 10)) +(assert_return (invoke "load8_u" (i32.const 65517)) (i32.const 11)) +(assert_return (invoke "load8_u" (i32.const 65518)) (i32.const 12)) +(assert_return (invoke "load8_u" (i32.const 65519)) (i32.const 13)) +(assert_return (invoke "load8_u" (i32.const 65520)) (i32.const 14)) +(assert_return (invoke "load8_u" (i32.const 65521)) (i32.const 15)) +(assert_return (invoke "load8_u" (i32.const 65522)) (i32.const 16)) +(assert_return (invoke "load8_u" (i32.const 65523)) (i32.const 17)) +(assert_return (invoke "load8_u" (i32.const 65524)) (i32.const 18)) +(assert_return (invoke "load8_u" (i32.const 65525)) (i32.const 19)) + +(module + (memory (export "mem") 1 1 ) + (data (i32.const 65516) "\00\01\02\03\04\05\06\07\08\09\0a\0b\0c\0d\0e\0f\10\11\12\13") + (func (export "run") (param $targetOffs i32) (param $srcOffs i32) (param $len i32) + (memory.copy (local.get $targetOffs) (local.get $srcOffs) (local.get $len))) + (func (export "load8_u") (param i32) (result i32) + (i32.load8_u (local.get 0)))) + +(assert_trap (invoke "run" (i32.const 65506) (i32.const 65516) (i32.const 40)) + "out of bounds") + +(assert_return (invoke "load8_u" (i32.const 198)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 397)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 596)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 795)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 994)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 1193)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 1392)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 1591)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 1790)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 1989)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 2188)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 2387)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 2586)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 2785)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 2984)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 3183)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 3382)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 3581)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 3780)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 3979)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 4178)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 4377)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 4576)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 4775)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 4974)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 5173)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 5372)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 5571)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 5770)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 5969)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 6168)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 6367)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 6566)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 6765)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 6964)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 7163)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 7362)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 7561)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 7760)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 7959)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 8158)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 8357)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 8556)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 8755)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 8954)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 9153)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 9352)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 9551)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 9750)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 9949)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 10148)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 10347)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 10546)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 10745)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 10944)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 11143)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 11342)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 11541)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 11740)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 11939)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 12138)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 12337)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 12536)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 12735)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 12934)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 13133)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 13332)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 13531)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 13730)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 13929)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 14128)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 14327)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 14526)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 14725)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 14924)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 15123)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 15322)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 15521)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 15720)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 15919)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 16118)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 16317)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 16516)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 16715)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 16914)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 17113)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 17312)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 17511)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 17710)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 17909)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 18108)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 18307)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 18506)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 18705)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 18904)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 19103)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 19302)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 19501)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 19700)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 19899)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 20098)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 20297)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 20496)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 20695)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 20894)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 21093)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 21292)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 21491)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 21690)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 21889)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 22088)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 22287)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 22486)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 22685)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 22884)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 23083)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 23282)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 23481)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 23680)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 23879)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 24078)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 24277)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 24476)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 24675)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 24874)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 25073)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 25272)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 25471)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 25670)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 25869)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 26068)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 26267)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 26466)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 26665)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 26864)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 27063)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 27262)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 27461)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 27660)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 27859)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 28058)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 28257)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 28456)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 28655)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 28854)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 29053)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 29252)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 29451)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 29650)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 29849)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 30048)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 30247)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 30446)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 30645)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 30844)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 31043)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 31242)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 31441)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 31640)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 31839)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 32038)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 32237)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 32436)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 32635)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 32834)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 33033)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 33232)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 33431)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 33630)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 33829)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 34028)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 34227)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 34426)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 34625)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 34824)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 35023)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 35222)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 35421)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 35620)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 35819)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 36018)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 36217)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 36416)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 36615)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 36814)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 37013)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 37212)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 37411)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 37610)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 37809)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 38008)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 38207)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 38406)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 38605)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 38804)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 39003)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 39202)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 39401)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 39600)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 39799)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 39998)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 40197)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 40396)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 40595)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 40794)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 40993)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 41192)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 41391)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 41590)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 41789)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 41988)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 42187)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 42386)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 42585)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 42784)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 42983)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 43182)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 43381)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 43580)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 43779)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 43978)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 44177)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 44376)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 44575)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 44774)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 44973)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 45172)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 45371)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 45570)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 45769)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 45968)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 46167)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 46366)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 46565)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 46764)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 46963)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 47162)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 47361)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 47560)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 47759)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 47958)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 48157)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 48356)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 48555)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 48754)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 48953)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 49152)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 49351)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 49550)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 49749)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 49948)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 50147)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 50346)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 50545)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 50744)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 50943)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 51142)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 51341)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 51540)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 51739)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 51938)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 52137)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 52336)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 52535)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 52734)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 52933)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 53132)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 53331)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 53530)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 53729)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 53928)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 54127)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 54326)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 54525)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 54724)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 54923)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 55122)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 55321)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 55520)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 55719)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 55918)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 56117)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 56316)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 56515)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 56714)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 56913)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 57112)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 57311)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 57510)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 57709)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 57908)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 58107)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 58306)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 58505)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 58704)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 58903)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 59102)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 59301)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 59500)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 59699)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 59898)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 60097)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 60296)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 60495)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 60694)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 60893)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 61092)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 61291)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 61490)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 61689)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 61888)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 62087)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 62286)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 62485)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 62684)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 62883)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 63082)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 63281)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 63480)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 63679)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 63878)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 64077)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 64276)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 64475)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 64674)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 64873)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 65072)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 65271)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 65470)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 65516)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 65517)) (i32.const 1)) +(assert_return (invoke "load8_u" (i32.const 65518)) (i32.const 2)) +(assert_return (invoke "load8_u" (i32.const 65519)) (i32.const 3)) +(assert_return (invoke "load8_u" (i32.const 65520)) (i32.const 4)) +(assert_return (invoke "load8_u" (i32.const 65521)) (i32.const 5)) +(assert_return (invoke "load8_u" (i32.const 65522)) (i32.const 6)) +(assert_return (invoke "load8_u" (i32.const 65523)) (i32.const 7)) +(assert_return (invoke "load8_u" (i32.const 65524)) (i32.const 8)) +(assert_return (invoke "load8_u" (i32.const 65525)) (i32.const 9)) +(assert_return (invoke "load8_u" (i32.const 65526)) (i32.const 10)) +(assert_return (invoke "load8_u" (i32.const 65527)) (i32.const 11)) +(assert_return (invoke "load8_u" (i32.const 65528)) (i32.const 12)) +(assert_return (invoke "load8_u" (i32.const 65529)) (i32.const 13)) +(assert_return (invoke "load8_u" (i32.const 65530)) (i32.const 14)) +(assert_return (invoke "load8_u" (i32.const 65531)) (i32.const 15)) +(assert_return (invoke "load8_u" (i32.const 65532)) (i32.const 16)) +(assert_return (invoke "load8_u" (i32.const 65533)) (i32.const 17)) +(assert_return (invoke "load8_u" (i32.const 65534)) (i32.const 18)) +(assert_return (invoke "load8_u" (i32.const 65535)) (i32.const 19)) + +(module + (memory (export "mem") 1 1 ) + (data (i32.const 65516) "\00\01\02\03\04\05\06\07\08\09\0a\0b\0c\0d\0e\0f\10\11\12\13") + (func (export "run") (param $targetOffs i32) (param $srcOffs i32) (param $len i32) + (memory.copy (local.get $targetOffs) (local.get $srcOffs) (local.get $len))) + (func (export "load8_u") (param i32) (result i32) + (i32.load8_u (local.get 0)))) + +(assert_trap (invoke "run" (i32.const 65516) (i32.const 65516) (i32.const 40)) + "out of bounds") + +(assert_return (invoke "load8_u" (i32.const 198)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 397)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 596)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 795)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 994)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 1193)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 1392)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 1591)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 1790)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 1989)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 2188)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 2387)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 2586)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 2785)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 2984)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 3183)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 3382)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 3581)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 3780)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 3979)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 4178)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 4377)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 4576)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 4775)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 4974)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 5173)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 5372)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 5571)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 5770)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 5969)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 6168)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 6367)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 6566)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 6765)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 6964)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 7163)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 7362)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 7561)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 7760)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 7959)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 8158)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 8357)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 8556)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 8755)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 8954)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 9153)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 9352)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 9551)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 9750)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 9949)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 10148)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 10347)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 10546)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 10745)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 10944)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 11143)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 11342)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 11541)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 11740)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 11939)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 12138)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 12337)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 12536)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 12735)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 12934)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 13133)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 13332)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 13531)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 13730)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 13929)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 14128)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 14327)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 14526)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 14725)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 14924)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 15123)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 15322)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 15521)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 15720)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 15919)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 16118)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 16317)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 16516)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 16715)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 16914)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 17113)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 17312)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 17511)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 17710)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 17909)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 18108)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 18307)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 18506)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 18705)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 18904)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 19103)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 19302)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 19501)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 19700)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 19899)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 20098)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 20297)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 20496)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 20695)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 20894)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 21093)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 21292)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 21491)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 21690)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 21889)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 22088)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 22287)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 22486)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 22685)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 22884)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 23083)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 23282)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 23481)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 23680)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 23879)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 24078)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 24277)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 24476)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 24675)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 24874)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 25073)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 25272)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 25471)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 25670)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 25869)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 26068)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 26267)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 26466)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 26665)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 26864)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 27063)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 27262)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 27461)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 27660)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 27859)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 28058)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 28257)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 28456)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 28655)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 28854)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 29053)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 29252)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 29451)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 29650)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 29849)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 30048)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 30247)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 30446)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 30645)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 30844)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 31043)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 31242)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 31441)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 31640)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 31839)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 32038)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 32237)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 32436)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 32635)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 32834)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 33033)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 33232)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 33431)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 33630)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 33829)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 34028)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 34227)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 34426)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 34625)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 34824)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 35023)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 35222)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 35421)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 35620)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 35819)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 36018)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 36217)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 36416)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 36615)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 36814)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 37013)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 37212)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 37411)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 37610)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 37809)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 38008)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 38207)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 38406)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 38605)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 38804)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 39003)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 39202)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 39401)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 39600)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 39799)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 39998)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 40197)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 40396)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 40595)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 40794)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 40993)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 41192)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 41391)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 41590)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 41789)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 41988)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 42187)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 42386)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 42585)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 42784)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 42983)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 43182)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 43381)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 43580)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 43779)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 43978)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 44177)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 44376)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 44575)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 44774)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 44973)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 45172)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 45371)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 45570)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 45769)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 45968)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 46167)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 46366)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 46565)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 46764)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 46963)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 47162)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 47361)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 47560)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 47759)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 47958)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 48157)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 48356)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 48555)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 48754)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 48953)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 49152)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 49351)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 49550)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 49749)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 49948)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 50147)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 50346)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 50545)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 50744)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 50943)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 51142)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 51341)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 51540)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 51739)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 51938)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 52137)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 52336)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 52535)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 52734)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 52933)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 53132)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 53331)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 53530)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 53729)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 53928)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 54127)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 54326)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 54525)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 54724)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 54923)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 55122)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 55321)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 55520)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 55719)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 55918)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 56117)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 56316)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 56515)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 56714)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 56913)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 57112)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 57311)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 57510)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 57709)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 57908)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 58107)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 58306)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 58505)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 58704)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 58903)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 59102)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 59301)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 59500)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 59699)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 59898)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 60097)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 60296)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 60495)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 60694)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 60893)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 61092)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 61291)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 61490)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 61689)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 61888)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 62087)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 62286)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 62485)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 62684)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 62883)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 63082)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 63281)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 63480)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 63679)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 63878)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 64077)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 64276)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 64475)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 64674)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 64873)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 65072)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 65271)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 65470)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 65516)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 65517)) (i32.const 1)) +(assert_return (invoke "load8_u" (i32.const 65518)) (i32.const 2)) +(assert_return (invoke "load8_u" (i32.const 65519)) (i32.const 3)) +(assert_return (invoke "load8_u" (i32.const 65520)) (i32.const 4)) +(assert_return (invoke "load8_u" (i32.const 65521)) (i32.const 5)) +(assert_return (invoke "load8_u" (i32.const 65522)) (i32.const 6)) +(assert_return (invoke "load8_u" (i32.const 65523)) (i32.const 7)) +(assert_return (invoke "load8_u" (i32.const 65524)) (i32.const 8)) +(assert_return (invoke "load8_u" (i32.const 65525)) (i32.const 9)) +(assert_return (invoke "load8_u" (i32.const 65526)) (i32.const 10)) +(assert_return (invoke "load8_u" (i32.const 65527)) (i32.const 11)) +(assert_return (invoke "load8_u" (i32.const 65528)) (i32.const 12)) +(assert_return (invoke "load8_u" (i32.const 65529)) (i32.const 13)) +(assert_return (invoke "load8_u" (i32.const 65530)) (i32.const 14)) +(assert_return (invoke "load8_u" (i32.const 65531)) (i32.const 15)) +(assert_return (invoke "load8_u" (i32.const 65532)) (i32.const 16)) +(assert_return (invoke "load8_u" (i32.const 65533)) (i32.const 17)) +(assert_return (invoke "load8_u" (i32.const 65534)) (i32.const 18)) +(assert_return (invoke "load8_u" (i32.const 65535)) (i32.const 19)) + +(module + (memory (export "mem") 1 ) + (data (i32.const 65516) "\00\01\02\03\04\05\06\07\08\09\0a\0b\0c\0d\0e\0f\10\11\12\13") + (func (export "run") (param $targetOffs i32) (param $srcOffs i32) (param $len i32) + (memory.copy (local.get $targetOffs) (local.get $srcOffs) (local.get $len))) + (func (export "load8_u") (param i32) (result i32) + (i32.load8_u (local.get 0)))) + +(assert_trap (invoke "run" (i32.const 0) (i32.const 65516) (i32.const 4294963200)) + "out of bounds") + +(assert_return (invoke "load8_u" (i32.const 198)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 397)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 596)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 795)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 994)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 1193)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 1392)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 1591)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 1790)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 1989)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 2188)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 2387)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 2586)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 2785)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 2984)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 3183)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 3382)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 3581)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 3780)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 3979)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 4178)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 4377)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 4576)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 4775)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 4974)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 5173)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 5372)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 5571)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 5770)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 5969)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 6168)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 6367)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 6566)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 6765)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 6964)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 7163)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 7362)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 7561)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 7760)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 7959)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 8158)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 8357)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 8556)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 8755)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 8954)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 9153)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 9352)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 9551)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 9750)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 9949)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 10148)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 10347)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 10546)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 10745)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 10944)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 11143)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 11342)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 11541)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 11740)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 11939)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 12138)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 12337)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 12536)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 12735)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 12934)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 13133)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 13332)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 13531)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 13730)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 13929)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 14128)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 14327)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 14526)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 14725)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 14924)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 15123)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 15322)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 15521)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 15720)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 15919)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 16118)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 16317)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 16516)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 16715)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 16914)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 17113)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 17312)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 17511)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 17710)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 17909)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 18108)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 18307)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 18506)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 18705)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 18904)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 19103)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 19302)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 19501)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 19700)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 19899)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 20098)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 20297)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 20496)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 20695)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 20894)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 21093)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 21292)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 21491)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 21690)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 21889)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 22088)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 22287)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 22486)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 22685)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 22884)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 23083)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 23282)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 23481)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 23680)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 23879)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 24078)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 24277)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 24476)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 24675)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 24874)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 25073)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 25272)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 25471)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 25670)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 25869)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 26068)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 26267)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 26466)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 26665)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 26864)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 27063)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 27262)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 27461)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 27660)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 27859)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 28058)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 28257)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 28456)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 28655)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 28854)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 29053)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 29252)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 29451)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 29650)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 29849)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 30048)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 30247)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 30446)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 30645)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 30844)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 31043)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 31242)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 31441)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 31640)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 31839)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 32038)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 32237)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 32436)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 32635)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 32834)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 33033)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 33232)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 33431)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 33630)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 33829)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 34028)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 34227)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 34426)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 34625)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 34824)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 35023)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 35222)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 35421)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 35620)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 35819)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 36018)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 36217)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 36416)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 36615)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 36814)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 37013)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 37212)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 37411)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 37610)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 37809)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 38008)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 38207)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 38406)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 38605)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 38804)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 39003)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 39202)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 39401)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 39600)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 39799)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 39998)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 40197)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 40396)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 40595)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 40794)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 40993)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 41192)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 41391)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 41590)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 41789)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 41988)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 42187)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 42386)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 42585)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 42784)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 42983)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 43182)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 43381)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 43580)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 43779)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 43978)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 44177)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 44376)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 44575)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 44774)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 44973)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 45172)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 45371)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 45570)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 45769)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 45968)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 46167)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 46366)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 46565)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 46764)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 46963)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 47162)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 47361)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 47560)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 47759)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 47958)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 48157)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 48356)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 48555)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 48754)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 48953)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 49152)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 49351)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 49550)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 49749)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 49948)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 50147)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 50346)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 50545)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 50744)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 50943)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 51142)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 51341)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 51540)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 51739)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 51938)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 52137)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 52336)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 52535)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 52734)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 52933)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 53132)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 53331)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 53530)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 53729)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 53928)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 54127)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 54326)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 54525)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 54724)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 54923)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 55122)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 55321)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 55520)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 55719)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 55918)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 56117)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 56316)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 56515)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 56714)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 56913)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 57112)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 57311)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 57510)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 57709)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 57908)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 58107)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 58306)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 58505)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 58704)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 58903)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 59102)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 59301)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 59500)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 59699)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 59898)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 60097)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 60296)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 60495)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 60694)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 60893)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 61092)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 61291)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 61490)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 61689)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 61888)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 62087)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 62286)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 62485)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 62684)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 62883)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 63082)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 63281)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 63480)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 63679)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 63878)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 64077)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 64276)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 64475)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 64674)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 64873)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 65072)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 65271)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 65470)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 65516)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 65517)) (i32.const 1)) +(assert_return (invoke "load8_u" (i32.const 65518)) (i32.const 2)) +(assert_return (invoke "load8_u" (i32.const 65519)) (i32.const 3)) +(assert_return (invoke "load8_u" (i32.const 65520)) (i32.const 4)) +(assert_return (invoke "load8_u" (i32.const 65521)) (i32.const 5)) +(assert_return (invoke "load8_u" (i32.const 65522)) (i32.const 6)) +(assert_return (invoke "load8_u" (i32.const 65523)) (i32.const 7)) +(assert_return (invoke "load8_u" (i32.const 65524)) (i32.const 8)) +(assert_return (invoke "load8_u" (i32.const 65525)) (i32.const 9)) +(assert_return (invoke "load8_u" (i32.const 65526)) (i32.const 10)) +(assert_return (invoke "load8_u" (i32.const 65527)) (i32.const 11)) +(assert_return (invoke "load8_u" (i32.const 65528)) (i32.const 12)) +(assert_return (invoke "load8_u" (i32.const 65529)) (i32.const 13)) +(assert_return (invoke "load8_u" (i32.const 65530)) (i32.const 14)) +(assert_return (invoke "load8_u" (i32.const 65531)) (i32.const 15)) +(assert_return (invoke "load8_u" (i32.const 65532)) (i32.const 16)) +(assert_return (invoke "load8_u" (i32.const 65533)) (i32.const 17)) +(assert_return (invoke "load8_u" (i32.const 65534)) (i32.const 18)) +(assert_return (invoke "load8_u" (i32.const 65535)) (i32.const 19)) + +(module + (memory (export "mem") 1 1 ) + (data (i32.const 61440) "\00\01\02\03\04\05\06\07\08\09\0a\0b\0c\0d\0e\0f\10\11\12\13") + (func (export "run") (param $targetOffs i32) (param $srcOffs i32) (param $len i32) + (memory.copy (local.get $targetOffs) (local.get $srcOffs) (local.get $len))) + (func (export "load8_u") (param i32) (result i32) + (i32.load8_u (local.get 0)))) + +(assert_trap (invoke "run" (i32.const 65516) (i32.const 61440) (i32.const 4294967040)) + "out of bounds") + +(assert_return (invoke "load8_u" (i32.const 198)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 397)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 596)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 795)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 994)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 1193)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 1392)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 1591)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 1790)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 1989)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 2188)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 2387)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 2586)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 2785)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 2984)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 3183)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 3382)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 3581)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 3780)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 3979)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 4178)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 4377)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 4576)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 4775)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 4974)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 5173)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 5372)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 5571)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 5770)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 5969)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 6168)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 6367)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 6566)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 6765)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 6964)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 7163)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 7362)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 7561)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 7760)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 7959)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 8158)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 8357)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 8556)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 8755)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 8954)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 9153)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 9352)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 9551)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 9750)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 9949)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 10148)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 10347)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 10546)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 10745)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 10944)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 11143)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 11342)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 11541)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 11740)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 11939)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 12138)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 12337)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 12536)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 12735)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 12934)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 13133)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 13332)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 13531)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 13730)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 13929)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 14128)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 14327)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 14526)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 14725)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 14924)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 15123)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 15322)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 15521)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 15720)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 15919)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 16118)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 16317)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 16516)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 16715)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 16914)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 17113)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 17312)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 17511)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 17710)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 17909)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 18108)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 18307)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 18506)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 18705)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 18904)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 19103)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 19302)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 19501)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 19700)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 19899)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 20098)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 20297)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 20496)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 20695)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 20894)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 21093)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 21292)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 21491)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 21690)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 21889)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 22088)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 22287)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 22486)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 22685)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 22884)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 23083)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 23282)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 23481)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 23680)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 23879)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 24078)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 24277)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 24476)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 24675)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 24874)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 25073)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 25272)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 25471)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 25670)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 25869)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 26068)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 26267)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 26466)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 26665)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 26864)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 27063)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 27262)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 27461)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 27660)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 27859)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 28058)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 28257)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 28456)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 28655)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 28854)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 29053)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 29252)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 29451)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 29650)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 29849)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 30048)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 30247)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 30446)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 30645)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 30844)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 31043)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 31242)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 31441)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 31640)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 31839)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 32038)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 32237)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 32436)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 32635)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 32834)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 33033)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 33232)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 33431)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 33630)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 33829)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 34028)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 34227)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 34426)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 34625)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 34824)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 35023)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 35222)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 35421)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 35620)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 35819)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 36018)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 36217)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 36416)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 36615)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 36814)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 37013)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 37212)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 37411)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 37610)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 37809)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 38008)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 38207)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 38406)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 38605)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 38804)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 39003)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 39202)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 39401)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 39600)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 39799)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 39998)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 40197)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 40396)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 40595)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 40794)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 40993)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 41192)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 41391)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 41590)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 41789)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 41988)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 42187)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 42386)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 42585)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 42784)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 42983)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 43182)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 43381)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 43580)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 43779)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 43978)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 44177)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 44376)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 44575)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 44774)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 44973)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 45172)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 45371)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 45570)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 45769)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 45968)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 46167)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 46366)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 46565)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 46764)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 46963)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 47162)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 47361)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 47560)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 47759)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 47958)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 48157)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 48356)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 48555)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 48754)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 48953)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 49152)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 49351)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 49550)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 49749)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 49948)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 50147)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 50346)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 50545)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 50744)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 50943)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 51142)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 51341)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 51540)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 51739)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 51938)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 52137)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 52336)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 52535)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 52734)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 52933)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 53132)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 53331)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 53530)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 53729)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 53928)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 54127)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 54326)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 54525)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 54724)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 54923)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 55122)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 55321)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 55520)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 55719)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 55918)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 56117)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 56316)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 56515)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 56714)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 56913)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 57112)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 57311)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 57510)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 57709)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 57908)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 58107)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 58306)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 58505)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 58704)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 58903)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 59102)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 59301)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 59500)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 59699)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 59898)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 60097)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 60296)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 60495)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 60694)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 60893)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 61092)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 61291)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 61440)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 61441)) (i32.const 1)) +(assert_return (invoke "load8_u" (i32.const 61442)) (i32.const 2)) +(assert_return (invoke "load8_u" (i32.const 61443)) (i32.const 3)) +(assert_return (invoke "load8_u" (i32.const 61444)) (i32.const 4)) +(assert_return (invoke "load8_u" (i32.const 61445)) (i32.const 5)) +(assert_return (invoke "load8_u" (i32.const 61446)) (i32.const 6)) +(assert_return (invoke "load8_u" (i32.const 61447)) (i32.const 7)) +(assert_return (invoke "load8_u" (i32.const 61448)) (i32.const 8)) +(assert_return (invoke "load8_u" (i32.const 61449)) (i32.const 9)) +(assert_return (invoke "load8_u" (i32.const 61450)) (i32.const 10)) +(assert_return (invoke "load8_u" (i32.const 61451)) (i32.const 11)) +(assert_return (invoke "load8_u" (i32.const 61452)) (i32.const 12)) +(assert_return (invoke "load8_u" (i32.const 61453)) (i32.const 13)) +(assert_return (invoke "load8_u" (i32.const 61454)) (i32.const 14)) +(assert_return (invoke "load8_u" (i32.const 61455)) (i32.const 15)) +(assert_return (invoke "load8_u" (i32.const 61456)) (i32.const 16)) +(assert_return (invoke "load8_u" (i32.const 61457)) (i32.const 17)) +(assert_return (invoke "load8_u" (i32.const 61458)) (i32.const 18)) +(assert_return (invoke "load8_u" (i32.const 61459)) (i32.const 19)) +(assert_return (invoke "load8_u" (i32.const 61510)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 61709)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 61908)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 62107)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 62306)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 62505)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 62704)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 62903)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 63102)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 63301)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 63500)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 63699)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 63898)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 64097)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 64296)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 64495)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 64694)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 64893)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 65092)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 65291)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 65490)) (i32.const 0)) + +(assert_invalid + (module + (func (export "testfn") + (memory.copy (i32.const 10) (i32.const 20) (i32.const 30)))) + "unknown memory 0") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.copy (i32.const 10) (i32.const 20) (f32.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.copy (i32.const 10) (i32.const 20) (i64.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.copy (i32.const 10) (i32.const 20) (f64.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.copy (i32.const 10) (f32.const 20) (i32.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.copy (i32.const 10) (f32.const 20) (f32.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.copy (i32.const 10) (f32.const 20) (i64.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.copy (i32.const 10) (f32.const 20) (f64.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.copy (i32.const 10) (i64.const 20) (i32.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.copy (i32.const 10) (i64.const 20) (f32.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.copy (i32.const 10) (i64.const 20) (i64.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.copy (i32.const 10) (i64.const 20) (f64.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.copy (i32.const 10) (f64.const 20) (i32.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.copy (i32.const 10) (f64.const 20) (f32.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.copy (i32.const 10) (f64.const 20) (i64.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.copy (i32.const 10) (f64.const 20) (f64.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.copy (f32.const 10) (i32.const 20) (i32.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.copy (f32.const 10) (i32.const 20) (f32.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.copy (f32.const 10) (i32.const 20) (i64.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.copy (f32.const 10) (i32.const 20) (f64.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.copy (f32.const 10) (f32.const 20) (i32.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.copy (f32.const 10) (f32.const 20) (f32.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.copy (f32.const 10) (f32.const 20) (i64.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.copy (f32.const 10) (f32.const 20) (f64.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.copy (f32.const 10) (i64.const 20) (i32.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.copy (f32.const 10) (i64.const 20) (f32.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.copy (f32.const 10) (i64.const 20) (i64.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.copy (f32.const 10) (i64.const 20) (f64.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.copy (f32.const 10) (f64.const 20) (i32.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.copy (f32.const 10) (f64.const 20) (f32.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.copy (f32.const 10) (f64.const 20) (i64.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.copy (f32.const 10) (f64.const 20) (f64.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.copy (i64.const 10) (i32.const 20) (i32.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.copy (i64.const 10) (i32.const 20) (f32.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.copy (i64.const 10) (i32.const 20) (i64.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.copy (i64.const 10) (i32.const 20) (f64.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.copy (i64.const 10) (f32.const 20) (i32.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.copy (i64.const 10) (f32.const 20) (f32.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.copy (i64.const 10) (f32.const 20) (i64.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.copy (i64.const 10) (f32.const 20) (f64.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.copy (i64.const 10) (i64.const 20) (i32.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.copy (i64.const 10) (i64.const 20) (f32.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.copy (i64.const 10) (i64.const 20) (i64.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.copy (i64.const 10) (i64.const 20) (f64.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.copy (i64.const 10) (f64.const 20) (i32.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.copy (i64.const 10) (f64.const 20) (f32.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.copy (i64.const 10) (f64.const 20) (i64.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.copy (i64.const 10) (f64.const 20) (f64.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.copy (f64.const 10) (i32.const 20) (i32.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.copy (f64.const 10) (i32.const 20) (f32.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.copy (f64.const 10) (i32.const 20) (i64.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.copy (f64.const 10) (i32.const 20) (f64.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.copy (f64.const 10) (f32.const 20) (i32.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.copy (f64.const 10) (f32.const 20) (f32.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.copy (f64.const 10) (f32.const 20) (i64.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.copy (f64.const 10) (f32.const 20) (f64.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.copy (f64.const 10) (i64.const 20) (i32.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.copy (f64.const 10) (i64.const 20) (f32.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.copy (f64.const 10) (i64.const 20) (i64.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.copy (f64.const 10) (i64.const 20) (f64.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.copy (f64.const 10) (f64.const 20) (i32.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.copy (f64.const 10) (f64.const 20) (f32.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.copy (f64.const 10) (f64.const 20) (i64.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.copy (f64.const 10) (f64.const 20) (f64.const 30)))) + "type mismatch") + + +(module + (memory 1 1) + (func (export "test") + (memory.fill (i32.const 10) (i32.const 0x55) (i32.const 10)) + (memory.copy (i32.const 9) (i32.const 10) (i32.const 5))) + + (func (export "checkRange") (param $from i32) (param $to i32) (param $expected i32) (result i32) + (loop $cont + (if (i32.eq (local.get $from) (local.get $to)) + (then + (return (i32.const -1)))) + (if (i32.eq (i32.load8_u (local.get $from)) (local.get $expected)) + (then + (local.set $from (i32.add (local.get $from) (i32.const 1))) + (br $cont)))) + (return (local.get $from))) +) +(invoke "test") + +(assert_return (invoke "checkRange" (i32.const 0) (i32.const 9) (i32.const 0)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 9) (i32.const 20) (i32.const 85)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 20) (i32.const 65536) (i32.const 0)) + (i32.const -1)) + +(module + (memory 1 1) + (func (export "test") + (memory.fill (i32.const 10) (i32.const 0x55) (i32.const 10)) + (memory.copy (i32.const 16) (i32.const 15) (i32.const 5))) + + (func (export "checkRange") (param $from i32) (param $to i32) (param $expected i32) (result i32) + (loop $cont + (if (i32.eq (local.get $from) (local.get $to)) + (then + (return (i32.const -1)))) + (if (i32.eq (i32.load8_u (local.get $from)) (local.get $expected)) + (then + (local.set $from (i32.add (local.get $from) (i32.const 1))) + (br $cont)))) + (return (local.get $from))) +) +(invoke "test") + +(assert_return (invoke "checkRange" (i32.const 0) (i32.const 10) (i32.const 0)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 10) (i32.const 21) (i32.const 85)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 21) (i32.const 65536) (i32.const 0)) + (i32.const -1)) + +(module + (memory 1 1) + (func (export "test") + (memory.copy (i32.const 0xFF00) (i32.const 0x8000) (i32.const 257)))) +(assert_trap (invoke "test") "out of bounds") + +(module + (memory 1 1) + (func (export "test") + (memory.copy (i32.const 0xFFFFFF00) (i32.const 0x4000) (i32.const 257)))) +(assert_trap (invoke "test") "out of bounds") + +(module + (memory 1 1) + (func (export "test") + (memory.copy (i32.const 0x8000) (i32.const 0xFF00) (i32.const 257)))) +(assert_trap (invoke "test") "out of bounds") + +(module + (memory 1 1) + (func (export "test") + (memory.copy (i32.const 0x4000) (i32.const 0xFFFFFF00) (i32.const 257)))) +(assert_trap (invoke "test") "out of bounds") + +(module + (memory 1 1) + (func (export "test") + (memory.fill (i32.const 0x0000) (i32.const 0x55) (i32.const 0x8000)) + (memory.fill (i32.const 0x8000) (i32.const 0xAA) (i32.const 0x8000)) + (memory.copy (i32.const 0x9000) (i32.const 0x7000) (i32.const 0))) + + (func (export "checkRange") (param $from i32) (param $to i32) (param $expected i32) (result i32) + (loop $cont + (if (i32.eq (local.get $from) (local.get $to)) + (then + (return (i32.const -1)))) + (if (i32.eq (i32.load8_u (local.get $from)) (local.get $expected)) + (then + (local.set $from (i32.add (local.get $from) (i32.const 1))) + (br $cont)))) + (return (local.get $from))) +) +(invoke "test") + +(assert_return (invoke "checkRange" (i32.const 0) (i32.const 32768) (i32.const 85)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 32768) (i32.const 65536) (i32.const 170)) + (i32.const -1)) +(module + (memory 1 1) + (func (export "test") + (memory.copy (i32.const 0x10000) (i32.const 0x7000) (i32.const 0)))) +(invoke "test") + +(module + (memory 1 1) + (func (export "test") + (memory.copy (i32.const 0x20000) (i32.const 0x7000) (i32.const 0)))) +(assert_trap (invoke "test") "out of bounds") + +(module + (memory 1 1) + (func (export "test") + (memory.copy (i32.const 0x9000) (i32.const 0x10000) (i32.const 0)))) +(invoke "test") + +(module + (memory 1 1) + (func (export "test") + (memory.copy (i32.const 0x9000) (i32.const 0x20000) (i32.const 0)))) +(assert_trap (invoke "test") "out of bounds") + +(module + (memory 1 1) + (func (export "test") + (memory.copy (i32.const 0x10000) (i32.const 0x10000) (i32.const 0)))) +(invoke "test") + +(module + (memory 1 1) + (func (export "test") + (memory.copy (i32.const 0x20000) (i32.const 0x20000) (i32.const 0)))) +(assert_trap (invoke "test") "out of bounds") + +(module + (memory 1 1) + (func (export "test") + (memory.fill (i32.const 17767) (i32.const 1) (i32.const 1344)) + (memory.fill (i32.const 39017) (i32.const 2) (i32.const 1055)) + (memory.fill (i32.const 56401) (i32.const 3) (i32.const 988)) + (memory.fill (i32.const 37962) (i32.const 4) (i32.const 322)) + (memory.fill (i32.const 7977) (i32.const 5) (i32.const 1994)) + (memory.fill (i32.const 22714) (i32.const 6) (i32.const 3036)) + (memory.fill (i32.const 16882) (i32.const 7) (i32.const 2372)) + (memory.fill (i32.const 43491) (i32.const 8) (i32.const 835)) + (memory.fill (i32.const 124) (i32.const 9) (i32.const 1393)) + (memory.fill (i32.const 2132) (i32.const 10) (i32.const 2758)) + (memory.fill (i32.const 8987) (i32.const 11) (i32.const 3098)) + (memory.fill (i32.const 52711) (i32.const 12) (i32.const 741)) + (memory.fill (i32.const 3958) (i32.const 13) (i32.const 2823)) + (memory.fill (i32.const 49715) (i32.const 14) (i32.const 1280)) + (memory.fill (i32.const 50377) (i32.const 15) (i32.const 1466)) + (memory.fill (i32.const 20493) (i32.const 16) (i32.const 3158)) + (memory.fill (i32.const 47665) (i32.const 17) (i32.const 544)) + (memory.fill (i32.const 12451) (i32.const 18) (i32.const 2669)) + (memory.fill (i32.const 24869) (i32.const 19) (i32.const 2651)) + (memory.fill (i32.const 45317) (i32.const 20) (i32.const 1570)) + (memory.fill (i32.const 43096) (i32.const 21) (i32.const 1691)) + (memory.fill (i32.const 33886) (i32.const 22) (i32.const 646)) + (memory.fill (i32.const 48555) (i32.const 23) (i32.const 1858)) + (memory.fill (i32.const 53453) (i32.const 24) (i32.const 2657)) + (memory.fill (i32.const 30363) (i32.const 25) (i32.const 981)) + (memory.fill (i32.const 9300) (i32.const 26) (i32.const 1807)) + (memory.fill (i32.const 50190) (i32.const 27) (i32.const 487)) + (memory.fill (i32.const 62753) (i32.const 28) (i32.const 530)) + (memory.fill (i32.const 36316) (i32.const 29) (i32.const 943)) + (memory.fill (i32.const 6768) (i32.const 30) (i32.const 381)) + (memory.fill (i32.const 51262) (i32.const 31) (i32.const 3089)) + (memory.fill (i32.const 49729) (i32.const 32) (i32.const 658)) + (memory.fill (i32.const 44540) (i32.const 33) (i32.const 1702)) + (memory.fill (i32.const 33342) (i32.const 34) (i32.const 1092)) + (memory.fill (i32.const 50814) (i32.const 35) (i32.const 1410)) + (memory.fill (i32.const 47594) (i32.const 36) (i32.const 2204)) + (memory.fill (i32.const 54123) (i32.const 37) (i32.const 2394)) + (memory.fill (i32.const 55183) (i32.const 38) (i32.const 250)) + (memory.fill (i32.const 22620) (i32.const 39) (i32.const 2097)) + (memory.fill (i32.const 17132) (i32.const 40) (i32.const 3264)) + (memory.fill (i32.const 54331) (i32.const 41) (i32.const 3299)) + (memory.fill (i32.const 39474) (i32.const 42) (i32.const 2796)) + (memory.fill (i32.const 36156) (i32.const 43) (i32.const 2070)) + (memory.fill (i32.const 35308) (i32.const 44) (i32.const 2763)) + (memory.fill (i32.const 32731) (i32.const 45) (i32.const 312)) + (memory.fill (i32.const 63746) (i32.const 46) (i32.const 192)) + (memory.fill (i32.const 30974) (i32.const 47) (i32.const 596)) + (memory.fill (i32.const 16635) (i32.const 48) (i32.const 501)) + (memory.fill (i32.const 57002) (i32.const 49) (i32.const 686)) + (memory.fill (i32.const 34299) (i32.const 50) (i32.const 385)) + (memory.fill (i32.const 60881) (i32.const 51) (i32.const 903)) + (memory.fill (i32.const 61445) (i32.const 52) (i32.const 2390)) + (memory.fill (i32.const 46972) (i32.const 53) (i32.const 1441)) + (memory.fill (i32.const 25973) (i32.const 54) (i32.const 3162)) + (memory.fill (i32.const 5566) (i32.const 55) (i32.const 2135)) + (memory.fill (i32.const 35977) (i32.const 56) (i32.const 519)) + (memory.fill (i32.const 44892) (i32.const 57) (i32.const 3280)) + (memory.fill (i32.const 46760) (i32.const 58) (i32.const 1678)) + (memory.fill (i32.const 46607) (i32.const 59) (i32.const 3168)) + (memory.fill (i32.const 22449) (i32.const 60) (i32.const 1441)) + (memory.fill (i32.const 58609) (i32.const 61) (i32.const 663)) + (memory.fill (i32.const 32261) (i32.const 62) (i32.const 1671)) + (memory.fill (i32.const 3063) (i32.const 63) (i32.const 721)) + (memory.fill (i32.const 34025) (i32.const 64) (i32.const 84)) + (memory.fill (i32.const 33338) (i32.const 65) (i32.const 2029)) + (memory.fill (i32.const 36810) (i32.const 66) (i32.const 29)) + (memory.fill (i32.const 19147) (i32.const 67) (i32.const 3034)) + (memory.fill (i32.const 12616) (i32.const 68) (i32.const 1043)) + (memory.fill (i32.const 18276) (i32.const 69) (i32.const 3324)) + (memory.fill (i32.const 4639) (i32.const 70) (i32.const 1091)) + (memory.fill (i32.const 16158) (i32.const 71) (i32.const 1997)) + (memory.fill (i32.const 18204) (i32.const 72) (i32.const 2259)) + (memory.fill (i32.const 50532) (i32.const 73) (i32.const 3189)) + (memory.fill (i32.const 11028) (i32.const 74) (i32.const 1968)) + (memory.fill (i32.const 15962) (i32.const 75) (i32.const 1455)) + (memory.fill (i32.const 45406) (i32.const 76) (i32.const 1177)) + (memory.fill (i32.const 54137) (i32.const 77) (i32.const 1568)) + (memory.fill (i32.const 33083) (i32.const 78) (i32.const 1642)) + (memory.fill (i32.const 61028) (i32.const 79) (i32.const 3284)) + (memory.fill (i32.const 51729) (i32.const 80) (i32.const 223)) + (memory.fill (i32.const 4361) (i32.const 81) (i32.const 2171)) + (memory.fill (i32.const 57514) (i32.const 82) (i32.const 1322)) + (memory.fill (i32.const 55724) (i32.const 83) (i32.const 2648)) + (memory.fill (i32.const 24091) (i32.const 84) (i32.const 1045)) + (memory.fill (i32.const 43183) (i32.const 85) (i32.const 3097)) + (memory.fill (i32.const 32307) (i32.const 86) (i32.const 2796)) + (memory.fill (i32.const 3811) (i32.const 87) (i32.const 2010)) + (memory.fill (i32.const 54856) (i32.const 88) (i32.const 0)) + (memory.fill (i32.const 49941) (i32.const 89) (i32.const 2069)) + (memory.fill (i32.const 20411) (i32.const 90) (i32.const 2896)) + (memory.fill (i32.const 33826) (i32.const 91) (i32.const 192)) + (memory.fill (i32.const 9402) (i32.const 92) (i32.const 2195)) + (memory.fill (i32.const 12413) (i32.const 93) (i32.const 24)) + (memory.fill (i32.const 14091) (i32.const 94) (i32.const 577)) + (memory.fill (i32.const 44058) (i32.const 95) (i32.const 2089)) + (memory.fill (i32.const 36735) (i32.const 96) (i32.const 3436)) + (memory.fill (i32.const 23288) (i32.const 97) (i32.const 2765)) + (memory.fill (i32.const 6392) (i32.const 98) (i32.const 830)) + (memory.fill (i32.const 33307) (i32.const 99) (i32.const 1938)) + (memory.fill (i32.const 21941) (i32.const 100) (i32.const 2750)) + (memory.copy (i32.const 59214) (i32.const 54248) (i32.const 2098)) + (memory.copy (i32.const 63026) (i32.const 39224) (i32.const 230)) + (memory.copy (i32.const 51833) (i32.const 23629) (i32.const 2300)) + (memory.copy (i32.const 6708) (i32.const 23996) (i32.const 639)) + (memory.copy (i32.const 6990) (i32.const 33399) (i32.const 1097)) + (memory.copy (i32.const 19403) (i32.const 10348) (i32.const 3197)) + (memory.copy (i32.const 27308) (i32.const 54406) (i32.const 100)) + (memory.copy (i32.const 27221) (i32.const 43682) (i32.const 1717)) + (memory.copy (i32.const 60528) (i32.const 8629) (i32.const 119)) + (memory.copy (i32.const 5947) (i32.const 2308) (i32.const 658)) + (memory.copy (i32.const 4787) (i32.const 51631) (i32.const 2269)) + (memory.copy (i32.const 12617) (i32.const 19197) (i32.const 833)) + (memory.copy (i32.const 11854) (i32.const 46505) (i32.const 3300)) + (memory.copy (i32.const 11376) (i32.const 45012) (i32.const 2281)) + (memory.copy (i32.const 34186) (i32.const 6697) (i32.const 2572)) + (memory.copy (i32.const 4936) (i32.const 1690) (i32.const 1328)) + (memory.copy (i32.const 63164) (i32.const 7637) (i32.const 1670)) + (memory.copy (i32.const 44568) (i32.const 18344) (i32.const 33)) + (memory.copy (i32.const 43918) (i32.const 22348) (i32.const 1427)) + (memory.copy (i32.const 46637) (i32.const 49819) (i32.const 1434)) + (memory.copy (i32.const 63684) (i32.const 8755) (i32.const 834)) + (memory.copy (i32.const 33485) (i32.const 20131) (i32.const 3317)) + (memory.copy (i32.const 40575) (i32.const 54317) (i32.const 3201)) + (memory.copy (i32.const 25812) (i32.const 59254) (i32.const 2452)) + (memory.copy (i32.const 19678) (i32.const 56882) (i32.const 346)) + (memory.copy (i32.const 15852) (i32.const 35914) (i32.const 2430)) + (memory.copy (i32.const 11824) (i32.const 35574) (i32.const 300)) + (memory.copy (i32.const 59427) (i32.const 13957) (i32.const 3153)) + (memory.copy (i32.const 34299) (i32.const 60594) (i32.const 1281)) + (memory.copy (i32.const 8964) (i32.const 12276) (i32.const 943)) + (memory.copy (i32.const 2827) (i32.const 10425) (i32.const 1887)) + (memory.copy (i32.const 43194) (i32.const 43910) (i32.const 738)) + (memory.copy (i32.const 63038) (i32.const 18949) (i32.const 122)) + (memory.copy (i32.const 24044) (i32.const 44761) (i32.const 1755)) + (memory.copy (i32.const 22608) (i32.const 14755) (i32.const 702)) + (memory.copy (i32.const 11284) (i32.const 26579) (i32.const 1830)) + (memory.copy (i32.const 23092) (i32.const 20471) (i32.const 1064)) + (memory.copy (i32.const 57248) (i32.const 54770) (i32.const 2631)) + (memory.copy (i32.const 25492) (i32.const 1025) (i32.const 3113)) + (memory.copy (i32.const 49588) (i32.const 44220) (i32.const 975)) + (memory.copy (i32.const 28280) (i32.const 41722) (i32.const 2336)) + (memory.copy (i32.const 61289) (i32.const 230) (i32.const 2872)) + (memory.copy (i32.const 22480) (i32.const 52506) (i32.const 2197)) + (memory.copy (i32.const 40553) (i32.const 9578) (i32.const 1958)) + (memory.copy (i32.const 29004) (i32.const 20862) (i32.const 2186)) + (memory.copy (i32.const 53029) (i32.const 43955) (i32.const 1037)) + (memory.copy (i32.const 25476) (i32.const 35667) (i32.const 1650)) + (memory.copy (i32.const 58516) (i32.const 45819) (i32.const 1986)) + (memory.copy (i32.const 38297) (i32.const 5776) (i32.const 1955)) + (memory.copy (i32.const 28503) (i32.const 55364) (i32.const 2368)) + (memory.copy (i32.const 62619) (i32.const 18108) (i32.const 1356)) + (memory.copy (i32.const 50149) (i32.const 13861) (i32.const 382)) + (memory.copy (i32.const 16904) (i32.const 36341) (i32.const 1900)) + (memory.copy (i32.const 48098) (i32.const 11358) (i32.const 2807)) + (memory.copy (i32.const 28512) (i32.const 40362) (i32.const 323)) + (memory.copy (i32.const 35506) (i32.const 27856) (i32.const 1670)) + (memory.copy (i32.const 62970) (i32.const 53332) (i32.const 1341)) + (memory.copy (i32.const 14133) (i32.const 46312) (i32.const 644)) + (memory.copy (i32.const 29030) (i32.const 19074) (i32.const 496)) + (memory.copy (i32.const 44952) (i32.const 47577) (i32.const 2784)) + (memory.copy (i32.const 39559) (i32.const 44661) (i32.const 1350)) + (memory.copy (i32.const 10352) (i32.const 29274) (i32.const 1475)) + (memory.copy (i32.const 46911) (i32.const 46178) (i32.const 1467)) + (memory.copy (i32.const 4905) (i32.const 28740) (i32.const 1895)) + (memory.copy (i32.const 38012) (i32.const 57253) (i32.const 1751)) + (memory.copy (i32.const 26446) (i32.const 27223) (i32.const 1127)) + (memory.copy (i32.const 58835) (i32.const 24657) (i32.const 1063)) + (memory.copy (i32.const 61356) (i32.const 38790) (i32.const 766)) + (memory.copy (i32.const 44160) (i32.const 2284) (i32.const 1520)) + (memory.copy (i32.const 32740) (i32.const 47237) (i32.const 3014)) + (memory.copy (i32.const 11148) (i32.const 21260) (i32.const 1011)) + (memory.copy (i32.const 7665) (i32.const 31612) (i32.const 3034)) + (memory.copy (i32.const 18044) (i32.const 12987) (i32.const 3320)) + (memory.copy (i32.const 57306) (i32.const 55905) (i32.const 308)) + (memory.copy (i32.const 24675) (i32.const 16815) (i32.const 1155)) + (memory.copy (i32.const 19900) (i32.const 10115) (i32.const 722)) + (memory.copy (i32.const 2921) (i32.const 5935) (i32.const 2370)) + (memory.copy (i32.const 32255) (i32.const 50095) (i32.const 2926)) + (memory.copy (i32.const 15126) (i32.const 17299) (i32.const 2607)) + (memory.copy (i32.const 45575) (i32.const 28447) (i32.const 2045)) + (memory.copy (i32.const 55149) (i32.const 36113) (i32.const 2596)) + (memory.copy (i32.const 28461) (i32.const 54157) (i32.const 1168)) + (memory.copy (i32.const 47951) (i32.const 53385) (i32.const 3137)) + (memory.copy (i32.const 30646) (i32.const 45155) (i32.const 2649)) + (memory.copy (i32.const 5057) (i32.const 4295) (i32.const 52)) + (memory.copy (i32.const 6692) (i32.const 24195) (i32.const 441)) + (memory.copy (i32.const 32984) (i32.const 27117) (i32.const 3445)) + (memory.copy (i32.const 32530) (i32.const 59372) (i32.const 2785)) + (memory.copy (i32.const 34361) (i32.const 8962) (i32.const 2406)) + (memory.copy (i32.const 17893) (i32.const 54538) (i32.const 3381)) + (memory.copy (i32.const 22685) (i32.const 44151) (i32.const 136)) + (memory.copy (i32.const 59089) (i32.const 7077) (i32.const 1045)) + (memory.copy (i32.const 42945) (i32.const 55028) (i32.const 2389)) + (memory.copy (i32.const 44693) (i32.const 20138) (i32.const 877)) + (memory.copy (i32.const 36810) (i32.const 25196) (i32.const 3447)) + (memory.copy (i32.const 45742) (i32.const 31888) (i32.const 854)) + (memory.copy (i32.const 24236) (i32.const 31866) (i32.const 1377)) + (memory.copy (i32.const 33778) (i32.const 692) (i32.const 1594)) + (memory.copy (i32.const 60618) (i32.const 18585) (i32.const 2987)) + (memory.copy (i32.const 50370) (i32.const 41271) (i32.const 1406)) + ) + + (func (export "checkRange") (param $from i32) (param $to i32) (param $expected i32) (result i32) + (loop $cont + (if (i32.eq (local.get $from) (local.get $to)) + (then + (return (i32.const -1)))) + (if (i32.eq (i32.load8_u (local.get $from)) (local.get $expected)) + (then + (local.set $from (i32.add (local.get $from) (i32.const 1))) + (br $cont)))) + (return (local.get $from))) +) +(invoke "test") + +(assert_return (invoke "checkRange" (i32.const 0) (i32.const 124) (i32.const 0)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 124) (i32.const 1517) (i32.const 9)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 1517) (i32.const 2132) (i32.const 0)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 2132) (i32.const 2827) (i32.const 10)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 2827) (i32.const 2921) (i32.const 92)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 2921) (i32.const 3538) (i32.const 83)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 3538) (i32.const 3786) (i32.const 77)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 3786) (i32.const 4042) (i32.const 97)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 4042) (i32.const 4651) (i32.const 99)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 4651) (i32.const 5057) (i32.const 0)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 5057) (i32.const 5109) (i32.const 99)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 5109) (i32.const 5291) (i32.const 0)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 5291) (i32.const 5524) (i32.const 72)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 5524) (i32.const 5691) (i32.const 92)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 5691) (i32.const 6552) (i32.const 83)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 6552) (i32.const 7133) (i32.const 77)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 7133) (i32.const 7665) (i32.const 99)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 7665) (i32.const 8314) (i32.const 0)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 8314) (i32.const 8360) (i32.const 62)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 8360) (i32.const 8793) (i32.const 86)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 8793) (i32.const 8979) (i32.const 83)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 8979) (i32.const 9373) (i32.const 79)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 9373) (i32.const 9518) (i32.const 95)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 9518) (i32.const 9934) (i32.const 59)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 9934) (i32.const 10087) (i32.const 77)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 10087) (i32.const 10206) (i32.const 5)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 10206) (i32.const 10230) (i32.const 77)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 10230) (i32.const 10249) (i32.const 41)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 10249) (i32.const 11148) (i32.const 83)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 11148) (i32.const 11356) (i32.const 74)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 11356) (i32.const 11380) (i32.const 93)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 11380) (i32.const 11939) (i32.const 74)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 11939) (i32.const 12159) (i32.const 68)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 12159) (i32.const 12575) (i32.const 83)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 12575) (i32.const 12969) (i32.const 79)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 12969) (i32.const 13114) (i32.const 95)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 13114) (i32.const 14133) (i32.const 59)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 14133) (i32.const 14404) (i32.const 76)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 14404) (i32.const 14428) (i32.const 57)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 14428) (i32.const 14458) (i32.const 59)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 14458) (i32.const 14580) (i32.const 32)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 14580) (i32.const 14777) (i32.const 89)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 14777) (i32.const 15124) (i32.const 59)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 15124) (i32.const 15126) (i32.const 36)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 15126) (i32.const 15192) (i32.const 100)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 15192) (i32.const 15871) (i32.const 96)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 15871) (i32.const 15998) (i32.const 95)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 15998) (i32.const 17017) (i32.const 59)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 17017) (i32.const 17288) (i32.const 76)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 17288) (i32.const 17312) (i32.const 57)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 17312) (i32.const 17342) (i32.const 59)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 17342) (i32.const 17464) (i32.const 32)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 17464) (i32.const 17661) (i32.const 89)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 17661) (i32.const 17727) (i32.const 59)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 17727) (i32.const 17733) (i32.const 5)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 17733) (i32.const 17893) (i32.const 96)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 17893) (i32.const 18553) (i32.const 77)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 18553) (i32.const 18744) (i32.const 42)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 18744) (i32.const 18801) (i32.const 76)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 18801) (i32.const 18825) (i32.const 57)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 18825) (i32.const 18876) (i32.const 59)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 18876) (i32.const 18885) (i32.const 77)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 18885) (i32.const 18904) (i32.const 41)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 18904) (i32.const 19567) (i32.const 83)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 19567) (i32.const 20403) (i32.const 96)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 20403) (i32.const 21274) (i32.const 77)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 21274) (i32.const 21364) (i32.const 100)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 21364) (i32.const 21468) (i32.const 74)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 21468) (i32.const 21492) (i32.const 93)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 21492) (i32.const 22051) (i32.const 74)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 22051) (i32.const 22480) (i32.const 68)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 22480) (i32.const 22685) (i32.const 100)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 22685) (i32.const 22694) (i32.const 68)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 22694) (i32.const 22821) (i32.const 10)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 22821) (i32.const 22869) (i32.const 100)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 22869) (i32.const 24107) (i32.const 97)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 24107) (i32.const 24111) (i32.const 37)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 24111) (i32.const 24236) (i32.const 77)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 24236) (i32.const 24348) (i32.const 72)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 24348) (i32.const 24515) (i32.const 92)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 24515) (i32.const 24900) (i32.const 83)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 24900) (i32.const 25136) (i32.const 95)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 25136) (i32.const 25182) (i32.const 85)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 25182) (i32.const 25426) (i32.const 68)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 25426) (i32.const 25613) (i32.const 89)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 25613) (i32.const 25830) (i32.const 96)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 25830) (i32.const 26446) (i32.const 100)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 26446) (i32.const 26517) (i32.const 10)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 26517) (i32.const 27468) (i32.const 92)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 27468) (i32.const 27503) (i32.const 95)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 27503) (i32.const 27573) (i32.const 77)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 27573) (i32.const 28245) (i32.const 92)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 28245) (i32.const 28280) (i32.const 95)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 28280) (i32.const 29502) (i32.const 77)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 29502) (i32.const 29629) (i32.const 42)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 29629) (i32.const 30387) (i32.const 83)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 30387) (i32.const 30646) (i32.const 77)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 30646) (i32.const 31066) (i32.const 92)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 31066) (i32.const 31131) (i32.const 77)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 31131) (i32.const 31322) (i32.const 42)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 31322) (i32.const 31379) (i32.const 76)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 31379) (i32.const 31403) (i32.const 57)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 31403) (i32.const 31454) (i32.const 59)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 31454) (i32.const 31463) (i32.const 77)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 31463) (i32.const 31482) (i32.const 41)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 31482) (i32.const 31649) (i32.const 83)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 31649) (i32.const 31978) (i32.const 72)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 31978) (i32.const 32145) (i32.const 92)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 32145) (i32.const 32530) (i32.const 83)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 32530) (i32.const 32766) (i32.const 95)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 32766) (i32.const 32812) (i32.const 85)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 32812) (i32.const 33056) (i32.const 68)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 33056) (i32.const 33660) (i32.const 89)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 33660) (i32.const 33752) (i32.const 59)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 33752) (i32.const 33775) (i32.const 36)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 33775) (i32.const 33778) (i32.const 32)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 33778) (i32.const 34603) (i32.const 9)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 34603) (i32.const 35218) (i32.const 0)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 35218) (i32.const 35372) (i32.const 10)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 35372) (i32.const 35486) (i32.const 77)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 35486) (i32.const 35605) (i32.const 5)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 35605) (i32.const 35629) (i32.const 77)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 35629) (i32.const 35648) (i32.const 41)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 35648) (i32.const 36547) (i32.const 83)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 36547) (i32.const 36755) (i32.const 74)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 36755) (i32.const 36767) (i32.const 93)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 36767) (i32.const 36810) (i32.const 83)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 36810) (i32.const 36839) (i32.const 100)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 36839) (i32.const 37444) (i32.const 96)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 37444) (i32.const 38060) (i32.const 100)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 38060) (i32.const 38131) (i32.const 10)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 38131) (i32.const 39082) (i32.const 92)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 39082) (i32.const 39117) (i32.const 95)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 39117) (i32.const 39187) (i32.const 77)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 39187) (i32.const 39859) (i32.const 92)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 39859) (i32.const 39894) (i32.const 95)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 39894) (i32.const 40257) (i32.const 77)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 40257) (i32.const 40344) (i32.const 89)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 40344) (i32.const 40371) (i32.const 59)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 40371) (i32.const 40804) (i32.const 77)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 40804) (i32.const 40909) (i32.const 5)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 40909) (i32.const 42259) (i32.const 92)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 42259) (i32.const 42511) (i32.const 77)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 42511) (i32.const 42945) (i32.const 83)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 42945) (i32.const 43115) (i32.const 77)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 43115) (i32.const 43306) (i32.const 42)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 43306) (i32.const 43363) (i32.const 76)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 43363) (i32.const 43387) (i32.const 57)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 43387) (i32.const 43438) (i32.const 59)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 43438) (i32.const 43447) (i32.const 77)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 43447) (i32.const 43466) (i32.const 41)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 43466) (i32.const 44129) (i32.const 83)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 44129) (i32.const 44958) (i32.const 96)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 44958) (i32.const 45570) (i32.const 77)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 45570) (i32.const 45575) (i32.const 92)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 45575) (i32.const 45640) (i32.const 77)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 45640) (i32.const 45742) (i32.const 42)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 45742) (i32.const 45832) (i32.const 72)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 45832) (i32.const 45999) (i32.const 92)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 45999) (i32.const 46384) (i32.const 83)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 46384) (i32.const 46596) (i32.const 95)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 46596) (i32.const 46654) (i32.const 92)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 46654) (i32.const 47515) (i32.const 83)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 47515) (i32.const 47620) (i32.const 77)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 47620) (i32.const 47817) (i32.const 79)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 47817) (i32.const 47951) (i32.const 95)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 47951) (i32.const 48632) (i32.const 100)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 48632) (i32.const 48699) (i32.const 97)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 48699) (i32.const 48703) (i32.const 37)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 48703) (i32.const 49764) (i32.const 77)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 49764) (i32.const 49955) (i32.const 42)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 49955) (i32.const 50012) (i32.const 76)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 50012) (i32.const 50036) (i32.const 57)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 50036) (i32.const 50087) (i32.const 59)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 50087) (i32.const 50096) (i32.const 77)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 50096) (i32.const 50115) (i32.const 41)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 50115) (i32.const 50370) (i32.const 83)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 50370) (i32.const 51358) (i32.const 92)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 51358) (i32.const 51610) (i32.const 77)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 51610) (i32.const 51776) (i32.const 83)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 51776) (i32.const 51833) (i32.const 89)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 51833) (i32.const 52895) (i32.const 100)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 52895) (i32.const 53029) (i32.const 97)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 53029) (i32.const 53244) (i32.const 68)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 53244) (i32.const 54066) (i32.const 100)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 54066) (i32.const 54133) (i32.const 97)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 54133) (i32.const 54137) (i32.const 37)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 54137) (i32.const 55198) (i32.const 77)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 55198) (i32.const 55389) (i32.const 42)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 55389) (i32.const 55446) (i32.const 76)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 55446) (i32.const 55470) (i32.const 57)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 55470) (i32.const 55521) (i32.const 59)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 55521) (i32.const 55530) (i32.const 77)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 55530) (i32.const 55549) (i32.const 41)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 55549) (i32.const 56212) (i32.const 83)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 56212) (i32.const 57048) (i32.const 96)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 57048) (i32.const 58183) (i32.const 77)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 58183) (i32.const 58202) (i32.const 41)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 58202) (i32.const 58516) (i32.const 83)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 58516) (i32.const 58835) (i32.const 95)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 58835) (i32.const 58855) (i32.const 77)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 58855) (i32.const 59089) (i32.const 95)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 59089) (i32.const 59145) (i32.const 77)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 59145) (i32.const 59677) (i32.const 99)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 59677) (i32.const 60134) (i32.const 0)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 60134) (i32.const 60502) (i32.const 89)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 60502) (i32.const 60594) (i32.const 59)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 60594) (i32.const 60617) (i32.const 36)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 60617) (i32.const 60618) (i32.const 32)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 60618) (i32.const 60777) (i32.const 42)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 60777) (i32.const 60834) (i32.const 76)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 60834) (i32.const 60858) (i32.const 57)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 60858) (i32.const 60909) (i32.const 59)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 60909) (i32.const 60918) (i32.const 77)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 60918) (i32.const 60937) (i32.const 41)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 60937) (i32.const 61600) (i32.const 83)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 61600) (i32.const 62436) (i32.const 96)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 62436) (i32.const 63307) (i32.const 77)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 63307) (i32.const 63397) (i32.const 100)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 63397) (i32.const 63501) (i32.const 74)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 63501) (i32.const 63525) (i32.const 93)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 63525) (i32.const 63605) (i32.const 74)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 63605) (i32.const 63704) (i32.const 100)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 63704) (i32.const 63771) (i32.const 97)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 63771) (i32.const 63775) (i32.const 37)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 63775) (i32.const 64311) (i32.const 77)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 64311) (i32.const 64331) (i32.const 26)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 64331) (i32.const 64518) (i32.const 92)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 64518) (i32.const 64827) (i32.const 11)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 64827) (i32.const 64834) (i32.const 26)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 64834) (i32.const 65536) (i32.const 0)) + (i32.const -1)) diff --git a/runtime/near-vm/tests/wast/spec/proposals/bulk-memory-operations/memory_fill.wast b/runtime/near-vm/tests/wast/spec/proposals/bulk-memory-operations/memory_fill.wast new file mode 100644 index 00000000000..caca80b5daa --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/proposals/bulk-memory-operations/memory_fill.wast @@ -0,0 +1,685 @@ +;; +;; Generated by ../meta/generate_memory_fill.js +;; + +(module + (memory 1 1) + + (func (export "checkRange") (param $from i32) (param $to i32) (param $expected i32) (result i32) + (loop $cont + (if (i32.eq (local.get $from) (local.get $to)) + (then + (return (i32.const -1)))) + (if (i32.eq (i32.load8_u (local.get $from)) (local.get $expected)) + (then + (local.set $from (i32.add (local.get $from) (i32.const 1))) + (br $cont)))) + (return (local.get $from))) + + (func (export "test") + (memory.fill (i32.const 0xFF00) (i32.const 0x55) (i32.const 256)))) +(invoke "test") + +(assert_return (invoke "checkRange" (i32.const 0) (i32.const 65280) (i32.const 0)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 65280) (i32.const 65536) (i32.const 85)) + (i32.const -1)) +(module + (memory 1 1) + + (func (export "checkRange") (param $from i32) (param $to i32) (param $expected i32) (result i32) + (loop $cont + (if (i32.eq (local.get $from) (local.get $to)) + (then + (return (i32.const -1)))) + (if (i32.eq (i32.load8_u (local.get $from)) (local.get $expected)) + (then + (local.set $from (i32.add (local.get $from) (i32.const 1))) + (br $cont)))) + (return (local.get $from))) + + (func (export "test") + (memory.fill (i32.const 0xFF00) (i32.const 0x55) (i32.const 257)))) +(assert_trap (invoke "test") "out of bounds memory access") + +(module + (memory 1 1) + + (func (export "checkRange") (param $from i32) (param $to i32) (param $expected i32) (result i32) + (loop $cont + (if (i32.eq (local.get $from) (local.get $to)) + (then + (return (i32.const -1)))) + (if (i32.eq (i32.load8_u (local.get $from)) (local.get $expected)) + (then + (local.set $from (i32.add (local.get $from) (i32.const 1))) + (br $cont)))) + (return (local.get $from))) + + (func (export "test") + (memory.fill (i32.const 0xFFFFFF00) (i32.const 0x55) (i32.const 257)))) +(assert_trap (invoke "test") "out of bounds memory access") + +(module + (memory 1 1) + + (func (export "checkRange") (param $from i32) (param $to i32) (param $expected i32) (result i32) + (loop $cont + (if (i32.eq (local.get $from) (local.get $to)) + (then + (return (i32.const -1)))) + (if (i32.eq (i32.load8_u (local.get $from)) (local.get $expected)) + (then + (local.set $from (i32.add (local.get $from) (i32.const 1))) + (br $cont)))) + (return (local.get $from))) + + (func (export "test") + (memory.fill (i32.const 0x12) (i32.const 0x55) (i32.const 0)))) +(invoke "test") + +(assert_return (invoke "checkRange" (i32.const 0) (i32.const 65536) (i32.const 0)) + (i32.const -1)) +(module + (memory 1 1) + + (func (export "checkRange") (param $from i32) (param $to i32) (param $expected i32) (result i32) + (loop $cont + (if (i32.eq (local.get $from) (local.get $to)) + (then + (return (i32.const -1)))) + (if (i32.eq (i32.load8_u (local.get $from)) (local.get $expected)) + (then + (local.set $from (i32.add (local.get $from) (i32.const 1))) + (br $cont)))) + (return (local.get $from))) + + (func (export "test") + (memory.fill (i32.const 0x10000) (i32.const 0x55) (i32.const 0)))) +(invoke "test") + +(module + (memory 1 1) + + (func (export "checkRange") (param $from i32) (param $to i32) (param $expected i32) (result i32) + (loop $cont + (if (i32.eq (local.get $from) (local.get $to)) + (then + (return (i32.const -1)))) + (if (i32.eq (i32.load8_u (local.get $from)) (local.get $expected)) + (then + (local.set $from (i32.add (local.get $from) (i32.const 1))) + (br $cont)))) + (return (local.get $from))) + + (func (export "test") + (memory.fill (i32.const 0x20000) (i32.const 0x55) (i32.const 0)))) +(assert_trap (invoke "test") "out of bounds") + +(module + (memory 1 1) + + (func (export "checkRange") (param $from i32) (param $to i32) (param $expected i32) (result i32) + (loop $cont + (if (i32.eq (local.get $from) (local.get $to)) + (then + (return (i32.const -1)))) + (if (i32.eq (i32.load8_u (local.get $from)) (local.get $expected)) + (then + (local.set $from (i32.add (local.get $from) (i32.const 1))) + (br $cont)))) + (return (local.get $from))) + + (func (export "test") + (memory.fill (i32.const 0x1) (i32.const 0xAA) (i32.const 0xFFFE)))) +(invoke "test") + +(assert_return (invoke "checkRange" (i32.const 0) (i32.const 1) (i32.const 0)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 1) (i32.const 65535) (i32.const 170)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 65535) (i32.const 65536) (i32.const 0)) + (i32.const -1)) + +(module + (memory 1 1) + + (func (export "checkRange") (param $from i32) (param $to i32) (param $expected i32) (result i32) + (loop $cont + (if (i32.eq (local.get $from) (local.get $to)) + (then + (return (i32.const -1)))) + (if (i32.eq (i32.load8_u (local.get $from)) (local.get $expected)) + (then + (local.set $from (i32.add (local.get $from) (i32.const 1))) + (br $cont)))) + (return (local.get $from))) + + (func (export "test") + (memory.fill (i32.const 0x12) (i32.const 0x55) (i32.const 10)) + (memory.fill (i32.const 0x15) (i32.const 0xAA) (i32.const 4)))) +(invoke "test") + +(assert_return (invoke "checkRange" (i32.const 0) (i32.const 18) (i32.const 0)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 18) (i32.const 21) (i32.const 85)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 21) (i32.const 25) (i32.const 170)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 25) (i32.const 28) (i32.const 85)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 28) (i32.const 65536) (i32.const 0)) + (i32.const -1)) +(assert_invalid + (module + (func (export "testfn") + (memory.fill (i32.const 10) (i32.const 20) (i32.const 30)))) + "unknown memory 0") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.fill (i32.const 10) (i32.const 20) (f32.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.fill (i32.const 10) (i32.const 20) (i64.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.fill (i32.const 10) (i32.const 20) (f64.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.fill (i32.const 10) (f32.const 20) (i32.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.fill (i32.const 10) (f32.const 20) (f32.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.fill (i32.const 10) (f32.const 20) (i64.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.fill (i32.const 10) (f32.const 20) (f64.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.fill (i32.const 10) (i64.const 20) (i32.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.fill (i32.const 10) (i64.const 20) (f32.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.fill (i32.const 10) (i64.const 20) (i64.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.fill (i32.const 10) (i64.const 20) (f64.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.fill (i32.const 10) (f64.const 20) (i32.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.fill (i32.const 10) (f64.const 20) (f32.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.fill (i32.const 10) (f64.const 20) (i64.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.fill (i32.const 10) (f64.const 20) (f64.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.fill (f32.const 10) (i32.const 20) (i32.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.fill (f32.const 10) (i32.const 20) (f32.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.fill (f32.const 10) (i32.const 20) (i64.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.fill (f32.const 10) (i32.const 20) (f64.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.fill (f32.const 10) (f32.const 20) (i32.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.fill (f32.const 10) (f32.const 20) (f32.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.fill (f32.const 10) (f32.const 20) (i64.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.fill (f32.const 10) (f32.const 20) (f64.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.fill (f32.const 10) (i64.const 20) (i32.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.fill (f32.const 10) (i64.const 20) (f32.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.fill (f32.const 10) (i64.const 20) (i64.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.fill (f32.const 10) (i64.const 20) (f64.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.fill (f32.const 10) (f64.const 20) (i32.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.fill (f32.const 10) (f64.const 20) (f32.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.fill (f32.const 10) (f64.const 20) (i64.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.fill (f32.const 10) (f64.const 20) (f64.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.fill (i64.const 10) (i32.const 20) (i32.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.fill (i64.const 10) (i32.const 20) (f32.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.fill (i64.const 10) (i32.const 20) (i64.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.fill (i64.const 10) (i32.const 20) (f64.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.fill (i64.const 10) (f32.const 20) (i32.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.fill (i64.const 10) (f32.const 20) (f32.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.fill (i64.const 10) (f32.const 20) (i64.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.fill (i64.const 10) (f32.const 20) (f64.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.fill (i64.const 10) (i64.const 20) (i32.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.fill (i64.const 10) (i64.const 20) (f32.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.fill (i64.const 10) (i64.const 20) (i64.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.fill (i64.const 10) (i64.const 20) (f64.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.fill (i64.const 10) (f64.const 20) (i32.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.fill (i64.const 10) (f64.const 20) (f32.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.fill (i64.const 10) (f64.const 20) (i64.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.fill (i64.const 10) (f64.const 20) (f64.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.fill (f64.const 10) (i32.const 20) (i32.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.fill (f64.const 10) (i32.const 20) (f32.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.fill (f64.const 10) (i32.const 20) (i64.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.fill (f64.const 10) (i32.const 20) (f64.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.fill (f64.const 10) (f32.const 20) (i32.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.fill (f64.const 10) (f32.const 20) (f32.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.fill (f64.const 10) (f32.const 20) (i64.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.fill (f64.const 10) (f32.const 20) (f64.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.fill (f64.const 10) (i64.const 20) (i32.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.fill (f64.const 10) (i64.const 20) (f32.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.fill (f64.const 10) (i64.const 20) (i64.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.fill (f64.const 10) (i64.const 20) (f64.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.fill (f64.const 10) (f64.const 20) (i32.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.fill (f64.const 10) (f64.const 20) (f32.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.fill (f64.const 10) (f64.const 20) (i64.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.fill (f64.const 10) (f64.const 20) (f64.const 30)))) + "type mismatch") + +(module + (memory 1 1 ) + + (func (export "checkRange") (param $from i32) (param $to i32) (param $expected i32) (result i32) + (loop $cont + (if (i32.eq (local.get $from) (local.get $to)) + (then + (return (i32.const -1)))) + (if (i32.eq (i32.load8_u (local.get $from)) (local.get $expected)) + (then + (local.set $from (i32.add (local.get $from) (i32.const 1))) + (br $cont)))) + (return (local.get $from))) + + (func (export "run") (param $offs i32) (param $val i32) (param $len i32) + (memory.fill (local.get $offs) (local.get $val) (local.get $len)))) + +(assert_trap (invoke "run" (i32.const 65280) (i32.const 37) (i32.const 512)) + "out of bounds") + +(assert_return (invoke "checkRange" (i32.const 0) (i32.const 1) (i32.const 0)) + (i32.const -1)) +(module + (memory 1 1 ) + + (func (export "checkRange") (param $from i32) (param $to i32) (param $expected i32) (result i32) + (loop $cont + (if (i32.eq (local.get $from) (local.get $to)) + (then + (return (i32.const -1)))) + (if (i32.eq (i32.load8_u (local.get $from)) (local.get $expected)) + (then + (local.set $from (i32.add (local.get $from) (i32.const 1))) + (br $cont)))) + (return (local.get $from))) + + (func (export "run") (param $offs i32) (param $val i32) (param $len i32) + (memory.fill (local.get $offs) (local.get $val) (local.get $len)))) + +(assert_trap (invoke "run" (i32.const 65279) (i32.const 37) (i32.const 514)) + "out of bounds") + +(assert_return (invoke "checkRange" (i32.const 0) (i32.const 1) (i32.const 0)) + (i32.const -1)) +(module + (memory 1 1 ) + + (func (export "checkRange") (param $from i32) (param $to i32) (param $expected i32) (result i32) + (loop $cont + (if (i32.eq (local.get $from) (local.get $to)) + (then + (return (i32.const -1)))) + (if (i32.eq (i32.load8_u (local.get $from)) (local.get $expected)) + (then + (local.set $from (i32.add (local.get $from) (i32.const 1))) + (br $cont)))) + (return (local.get $from))) + + (func (export "run") (param $offs i32) (param $val i32) (param $len i32) + (memory.fill (local.get $offs) (local.get $val) (local.get $len)))) + +(assert_trap (invoke "run" (i32.const 65279) (i32.const 37) (i32.const 4294967295)) + "out of bounds") + +(assert_return (invoke "checkRange" (i32.const 0) (i32.const 1) (i32.const 0)) + (i32.const -1)) diff --git a/runtime/near-vm/tests/wast/spec/proposals/bulk-memory-operations/memory_init.wast b/runtime/near-vm/tests/wast/spec/proposals/bulk-memory-operations/memory_init.wast new file mode 100644 index 00000000000..60b60578cf6 --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/proposals/bulk-memory-operations/memory_init.wast @@ -0,0 +1,967 @@ +;; +;; Generated by ../meta/generate_memory_init.js +;; + +(module + (memory (export "memory0") 1 1) + (data (i32.const 2) "\03\01\04\01") + (data "\02\07\01\08") + (data (i32.const 12) "\07\05\02\03\06") + (data "\05\09\02\07\06") + (func (export "test") + (nop)) + (func (export "load8_u") (param i32) (result i32) + (i32.load8_u (local.get 0)))) + +(invoke "test") + +(assert_return (invoke "load8_u" (i32.const 0)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 1)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 2)) (i32.const 3)) +(assert_return (invoke "load8_u" (i32.const 3)) (i32.const 1)) +(assert_return (invoke "load8_u" (i32.const 4)) (i32.const 4)) +(assert_return (invoke "load8_u" (i32.const 5)) (i32.const 1)) +(assert_return (invoke "load8_u" (i32.const 6)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 7)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 8)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 9)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 10)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 11)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 12)) (i32.const 7)) +(assert_return (invoke "load8_u" (i32.const 13)) (i32.const 5)) +(assert_return (invoke "load8_u" (i32.const 14)) (i32.const 2)) +(assert_return (invoke "load8_u" (i32.const 15)) (i32.const 3)) +(assert_return (invoke "load8_u" (i32.const 16)) (i32.const 6)) +(assert_return (invoke "load8_u" (i32.const 17)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 18)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 19)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 20)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 21)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 22)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 23)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 24)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 25)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 26)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 27)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 28)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 29)) (i32.const 0)) + +(module + (memory (export "memory0") 1 1) + (data (i32.const 2) "\03\01\04\01") + (data "\02\07\01\08") + (data (i32.const 12) "\07\05\02\03\06") + (data "\05\09\02\07\06") + (func (export "test") + (memory.init 1 (i32.const 7) (i32.const 0) (i32.const 4))) + (func (export "load8_u") (param i32) (result i32) + (i32.load8_u (local.get 0)))) + +(invoke "test") + +(assert_return (invoke "load8_u" (i32.const 0)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 1)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 2)) (i32.const 3)) +(assert_return (invoke "load8_u" (i32.const 3)) (i32.const 1)) +(assert_return (invoke "load8_u" (i32.const 4)) (i32.const 4)) +(assert_return (invoke "load8_u" (i32.const 5)) (i32.const 1)) +(assert_return (invoke "load8_u" (i32.const 6)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 7)) (i32.const 2)) +(assert_return (invoke "load8_u" (i32.const 8)) (i32.const 7)) +(assert_return (invoke "load8_u" (i32.const 9)) (i32.const 1)) +(assert_return (invoke "load8_u" (i32.const 10)) (i32.const 8)) +(assert_return (invoke "load8_u" (i32.const 11)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 12)) (i32.const 7)) +(assert_return (invoke "load8_u" (i32.const 13)) (i32.const 5)) +(assert_return (invoke "load8_u" (i32.const 14)) (i32.const 2)) +(assert_return (invoke "load8_u" (i32.const 15)) (i32.const 3)) +(assert_return (invoke "load8_u" (i32.const 16)) (i32.const 6)) +(assert_return (invoke "load8_u" (i32.const 17)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 18)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 19)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 20)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 21)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 22)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 23)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 24)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 25)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 26)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 27)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 28)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 29)) (i32.const 0)) + +(module + (memory (export "memory0") 1 1) + (data (i32.const 2) "\03\01\04\01") + (data "\02\07\01\08") + (data (i32.const 12) "\07\05\02\03\06") + (data "\05\09\02\07\06") + (func (export "test") + (memory.init 3 (i32.const 15) (i32.const 1) (i32.const 3))) + (func (export "load8_u") (param i32) (result i32) + (i32.load8_u (local.get 0)))) + +(invoke "test") + +(assert_return (invoke "load8_u" (i32.const 0)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 1)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 2)) (i32.const 3)) +(assert_return (invoke "load8_u" (i32.const 3)) (i32.const 1)) +(assert_return (invoke "load8_u" (i32.const 4)) (i32.const 4)) +(assert_return (invoke "load8_u" (i32.const 5)) (i32.const 1)) +(assert_return (invoke "load8_u" (i32.const 6)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 7)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 8)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 9)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 10)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 11)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 12)) (i32.const 7)) +(assert_return (invoke "load8_u" (i32.const 13)) (i32.const 5)) +(assert_return (invoke "load8_u" (i32.const 14)) (i32.const 2)) +(assert_return (invoke "load8_u" (i32.const 15)) (i32.const 9)) +(assert_return (invoke "load8_u" (i32.const 16)) (i32.const 2)) +(assert_return (invoke "load8_u" (i32.const 17)) (i32.const 7)) +(assert_return (invoke "load8_u" (i32.const 18)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 19)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 20)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 21)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 22)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 23)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 24)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 25)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 26)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 27)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 28)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 29)) (i32.const 0)) + +(module + (memory (export "memory0") 1 1) + (data (i32.const 2) "\03\01\04\01") + (data "\02\07\01\08") + (data (i32.const 12) "\07\05\02\03\06") + (data "\05\09\02\07\06") + (func (export "test") + (memory.init 1 (i32.const 7) (i32.const 0) (i32.const 4)) + (data.drop 1) + (memory.init 3 (i32.const 15) (i32.const 1) (i32.const 3)) + (data.drop 3) + (memory.copy (i32.const 20) (i32.const 15) (i32.const 5)) + (memory.copy (i32.const 21) (i32.const 29) (i32.const 1)) + (memory.copy (i32.const 24) (i32.const 10) (i32.const 1)) + (memory.copy (i32.const 13) (i32.const 11) (i32.const 4)) + (memory.copy (i32.const 19) (i32.const 20) (i32.const 5))) + (func (export "load8_u") (param i32) (result i32) + (i32.load8_u (local.get 0)))) + +(invoke "test") + +(assert_return (invoke "load8_u" (i32.const 0)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 1)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 2)) (i32.const 3)) +(assert_return (invoke "load8_u" (i32.const 3)) (i32.const 1)) +(assert_return (invoke "load8_u" (i32.const 4)) (i32.const 4)) +(assert_return (invoke "load8_u" (i32.const 5)) (i32.const 1)) +(assert_return (invoke "load8_u" (i32.const 6)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 7)) (i32.const 2)) +(assert_return (invoke "load8_u" (i32.const 8)) (i32.const 7)) +(assert_return (invoke "load8_u" (i32.const 9)) (i32.const 1)) +(assert_return (invoke "load8_u" (i32.const 10)) (i32.const 8)) +(assert_return (invoke "load8_u" (i32.const 11)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 12)) (i32.const 7)) +(assert_return (invoke "load8_u" (i32.const 13)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 14)) (i32.const 7)) +(assert_return (invoke "load8_u" (i32.const 15)) (i32.const 5)) +(assert_return (invoke "load8_u" (i32.const 16)) (i32.const 2)) +(assert_return (invoke "load8_u" (i32.const 17)) (i32.const 7)) +(assert_return (invoke "load8_u" (i32.const 18)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 19)) (i32.const 9)) +(assert_return (invoke "load8_u" (i32.const 20)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 21)) (i32.const 7)) +(assert_return (invoke "load8_u" (i32.const 22)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 23)) (i32.const 8)) +(assert_return (invoke "load8_u" (i32.const 24)) (i32.const 8)) +(assert_return (invoke "load8_u" (i32.const 25)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 26)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 27)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 28)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 29)) (i32.const 0)) +(assert_invalid + (module + (func (export "test") + (data.drop 0))) + "unknown data segment") + +(assert_invalid + (module + (memory 1) + (data "\37") + (func (export "test") + (data.drop 4))) + "unknown data segment") + +(module + (memory 1) + (data "\37") + (func (export "test") + (data.drop 0) + (data.drop 0))) +(invoke "test") + +(module + (memory 1) + (data "\37") + (func (export "test") + (data.drop 0) + (memory.init 0 (i32.const 1234) (i32.const 1) (i32.const 1)))) +(assert_trap (invoke "test") "out of bounds") + +(module + (memory 1) + (data (i32.const 0) "\37") + (func (export "test") + (memory.init 0 (i32.const 1234) (i32.const 1) (i32.const 1)))) +(assert_trap (invoke "test") "out of bounds") + +(assert_invalid + (module + (func (export "test") + (memory.init 1 (i32.const 1234) (i32.const 1) (i32.const 1)))) + "unknown memory 0") + +(assert_invalid + (module + (memory 1) + (data "\37") + (func (export "test") + (memory.init 1 (i32.const 1234) (i32.const 1) (i32.const 1)))) + "unknown data segment 1") + +(module + (memory 1) + (data "\37") + (func (export "test") + (memory.init 0 (i32.const 1) (i32.const 0) (i32.const 1)) + (memory.init 0 (i32.const 1) (i32.const 0) (i32.const 1)))) +(invoke "test") + +(module + (memory 1) + (data "\37") + (func (export "test") + (memory.init 0 (i32.const 1234) (i32.const 0) (i32.const 5)))) +(assert_trap (invoke "test") "out of bounds") + +(module + (memory 1) + (data "\37") + (func (export "test") + (memory.init 0 (i32.const 1234) (i32.const 2) (i32.const 3)))) +(assert_trap (invoke "test") "out of bounds") + +(module + (memory 1) + (data "\37") + (func (export "test") + (memory.init 0 (i32.const 0xFFFE) (i32.const 1) (i32.const 3)))) +(assert_trap (invoke "test") "out of bounds") + +(module + (memory 1) + (data "\37") + (func (export "test") + (memory.init 0 (i32.const 1234) (i32.const 4) (i32.const 0)))) +(assert_trap (invoke "test") "out of bounds") + +(module + (memory 1) + (data "\37") + (func (export "test") + (memory.init 0 (i32.const 1234) (i32.const 1) (i32.const 0)))) +(invoke "test") + +(module + (memory 1) + (data "\37") + (func (export "test") + (memory.init 0 (i32.const 0x10001) (i32.const 0) (i32.const 0)))) +(assert_trap (invoke "test") "out of bounds") + +(module + (memory 1) + (data "\37") + (func (export "test") + (memory.init 0 (i32.const 0x10000) (i32.const 0) (i32.const 0)))) +(invoke "test") + +(module + (memory 1) + (data "\37") + (func (export "test") + (memory.init 0 (i32.const 0x10000) (i32.const 1) (i32.const 0)))) +(invoke "test") + +(module + (memory 1) + (data "\37") + (func (export "test") + (memory.init 0 (i32.const 0x10001) (i32.const 4) (i32.const 0)))) +(assert_trap (invoke "test") "out of bounds") + +(assert_invalid + (module + (memory 1) + (data "\37") + (func (export "test") + (memory.init 0 (i32.const 1) (i32.const 1) (f32.const 1)))) + "type mismatch") + +(assert_invalid + (module + (memory 1) + (data "\37") + (func (export "test") + (memory.init 0 (i32.const 1) (i32.const 1) (i64.const 1)))) + "type mismatch") + +(assert_invalid + (module + (memory 1) + (data "\37") + (func (export "test") + (memory.init 0 (i32.const 1) (i32.const 1) (f64.const 1)))) + "type mismatch") + +(assert_invalid + (module + (memory 1) + (data "\37") + (func (export "test") + (memory.init 0 (i32.const 1) (f32.const 1) (i32.const 1)))) + "type mismatch") + +(assert_invalid + (module + (memory 1) + (data "\37") + (func (export "test") + (memory.init 0 (i32.const 1) (f32.const 1) (f32.const 1)))) + "type mismatch") + +(assert_invalid + (module + (memory 1) + (data "\37") + (func (export "test") + (memory.init 0 (i32.const 1) (f32.const 1) (i64.const 1)))) + "type mismatch") + +(assert_invalid + (module + (memory 1) + (data "\37") + (func (export "test") + (memory.init 0 (i32.const 1) (f32.const 1) (f64.const 1)))) + "type mismatch") + +(assert_invalid + (module + (memory 1) + (data "\37") + (func (export "test") + (memory.init 0 (i32.const 1) (i64.const 1) (i32.const 1)))) + "type mismatch") + +(assert_invalid + (module + (memory 1) + (data "\37") + (func (export "test") + (memory.init 0 (i32.const 1) (i64.const 1) (f32.const 1)))) + "type mismatch") + +(assert_invalid + (module + (memory 1) + (data "\37") + (func (export "test") + (memory.init 0 (i32.const 1) (i64.const 1) (i64.const 1)))) + "type mismatch") + +(assert_invalid + (module + (memory 1) + (data "\37") + (func (export "test") + (memory.init 0 (i32.const 1) (i64.const 1) (f64.const 1)))) + "type mismatch") + +(assert_invalid + (module + (memory 1) + (data "\37") + (func (export "test") + (memory.init 0 (i32.const 1) (f64.const 1) (i32.const 1)))) + "type mismatch") + +(assert_invalid + (module + (memory 1) + (data "\37") + (func (export "test") + (memory.init 0 (i32.const 1) (f64.const 1) (f32.const 1)))) + "type mismatch") + +(assert_invalid + (module + (memory 1) + (data "\37") + (func (export "test") + (memory.init 0 (i32.const 1) (f64.const 1) (i64.const 1)))) + "type mismatch") + +(assert_invalid + (module + (memory 1) + (data "\37") + (func (export "test") + (memory.init 0 (i32.const 1) (f64.const 1) (f64.const 1)))) + "type mismatch") + +(assert_invalid + (module + (memory 1) + (data "\37") + (func (export "test") + (memory.init 0 (f32.const 1) (i32.const 1) (i32.const 1)))) + "type mismatch") + +(assert_invalid + (module + (memory 1) + (data "\37") + (func (export "test") + (memory.init 0 (f32.const 1) (i32.const 1) (f32.const 1)))) + "type mismatch") + +(assert_invalid + (module + (memory 1) + (data "\37") + (func (export "test") + (memory.init 0 (f32.const 1) (i32.const 1) (i64.const 1)))) + "type mismatch") + +(assert_invalid + (module + (memory 1) + (data "\37") + (func (export "test") + (memory.init 0 (f32.const 1) (i32.const 1) (f64.const 1)))) + "type mismatch") + +(assert_invalid + (module + (memory 1) + (data "\37") + (func (export "test") + (memory.init 0 (f32.const 1) (f32.const 1) (i32.const 1)))) + "type mismatch") + +(assert_invalid + (module + (memory 1) + (data "\37") + (func (export "test") + (memory.init 0 (f32.const 1) (f32.const 1) (f32.const 1)))) + "type mismatch") + +(assert_invalid + (module + (memory 1) + (data "\37") + (func (export "test") + (memory.init 0 (f32.const 1) (f32.const 1) (i64.const 1)))) + "type mismatch") + +(assert_invalid + (module + (memory 1) + (data "\37") + (func (export "test") + (memory.init 0 (f32.const 1) (f32.const 1) (f64.const 1)))) + "type mismatch") + +(assert_invalid + (module + (memory 1) + (data "\37") + (func (export "test") + (memory.init 0 (f32.const 1) (i64.const 1) (i32.const 1)))) + "type mismatch") + +(assert_invalid + (module + (memory 1) + (data "\37") + (func (export "test") + (memory.init 0 (f32.const 1) (i64.const 1) (f32.const 1)))) + "type mismatch") + +(assert_invalid + (module + (memory 1) + (data "\37") + (func (export "test") + (memory.init 0 (f32.const 1) (i64.const 1) (i64.const 1)))) + "type mismatch") + +(assert_invalid + (module + (memory 1) + (data "\37") + (func (export "test") + (memory.init 0 (f32.const 1) (i64.const 1) (f64.const 1)))) + "type mismatch") + +(assert_invalid + (module + (memory 1) + (data "\37") + (func (export "test") + (memory.init 0 (f32.const 1) (f64.const 1) (i32.const 1)))) + "type mismatch") + +(assert_invalid + (module + (memory 1) + (data "\37") + (func (export "test") + (memory.init 0 (f32.const 1) (f64.const 1) (f32.const 1)))) + "type mismatch") + +(assert_invalid + (module + (memory 1) + (data "\37") + (func (export "test") + (memory.init 0 (f32.const 1) (f64.const 1) (i64.const 1)))) + "type mismatch") + +(assert_invalid + (module + (memory 1) + (data "\37") + (func (export "test") + (memory.init 0 (f32.const 1) (f64.const 1) (f64.const 1)))) + "type mismatch") + +(assert_invalid + (module + (memory 1) + (data "\37") + (func (export "test") + (memory.init 0 (i64.const 1) (i32.const 1) (i32.const 1)))) + "type mismatch") + +(assert_invalid + (module + (memory 1) + (data "\37") + (func (export "test") + (memory.init 0 (i64.const 1) (i32.const 1) (f32.const 1)))) + "type mismatch") + +(assert_invalid + (module + (memory 1) + (data "\37") + (func (export "test") + (memory.init 0 (i64.const 1) (i32.const 1) (i64.const 1)))) + "type mismatch") + +(assert_invalid + (module + (memory 1) + (data "\37") + (func (export "test") + (memory.init 0 (i64.const 1) (i32.const 1) (f64.const 1)))) + "type mismatch") + +(assert_invalid + (module + (memory 1) + (data "\37") + (func (export "test") + (memory.init 0 (i64.const 1) (f32.const 1) (i32.const 1)))) + "type mismatch") + +(assert_invalid + (module + (memory 1) + (data "\37") + (func (export "test") + (memory.init 0 (i64.const 1) (f32.const 1) (f32.const 1)))) + "type mismatch") + +(assert_invalid + (module + (memory 1) + (data "\37") + (func (export "test") + (memory.init 0 (i64.const 1) (f32.const 1) (i64.const 1)))) + "type mismatch") + +(assert_invalid + (module + (memory 1) + (data "\37") + (func (export "test") + (memory.init 0 (i64.const 1) (f32.const 1) (f64.const 1)))) + "type mismatch") + +(assert_invalid + (module + (memory 1) + (data "\37") + (func (export "test") + (memory.init 0 (i64.const 1) (i64.const 1) (i32.const 1)))) + "type mismatch") + +(assert_invalid + (module + (memory 1) + (data "\37") + (func (export "test") + (memory.init 0 (i64.const 1) (i64.const 1) (f32.const 1)))) + "type mismatch") + +(assert_invalid + (module + (memory 1) + (data "\37") + (func (export "test") + (memory.init 0 (i64.const 1) (i64.const 1) (i64.const 1)))) + "type mismatch") + +(assert_invalid + (module + (memory 1) + (data "\37") + (func (export "test") + (memory.init 0 (i64.const 1) (i64.const 1) (f64.const 1)))) + "type mismatch") + +(assert_invalid + (module + (memory 1) + (data "\37") + (func (export "test") + (memory.init 0 (i64.const 1) (f64.const 1) (i32.const 1)))) + "type mismatch") + +(assert_invalid + (module + (memory 1) + (data "\37") + (func (export "test") + (memory.init 0 (i64.const 1) (f64.const 1) (f32.const 1)))) + "type mismatch") + +(assert_invalid + (module + (memory 1) + (data "\37") + (func (export "test") + (memory.init 0 (i64.const 1) (f64.const 1) (i64.const 1)))) + "type mismatch") + +(assert_invalid + (module + (memory 1) + (data "\37") + (func (export "test") + (memory.init 0 (i64.const 1) (f64.const 1) (f64.const 1)))) + "type mismatch") + +(assert_invalid + (module + (memory 1) + (data "\37") + (func (export "test") + (memory.init 0 (f64.const 1) (i32.const 1) (i32.const 1)))) + "type mismatch") + +(assert_invalid + (module + (memory 1) + (data "\37") + (func (export "test") + (memory.init 0 (f64.const 1) (i32.const 1) (f32.const 1)))) + "type mismatch") + +(assert_invalid + (module + (memory 1) + (data "\37") + (func (export "test") + (memory.init 0 (f64.const 1) (i32.const 1) (i64.const 1)))) + "type mismatch") + +(assert_invalid + (module + (memory 1) + (data "\37") + (func (export "test") + (memory.init 0 (f64.const 1) (i32.const 1) (f64.const 1)))) + "type mismatch") + +(assert_invalid + (module + (memory 1) + (data "\37") + (func (export "test") + (memory.init 0 (f64.const 1) (f32.const 1) (i32.const 1)))) + "type mismatch") + +(assert_invalid + (module + (memory 1) + (data "\37") + (func (export "test") + (memory.init 0 (f64.const 1) (f32.const 1) (f32.const 1)))) + "type mismatch") + +(assert_invalid + (module + (memory 1) + (data "\37") + (func (export "test") + (memory.init 0 (f64.const 1) (f32.const 1) (i64.const 1)))) + "type mismatch") + +(assert_invalid + (module + (memory 1) + (data "\37") + (func (export "test") + (memory.init 0 (f64.const 1) (f32.const 1) (f64.const 1)))) + "type mismatch") + +(assert_invalid + (module + (memory 1) + (data "\37") + (func (export "test") + (memory.init 0 (f64.const 1) (i64.const 1) (i32.const 1)))) + "type mismatch") + +(assert_invalid + (module + (memory 1) + (data "\37") + (func (export "test") + (memory.init 0 (f64.const 1) (i64.const 1) (f32.const 1)))) + "type mismatch") + +(assert_invalid + (module + (memory 1) + (data "\37") + (func (export "test") + (memory.init 0 (f64.const 1) (i64.const 1) (i64.const 1)))) + "type mismatch") + +(assert_invalid + (module + (memory 1) + (data "\37") + (func (export "test") + (memory.init 0 (f64.const 1) (i64.const 1) (f64.const 1)))) + "type mismatch") + +(assert_invalid + (module + (memory 1) + (data "\37") + (func (export "test") + (memory.init 0 (f64.const 1) (f64.const 1) (i32.const 1)))) + "type mismatch") + +(assert_invalid + (module + (memory 1) + (data "\37") + (func (export "test") + (memory.init 0 (f64.const 1) (f64.const 1) (f32.const 1)))) + "type mismatch") + +(assert_invalid + (module + (memory 1) + (data "\37") + (func (export "test") + (memory.init 0 (f64.const 1) (f64.const 1) (i64.const 1)))) + "type mismatch") + +(assert_invalid + (module + (memory 1) + (data "\37") + (func (export "test") + (memory.init 0 (f64.const 1) (f64.const 1) (f64.const 1)))) + "type mismatch") + +(module + (memory 1 1 ) + (data "\42\42\42\42\42\42\42\42\42\42\42\42\42\42\42\42") + + (func (export "checkRange") (param $from i32) (param $to i32) (param $expected i32) (result i32) + (loop $cont + (if (i32.eq (local.get $from) (local.get $to)) + (then + (return (i32.const -1)))) + (if (i32.eq (i32.load8_u (local.get $from)) (local.get $expected)) + (then + (local.set $from (i32.add (local.get $from) (i32.const 1))) + (br $cont)))) + (return (local.get $from))) + + (func (export "run") (param $offs i32) (param $len i32) + (memory.init 0 (local.get $offs) (i32.const 0) (local.get $len)))) + +(assert_trap (invoke "run" (i32.const 65528) (i32.const 16)) + "out of bounds") + +(assert_return (invoke "checkRange" (i32.const 0) (i32.const 1) (i32.const 0)) + (i32.const -1)) +(module + (memory 1 1 ) + (data "\42\42\42\42\42\42\42\42\42\42\42\42\42\42\42\42") + + (func (export "checkRange") (param $from i32) (param $to i32) (param $expected i32) (result i32) + (loop $cont + (if (i32.eq (local.get $from) (local.get $to)) + (then + (return (i32.const -1)))) + (if (i32.eq (i32.load8_u (local.get $from)) (local.get $expected)) + (then + (local.set $from (i32.add (local.get $from) (i32.const 1))) + (br $cont)))) + (return (local.get $from))) + + (func (export "run") (param $offs i32) (param $len i32) + (memory.init 0 (local.get $offs) (i32.const 0) (local.get $len)))) + +(assert_trap (invoke "run" (i32.const 65527) (i32.const 16)) + "out of bounds") + +(assert_return (invoke "checkRange" (i32.const 0) (i32.const 1) (i32.const 0)) + (i32.const -1)) +(module + (memory 1 1 ) + (data "\42\42\42\42\42\42\42\42\42\42\42\42\42\42\42\42") + + (func (export "checkRange") (param $from i32) (param $to i32) (param $expected i32) (result i32) + (loop $cont + (if (i32.eq (local.get $from) (local.get $to)) + (then + (return (i32.const -1)))) + (if (i32.eq (i32.load8_u (local.get $from)) (local.get $expected)) + (then + (local.set $from (i32.add (local.get $from) (i32.const 1))) + (br $cont)))) + (return (local.get $from))) + + (func (export "run") (param $offs i32) (param $len i32) + (memory.init 0 (local.get $offs) (i32.const 0) (local.get $len)))) + +(assert_trap (invoke "run" (i32.const 65472) (i32.const 30)) + "out of bounds") + +(assert_return (invoke "checkRange" (i32.const 0) (i32.const 1) (i32.const 0)) + (i32.const -1)) +(module + (memory 1 1 ) + (data "\42\42\42\42\42\42\42\42\42\42\42\42\42\42\42\42") + + (func (export "checkRange") (param $from i32) (param $to i32) (param $expected i32) (result i32) + (loop $cont + (if (i32.eq (local.get $from) (local.get $to)) + (then + (return (i32.const -1)))) + (if (i32.eq (i32.load8_u (local.get $from)) (local.get $expected)) + (then + (local.set $from (i32.add (local.get $from) (i32.const 1))) + (br $cont)))) + (return (local.get $from))) + + (func (export "run") (param $offs i32) (param $len i32) + (memory.init 0 (local.get $offs) (i32.const 0) (local.get $len)))) + +(assert_trap (invoke "run" (i32.const 65473) (i32.const 31)) + "out of bounds") + +(assert_return (invoke "checkRange" (i32.const 0) (i32.const 1) (i32.const 0)) + (i32.const -1)) +(module + (memory 1 ) + (data "\42\42\42\42\42\42\42\42\42\42\42\42\42\42\42\42") + + (func (export "checkRange") (param $from i32) (param $to i32) (param $expected i32) (result i32) + (loop $cont + (if (i32.eq (local.get $from) (local.get $to)) + (then + (return (i32.const -1)))) + (if (i32.eq (i32.load8_u (local.get $from)) (local.get $expected)) + (then + (local.set $from (i32.add (local.get $from) (i32.const 1))) + (br $cont)))) + (return (local.get $from))) + + (func (export "run") (param $offs i32) (param $len i32) + (memory.init 0 (local.get $offs) (i32.const 0) (local.get $len)))) + +(assert_trap (invoke "run" (i32.const 65528) (i32.const 4294967040)) + "out of bounds") + +(assert_return (invoke "checkRange" (i32.const 0) (i32.const 1) (i32.const 0)) + (i32.const -1)) +(module + (memory 1 ) + (data "\42\42\42\42\42\42\42\42\42\42\42\42\42\42\42\42") + + (func (export "checkRange") (param $from i32) (param $to i32) (param $expected i32) (result i32) + (loop $cont + (if (i32.eq (local.get $from) (local.get $to)) + (then + (return (i32.const -1)))) + (if (i32.eq (i32.load8_u (local.get $from)) (local.get $expected)) + (then + (local.set $from (i32.add (local.get $from) (i32.const 1))) + (br $cont)))) + (return (local.get $from))) + + (func (export "run") (param $offs i32) (param $len i32) + (memory.init 0 (local.get $offs) (i32.const 0) (local.get $len)))) + +(assert_trap (invoke "run" (i32.const 0) (i32.const 4294967292)) + "out of bounds") + +(assert_return (invoke "checkRange" (i32.const 0) (i32.const 1) (i32.const 0)) + (i32.const -1)) + +(module + (memory 1) + ;; 65 data segments. 64 is the smallest positive number that is encoded + ;; differently as a signed LEB. + (data "") (data "") (data "") (data "") (data "") (data "") (data "") (data "") + (data "") (data "") (data "") (data "") (data "") (data "") (data "") (data "") + (data "") (data "") (data "") (data "") (data "") (data "") (data "") (data "") + (data "") (data "") (data "") (data "") (data "") (data "") (data "") (data "") + (data "") (data "") (data "") (data "") (data "") (data "") (data "") (data "") + (data "") (data "") (data "") (data "") (data "") (data "") (data "") (data "") + (data "") (data "") (data "") (data "") (data "") (data "") (data "") (data "") + (data "") (data "") (data "") (data "") (data "") (data "") (data "") (data "") + (data "") + (func (memory.init 64 (i32.const 0) (i32.const 0) (i32.const 0)))) + diff --git a/runtime/near-vm/tests/wast/spec/proposals/bulk-memory-operations/table_copy.wast b/runtime/near-vm/tests/wast/spec/proposals/bulk-memory-operations/table_copy.wast new file mode 100644 index 00000000000..d0aa77b2050 --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/proposals/bulk-memory-operations/table_copy.wast @@ -0,0 +1,1595 @@ +;; +;; Generated by ../meta/generate_table_copy.js +;; + +(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 + (import "a" "ef0" (func (result i32))) ;; index 0 + (import "a" "ef1" (func (result i32))) + (import "a" "ef2" (func (result i32))) + (import "a" "ef3" (func (result i32))) + (import "a" "ef4" (func (result i32))) ;; index 4 + (table 30 30 funcref) + (elem (i32.const 2) 3 1 4 1) + (elem funcref + (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8)) + (elem (i32.const 12) 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") + (nop)) + (func (export "check") (param i32) (result i32) + (call_indirect (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 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 + (import "a" "ef0" (func (result i32))) ;; index 0 + (import "a" "ef1" (func (result i32))) + (import "a" "ef2" (func (result i32))) + (import "a" "ef3" (func (result i32))) + (import "a" "ef4" (func (result i32))) ;; index 4 + (table 30 30 funcref) + (elem (i32.const 2) 3 1 4 1) + (elem funcref + (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8)) + (elem (i32.const 12) 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.copy (i32.const 13) (i32.const 2) (i32.const 3))) + (func (export "check") (param i32) (result i32) + (call_indirect (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 3)) +(assert_return (invoke "check" (i32.const 14)) (i32.const 1)) +(assert_return (invoke "check" (i32.const 15)) (i32.const 4)) +(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 + (import "a" "ef0" (func (result i32))) ;; index 0 + (import "a" "ef1" (func (result i32))) + (import "a" "ef2" (func (result i32))) + (import "a" "ef3" (func (result i32))) + (import "a" "ef4" (func (result i32))) ;; index 4 + (table 30 30 funcref) + (elem (i32.const 2) 3 1 4 1) + (elem funcref + (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8)) + (elem (i32.const 12) 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.copy (i32.const 25) (i32.const 15) (i32.const 2))) + (func (export "check") (param i32) (result i32) + (call_indirect (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 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_return (invoke "check" (i32.const 25)) (i32.const 3)) +(assert_return (invoke "check" (i32.const 26)) (i32.const 6)) +(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 + (import "a" "ef0" (func (result i32))) ;; index 0 + (import "a" "ef1" (func (result i32))) + (import "a" "ef2" (func (result i32))) + (import "a" "ef3" (func (result i32))) + (import "a" "ef4" (func (result i32))) ;; index 4 + (table 30 30 funcref) + (elem (i32.const 2) 3 1 4 1) + (elem funcref + (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8)) + (elem (i32.const 12) 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.copy (i32.const 13) (i32.const 25) (i32.const 3))) + (func (export "check") (param i32) (result i32) + (call_indirect (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_trap (invoke "check" (i32.const 13)) "uninitialized element") +(assert_trap (invoke "check" (i32.const 14)) "uninitialized element") +(assert_trap (invoke "check" (i32.const 15)) "uninitialized element") +(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 + (import "a" "ef0" (func (result i32))) ;; index 0 + (import "a" "ef1" (func (result i32))) + (import "a" "ef2" (func (result i32))) + (import "a" "ef3" (func (result i32))) + (import "a" "ef4" (func (result i32))) ;; index 4 + (table 30 30 funcref) + (elem (i32.const 2) 3 1 4 1) + (elem funcref + (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8)) + (elem (i32.const 12) 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.copy (i32.const 20) (i32.const 22) (i32.const 4))) + (func (export "check") (param i32) (result i32) + (call_indirect (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 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 + (import "a" "ef0" (func (result i32))) ;; index 0 + (import "a" "ef1" (func (result i32))) + (import "a" "ef2" (func (result i32))) + (import "a" "ef3" (func (result i32))) + (import "a" "ef4" (func (result i32))) ;; index 4 + (table 30 30 funcref) + (elem (i32.const 2) 3 1 4 1) + (elem funcref + (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8)) + (elem (i32.const 12) 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.copy (i32.const 25) (i32.const 1) (i32.const 3))) + (func (export "check") (param i32) (result i32) + (call_indirect (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 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_return (invoke "check" (i32.const 26)) (i32.const 3)) +(assert_return (invoke "check" (i32.const 27)) (i32.const 1)) +(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 + (import "a" "ef0" (func (result i32))) ;; index 0 + (import "a" "ef1" (func (result i32))) + (import "a" "ef2" (func (result i32))) + (import "a" "ef3" (func (result i32))) + (import "a" "ef4" (func (result i32))) ;; index 4 + (table 30 30 funcref) + (elem (i32.const 2) 3 1 4 1) + (elem funcref + (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8)) + (elem (i32.const 12) 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.copy (i32.const 10) (i32.const 12) (i32.const 7))) + (func (export "check") (param i32) (result i32) + (call_indirect (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_return (invoke "check" (i32.const 10)) (i32.const 7)) +(assert_return (invoke "check" (i32.const 11)) (i32.const 5)) +(assert_return (invoke "check" (i32.const 12)) (i32.const 2)) +(assert_return (invoke "check" (i32.const 13)) (i32.const 3)) +(assert_return (invoke "check" (i32.const 14)) (i32.const 6)) +(assert_trap (invoke "check" (i32.const 15)) "uninitialized element") +(assert_trap (invoke "check" (i32.const 16)) "uninitialized element") +(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 + (import "a" "ef0" (func (result i32))) ;; index 0 + (import "a" "ef1" (func (result i32))) + (import "a" "ef2" (func (result i32))) + (import "a" "ef3" (func (result i32))) + (import "a" "ef4" (func (result i32))) ;; index 4 + (table 30 30 funcref) + (elem (i32.const 2) 3 1 4 1) + (elem funcref + (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8)) + (elem (i32.const 12) 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.copy (i32.const 12) (i32.const 10) (i32.const 7))) + (func (export "check") (param i32) (result i32) + (call_indirect (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_trap (invoke "check" (i32.const 12)) "uninitialized element") +(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 3)) +(assert_return (invoke "check" (i32.const 18)) (i32.const 6)) +(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 + (table 30 30 funcref) + (elem (i32.const 2) 3 1 4 1) + (elem funcref + (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8)) + (elem (i32.const 12) 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.copy (i32.const 28) (i32.const 1) (i32.const 3)) + )) + +(assert_trap (invoke "test") "out of bounds") + +(module + (table 30 30 funcref) + (elem (i32.const 2) 3 1 4 1) + (elem funcref + (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8)) + (elem (i32.const 12) 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.copy (i32.const 0xFFFFFFFE) (i32.const 1) (i32.const 2)) + )) + +(assert_trap (invoke "test") "out of bounds") + +(module + (table 30 30 funcref) + (elem (i32.const 2) 3 1 4 1) + (elem funcref + (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8)) + (elem (i32.const 12) 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.copy (i32.const 15) (i32.const 25) (i32.const 6)) + )) + +(assert_trap (invoke "test") "out of bounds") + +(module + (table 30 30 funcref) + (elem (i32.const 2) 3 1 4 1) + (elem funcref + (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8)) + (elem (i32.const 12) 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.copy (i32.const 15) (i32.const 0xFFFFFFFE) (i32.const 2)) + )) + +(assert_trap (invoke "test") "out of bounds") + +(module + (table 30 30 funcref) + (elem (i32.const 2) 3 1 4 1) + (elem funcref + (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8)) + (elem (i32.const 12) 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.copy (i32.const 15) (i32.const 25) (i32.const 0)) + )) + +(invoke "test") + +(module + (table 30 30 funcref) + (elem (i32.const 2) 3 1 4 1) + (elem funcref + (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8)) + (elem (i32.const 12) 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.copy (i32.const 30) (i32.const 15) (i32.const 0)) + )) + +(invoke "test") + +(module + (table 30 30 funcref) + (elem (i32.const 2) 3 1 4 1) + (elem funcref + (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8)) + (elem (i32.const 12) 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.copy (i32.const 31) (i32.const 15) (i32.const 0)) + )) + +(assert_trap (invoke "test") "out of bounds") + +(module + (table 30 30 funcref) + (elem (i32.const 2) 3 1 4 1) + (elem funcref + (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8)) + (elem (i32.const 12) 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.copy (i32.const 15) (i32.const 30) (i32.const 0)) + )) + +(invoke "test") + +(module + (table 30 30 funcref) + (elem (i32.const 2) 3 1 4 1) + (elem funcref + (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8)) + (elem (i32.const 12) 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.copy (i32.const 15) (i32.const 31) (i32.const 0)) + )) + +(assert_trap (invoke "test") "out of bounds") + +(module + (table 30 30 funcref) + (elem (i32.const 2) 3 1 4 1) + (elem funcref + (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8)) + (elem (i32.const 12) 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.copy (i32.const 30) (i32.const 30) (i32.const 0)) + )) + +(invoke "test") + +(module + (table 30 30 funcref) + (elem (i32.const 2) 3 1 4 1) + (elem funcref + (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8)) + (elem (i32.const 12) 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.copy (i32.const 31) (i32.const 31) (i32.const 0)) + )) + +(assert_trap (invoke "test") "out of bounds") + +(module + (type (func (result i32))) + (table 32 64 funcref) + (elem (i32.const 0) + $f0 $f1 $f2 $f3 $f4 $f5 $f6 $f7) + (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 $targetOffs i32) (param $srcOffs i32) (param $len i32) + (table.copy (local.get $targetOffs) (local.get $srcOffs) (local.get $len)))) + +(assert_trap (invoke "run" (i32.const 24) (i32.const 0) (i32.const 16)) + "out of bounds") +(assert_return (invoke "test" (i32.const 0)) (i32.const 0)) +(assert_return (invoke "test" (i32.const 1)) (i32.const 1)) +(assert_return (invoke "test" (i32.const 2)) (i32.const 2)) +(assert_return (invoke "test" (i32.const 3)) (i32.const 3)) +(assert_return (invoke "test" (i32.const 4)) (i32.const 4)) +(assert_return (invoke "test" (i32.const 5)) (i32.const 5)) +(assert_return (invoke "test" (i32.const 6)) (i32.const 6)) +(assert_return (invoke "test" (i32.const 7)) (i32.const 7)) +(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 (i32.const 0) + $f0 $f1 $f2 $f3 $f4 $f5 $f6 $f7 $f8) + (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 $targetOffs i32) (param $srcOffs i32) (param $len i32) + (table.copy (local.get $targetOffs) (local.get $srcOffs) (local.get $len)))) + +(assert_trap (invoke "run" (i32.const 23) (i32.const 0) (i32.const 15)) + "out of bounds") +(assert_return (invoke "test" (i32.const 0)) (i32.const 0)) +(assert_return (invoke "test" (i32.const 1)) (i32.const 1)) +(assert_return (invoke "test" (i32.const 2)) (i32.const 2)) +(assert_return (invoke "test" (i32.const 3)) (i32.const 3)) +(assert_return (invoke "test" (i32.const 4)) (i32.const 4)) +(assert_return (invoke "test" (i32.const 5)) (i32.const 5)) +(assert_return (invoke "test" (i32.const 6)) (i32.const 6)) +(assert_return (invoke "test" (i32.const 7)) (i32.const 7)) +(assert_return (invoke "test" (i32.const 8)) (i32.const 8)) +(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 (i32.const 24) + $f0 $f1 $f2 $f3 $f4 $f5 $f6 $f7) + (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 $targetOffs i32) (param $srcOffs i32) (param $len i32) + (table.copy (local.get $targetOffs) (local.get $srcOffs) (local.get $len)))) + +(assert_trap (invoke "run" (i32.const 0) (i32.const 24) (i32.const 16)) + "out of bounds") +(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_return (invoke "test" (i32.const 24)) (i32.const 0)) +(assert_return (invoke "test" (i32.const 25)) (i32.const 1)) +(assert_return (invoke "test" (i32.const 26)) (i32.const 2)) +(assert_return (invoke "test" (i32.const 27)) (i32.const 3)) +(assert_return (invoke "test" (i32.const 28)) (i32.const 4)) +(assert_return (invoke "test" (i32.const 29)) (i32.const 5)) +(assert_return (invoke "test" (i32.const 30)) (i32.const 6)) +(assert_return (invoke "test" (i32.const 31)) (i32.const 7)) + +(module + (type (func (result i32))) + (table 32 64 funcref) + (elem (i32.const 23) + $f0 $f1 $f2 $f3 $f4 $f5 $f6 $f7 $f8) + (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 $targetOffs i32) (param $srcOffs i32) (param $len i32) + (table.copy (local.get $targetOffs) (local.get $srcOffs) (local.get $len)))) + +(assert_trap (invoke "run" (i32.const 0) (i32.const 23) (i32.const 15)) + "out of bounds") +(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_return (invoke "test" (i32.const 23)) (i32.const 0)) +(assert_return (invoke "test" (i32.const 24)) (i32.const 1)) +(assert_return (invoke "test" (i32.const 25)) (i32.const 2)) +(assert_return (invoke "test" (i32.const 26)) (i32.const 3)) +(assert_return (invoke "test" (i32.const 27)) (i32.const 4)) +(assert_return (invoke "test" (i32.const 28)) (i32.const 5)) +(assert_return (invoke "test" (i32.const 29)) (i32.const 6)) +(assert_return (invoke "test" (i32.const 30)) (i32.const 7)) +(assert_return (invoke "test" (i32.const 31)) (i32.const 8)) + +(module + (type (func (result i32))) + (table 32 64 funcref) + (elem (i32.const 11) + $f0 $f1 $f2 $f3 $f4 $f5 $f6 $f7) + (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 $targetOffs i32) (param $srcOffs i32) (param $len i32) + (table.copy (local.get $targetOffs) (local.get $srcOffs) (local.get $len)))) + +(assert_trap (invoke "run" (i32.const 24) (i32.const 11) (i32.const 16)) + "out of bounds") +(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_return (invoke "test" (i32.const 11)) (i32.const 0)) +(assert_return (invoke "test" (i32.const 12)) (i32.const 1)) +(assert_return (invoke "test" (i32.const 13)) (i32.const 2)) +(assert_return (invoke "test" (i32.const 14)) (i32.const 3)) +(assert_return (invoke "test" (i32.const 15)) (i32.const 4)) +(assert_return (invoke "test" (i32.const 16)) (i32.const 5)) +(assert_return (invoke "test" (i32.const 17)) (i32.const 6)) +(assert_return (invoke "test" (i32.const 18)) (i32.const 7)) +(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 (i32.const 24) + $f0 $f1 $f2 $f3 $f4 $f5 $f6 $f7) + (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 $targetOffs i32) (param $srcOffs i32) (param $len i32) + (table.copy (local.get $targetOffs) (local.get $srcOffs) (local.get $len)))) + +(assert_trap (invoke "run" (i32.const 11) (i32.const 24) (i32.const 16)) + "out of bounds") +(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_return (invoke "test" (i32.const 24)) (i32.const 0)) +(assert_return (invoke "test" (i32.const 25)) (i32.const 1)) +(assert_return (invoke "test" (i32.const 26)) (i32.const 2)) +(assert_return (invoke "test" (i32.const 27)) (i32.const 3)) +(assert_return (invoke "test" (i32.const 28)) (i32.const 4)) +(assert_return (invoke "test" (i32.const 29)) (i32.const 5)) +(assert_return (invoke "test" (i32.const 30)) (i32.const 6)) +(assert_return (invoke "test" (i32.const 31)) (i32.const 7)) + +(module + (type (func (result i32))) + (table 32 64 funcref) + (elem (i32.const 21) + $f0 $f1 $f2 $f3 $f4 $f5 $f6 $f7) + (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 $targetOffs i32) (param $srcOffs i32) (param $len i32) + (table.copy (local.get $targetOffs) (local.get $srcOffs) (local.get $len)))) + +(assert_trap (invoke "run" (i32.const 24) (i32.const 21) (i32.const 16)) + "out of bounds") +(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_return (invoke "test" (i32.const 21)) (i32.const 0)) +(assert_return (invoke "test" (i32.const 22)) (i32.const 1)) +(assert_return (invoke "test" (i32.const 23)) (i32.const 2)) +(assert_return (invoke "test" (i32.const 24)) (i32.const 3)) +(assert_return (invoke "test" (i32.const 25)) (i32.const 4)) +(assert_return (invoke "test" (i32.const 26)) (i32.const 5)) +(assert_return (invoke "test" (i32.const 27)) (i32.const 6)) +(assert_return (invoke "test" (i32.const 28)) (i32.const 7)) +(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 (i32.const 24) + $f0 $f1 $f2 $f3 $f4 $f5 $f6 $f7) + (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 $targetOffs i32) (param $srcOffs i32) (param $len i32) + (table.copy (local.get $targetOffs) (local.get $srcOffs) (local.get $len)))) + +(assert_trap (invoke "run" (i32.const 21) (i32.const 24) (i32.const 16)) + "out of bounds") +(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_return (invoke "test" (i32.const 24)) (i32.const 0)) +(assert_return (invoke "test" (i32.const 25)) (i32.const 1)) +(assert_return (invoke "test" (i32.const 26)) (i32.const 2)) +(assert_return (invoke "test" (i32.const 27)) (i32.const 3)) +(assert_return (invoke "test" (i32.const 28)) (i32.const 4)) +(assert_return (invoke "test" (i32.const 29)) (i32.const 5)) +(assert_return (invoke "test" (i32.const 30)) (i32.const 6)) +(assert_return (invoke "test" (i32.const 31)) (i32.const 7)) + +(module + (type (func (result i32))) + (table 32 64 funcref) + (elem (i32.const 21) + $f0 $f1 $f2 $f3 $f4 $f5 $f6 $f7 $f8 $f9 $f10) + (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 $targetOffs i32) (param $srcOffs i32) (param $len i32) + (table.copy (local.get $targetOffs) (local.get $srcOffs) (local.get $len)))) + +(assert_trap (invoke "run" (i32.const 21) (i32.const 21) (i32.const 16)) + "out of bounds") +(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_return (invoke "test" (i32.const 21)) (i32.const 0)) +(assert_return (invoke "test" (i32.const 22)) (i32.const 1)) +(assert_return (invoke "test" (i32.const 23)) (i32.const 2)) +(assert_return (invoke "test" (i32.const 24)) (i32.const 3)) +(assert_return (invoke "test" (i32.const 25)) (i32.const 4)) +(assert_return (invoke "test" (i32.const 26)) (i32.const 5)) +(assert_return (invoke "test" (i32.const 27)) (i32.const 6)) +(assert_return (invoke "test" (i32.const 28)) (i32.const 7)) +(assert_return (invoke "test" (i32.const 29)) (i32.const 8)) +(assert_return (invoke "test" (i32.const 30)) (i32.const 9)) +(assert_return (invoke "test" (i32.const 31)) (i32.const 10)) + +(module + (type (func (result i32))) + (table 128 128 funcref) + (elem (i32.const 112) + $f0 $f1 $f2 $f3 $f4 $f5 $f6 $f7 $f8 $f9 $f10 $f11 $f12 $f13 $f14 $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 $targetOffs i32) (param $srcOffs i32) (param $len i32) + (table.copy (local.get $targetOffs) (local.get $srcOffs) (local.get $len)))) + +(assert_trap (invoke "run" (i32.const 0) (i32.const 112) (i32.const 4294967264)) + "out of bounds") +(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_return (invoke "test" (i32.const 112)) (i32.const 0)) +(assert_return (invoke "test" (i32.const 113)) (i32.const 1)) +(assert_return (invoke "test" (i32.const 114)) (i32.const 2)) +(assert_return (invoke "test" (i32.const 115)) (i32.const 3)) +(assert_return (invoke "test" (i32.const 116)) (i32.const 4)) +(assert_return (invoke "test" (i32.const 117)) (i32.const 5)) +(assert_return (invoke "test" (i32.const 118)) (i32.const 6)) +(assert_return (invoke "test" (i32.const 119)) (i32.const 7)) +(assert_return (invoke "test" (i32.const 120)) (i32.const 8)) +(assert_return (invoke "test" (i32.const 121)) (i32.const 9)) +(assert_return (invoke "test" (i32.const 122)) (i32.const 10)) +(assert_return (invoke "test" (i32.const 123)) (i32.const 11)) +(assert_return (invoke "test" (i32.const 124)) (i32.const 12)) +(assert_return (invoke "test" (i32.const 125)) (i32.const 13)) +(assert_return (invoke "test" (i32.const 126)) (i32.const 14)) +(assert_return (invoke "test" (i32.const 127)) (i32.const 15)) + +(module + (type (func (result i32))) + (table 128 128 funcref) + (elem (i32.const 0) + $f0 $f1 $f2 $f3 $f4 $f5 $f6 $f7 $f8 $f9 $f10 $f11 $f12 $f13 $f14 $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 $targetOffs i32) (param $srcOffs i32) (param $len i32) + (table.copy (local.get $targetOffs) (local.get $srcOffs) (local.get $len)))) + +(assert_trap (invoke "run" (i32.const 112) (i32.const 0) (i32.const 4294967264)) + "out of bounds") +(assert_return (invoke "test" (i32.const 0)) (i32.const 0)) +(assert_return (invoke "test" (i32.const 1)) (i32.const 1)) +(assert_return (invoke "test" (i32.const 2)) (i32.const 2)) +(assert_return (invoke "test" (i32.const 3)) (i32.const 3)) +(assert_return (invoke "test" (i32.const 4)) (i32.const 4)) +(assert_return (invoke "test" (i32.const 5)) (i32.const 5)) +(assert_return (invoke "test" (i32.const 6)) (i32.const 6)) +(assert_return (invoke "test" (i32.const 7)) (i32.const 7)) +(assert_return (invoke "test" (i32.const 8)) (i32.const 8)) +(assert_return (invoke "test" (i32.const 9)) (i32.const 9)) +(assert_return (invoke "test" (i32.const 10)) (i32.const 10)) +(assert_return (invoke "test" (i32.const 11)) (i32.const 11)) +(assert_return (invoke "test" (i32.const 12)) (i32.const 12)) +(assert_return (invoke "test" (i32.const 13)) (i32.const 13)) +(assert_return (invoke "test" (i32.const 14)) (i32.const 14)) +(assert_return (invoke "test" (i32.const 15)) (i32.const 15)) +(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") diff --git a/runtime/near-vm/tests/wast/spec/proposals/bulk-memory-operations/table_init.wast b/runtime/near-vm/tests/wast/spec/proposals/bulk-memory-operations/table_init.wast new file mode 100644 index 00000000000..90f86ac17e8 --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/proposals/bulk-memory-operations/table_init.wast @@ -0,0 +1,1776 @@ +;; +;; Generated by ../meta/generate_table_init.js +;; + +(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 + (import "a" "ef0" (func (result i32))) ;; index 0 + (import "a" "ef1" (func (result i32))) + (import "a" "ef2" (func (result i32))) + (import "a" "ef3" (func (result i32))) + (import "a" "ef4" (func (result i32))) ;; index 4 + (table 30 30 funcref) + (elem (i32.const 2) 3 1 4 1) + (elem funcref + (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8)) + (elem (i32.const 12) 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 1 (i32.const 7) (i32.const 0) (i32.const 4))) + (func (export "check") (param i32) (result i32) + (call_indirect (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 + (import "a" "ef0" (func (result i32))) ;; index 0 + (import "a" "ef1" (func (result i32))) + (import "a" "ef2" (func (result i32))) + (import "a" "ef3" (func (result i32))) + (import "a" "ef4" (func (result i32))) ;; index 4 + (table 30 30 funcref) + (elem (i32.const 2) 3 1 4 1) + (elem funcref + (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8)) + (elem (i32.const 12) 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 3 (i32.const 15) (i32.const 1) (i32.const 3))) + (func (export "check") (param i32) (result i32) + (call_indirect (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 + (import "a" "ef0" (func (result i32))) ;; index 0 + (import "a" "ef1" (func (result i32))) + (import "a" "ef2" (func (result i32))) + (import "a" "ef3" (func (result i32))) + (import "a" "ef4" (func (result i32))) ;; index 4 + (table 30 30 funcref) + (elem (i32.const 2) 3 1 4 1) + (elem funcref + (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8)) + (elem (i32.const 12) 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 1 (i32.const 7) (i32.const 0) (i32.const 4)) + (elem.drop 1) + (table.init 3 (i32.const 15) (i32.const 1) (i32.const 3)) + (elem.drop 3) + (table.copy (i32.const 20) (i32.const 15) (i32.const 5)) + (table.copy (i32.const 21) (i32.const 29) (i32.const 1)) + (table.copy (i32.const 24) (i32.const 10) (i32.const 1)) + (table.copy (i32.const 13) (i32.const 11) (i32.const 4)) + (table.copy (i32.const 19) (i32.const 20) (i32.const 5))) + (func (export "check") (param i32) (result i32) + (call_indirect (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 30 30 funcref) + (elem (i32.const 2) 3 1 4 1) + (elem funcref + (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8)) + (elem (i32.const 12) 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 30 30 funcref) + (elem (i32.const 2) 3 1 4 1) + (elem funcref + (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8)) + (elem (i32.const 12) 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") + +(module + (table 30 30 funcref) + (elem (i32.const 2) 3 1 4 1) + (elem funcref + (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8)) + (elem (i32.const 12) 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 30 30 funcref) + (elem (i32.const 2) 3 1 4 1) + (elem funcref + (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8)) + (elem (i32.const 12) 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 30 30 funcref) + (elem (i32.const 2) 3 1 4 1) + (elem funcref + (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8)) + (elem (i32.const 12) 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") + +(module + (table 30 30 funcref) + (elem (i32.const 2) 3 1 4 1) + (elem funcref + (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8)) + (elem (i32.const 12) 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") + +(module + (table 30 30 funcref) + (elem (i32.const 2) 3 1 4 1) + (elem funcref + (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8)) + (elem (i32.const 12) 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") + +(module + (table 30 30 funcref) + (elem (i32.const 2) 3 1 4 1) + (elem funcref + (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8)) + (elem (i32.const 12) 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 28) (i32.const 1) (i32.const 3)) + )) +(assert_trap (invoke "test") "out of bounds") + +(module + (table 30 30 funcref) + (elem (i32.const 2) 3 1 4 1) + (elem funcref + (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8)) + (elem (i32.const 12) 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 4) (i32.const 0)) + )) +(invoke "test") + +(module + (table 30 30 funcref) + (elem (i32.const 2) 3 1 4 1) + (elem funcref + (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8)) + (elem (i32.const 12) 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 5) (i32.const 0)) + )) +(assert_trap (invoke "test") "out of bounds") + +(module + (table 30 30 funcref) + (elem (i32.const 2) 3 1 4 1) + (elem funcref + (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8)) + (elem (i32.const 12) 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 30) (i32.const 2) (i32.const 0)) + )) +(invoke "test") + +(module + (table 30 30 funcref) + (elem (i32.const 2) 3 1 4 1) + (elem funcref + (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8)) + (elem (i32.const 12) 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 31) (i32.const 2) (i32.const 0)) + )) +(assert_trap (invoke "test") "out of bounds") + +(module + (table 30 30 funcref) + (elem (i32.const 2) 3 1 4 1) + (elem funcref + (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8)) + (elem (i32.const 12) 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 30) (i32.const 4) (i32.const 0)) + )) +(invoke "test") + +(module + (table 30 30 funcref) + (elem (i32.const 2) 3 1 4 1) + (elem funcref + (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8)) + (elem (i32.const 12) 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 31) (i32.const 5) (i32.const 0)) + )) +(assert_trap (invoke "test") "out of bounds") + +(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") +(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") +(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") +(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") +(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") +(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") +(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/runtime/near-vm/tests/wast/spec/proposals/gc/array.wast b/runtime/near-vm/tests/wast/spec/proposals/gc/array.wast new file mode 100644 index 00000000000..48a58108b7d --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/proposals/gc/array.wast @@ -0,0 +1,144 @@ +;; 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 data))) + (type (array (ref 0))) + (type (array (ref null 1))) + (type (array (rtt 1))) + (type (array (rtt 10 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 data)))) + (type (array (mut (ref 0)))) + (type (array (mut (ref null i31)))) + (type (array (mut (rtt 0)))) + (type (array (mut (rtt 10 0)))) +) + + +(assert_invalid + (module + (type (array (mut (ref null 10)))) + ) + "unknown type" +) + + +;; Binding structure + +(module + (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))) + + (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) + (array.new_default $vec (i32.const 3) (rtt.canon $vec)) + ) + ) + + (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) (rtt.canon $mvec)) + (local.get $y) + ) + ) + + (func $len (param $v (ref $vec)) (result i32) + (array.len $vec (local.get $v)) + ) + (func (export "len") (result i32) + (call $len (array.new_default $vec (i32.const 3) (rtt.canon $vec))) + ) +) + +(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") +(assert_trap (invoke "set_get" (i32.const 10) (f32.const 7)) "out of bounds") + +(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" +) + + +;; 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") + +(assert_invalid + (module + (type $t (array i32)) + (func (export "array.new-null") + (local (ref null (rtt $t))) (drop (array.new_default $t (i32.const 1) (i32.const 3) (local.get 0))) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (type $t (array (mut i32))) + (func (export "array.new_default-null") + (local (ref null (rtt $t))) (drop (array.new_default $t (i32.const 3) (local.get 0))) + ) + ) + "type mismatch" +) diff --git a/runtime/near-vm/tests/wast/spec/proposals/gc/binary.wast b/runtime/near-vm/tests/wast/spec/proposals/gc/binary.wast new file mode 100644 index 00000000000..1f76dc136ab --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/proposals/gc/binary.wast @@ -0,0 +1,1765 @@ +(module binary "\00asm\01\00\00\00") +(module binary "\00asm" "\01\00\00\00") +(module $M1 binary "\00asm\01\00\00\00") +(module $M2 binary "\00asm" "\01\00\00\00") + +(assert_malformed (module binary "") "unexpected end") +(assert_malformed (module binary "\01") "unexpected end") +(assert_malformed (module binary "\00as") "unexpected end") +(assert_malformed (module binary "asm\00") "magic header not detected") +(assert_malformed (module binary "msa\00") "magic header not detected") +(assert_malformed (module binary "msa\00\01\00\00\00") "magic header not detected") +(assert_malformed (module binary "msa\00\00\00\00\01") "magic header not detected") +(assert_malformed (module binary "asm\01\00\00\00\00") "magic header not detected") +(assert_malformed (module binary "wasm\01\00\00\00") "magic header not detected") +(assert_malformed (module binary "\7fasm\01\00\00\00") "magic header not detected") +(assert_malformed (module binary "\80asm\01\00\00\00") "magic header not detected") +(assert_malformed (module binary "\82asm\01\00\00\00") "magic header not detected") +(assert_malformed (module binary "\ffasm\01\00\00\00") "magic header not detected") + +;; 8-byte endian-reversed. +(assert_malformed (module binary "\00\00\00\01msa\00") "magic header not detected") + +;; Middle-endian byte orderings. +(assert_malformed (module binary "a\00ms\00\01\00\00") "magic header not detected") +(assert_malformed (module binary "sm\00a\00\00\01\00") "magic header not detected") + +;; Upper-cased. +(assert_malformed (module binary "\00ASM\01\00\00\00") "magic header not detected") + +;; EBCDIC-encoded magic. +(assert_malformed (module binary "\00\81\a2\94\01\00\00\00") "magic header not detected") + +;; Leading UTF-8 BOM. +(assert_malformed (module binary "\ef\bb\bf\00asm\01\00\00\00") "magic header not detected") + +;; Malformed binary version. +(assert_malformed (module binary "\00asm") "unexpected end") +(assert_malformed (module binary "\00asm\01") "unexpected end") +(assert_malformed (module binary "\00asm\01\00\00") "unexpected end") +(assert_malformed (module binary "\00asm\00\00\00\00") "unknown binary version") +(assert_malformed (module binary "\00asm\0d\00\00\00") "unknown binary version") +(assert_malformed (module binary "\00asm\0e\00\00\00") "unknown binary version") +(assert_malformed (module binary "\00asm\00\01\00\00") "unknown binary version") +(assert_malformed (module binary "\00asm\00\00\01\00") "unknown binary version") +(assert_malformed (module binary "\00asm\00\00\00\01") "unknown binary version") + +;; Invalid section id. +(assert_malformed (module binary "\00asm" "\01\00\00\00" "\0d\00") "malformed section id") +(assert_malformed (module binary "\00asm" "\01\00\00\00" "\7f\00") "malformed section id") +(assert_malformed (module binary "\00asm" "\01\00\00\00" "\80\00\01\00") "malformed section id") +(assert_malformed (module binary "\00asm" "\01\00\00\00" "\81\00\01\00") "malformed section id") +(assert_malformed (module binary "\00asm" "\01\00\00\00" "\ff\00\01\00") "malformed section id") + +;; Unsigned LEB128 can have non-minimal length +(module binary + "\00asm" "\01\00\00\00" + "\05\04\01" ;; Memory section with 1 entry + "\00\82\00" ;; no max, minimum 2 +) +(module binary + "\00asm" "\01\00\00\00" + "\05\07\01" ;; Memory section with 1 entry + "\00\82\80\80\80\00" ;; no max, minimum 2 +) + +;; Signed LEB128 can have non-minimal length +(module binary + "\00asm" "\01\00\00\00" + "\06\07\01" ;; Global section with 1 entry + "\7f\00" ;; i32, immutable + "\41\80\00" ;; i32.const 0 + "\0b" ;; end +) +(module binary + "\00asm" "\01\00\00\00" + "\06\07\01" ;; Global section with 1 entry + "\7f\00" ;; i32, immutable + "\41\ff\7f" ;; i32.const -1 + "\0b" ;; end +) +(module binary + "\00asm" "\01\00\00\00" + "\06\0a\01" ;; Global section with 1 entry + "\7f\00" ;; i32, immutable + "\41\80\80\80\80\00" ;; i32.const 0 + "\0b" ;; end +) +(module binary + "\00asm" "\01\00\00\00" + "\06\0a\01" ;; Global section with 1 entry + "\7f\00" ;; i32, immutable + "\41\ff\ff\ff\ff\7f" ;; i32.const -1 + "\0b" ;; end +) + +(module binary + "\00asm" "\01\00\00\00" + "\06\07\01" ;; Global section with 1 entry + "\7e\00" ;; i64, immutable + "\42\80\00" ;; i64.const 0 with unused bits set + "\0b" ;; end +) +(module binary + "\00asm" "\01\00\00\00" + "\06\07\01" ;; Global section with 1 entry + "\7e\00" ;; i64, immutable + "\42\ff\7f" ;; i64.const -1 with unused bits unset + "\0b" ;; end +) +(module binary + "\00asm" "\01\00\00\00" + "\06\0f\01" ;; Global section with 1 entry + "\7e\00" ;; i64, immutable + "\42\80\80\80\80\80\80\80\80\80\00" ;; i64.const 0 with unused bits set + "\0b" ;; end +) +(module binary + "\00asm" "\01\00\00\00" + "\06\0f\01" ;; Global section with 1 entry + "\7e\00" ;; i64, immutable + "\42\ff\ff\ff\ff\ff\ff\ff\ff\ff\7f" ;; i64.const -1 with unused bits unset + "\0b" ;; end +) + +(module binary + "\00asm" "\01\00\00\00" + "\05\03\01" ;; Memory section with 1 entry + "\00\00" ;; no max, minimum 0 + "\0b\06\01" ;; Data section with 1 entry + "\00" ;; Memory index 0 + "\41\00\0b\00" ;; (i32.const 0) with contents "" +) + +(module binary + "\00asm" "\01\00\00\00" + "\04\04\01" ;; Table section with 1 entry + "\70\00\00" ;; no max, minimum 0, funcref + "\09\06\01" ;; Element section with 1 entry + "\00" ;; Table index 0 + "\41\00\0b\00" ;; (i32.const 0) with no elements +) + +;; Data segment memory index can have non-minimal length +(module binary + "\00asm" "\01\00\00\00" + "\05\03\01" ;; Memory section with 1 entry + "\00\00" ;; no max, minimum 0 + "\0b\07\01" ;; Data section with 1 entry + "\80\00" ;; Memory index 0, encoded with 2 bytes + "\41\00\0b\00" ;; (i32.const 0) with contents "" +) + +;; Element segment table index can have non-minimal length +(module binary + "\00asm" "\01\00\00\00" + "\04\04\01" ;; Table section with 1 entry + "\70\00\00" ;; no max, minimum 0, funcref + "\09\09\01" ;; Element section with 1 entry + "\02\80\00" ;; Table index 0, encoded with 2 bytes + "\41\00\0b\00\00" ;; (i32.const 0) with no elements +) + +;; Type section with signed LEB128 encoded type +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01" ;; Type section id + "\05" ;; Type section length + "\01" ;; Types vector length + "\e0\7f" ;; Malformed functype, -0x20 in signed LEB128 encoding + "\00\00" + ) + "integer representation too long" +) + +;; Unsigned LEB128 must not be overlong +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\05\08\01" ;; Memory section with 1 entry + "\00\82\80\80\80\80\00" ;; no max, minimum 2 with one byte too many + ) + "integer representation too long" +) + +;; Signed LEB128 must not be overlong +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\06\0b\01" ;; Global section with 1 entry + "\7f\00" ;; i32, immutable + "\41\80\80\80\80\80\00" ;; i32.const 0 with one byte too many + "\0b" ;; end + ) + "integer representation too long" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\06\0b\01" ;; Global section with 1 entry + "\7f\00" ;; i32, immutable + "\41\ff\ff\ff\ff\ff\7f" ;; i32.const -1 with one byte too many + "\0b" ;; end + ) + "integer representation too long" +) + +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\06\10\01" ;; Global section with 1 entry + "\7e\00" ;; i64, immutable + "\42\80\80\80\80\80\80\80\80\80\80\00" ;; i64.const 0 with one byte too many + "\0b" ;; end + ) + "integer representation too long" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\06\10\01" ;; Global section with 1 entry + "\7e\00" ;; i64, immutable + "\42\ff\ff\ff\ff\ff\ff\ff\ff\ff\ff\7f" ;; i64.const -1 with one byte too many + "\0b" ;; end + ) + "integer representation too long" +) + +;; Unsigned LEB128s zero-extend +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\05\07\01" ;; Memory section with 1 entry + "\00\82\80\80\80\70" ;; no max, minimum 2 with unused bits set + ) + "integer too large" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\05\07\01" ;; Memory section with 1 entry + "\00\82\80\80\80\40" ;; no max, minimum 2 with some unused bits set + ) + "integer too large" +) + +;; Signed LEB128s sign-extend +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\06\0a\01" ;; Global section with 1 entry + "\7f\00" ;; i32, immutable + "\41\80\80\80\80\70" ;; i32.const 0 with unused bits set + "\0b" ;; end + ) + "integer too large" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\06\0a\01" ;; Global section with 1 entry + "\7f\00" ;; i32, immutable + "\41\ff\ff\ff\ff\0f" ;; i32.const -1 with unused bits unset + "\0b" ;; end + ) + "integer too large" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\06\0a\01" ;; Global section with 1 entry + "\7f\00" ;; i32, immutable + "\41\80\80\80\80\1f" ;; i32.const 0 with some unused bits set + "\0b" ;; end + ) + "integer too large" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\06\0a\01" ;; Global section with 1 entry + "\7f\00" ;; i32, immutable + "\41\ff\ff\ff\ff\4f" ;; i32.const -1 with some unused bits unset + "\0b" ;; end + ) + "integer too large" +) + +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\06\0f\01" ;; Global section with 1 entry + "\7e\00" ;; i64, immutable + "\42\80\80\80\80\80\80\80\80\80\7e" ;; i64.const 0 with unused bits set + "\0b" ;; end + ) + "integer too large" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\06\0f\01" ;; Global section with 1 entry + "\7e\00" ;; i64, immutable + "\42\ff\ff\ff\ff\ff\ff\ff\ff\ff\01" ;; i64.const -1 with unused bits unset + "\0b" ;; end + ) + "integer too large" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\06\0f\01" ;; Global section with 1 entry + "\7e\00" ;; i64, immutable + "\42\80\80\80\80\80\80\80\80\80\02" ;; i64.const 0 with some unused bits set + "\0b" ;; end + ) + "integer too large" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\06\0f\01" ;; Global section with 1 entry + "\7e\00" ;; i64, immutable + "\42\ff\ff\ff\ff\ff\ff\ff\ff\ff\41" ;; i64.const -1 with some unused bits unset + "\0b" ;; end + ) + "integer too large" +) + +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\06\0f\01" ;; Global section with 1 entry + "\7e\00" ;; i64, immutable + "\42\80\80\80\80\80\80\80\80\80\7e" ;; i64.const 0 with unused bits set + "\0b" ;; end + ) + "integer too large" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\06\0f\01" ;; Global section with 1 entry + "\7e\00" ;; i64, immutable + "\42\ff\ff\ff\ff\ff\ff\ff\ff\ff\01" ;; i64.const -1 with unused bits unset + "\0b" ;; end + ) + "integer too large" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\06\0f\01" ;; Global section with 1 entry + "\7e\00" ;; i64, immutable + "\42\80\80\80\80\80\80\80\80\80\02" ;; i64.const 0 with some unused bits set + "\0b" ;; end + ) + "integer too large" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\06\0f\01" ;; Global section with 1 entry + "\7e\00" ;; i64, immutable + "\42\ff\ff\ff\ff\ff\ff\ff\ff\ff\41" ;; i64.const -1 with some unused bits unset + "\0b" ;; end + ) + "integer too large" +) + + +;; Unsigned LEB128 must not be overlong +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\05\08\01" ;; Memory section with 1 entry + "\00\82\80\80\80\80\00" ;; no max, minimum 2 with one byte too many + ) + "integer representation too long" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01\60\00\00" ;; Type section + "\03\02\01\00" ;; Function section + "\05\03\01\00\01" ;; Memory section + "\0a\11\01" ;; Code section + ;; function 0 + "\0f\01\01" ;; local type count + "\7f" ;; i32 + "\41\00" ;; i32.const 0 + "\28" ;; i32.load + "\02" ;; alignment 2 + "\82\80\80\80\80\00" ;; offset 2 with one byte too many + "\1a" ;; drop + "\0b" ;; end + ) + "integer representation too long" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01\60\00\00" ;; Type section + "\03\02\01\00" ;; Function section + "\05\03\01\00\01" ;; Memory section + "\0a\11\01" ;; Code section + ;; function 0 + "\0f\01\01" ;; local type count + "\7f" ;; i32 + "\41\00" ;; i32.const 0 + "\28" ;; i32.load + "\82\80\80\80\80\00" ;; alignment 2 with one byte too many + "\00" ;; offset 0 + "\1a" ;; drop + "\0b" ;; end + ) + "integer representation too long" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01\60\00\00" ;; Type section + "\03\02\01\00" ;; Function section + "\05\03\01\00\01" ;; Memory section + "\0a\12\01" ;; Code section + ;; function 0 + "\10\01\01" ;; local type count + "\7f" ;; i32 + "\41\00" ;; i32.const 0 + "\41\03" ;; i32.const 3 + "\36" ;; i32.store + "\82\80\80\80\80\00" ;; alignment 2 with one byte too many + "\03" ;; offset 3 + "\0b" ;; end + ) + "integer representation too long" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01\60\00\00" ;; Type section + "\03\02\01\00" ;; Function section + "\05\03\01\00\01" ;; Memory section + "\0a\12\01" ;; Code section + ;; function 0 + "\10\01\01" ;; local type count + "\7f" ;; i32 + "\41\00" ;; i32.const 0 + "\41\03" ;; i32.const 3 + "\36" ;; i32.store + "\02" ;; alignment 2 + "\82\80\80\80\80\00" ;; offset 2 with one byte too many + "\0b" ;; end + ) + "integer representation too long" +) + +;; Signed LEB128 must not be overlong +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\06\0b\01" ;; Global section with 1 entry + "\7f\00" ;; i32, immutable + "\41\80\80\80\80\80\00" ;; i32.const 0 with one byte too many + "\0b" ;; end + ) + "integer representation too long" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\06\0b\01" ;; Global section with 1 entry + "\7f\00" ;; i32, immutable + "\41\ff\ff\ff\ff\ff\7f" ;; i32.const -1 with one byte too many + "\0b" ;; end + ) + "integer representation too long" +) + +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\06\10\01" ;; Global section with 1 entry + "\7e\00" ;; i64, immutable + "\42\80\80\80\80\80\80\80\80\80\80\00" ;; i64.const 0 with one byte too many + "\0b" ;; end + ) + "integer representation too long" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\06\10\01" ;; Global section with 1 entry + "\7e\00" ;; i64, immutable + "\42\ff\ff\ff\ff\ff\ff\ff\ff\ff\ff\7f" ;; i64.const -1 with one byte too many + "\0b" ;; end + ) + "integer representation too long" +) + +;; Unsigned LEB128s zero-extend +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\05\07\01" ;; Memory section with 1 entry + "\00\82\80\80\80\70" ;; no max, minimum 2 with unused bits set + ) + "integer too large" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\05\07\01" ;; Memory section with 1 entry + "\00\82\80\80\80\40" ;; no max, minimum 2 with some unused bits set + ) + "integer too large" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01\60\00\00" ;; Type section + "\03\02\01\00" ;; Function section + "\05\03\01\00\01" ;; Memory section + "\0a\10\01" ;; Code section + ;; function 0 + "\0e\01\01" ;; local type count + "\7f" ;; i32 + "\41\00" ;; i32.const 0 + "\28" ;; i32.load + "\02" ;; alignment 2 + "\82\80\80\80\10" ;; offset 2 with unused bits set + "\1a" ;; drop + "\0b" ;; end + ) + "integer too large" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01\60\00\00" ;; Type section + "\03\02\01\00" ;; Function section + "\05\03\01\00\01" ;; Memory section + "\0a\10\01" ;; Code section + ;; function 0 + "\0e\01\01" ;; local type count + "\7f" ;; i32 + "\41\00" ;; i32.const 0 + "\28" ;; i32.load + "\02" ;; alignment 2 + "\82\80\80\80\40" ;; offset 2 with some unused bits set + "\1a" ;; drop + "\0b" ;; end + ) + "integer too large" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01\60\00\00" ;; Type section + "\03\02\01\00" ;; Function section + "\05\03\01\00\01" ;; Memory section + "\0a\10\01" ;; Code section + "\0e\01\01" ;; local type count + "\7f" ;; i32 + "\41\00" ;; i32.const 0 + "\28" ;; i32.load + "\82\80\80\80\10" ;; alignment 2 with unused bits set + "\00" ;; offset 0 + "\1a" ;; drop + "\0b" ;; end + ) + "integer too large" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01\60\00\00" ;; Type section + "\03\02\01\00" ;; Function section + "\05\03\01\00\01" ;; Memory section + "\0a\10\01" ;; Code section + ;; function 0 + "\0e\01\01" ;; local type count + "\7f" ;; i32 + "\41\00" ;; i32.const 0 + "\28" ;; i32.load + "\82\80\80\80\40" ;; alignment 2 with some unused bits set + "\00" ;; offset 0 + "\1a" ;; drop + "\0b" ;; end + ) + "integer too large" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01\60\00\00" ;; Type section + "\03\02\01\00" ;; Function section + "\05\03\01\00\01" ;; Memory section + "\0a\11\01" ;; Code section + ;; function 0 + "\0f\01\01" ;; local type count + "\7f" ;; i32 + "\41\00" ;; i32.const 0 + "\41\03" ;; i32.const 3 + "\36" ;; i32.store + "\82\80\80\80\10" ;; alignment 2 with unused bits set + "\03" ;; offset 3 + "\0b" ;; end + ) + "integer too large" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01\60\00\00" ;; Type section + "\03\02\01\00" ;; Function section + "\05\03\01\00\01" ;; Memory section + "\0a\11\01" ;; Code section + ;; function 0 + "\0f\01\01" ;; local type count + "\7f" ;; i32 + "\41\00" ;; i32.const 0 + "\41\03" ;; i32.const 3 + "\36" ;; i32.store + "\82\80\80\80\40" ;; alignment 2 with some unused bits set + "\03" ;; offset 3 + "\0b" ;; end + ) + "integer too large" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01\60\00\00" ;; Type section + "\03\02\01\00" ;; Function section + "\05\03\01\00\01" ;; Memory section + "\0a\11\01" ;; Code section + ;; function 0 + "\0f\01\01" ;; local type count + "\7f" ;; i32 + "\41\00" ;; i32.const 0 + "\41\03" ;; i32.const 3 + "\36" ;; i32.store + "\02" ;; alignment 2 + "\82\80\80\80\10" ;; offset 2 with unused bits set + "\0b" ;; end + ) + "integer too large" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01\60\00\00" ;; Type section + "\03\02\01\00" ;; Function section + "\05\03\01\00\01" ;; Memory section + "\0a\11\01" ;; Code section + + ;; function 0 + "\0f\01\01" ;; local type count + "\7f" ;; i32 + "\41\00" ;; i32.const 0 + "\41\03" ;; i32.const 3 + "\36" ;; i32.store + "\02" ;; alignment 2 + "\82\80\80\80\40" ;; offset 2 with some unused bits set + "\0b" ;; end + ) + "integer too large" +) + +;; Signed LEB128s sign-extend +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\06\0a\01" ;; Global section with 1 entry + "\7f\00" ;; i32, immutable + "\41\80\80\80\80\70" ;; i32.const 0 with unused bits set + "\0b" ;; end + ) + "integer too large" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\06\0a\01" ;; Global section with 1 entry + "\7f\00" ;; i32, immutable + "\41\ff\ff\ff\ff\0f" ;; i32.const -1 with unused bits unset + "\0b" ;; end + ) + "integer too large" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\06\0a\01" ;; Global section with 1 entry + "\7f\00" ;; i32, immutable + "\41\80\80\80\80\1f" ;; i32.const 0 with some unused bits set + "\0b" ;; end + ) + "integer too large" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\06\0a\01" ;; Global section with 1 entry + "\7f\00" ;; i32, immutable + "\41\ff\ff\ff\ff\4f" ;; i32.const -1 with some unused bits unset + "\0b" ;; end + ) + "integer too large" +) + +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\06\0f\01" ;; Global section with 1 entry + "\7e\00" ;; i64, immutable + "\42\80\80\80\80\80\80\80\80\80\7e" ;; i64.const 0 with unused bits set + "\0b" ;; end + ) + "integer too large" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\06\0f\01" ;; Global section with 1 entry + "\7e\00" ;; i64, immutable + "\42\ff\ff\ff\ff\ff\ff\ff\ff\ff\01" ;; i64.const -1 with unused bits unset + "\0b" ;; end + ) + "integer too large" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\06\0f\01" ;; Global section with 1 entry + "\7e\00" ;; i64, immutable + "\42\80\80\80\80\80\80\80\80\80\02" ;; i64.const 0 with some unused bits set + "\0b" ;; end + ) + "integer too large" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\06\0f\01" ;; Global section with 1 entry + "\7e\00" ;; i64, immutable + "\42\ff\ff\ff\ff\ff\ff\ff\ff\ff\41" ;; i64.const -1 with some unused bits unset + "\0b" ;; end + ) + "integer too large" +) + +;; memory.grow reserved byte equal to zero. +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01\60\00\00" ;; Type section + "\03\02\01\00" ;; Function section + "\05\03\01\00\00" ;; Memory section + "\0a\09\01" ;; Code section + + ;; function 0 + "\07\00" + "\41\00" ;; i32.const 0 + "\40" ;; memory.grow + "\01" ;; memory.grow reserved byte is not equal to zero! + "\1a" ;; drop + "\0b" ;; end + ) + "zero byte expected" +) + +;; memory.grow reserved byte should not be a "long" LEB128 zero. +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01\60\00\00" ;; Type section + "\03\02\01\00" ;; Function section + "\05\03\01\00\00" ;; Memory section + "\0a\0a\01" ;; Code section + + ;; function 0 + "\08\00" + "\41\00" ;; i32.const 0 + "\40" ;; memory.grow + "\80\00" ;; memory.grow reserved byte + "\1a" ;; drop + "\0b" ;; end + ) + "zero byte expected" +) + +;; Same as above for 3, 4, and 5-byte zero encodings. +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01\60\00\00" ;; Type section + "\03\02\01\00" ;; Function section + "\05\03\01\00\00" ;; Memory section + "\0a\0b\01" ;; Code section + + ;; function 0 + "\09\00" + "\41\00" ;; i32.const 0 + "\40" ;; memory.grow + "\80\80\00" ;; memory.grow reserved byte + "\1a" ;; drop + "\0b" ;; end + ) + "zero byte expected" +) + +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01\60\00\00" ;; Type section + "\03\02\01\00" ;; Function section + "\05\03\01\00\00" ;; Memory section + "\0a\0c\01" ;; Code section + + ;; function 0 + "\0a\00" + "\41\00" ;; i32.const 0 + "\40" ;; memory.grow + "\80\80\80\00" ;; memory.grow reserved byte + "\1a" ;; drop + "\0b" ;; end + ) + "zero byte expected" +) + +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01\60\00\00" ;; Type section + "\03\02\01\00" ;; Function section + "\05\03\01\00\00" ;; Memory section + "\0a\0d\01" ;; Code section + + ;; function 0 + "\0b\00" + "\41\00" ;; i32.const 0 + "\40" ;; memory.grow + "\80\80\80\80\00" ;; memory.grow reserved byte + "\1a" ;; drop + "\0b" ;; end + ) + "zero byte expected" +) + +;; memory.size reserved byte equal to zero. +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01\60\00\00" ;; Type section + "\03\02\01\00" ;; Function section + "\05\03\01\00\00" ;; Memory section + "\0a\07\01" ;; Code section + + ;; function 0 + "\05\00" + "\3f" ;; memory.size + "\01" ;; memory.size reserved byte is not equal to zero! + "\1a" ;; drop + "\0b" ;; end + ) + "zero byte expected" +) + +;; memory.size reserved byte should not be a "long" LEB128 zero. +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01\60\00\00" ;; Type section + "\03\02\01\00" ;; Function section + "\05\03\01\00\00" ;; Memory section + "\0a\08\01" ;; Code section + + ;; function 0 + "\06\00" + "\3f" ;; memory.size + "\80\00" ;; memory.size reserved byte + "\1a" ;; drop + "\0b" ;; end + ) + "zero byte expected" +) + +;; Same as above for 3, 4, and 5-byte zero encodings. +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01\60\00\00" ;; Type section + "\03\02\01\00" ;; Function section + "\05\03\01\00\00" ;; Memory section + "\0a\09\01" ;; Code section + + ;; function 0 + "\07\00" + "\3f" ;; memory.size + "\80\80\00" ;; memory.size reserved byte + "\1a" ;; drop + "\0b" ;; end + ) + "zero byte expected" +) + +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01\60\00\00" ;; Type section + "\03\02\01\00" ;; Function section + "\05\03\01\00\00" ;; Memory section + "\0a\0a\01" ;; Code section + + ;; function 0 + "\08\00" + "\3f" ;; memory.size + "\80\80\80\00" ;; memory.size reserved byte + "\1a" ;; drop + "\0b" ;; end + ) + "zero byte expected" +) + +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01\60\00\00" ;; Type section + "\03\02\01\00" ;; Function section + "\05\03\01\00\00" ;; Memory section + "\0a\0b\01" ;; Code section + + ;; function 0 + "\09\00" + "\3f" ;; memory.size + "\80\80\80\80\00" ;; memory.size reserved byte + "\1a" ;; drop + "\0b" ;; end + ) + "zero byte expected" +) + +;; Local number is unsigned 32 bit +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01\60\00\00" ;; Type section + "\03\02\01\00" ;; Function section + "\0a\0c\01" ;; Code section + + ;; function 0 + "\0a\02" + "\80\80\80\80\10\7f" ;; 0x100000000 i32 + "\02\7e" ;; 0x00000002 i64 + "\0b" ;; end + ) + "integer too large" +) + +;; Local number is unsigned 32 bit +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01\60\00\00" ;; Type section + "\03\02\01\00" ;; Function section + "\0a\0c\01" ;; Code section + + ;; function 0 + "\0a\02" + "\80\80\80\80\10\7f" ;; 0x100000000 i32 + "\02\7e" ;; 0x00000002 i64 + "\0b" ;; end + ) + "integer too large" +) + +;; No more than 2^32-1 locals. +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01\60\00\00" ;; Type section + "\03\02\01\00" ;; Function section + "\0a\0c\01" ;; Code section + + ;; function 0 + "\0a\02" + "\ff\ff\ff\ff\0f\7f" ;; 0xFFFFFFFF i32 + "\02\7e" ;; 0x00000002 i64 + "\0b" ;; end + ) + "too many locals" +) + +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\06\01\60\02\7f\7f\00" ;; Type section: (param i32 i32) + "\03\02\01\00" ;; Function section + "\0a\1c\01" ;; Code section + + ;; function 0 + "\1a\04" + "\80\80\80\80\04\7f" ;; 0x40000000 i32 + "\80\80\80\80\04\7e" ;; 0x40000000 i64 + "\80\80\80\80\04\7d" ;; 0x40000000 f32 + "\80\80\80\80\04\7c" ;; 0x40000000 f64 + "\0b" ;; end + ) + "too many locals" +) + +;; Local count can be 0. +(module binary + "\00asm" "\01\00\00\00" + "\01\04\01\60\00\00" ;; Type section + "\03\02\01\00" ;; Function section + "\0a\0a\01" ;; Code section + + ;; function 0 + "\08\03" + "\00\7f" ;; 0 i32 + "\00\7e" ;; 0 i64 + "\02\7d" ;; 2 f32 + "\0b" ;; end +) + +;; Function section has non-zero count, but code section is absent. +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01\60\00\00" ;; Type section + "\03\03\02\00\00" ;; Function section with 2 functions + ) + "function and code section have inconsistent lengths" +) + +;; Code section has non-zero count, but function section is absent. +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\0a\04\01\02\00\0b" ;; Code section with 1 empty function + ) + "function and code section have inconsistent lengths" +) + +;; Function section count > code section count +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01\60\00\00" ;; Type section + "\03\03\02\00\00" ;; Function section with 2 functions + "\0a\04\01\02\00\0b" ;; Code section with 1 empty function + ) + "function and code section have inconsistent lengths" +) + +;; Function section count < code section count +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01\60\00\00" ;; Type section + "\03\02\01\00" ;; Function section with 1 function + "\0a\07\02\02\00\0b\02\00\0b" ;; Code section with 2 empty functions + ) + "function and code section have inconsistent lengths" +) + +;; Function section has zero count, and code section is absent. +(module binary + "\00asm" "\01\00\00\00" + "\03\01\00" ;; Function section with 0 functions +) + +;; Code section has zero count, and function section is absent. +(module binary + "\00asm" "\01\00\00\00" + "\0a\01\00" ;; Code section with 0 functions +) + +;; Fewer passive segments than datacount +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\0c\01\03" ;; Datacount section with value "3" + "\0b\05\02" ;; Data section with two entries + "\01\00" ;; Passive data section + "\01\00") ;; Passive data section + "data count and data section have inconsistent lengths") + +;; More passive segments than datacount +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\0c\01\01" ;; Datacount section with value "1" + "\0b\05\02" ;; Data section with two entries + "\01\00" ;; Passive data section + "\01\00") ;; Passive data section + "data count and data section have inconsistent lengths") + +;; memory.init requires a datacount section +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + + "\01\04\01\60\00\00" ;; Type section + "\03\02\01\00" ;; Function section + "\05\03\01\00\00" ;; Memory section + "\0a\0e\01" ;; Code section + + ;; function 0 + "\0c\00" + "\41\00" ;; zero args + "\41\00" + "\41\00" + "\fc\08\00\00" ;; memory.init + "\0b" + + "\0b\03\01\01\00" ;; Data section + ) ;; end + "data count section required") + +;; data.drop requires a datacount section +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + + "\01\04\01\60\00\00" ;; Type section + "\03\02\01\00" ;; Function section + "\05\03\01\00\00" ;; Memory section + "\0a\07\01" ;; Code section + + ;; function 0 + "\05\00" + "\fc\09\00" ;; data.drop + "\0b" + + "\0b\03\01\01\00" ;; Data section + ) ;; end + "data count section required") + +;; passive element segment containing opcode other than ref.func or ref.null +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + + "\01\04\01\60\00\00" ;; Type section + + "\03\02\01\00" ;; Function section + + "\04\04\01" ;; Table section with 1 entry + "\70\00\00" ;; no max, minimum 0, funcref + + "\05\03\01\00\00" ;; Memory section + + "\09\07\01" ;; Element section with one segment + "\05\70" ;; Passive, funcref + "\01" ;; 1 element + "\ff\00\0b" ;; bad opcode, index 0, end + + "\0a\04\01" ;; Code section + + ;; function 0 + "\02\00" + "\0b") ;; end + "illegal opcode") + +;; passive element segment containing type other than funcref +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + + "\01\04\01\60\00\00" ;; Type section + + "\03\02\01\00" ;; Function section + + "\04\04\01" ;; Table section with 1 entry + "\70\00\00" ;; no max, minimum 0, funcref + + "\05\03\01\00\00" ;; Memory section + + "\09\07\01" ;; Element section with one segment + "\05\7f" ;; Passive, i32 + "\01" ;; 1 element + "\d2\00\0b" ;; ref.func, index 0, end + + "\0a\04\01" ;; Code section + + ;; function 0 + "\02\00" + "\0b") ;; end + "malformed reference type") + +;; passive element segment containing opcode ref.func +(module binary + "\00asm" "\01\00\00\00" + + "\01\04\01\60\00\00" ;; Type section + + "\03\02\01\00" ;; Function section + + "\04\04\01" ;; Table section with 1 entry + "\70\00\00" ;; no max, minimum 0, funcref + + "\05\03\01\00\00" ;; Memory section + + "\09\07\01" ;; Element section with one segment + "\05\70" ;; Passive, funcref + "\01" ;; 1 element + "\d2\00\0b" ;; ref.func, index 0, end + + "\0a\04\01" ;; Code section + + ;; function 0 + "\02\00" + "\0b") ;; end + +;; passive element segment containing opcode ref.null +(module binary + "\00asm" "\01\00\00\00" + + "\01\04\01\60\00\00" ;; Type section + + "\03\02\01\00" ;; Function section + + "\04\04\01" ;; Table section with 1 entry + "\70\00\00" ;; no max, minimum 0, funcref + + "\05\03\01\00\00" ;; Memory section + + "\09\07\01" ;; Element section with one segment + "\05\70" ;; Passive, funcref + "\01" ;; 1 element + "\d0\70\0b" ;; ref.null, end + + "\0a\04\01" ;; Code section + + ;; function 0 + "\02\00" + "\0b") ;; end + + +;; Type count can be zero +(module binary + "\00asm" "\01\00\00\00" + "\01\01\00" ;; type count can be zero +) + +;; 2 type declared, 1 given +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\07\02" ;; type section with inconsistent count (2 declared, 1 given) + "\60\00\00" ;; 1st type + ;; "\60\00\00" ;; 2nd type (missed) + ) + "unexpected end of section or function" +) + +;; 1 type declared, 2 given +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\07\01" ;; type section with inconsistent count (1 declared, 2 given) + "\60\00\00" ;; 1st type + "\60\00\00" ;; 2nd type (redundant) + ) + "section size mismatch" +) + +;; Import count can be zero +(module binary + "\00asm" "\01\00\00\00" + "\01\05\01" ;; type section + "\60\01\7f\00" ;; type 0 + "\02\01\00" ;; import count can be zero +) + +;; Malformed import kind +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\04\01" ;; import section with single entry + "\00" ;; string length 0 + "\00" ;; string length 0 + "\04" ;; malformed import kind + ) + "malformed import kind" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\05\01" ;; import section with single entry + "\00" ;; string length 0 + "\00" ;; string length 0 + "\04" ;; malformed import kind + "\00" ;; dummy byte + ) + "malformed import kind" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\04\01" ;; import section with single entry + "\00" ;; string length 0 + "\00" ;; string length 0 + "\05" ;; malformed import kind + ) + "malformed import kind" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\05\01" ;; import section with single entry + "\00" ;; string length 0 + "\00" ;; string length 0 + "\05" ;; malformed import kind + "\00" ;; dummy byte + ) + "malformed import kind" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\04\01" ;; import section with single entry + "\00" ;; string length 0 + "\00" ;; string length 0 + "\80" ;; malformed import kind + ) + "malformed import kind" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\05\01" ;; import section with single entry + "\00" ;; string length 0 + "\00" ;; string length 0 + "\80" ;; malformed import kind + "\00" ;; dummy byte + ) + "malformed import kind" +) + +;; 2 import declared, 1 given +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\05\01" ;; type section + "\60\01\7f\00" ;; type 0 + "\02\16\02" ;; import section with inconsistent count (2 declared, 1 given) + ;; 1st import + "\08" ;; string length + "\73\70\65\63\74\65\73\74" ;; spectest + "\09" ;; string length + "\70\72\69\6e\74\5f\69\33\32" ;; print_i32 + "\00\00" ;; import kind, import signature index + ;; 2nd import + ;; (missed) + ) + "unexpected end of section or function" +) + +;; 1 import declared, 2 given +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\09\02" ;; type section + "\60\01\7f\00" ;; type 0 + "\60\01\7d\00" ;; type 1 + "\02\2b\01" ;; import section with inconsistent count (1 declared, 2 given) + ;; 1st import + "\08" ;; string length + "\73\70\65\63\74\65\73\74" ;; spectest + "\09" ;; string length + "\70\72\69\6e\74\5f\69\33\32" ;; print_i32 + "\00\00" ;; import kind, import signature index + ;; 2nd import + ;; (redundant) + "\08" ;; string length + "\73\70\65\63\74\65\73\74" ;; spectest + "\09" ;; string length + "\70\72\69\6e\74\5f\66\33\32" ;; print_f32 + "\00\01" ;; import kind, import signature index + ) + "section size mismatch" +) + +;; Table count can be zero +(module binary + "\00asm" "\01\00\00\00" + "\04\01\00" ;; table count can be zero +) + +;; 1 table declared, 0 given +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\04\01\01" ;; table section with inconsistent count (1 declared, 0 given) + ;; "\70\01\00\00" ;; table entity + ) + "unexpected end of section or function" +) + +;; Malformed table limits flag +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\05\03\01" ;; table section with one entry + "\70" ;; anyfunc + "\02" ;; malformed table limits flag + ) + "integer too large" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\05\04\01" ;; table section with one entry + "\70" ;; anyfunc + "\02" ;; malformed table limits flag + "\00" ;; dummy byte + ) + "integer too large" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\05\06\01" ;; table section with one entry + "\70" ;; anyfunc + "\81\00" ;; malformed table limits flag as LEB128 + "\00\00" ;; dummy bytes + ) + "integer too large" +) + +;; Memory count can be zero +(module binary + "\00asm" "\01\00\00\00" + "\05\01\00" ;; memory count can be zero +) + +;; 1 memory declared, 0 given +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\05\01\01" ;; memory section with inconsistent count (1 declared, 0 given) + ;; "\00\00" ;; memory 0 (missed) + ) + "unexpected end of section or function" +) + +;; Malformed memory limits flag +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\05\02\01" ;; memory section with one entry + "\02" ;; malformed memory limits flag + ) + "integer too large" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\05\03\01" ;; memory section with one entry + "\02" ;; malformed memory limits flag + "\00" ;; dummy byte + ) + "integer too large" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\05\05\01" ;; memory section with one entry + "\81\00" ;; malformed memory limits flag as LEB128 + "\00\00" ;; dummy bytes + ) + "integer representation too long" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\05\05\01" ;; memory section with one entry + "\81\01" ;; malformed memory limits flag as LEB128 + "\00\00" ;; dummy bytes + ) + "integer representation too long" +) + +;; Global count can be zero +(module binary + "\00asm" "\01\00\00\00" + "\06\01\00" ;; global count can be zero +) + +;; 2 global declared, 1 given +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\06\06\02" ;; global section with inconsistent count (2 declared, 1 given) + "\7f\00\41\00\0b" ;; global 0 + ;; "\7f\00\41\00\0b" ;; global 1 (missed) + ) + "unexpected end of section or function" +) + +;; 1 global declared, 2 given +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\06\0b\01" ;; global section with inconsistent count (1 declared, 2 given) + "\7f\00\41\00\0b" ;; global 0 + "\7f\00\41\00\0b" ;; global 1 (redundant) + ) + "section size mismatch" +) + +;; Export count can be 0 +(module binary + "\00asm" "\01\00\00\00" + "\01\04\01" ;; type section + "\60\00\00" ;; type 0 + "\03\03\02\00\00" ;; func section + "\07\01\00" ;; export count can be zero + "\0a\07\02" ;; code section + "\02\00\0b" ;; function body 0 + "\02\00\0b" ;; function body 1 +) + +;; 2 export declared, 1 given +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01" ;; type section + "\60\00\00" ;; type 0 + "\03\03\02\00\00" ;; func section + "\07\06\02" ;; export section with inconsistent count (2 declared, 1 given) + "\02" ;; export 0 + "\66\31" ;; export name + "\00\00" ;; export kind, export func index + ;; "\02" ;; export 1 (missed) + ;; "\66\32" ;; export name + ;; "\00\01" ;; export kind, export func index + "\0a\07\02" ;; code section + "\02\00\0b" ;; function body 0 + "\02\00\0b" ;; function body 1 + ) + "unexpected end of section or function" +) + +;; 1 export declared, 2 given +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01" ;; type section + "\60\00\00" ;; type 0 + "\03\03\02\00\00" ;; func section + "\07\0b\01" ;; export section with inconsistent count (1 declared, 2 given) + "\02" ;; export 0 + "\66\31" ;; export name + "\00\00" ;; export kind, export func index + "\02" ;; export 1 (redundant) + "\66\32" ;; export name + "\00\01" ;; export kind, export func index + "\0a\07\02" ;; code section + "\02\00\0b" ;; function body 0 + "\02\00\0b" ;; function body 1 + ) + "section size mismatch" +) + +;; elem segment count can be zero +(module binary + "\00asm" "\01\00\00\00" + "\01\04\01" ;; type section + "\60\00\00" ;; type 0 + "\03\02\01\00" ;; func section + "\04\04\01" ;; table section + "\70\00\01" ;; table 0 + "\09\01\00" ;; elem segment count can be zero + "\0a\04\01" ;; code section + "\02\00\0b" ;; function body +) + +;; 2 elem segment declared, 1 given +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01" ;; type section + "\60\00\00" ;; type 0 + "\03\02\01\00" ;; func section + "\04\04\01" ;; table section + "\70\00\01" ;; table 0 + "\09\07\02" ;; elem with inconsistent segment count (2 declared, 1 given) + "\00\41\00\0b\01\00" ;; elem 0 + ;; "\00\41\00\0b\01\00" ;; elem 1 (missed) + ) + "unexpected end" +) + +;; 2 elem segment declared, 1.5 given +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01" ;; type section + "\60\00\00" ;; type 0 + "\03\02\01\00" ;; func section + "\04\04\01" ;; table section + "\70\00\01" ;; table 0 + "\09\07\02" ;; elem with inconsistent segment count (2 declared, 1 given) + "\00\41\00\0b\01\00" ;; elem 0 + "\00\41\00" ;; elem 1 (partial) + ;; "\0b\01\00" ;; elem 1 (missing part) + ) + "unexpected end" +) + +;; 1 elem segment declared, 2 given +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01" ;; type section + "\60\00\00" ;; type 0 + "\03\02\01\00" ;; func section + "\04\04\01" ;; table section + "\70\00\01" ;; table 0 + "\09\0d\01" ;; elem with inconsistent segment count (1 declared, 2 given) + "\00\41\00\0b\01\00" ;; elem 0 + "\00\41\00\0b\01\00" ;; elem 1 (redundant) + "\0a\04\01" ;; code section + "\02\00\0b" ;; function body + ) + "section size mismatch" +) + +;; data segment count can be zero +(module binary + "\00asm" "\01\00\00\00" + "\05\03\01" ;; memory section + "\00\01" ;; memory 0 + "\0b\01\00" ;; data segment count can be zero +) + +;; 2 data segment declared, 1 given +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\05\03\01" ;; memory section + "\00\01" ;; memory 0 + "\0b\07\02" ;; data with inconsistent segment count (2 declared, 1 given) + "\00\41\00\0b\01\61" ;; data 0 + ;; "\00\41\01\0b\01\62" ;; data 1 (missed) + ) + "unexpected end of section or function" +) + +;; 1 data segment declared, 2 given +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\05\03\01" ;; memory section + "\00\01" ;; memory 0 + "\0b\0d\01" ;; data with inconsistent segment count (1 declared, 2 given) + "\00\41\00\0b\01\61" ;; data 0 + "\00\41\01\0b\01\62" ;; data 1 (redundant) + ) + "section size mismatch" +) + +;; data segment has 7 bytes declared, but 6 bytes given +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\05\03\01" ;; memory section + "\00\01" ;; memory 0 + "\0b\0c\01" ;; data section + "\00\41\03\0b" ;; data segment 0 + "\07" ;; data segment size with inconsistent lengths (7 declared, 6 given) + "\61\62\63\64\65\66" ;; 6 bytes given + ) + "unexpected end of section or function" +) + +;; data segment has 5 bytes declared, but 6 bytes given +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\05\03\01" ;; memory section + "\00\01" ;; memory 0 + "\0b\0c\01" ;; data section + "\00\41\00\0b" ;; data segment 0 + "\05" ;; data segment size with inconsistent lengths (5 declared, 6 given) + "\61\62\63\64\65\66" ;; 6 bytes given + ) + "section size mismatch" +) + +;; br_table target count can be zero +(module binary + "\00asm" "\01\00\00\00" + "\01\04\01" ;; type section + "\60\00\00" ;; type 0 + "\03\02\01\00" ;; func section + "\0a\11\01" ;; code section + "\0f\00" ;; func 0 + "\02\40" ;; block 0 + "\41\01" ;; condition of if 0 + "\04\40" ;; if 0 + "\41\01" ;; index of br_table element + "\0e\00" ;; br_table target count can be zero + "\02" ;; break depth for default + "\0b\0b\0b" ;; end +) + +;; 1 br_table target declared, 2 given +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01" ;; type section + "\60\00\00" ;; type 0 + "\03\02\01\00" ;; func section + "\0a\12\01" ;; code section + "\11\00" ;; func 0 + "\02\40" ;; block 0 + "\41\01" ;; condition of if 0 + "\04\40" ;; if 0 + "\41\01" ;; index of br_table element + "\0e\01" ;; br_table with inconsistent target count (1 declared, 2 given) + "\00" ;; break depth 0 + "\01" ;; break depth 1 + "\02" ;; break depth for default + "\0b\0b\0b" ;; end + ) + "unexpected end of section or function" +) + +;; Start section +(module binary + "\00asm" "\01\00\00\00" + "\01\04\01\60\00\00" ;; Type section + "\03\02\01\00" ;; Function section + "\08\01\00" ;; Start section: function 0 + + "\0a\04\01" ;; Code section + ;; function 0 + "\02\00" + "\0b" ;; end +) + +;; Multiple start sections +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01\60\00\00" ;; Type section + "\03\02\01\00" ;; Function section + "\08\01\00" ;; Start section: function 0 + "\08\01\00" ;; Start section: function 0 + + "\0a\04\01" ;; Code section + ;; function 0 + "\02\00" + "\0b" ;; end + ) + "junk after last section" +) + diff --git a/runtime/near-vm/tests/wast/spec/proposals/gc/br_on.wast b/runtime/near-vm/tests/wast/spec/proposals/gc/br_on.wast new file mode 100644 index 00000000000..370eb9396ee --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/proposals/gc/br_on.wast @@ -0,0 +1,92 @@ +(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) (i31.new (i32.const 7))) + (table.set (i32.const 2) (struct.new $st (i32.const 6) (rtt.canon $st))) + (table.set (i32.const 3) (array.new $at (i32.const 5) (i32.const 1) (rtt.canon $at))) + (table.set (i32.const 4) (ref.func $f)) + (table.set (i32.const 5) (rtt.canon $ft)) + (table.set (i32.const 6) (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_i31 $l (table.get (local.get $i))) + (return (i32.const -1)) + ) + (i31.get_u) + ) + (func (export "br_on_data") (param $i i32) (result i32) + (block $l (result (ref data)) + (br_on_data $l (table.get (local.get $i))) + (return (i32.const -1)) + ) + (block $l2 (param dataref) (result (ref $st)) + (block $l3 (param dataref) (result (ref $at)) + (br_on_cast $l2 (rtt.canon $st)) + (br_on_cast $l3 (rtt.canon $at)) + (return (i32.const -2)) + ) + (return (array.get_u $at (i32.const 0))) + ) + (struct.get_s $st 0) + ) + (func (export "br_on_func") (param $i i32) (result i32) + (block $l (result (ref func)) + (br_on_func $l (table.get (local.get $i))) + (return (i32.const -1)) + ) + (ref.cast (rtt.canon $ft)) + (call_ref) + ) +) + +(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_null" (i32.const 5)) (i32.const -1)) +(assert_return (invoke "br_on_null" (i32.const 6)) (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_i31" (i32.const 5)) (i32.const -1)) +(assert_return (invoke "br_on_i31" (i32.const 6)) (i32.const -1)) + +(assert_return (invoke "br_on_data" (i32.const 0)) (i32.const -1)) +(assert_return (invoke "br_on_data" (i32.const 1)) (i32.const -1)) +(assert_return (invoke "br_on_data" (i32.const 2)) (i32.const 6)) +(assert_return (invoke "br_on_data" (i32.const 3)) (i32.const 5)) +(assert_return (invoke "br_on_data" (i32.const 4)) (i32.const -1)) +(assert_return (invoke "br_on_data" (i32.const 5)) (i32.const -1)) +(assert_return (invoke "br_on_data" (i32.const 6)) (i32.const -1)) + +(assert_return (invoke "br_on_func" (i32.const 0)) (i32.const -1)) +(assert_return (invoke "br_on_func" (i32.const 1)) (i32.const -1)) +(assert_return (invoke "br_on_func" (i32.const 2)) (i32.const -1)) +(assert_return (invoke "br_on_func" (i32.const 3)) (i32.const -1)) +(assert_return (invoke "br_on_func" (i32.const 4)) (i32.const 9)) +(assert_return (invoke "br_on_func" (i32.const 5)) (i32.const -1)) +(assert_return (invoke "br_on_func" (i32.const 6)) (i32.const -1)) diff --git a/runtime/near-vm/tests/wast/spec/proposals/gc/br_on_cast.wast b/runtime/near-vm/tests/wast/spec/proposals/gc/br_on_cast.wast new file mode 100644 index 00000000000..89ebc608a08 --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/proposals/gc/br_on_cast.wast @@ -0,0 +1,110 @@ +(module + (type $t0 (struct)) + (type $t1 (struct (field i32))) + (type $t1' (struct (field i32))) + (type $t2 (struct (field i32 i32))) + (type $t2' (struct (field i32 i32))) + (type $t3 (struct (field i32 i32))) + + (global $t0 (rtt $t0) (rtt.canon $t0)) + (global $t0' (rtt $t0) (rtt.canon $t0)) + (global $t1 (rtt $t1) (rtt.sub $t1 (global.get $t0))) + (global $t1' (rtt $t1') (rtt.sub $t1' (global.get $t0))) + (global $t2 (rtt $t2) (rtt.sub $t2 (global.get $t1))) + (global $t2' (rtt $t2') (rtt.sub $t2' (global.get $t1'))) + (global $t3 (rtt $t3) (rtt.sub $t3 (global.get $t0))) + (global $t4 (rtt $t3) (rtt.sub $t3 (rtt.sub $t0 (global.get $t0)))) + + (table 20 dataref) + + (func $init + (table.set (i32.const 0) (struct.new_default $t0 (global.get $t0))) + (table.set (i32.const 10) (struct.new_default $t0 (global.get $t0'))) + (table.set (i32.const 1) (struct.new_default $t1 (global.get $t1))) + (table.set (i32.const 11) (struct.new_default $t1' (global.get $t1'))) + (table.set (i32.const 2) (struct.new_default $t2 (global.get $t2))) + (table.set (i32.const 12) (struct.new_default $t2' (global.get $t2'))) + (table.set (i32.const 3) (struct.new_default $t3 (global.get $t3))) + (table.set (i32.const 4) (struct.new_default $t3 (global.get $t4))) + ) + + (func (export "test-sub") + (call $init) + (block $l (result dataref) + ;; must succeed + (drop (block (result dataref) (br_on_cast 0 (ref.null data) (global.get $t0)))) + (drop (block (result dataref) (br_on_cast 0 (table.get (i32.const 0)) (global.get $t0)))) + (drop (block (result dataref) (br_on_cast 0 (table.get (i32.const 1)) (global.get $t0)))) + (drop (block (result dataref) (br_on_cast 0 (table.get (i32.const 2)) (global.get $t0)))) + (drop (block (result dataref) (br_on_cast 0 (table.get (i32.const 3)) (global.get $t0)))) + (drop (block (result dataref) (br_on_cast 0 (table.get (i32.const 4)) (global.get $t0)))) + + (drop (block (result dataref) (br_on_cast 0 (ref.null data) (global.get $t1)))) + (drop (block (result dataref) (br_on_cast 0 (table.get (i32.const 1)) (global.get $t1)))) + (drop (block (result dataref) (br_on_cast 0 (table.get (i32.const 2)) (global.get $t1)))) + + (drop (block (result dataref) (br_on_cast 0 (ref.null data) (global.get $t2)))) + (drop (block (result dataref) (br_on_cast 0 (table.get (i32.const 2)) (global.get $t2)))) + + (drop (block (result dataref) (br_on_cast 0 (ref.null data) (global.get $t3)))) + (drop (block (result dataref) (br_on_cast 0 (table.get (i32.const 3)) (global.get $t3)))) + + (drop (block (result dataref) (br_on_cast 0 (ref.null data) (global.get $t4)))) + (drop (block (result dataref) (br_on_cast 0 (table.get (i32.const 4)) (global.get $t4)))) + + ;; must not succeed + (br_on_cast $l (table.get (i32.const 0)) (global.get $t1)) + (br_on_cast $l (table.get (i32.const 3)) (global.get $t1)) + (br_on_cast $l (table.get (i32.const 4)) (global.get $t1)) + + (br_on_cast $l (table.get (i32.const 0)) (global.get $t2)) + (br_on_cast $l (table.get (i32.const 1)) (global.get $t2)) + (br_on_cast $l (table.get (i32.const 3)) (global.get $t2)) + (br_on_cast $l (table.get (i32.const 4)) (global.get $t2)) + + (br_on_cast $l (table.get (i32.const 0)) (global.get $t3)) + (br_on_cast $l (table.get (i32.const 1)) (global.get $t3)) + (br_on_cast $l (table.get (i32.const 2)) (global.get $t3)) + (br_on_cast $l (table.get (i32.const 4)) (global.get $t3)) + + (br_on_cast $l (table.get (i32.const 0)) (global.get $t4)) + (br_on_cast $l (table.get (i32.const 1)) (global.get $t4)) + (br_on_cast $l (table.get (i32.const 2)) (global.get $t4)) + (br_on_cast $l (table.get (i32.const 3)) (global.get $t4)) + + (return) + ) + (unreachable) + ) + + (func (export "test-canon") + (call $init) + (block $l + (drop (block (result dataref) (br_on_cast 0 (table.get (i32.const 0)) (global.get $t0')))) + (drop (block (result dataref) (br_on_cast 0 (table.get (i32.const 1)) (global.get $t0')))) + (drop (block (result dataref) (br_on_cast 0 (table.get (i32.const 2)) (global.get $t0')))) + (drop (block (result dataref) (br_on_cast 0 (table.get (i32.const 3)) (global.get $t0')))) + (drop (block (result dataref) (br_on_cast 0 (table.get (i32.const 4)) (global.get $t0')))) + + (drop (block (result dataref) (br_on_cast 0 (table.get (i32.const 10)) (global.get $t0)))) + (drop (block (result dataref) (br_on_cast 0 (table.get (i32.const 11)) (global.get $t0)))) + (drop (block (result dataref) (br_on_cast 0 (table.get (i32.const 12)) (global.get $t0)))) + + (drop (block (result dataref) (br_on_cast 0 (table.get (i32.const 1)) (global.get $t1')))) + (drop (block (result dataref) (br_on_cast 0 (table.get (i32.const 2)) (global.get $t1')))) + + (drop (block (result dataref) (br_on_cast 0 (table.get (i32.const 11)) (global.get $t1)))) + (drop (block (result dataref) (br_on_cast 0 (table.get (i32.const 12)) (global.get $t1)))) + + (drop (block (result dataref) (br_on_cast 0 (table.get (i32.const 2)) (global.get $t2')))) + + (drop (block (result dataref) (br_on_cast 0 (table.get (i32.const 12)) (global.get $t2)))) + + (return) + ) + (unreachable) + ) +) + +(invoke "test-sub") +(invoke "test-canon") diff --git a/runtime/near-vm/tests/wast/spec/proposals/gc/br_on_null.wast b/runtime/near-vm/tests/wast/spec/proposals/gc/br_on_null.wast new file mode 100644 index 00000000000..3bae85000fd --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/proposals/gc/br_on_null.wast @@ -0,0 +1,75 @@ +(module + (type $t (func (result i32))) + + (func $nn (param $r (ref $t)) (result i32) + (block $l + (return (call_ref (br_on_null $l (local.get $r)))) + ) + (i32.const -1) + ) + (func $n (param $r (ref null $t)) (result i32) + (block $l + (return (call_ref (br_on_null $l (local.get $r)))) + ) + (i32.const -1) + ) + + (elem func $f) + (func $f (result i32) (i32.const 7)) + + (func (export "nullable-null") (result i32) (call $n (ref.null $t))) + (func (export "nonnullable-f") (result i32) (call $nn (ref.func $f))) + (func (export "nullable-f") (result i32) (call $n (ref.func $f))) + + (func (export "unreachable") (result i32) + (block $l + (return (call_ref (br_on_null $l (unreachable)))) + ) + (i32.const -1) + ) +) + +(assert_trap (invoke "unreachable") "unreachable") + +(assert_return (invoke "nullable-null") (i32.const -1)) +(assert_return (invoke "nonnullable-f") (i32.const 7)) +(assert_return (invoke "nullable-f") (i32.const 7)) + +(assert_invalid + (module + (type $t (func (result i32))) + (func $g (param $r (ref $t)) (drop (br_on_null 0 (local.get $r)))) + (func (call $g (ref.null $t))) + ) + "type mismatch" +) + +(module + (type $t (func)) + (func (param $r (ref $t)) (drop (br_on_null 0 (local.get $r)))) + (func (param $r (ref func)) (drop (br_on_null 0 (local.get $r)))) + (func (param $r (ref extern)) (drop (br_on_null 0 (local.get $r)))) +) + + +(module + (type $t (func (param i32) (result i32))) + (elem func $f) + (func $f (param i32) (result i32) (i32.mul (local.get 0) (local.get 0))) + + (func $a (param $n i32) (param $r (ref null $t)) (result i32) + (block $l (result i32) + (return (call_ref (br_on_null $l (local.get $n) (local.get $r)))) + ) + ) + + (func (export "args-null") (param $n i32) (result i32) + (call $a (local.get $n) (ref.null $t)) + ) + (func (export "args-f") (param $n i32) (result i32) + (call $a (local.get $n) (ref.func $f)) + ) +) + +(assert_return (invoke "args-null" (i32.const 3)) (i32.const 3)) +(assert_return (invoke "args-f" (i32.const 3)) (i32.const 9)) diff --git a/runtime/near-vm/tests/wast/spec/proposals/gc/br_table.wast b/runtime/near-vm/tests/wast/spec/proposals/gc/br_table.wast new file mode 100644 index 00000000000..33650e21578 --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/proposals/gc/br_table.wast @@ -0,0 +1,1728 @@ +;; Test `br_table` operator + +(module + ;; Auxiliary definition + (func $dummy) + + (func (export "type-i32") + (block (drop (i32.ctz (br_table 0 0 (i32.const 0))))) + ) + (func (export "type-i64") + (block (drop (i64.ctz (br_table 0 0 (i32.const 0))))) + ) + (func (export "type-f32") + (block (drop (f32.neg (br_table 0 0 (i32.const 0))))) + ) + (func (export "type-f64") + (block (drop (f64.neg (br_table 0 0 (i32.const 0))))) + ) + + (func (export "type-i32-value") (result i32) + (block (result i32) (i32.ctz (br_table 0 0 (i32.const 1) (i32.const 0)))) + ) + (func (export "type-i64-value") (result i64) + (block (result i64) (i64.ctz (br_table 0 0 (i64.const 2) (i32.const 0)))) + ) + (func (export "type-f32-value") (result f32) + (block (result f32) (f32.neg (br_table 0 0 (f32.const 3) (i32.const 0)))) + ) + (func (export "type-f64-value") (result f64) + (block (result f64) (f64.neg (br_table 0 0 (f64.const 4) (i32.const 0)))) + ) + + (func (export "empty") (param i32) (result i32) + (block (br_table 0 (local.get 0)) (return (i32.const 21))) + (i32.const 22) + ) + (func (export "empty-value") (param i32) (result i32) + (block (result i32) + (br_table 0 (i32.const 33) (local.get 0)) (i32.const 31) + ) + ) + + (func (export "singleton") (param i32) (result i32) + (block + (block + (br_table 1 0 (local.get 0)) + (return (i32.const 21)) + ) + (return (i32.const 20)) + ) + (i32.const 22) + ) + + (func (export "singleton-value") (param i32) (result i32) + (block (result i32) + (drop + (block (result i32) + (br_table 0 1 (i32.const 33) (local.get 0)) + (return (i32.const 31)) + ) + ) + (i32.const 32) + ) + ) + + (func (export "multiple") (param i32) (result i32) + (block + (block + (block + (block + (block + (br_table 3 2 1 0 4 (local.get 0)) + (return (i32.const 99)) + ) + (return (i32.const 100)) + ) + (return (i32.const 101)) + ) + (return (i32.const 102)) + ) + (return (i32.const 103)) + ) + (i32.const 104) + ) + + (func (export "multiple-value") (param i32) (result i32) + (local i32) + (local.set 1 (block (result i32) + (local.set 1 (block (result i32) + (local.set 1 (block (result i32) + (local.set 1 (block (result i32) + (local.set 1 (block (result i32) + (br_table 3 2 1 0 4 (i32.const 200) (local.get 0)) + (return (i32.add (local.get 1) (i32.const 99))) + )) + (return (i32.add (local.get 1) (i32.const 10))) + )) + (return (i32.add (local.get 1) (i32.const 11))) + )) + (return (i32.add (local.get 1) (i32.const 12))) + )) + (return (i32.add (local.get 1) (i32.const 13))) + )) + (i32.add (local.get 1) (i32.const 14)) + ) + + (func (export "large") (param i32) (result i32) + (block + (block + (br_table + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + (local.get 0) + ) + (return (i32.const -1)) + ) + (return (i32.const 0)) + ) + (return (i32.const 1)) + ) + + (func (export "as-block-first") + (block (br_table 0 0 0 (i32.const 0)) (call $dummy)) + ) + (func (export "as-block-mid") + (block (call $dummy) (br_table 0 0 0 (i32.const 0)) (call $dummy)) + ) + (func (export "as-block-last") + (block (nop) (call $dummy) (br_table 0 0 0 (i32.const 0))) + ) + (func (export "as-block-value") (result i32) + (block (result i32) + (nop) (call $dummy) (br_table 0 0 0 (i32.const 2) (i32.const 0)) + ) + ) + + (func (export "as-loop-first") (result i32) + (loop (result i32) (br_table 1 1 (i32.const 3) (i32.const 0)) (i32.const 1)) + ) + (func (export "as-loop-mid") (result i32) + (loop (result i32) + (call $dummy) + (br_table 1 1 1 (i32.const 4) (i32.const -1)) + (i32.const 2) + ) + ) + (func (export "as-loop-last") (result i32) + (loop (result i32) + (nop) (call $dummy) (br_table 1 1 1 (i32.const 5) (i32.const 1)) + ) + ) + + (func (export "as-br-value") (result i32) + (block (result i32) (br 0 (br_table 0 (i32.const 9) (i32.const 0)))) + ) + + (func (export "as-br_if-cond") + (block (br_if 0 (br_table 0 0 0 (i32.const 1)))) + ) + (func (export "as-br_if-value") (result i32) + (block (result i32) + (drop (br_if 0 (br_table 0 (i32.const 8) (i32.const 0)) (i32.const 1))) + (i32.const 7) + ) + ) + (func (export "as-br_if-value-cond") (result i32) + (block (result i32) + (drop (br_if 0 (i32.const 6) (br_table 0 0 (i32.const 9) (i32.const 0)))) + (i32.const 7) + ) + ) + + (func (export "as-br_table-index") + (block (br_table 0 0 0 (br_table 0 (i32.const 1)))) + ) + (func (export "as-br_table-value") (result i32) + (block (result i32) + (br_table 0 0 0 (br_table 0 (i32.const 10) (i32.const 0)) (i32.const 1)) + (i32.const 7) + ) + ) + (func (export "as-br_table-value-index") (result i32) + (block (result i32) + (br_table 0 0 (i32.const 6) (br_table 0 (i32.const 11) (i32.const 1))) + (i32.const 7) + ) + ) + + (func (export "as-return-value") (result i64) + (block (result i64) (return (br_table 0 (i64.const 7) (i32.const 0)))) + ) + + (func (export "as-if-cond") (result i32) + (block (result i32) + (if (result i32) + (br_table 0 (i32.const 2) (i32.const 0)) + (then (i32.const 0)) + (else (i32.const 1)) + ) + ) + ) + (func (export "as-if-then") (param i32 i32) (result i32) + (block (result i32) + (if (result i32) + (local.get 0) + (then (br_table 1 (i32.const 3) (i32.const 0))) + (else (local.get 1)) + ) + ) + ) + (func (export "as-if-else") (param i32 i32) (result i32) + (block (result i32) + (if (result i32) + (local.get 0) + (then (local.get 1)) + (else (br_table 1 0 (i32.const 4) (i32.const 0))) + ) + ) + ) + + (func (export "as-select-first") (param i32 i32) (result i32) + (block (result i32) + (select + (br_table 0 (i32.const 5) (i32.const 0)) (local.get 0) (local.get 1) + ) + ) + ) + (func (export "as-select-second") (param i32 i32) (result i32) + (block (result i32) + (select + (local.get 0) (br_table 0 (i32.const 6) (i32.const 1)) (local.get 1) + ) + ) + ) + (func (export "as-select-cond") (result i32) + (block (result i32) + (select + (i32.const 0) (i32.const 1) (br_table 0 (i32.const 7) (i32.const 1)) + ) + ) + ) + + (func $f (param i32 i32 i32) (result i32) (i32.const -1)) + (func (export "as-call-first") (result i32) + (block (result i32) + (call $f + (br_table 0 (i32.const 12) (i32.const 1)) (i32.const 2) (i32.const 3) + ) + ) + ) + (func (export "as-call-mid") (result i32) + (block (result i32) + (call $f + (i32.const 1) (br_table 0 (i32.const 13) (i32.const 1)) (i32.const 3) + ) + ) + ) + (func (export "as-call-last") (result i32) + (block (result i32) + (call $f + (i32.const 1) (i32.const 2) (br_table 0 (i32.const 14) (i32.const 1)) + ) + ) + ) + + (type $sig (func (param i32 i32 i32) (result i32))) + (table funcref (elem $f)) + (func (export "as-call_indirect-first") (result i32) + (block (result i32) + (call_indirect (type $sig) + (br_table 0 (i32.const 20) (i32.const 1)) (i32.const 1) (i32.const 2) + (i32.const 3) + ) + ) + ) + (func (export "as-call_indirect-mid") (result i32) + (block (result i32) + (call_indirect (type $sig) + (i32.const 0) (br_table 0 (i32.const 21) (i32.const 1)) (i32.const 2) + (i32.const 3) + ) + ) + ) + (func (export "as-call_indirect-last") (result i32) + (block (result i32) + (call_indirect (type $sig) + (i32.const 0) (i32.const 1) (br_table 0 (i32.const 22) (i32.const 1)) + (i32.const 3) + ) + ) + ) + (func (export "as-call_indirect-func") (result i32) + (block (result i32) + (call_indirect (type $sig) + (i32.const 0) (i32.const 1) (i32.const 2) + (br_table 0 (i32.const 23) (i32.const 1)) + ) + ) + ) + + (func (export "as-local.set-value") (result i32) + (local f32) + (block (result i32) + (local.set 0 (br_table 0 (i32.const 17) (i32.const 1))) + (i32.const -1) + ) + ) + (func (export "as-local.tee-value") (result i32) + (local i32) + (block (result i32) + (local.set 0 (br_table 0 (i32.const 1) (i32.const 1))) + (i32.const -1) + ) + ) + (global $a (mut i32) (i32.const 10)) + (func (export "as-global.set-value") (result i32) + (block (result i32) + (global.set $a (br_table 0 (i32.const 1) (i32.const 1))) + (i32.const -1) + ) + ) + + (memory 1) + (func (export "as-load-address") (result f32) + (block (result f32) (f32.load (br_table 0 (f32.const 1.7) (i32.const 1)))) + ) + (func (export "as-loadN-address") (result i64) + (block (result i64) (i64.load8_s (br_table 0 (i64.const 30) (i32.const 1)))) + ) + + (func (export "as-store-address") (result i32) + (block (result i32) + (f64.store (br_table 0 (i32.const 30) (i32.const 1)) (f64.const 7)) + (i32.const -1) + ) + ) + (func (export "as-store-value") (result i32) + (block (result i32) + (i64.store (i32.const 2) (br_table 0 (i32.const 31) (i32.const 1))) + (i32.const -1) + ) + ) + + (func (export "as-storeN-address") (result i32) + (block (result i32) + (i32.store8 (br_table 0 (i32.const 32) (i32.const 0)) (i32.const 7)) + (i32.const -1) + ) + ) + (func (export "as-storeN-value") (result i32) + (block (result i32) + (i64.store16 (i32.const 2) (br_table 0 (i32.const 33) (i32.const 0))) + (i32.const -1) + ) + ) + + (func (export "as-unary-operand") (result f32) + (block (result f32) (f32.neg (br_table 0 (f32.const 3.4) (i32.const 0)))) + ) + + (func (export "as-binary-left") (result i32) + (block (result i32) + (i32.add (br_table 0 0 (i32.const 3) (i32.const 0)) (i32.const 10)) + ) + ) + (func (export "as-binary-right") (result i64) + (block (result i64) + (i64.sub (i64.const 10) (br_table 0 (i64.const 45) (i32.const 0))) + ) + ) + + (func (export "as-test-operand") (result i32) + (block (result i32) (i32.eqz (br_table 0 (i32.const 44) (i32.const 0)))) + ) + + (func (export "as-compare-left") (result i32) + (block (result i32) + (f64.le (br_table 0 0 (i32.const 43) (i32.const 0)) (f64.const 10)) + ) + ) + (func (export "as-compare-right") (result i32) + (block (result i32) + (f32.ne (f32.const 10) (br_table 0 (i32.const 42) (i32.const 0))) + ) + ) + + (func (export "as-convert-operand") (result i32) + (block (result i32) + (i32.wrap_i64 (br_table 0 (i32.const 41) (i32.const 0))) + ) + ) + + (func (export "as-memory.grow-size") (result i32) + (block (result i32) (memory.grow (br_table 0 (i32.const 40) (i32.const 0)))) + ) + + (func (export "nested-block-value") (param i32) (result i32) + (block (result i32) + (drop (i32.const -1)) + (i32.add + (i32.const 1) + (block (result i32) + (i32.add + (i32.const 2) + (block (result i32) + (drop (i32.const 4)) + (i32.add + (i32.const 8) + (br_table 0 1 2 (i32.const 16) (local.get 0)) + ) + ) + ) + ) + ) + ) + ) + + (func (export "nested-br-value") (param i32) (result i32) + (block (result i32) + (i32.add + (i32.const 1) + (block (result i32) + (drop (i32.const 2)) + (drop + (block (result i32) + (drop (i32.const 4)) + (br 0 (br_table 2 1 0 (i32.const 8) (local.get 0))) + ) + ) + (i32.const 16) + ) + ) + ) + ) + + (func (export "nested-br_if-value") (param i32) (result i32) + (block (result i32) + (i32.add + (i32.const 1) + (block (result i32) + (drop (i32.const 2)) + (drop + (block (result i32) + (drop (i32.const 4)) + (drop + (br_if 0 + (br_table 0 1 2 (i32.const 8) (local.get 0)) + (i32.const 1) + ) + ) + (i32.const 32) + ) + ) + (i32.const 16) + ) + ) + ) + ) + + (func (export "nested-br_if-value-cond") (param i32) (result i32) + (block (result i32) + (i32.add + (i32.const 1) + (block (result i32) + (drop (i32.const 2)) + (drop + (br_if 0 (i32.const 4) (br_table 0 1 0 (i32.const 8) (local.get 0))) + ) + (i32.const 16) + ) + ) + ) + ) + + (func (export "nested-br_table-value") (param i32) (result i32) + (block (result i32) + (i32.add + (i32.const 1) + (block (result i32) + (drop (i32.const 2)) + (drop + (block (result i32) + (drop (i32.const 4)) + (br_table 0 (br_table 0 1 2 (i32.const 8) (local.get 0)) (i32.const 1)) + (i32.const 32) + ) + ) + (i32.const 16) + ) + ) + ) + ) + + (func (export "nested-br_table-value-index") (param i32) (result i32) + (block (result i32) + (i32.add + (i32.const 1) + (block (result i32) + (drop (i32.const 2)) + (br_table 0 (i32.const 4) (br_table 0 1 0 (i32.const 8) (local.get 0))) + (i32.const 16) + ) + ) + ) + ) + + (func (export "nested-br_table-loop-block") (param i32) (result i32) + (local.set 0 + (loop (result i32) + (block + (br_table 1 0 0 (local.get 0)) + ) + (i32.const 0) + ) + ) + (loop (result i32) + (block + (br_table 0 1 1 (local.get 0)) + ) + (i32.const 3) + ) + ) + + (func (export "meet-externref") (param i32) (param externref) (result externref) + (block $l1 (result externref) + (block $l2 (result externref) + (br_table $l1 $l2 $l1 (local.get 1) (local.get 0)) + ) + ) + ) + + (func (export "meet-bottom") + (block (result f64) + (block (result f32) + (unreachable) + (br_table 0 1 1 (i32.const 1)) + ) + (drop) + (f64.const 0) + ) + (drop) + ) + + (type $t (func)) + (func $tf) + (table $t (ref null $t) (elem $tf)) + (func (export "meet-funcref-1") (param i32) (result (ref null func)) + (block $l1 (result (ref null func)) + (block $l2 (result (ref null $t)) + (br_table $l1 $l1 $l2 (table.get $t (i32.const 0)) (local.get 0)) + ) + ) + ) + (func (export "meet-funcref-2") (param i32) (result (ref null func)) + (block $l1 (result (ref null func)) + (block $l2 (result (ref null $t)) + (br_table $l2 $l2 $l1 (table.get $t (i32.const 0)) (local.get 0)) + ) + ) + ) + (func (export "meet-funcref-3") (param i32) (result (ref null func)) + (block $l1 (result (ref null func)) + (block $l2 (result (ref null $t)) + (br_table $l2 $l1 $l2 (table.get $t (i32.const 0)) (local.get 0)) + ) + ) + ) + (func (export "meet-funcref-4") (param i32) (result (ref null func)) + (block $l1 (result (ref null func)) + (block $l2 (result (ref null $t)) + (br_table $l1 $l2 $l1 (table.get $t (i32.const 0)) (local.get 0)) + ) + ) + ) + + (func (export "meet-nullref") (param i32) (result (ref null func)) + (block $l1 (result (ref null func)) + (block $l2 (result (ref null $t)) + (br_table $l1 $l2 $l1 (ref.null $t) (local.get 0)) + ) + ) + ) + + (func (export "meet-multi-ref") (param i32) (result (ref null func)) + (block $l1 (result (ref null func)) + (block $l2 (result (ref null $t)) + (block $l3 (result (ref $t)) + (br_table $l3 $l2 $l1 (ref.func $tf) (local.get 0)) + ) + ) + ) + ) +) + +(assert_return (invoke "type-i32")) +(assert_return (invoke "type-i64")) +(assert_return (invoke "type-f32")) +(assert_return (invoke "type-f64")) + +(assert_return (invoke "type-i32-value") (i32.const 1)) +(assert_return (invoke "type-i64-value") (i64.const 2)) +(assert_return (invoke "type-f32-value") (f32.const 3)) +(assert_return (invoke "type-f64-value") (f64.const 4)) + +(assert_return (invoke "empty" (i32.const 0)) (i32.const 22)) +(assert_return (invoke "empty" (i32.const 1)) (i32.const 22)) +(assert_return (invoke "empty" (i32.const 11)) (i32.const 22)) +(assert_return (invoke "empty" (i32.const -1)) (i32.const 22)) +(assert_return (invoke "empty" (i32.const -100)) (i32.const 22)) +(assert_return (invoke "empty" (i32.const 0xffffffff)) (i32.const 22)) + +(assert_return (invoke "empty-value" (i32.const 0)) (i32.const 33)) +(assert_return (invoke "empty-value" (i32.const 1)) (i32.const 33)) +(assert_return (invoke "empty-value" (i32.const 11)) (i32.const 33)) +(assert_return (invoke "empty-value" (i32.const -1)) (i32.const 33)) +(assert_return (invoke "empty-value" (i32.const -100)) (i32.const 33)) +(assert_return (invoke "empty-value" (i32.const 0xffffffff)) (i32.const 33)) + +(assert_return (invoke "singleton" (i32.const 0)) (i32.const 22)) +(assert_return (invoke "singleton" (i32.const 1)) (i32.const 20)) +(assert_return (invoke "singleton" (i32.const 11)) (i32.const 20)) +(assert_return (invoke "singleton" (i32.const -1)) (i32.const 20)) +(assert_return (invoke "singleton" (i32.const -100)) (i32.const 20)) +(assert_return (invoke "singleton" (i32.const 0xffffffff)) (i32.const 20)) + +(assert_return (invoke "singleton-value" (i32.const 0)) (i32.const 32)) +(assert_return (invoke "singleton-value" (i32.const 1)) (i32.const 33)) +(assert_return (invoke "singleton-value" (i32.const 11)) (i32.const 33)) +(assert_return (invoke "singleton-value" (i32.const -1)) (i32.const 33)) +(assert_return (invoke "singleton-value" (i32.const -100)) (i32.const 33)) +(assert_return (invoke "singleton-value" (i32.const 0xffffffff)) (i32.const 33)) + +(assert_return (invoke "multiple" (i32.const 0)) (i32.const 103)) +(assert_return (invoke "multiple" (i32.const 1)) (i32.const 102)) +(assert_return (invoke "multiple" (i32.const 2)) (i32.const 101)) +(assert_return (invoke "multiple" (i32.const 3)) (i32.const 100)) +(assert_return (invoke "multiple" (i32.const 4)) (i32.const 104)) +(assert_return (invoke "multiple" (i32.const 5)) (i32.const 104)) +(assert_return (invoke "multiple" (i32.const 6)) (i32.const 104)) +(assert_return (invoke "multiple" (i32.const 10)) (i32.const 104)) +(assert_return (invoke "multiple" (i32.const -1)) (i32.const 104)) +(assert_return (invoke "multiple" (i32.const 0xffffffff)) (i32.const 104)) + +(assert_return (invoke "multiple-value" (i32.const 0)) (i32.const 213)) +(assert_return (invoke "multiple-value" (i32.const 1)) (i32.const 212)) +(assert_return (invoke "multiple-value" (i32.const 2)) (i32.const 211)) +(assert_return (invoke "multiple-value" (i32.const 3)) (i32.const 210)) +(assert_return (invoke "multiple-value" (i32.const 4)) (i32.const 214)) +(assert_return (invoke "multiple-value" (i32.const 5)) (i32.const 214)) +(assert_return (invoke "multiple-value" (i32.const 6)) (i32.const 214)) +(assert_return (invoke "multiple-value" (i32.const 10)) (i32.const 214)) +(assert_return (invoke "multiple-value" (i32.const -1)) (i32.const 214)) +(assert_return (invoke "multiple-value" (i32.const 0xffffffff)) (i32.const 214)) + +(assert_return (invoke "large" (i32.const 0)) (i32.const 0)) +(assert_return (invoke "large" (i32.const 1)) (i32.const 1)) +(assert_return (invoke "large" (i32.const 100)) (i32.const 0)) +(assert_return (invoke "large" (i32.const 101)) (i32.const 1)) +(assert_return (invoke "large" (i32.const 10000)) (i32.const 0)) +(assert_return (invoke "large" (i32.const 10001)) (i32.const 1)) +(assert_return (invoke "large" (i32.const 1000000)) (i32.const 1)) +(assert_return (invoke "large" (i32.const 1000001)) (i32.const 1)) + +(assert_return (invoke "as-block-first")) +(assert_return (invoke "as-block-mid")) +(assert_return (invoke "as-block-last")) +(assert_return (invoke "as-block-value") (i32.const 2)) + +(assert_return (invoke "as-loop-first") (i32.const 3)) +(assert_return (invoke "as-loop-mid") (i32.const 4)) +(assert_return (invoke "as-loop-last") (i32.const 5)) + +(assert_return (invoke "as-br-value") (i32.const 9)) + +(assert_return (invoke "as-br_if-cond")) +(assert_return (invoke "as-br_if-value") (i32.const 8)) +(assert_return (invoke "as-br_if-value-cond") (i32.const 9)) + +(assert_return (invoke "as-br_table-index")) +(assert_return (invoke "as-br_table-value") (i32.const 10)) +(assert_return (invoke "as-br_table-value-index") (i32.const 11)) + +(assert_return (invoke "as-return-value") (i64.const 7)) + +(assert_return (invoke "as-if-cond") (i32.const 2)) +(assert_return (invoke "as-if-then" (i32.const 1) (i32.const 6)) (i32.const 3)) +(assert_return (invoke "as-if-then" (i32.const 0) (i32.const 6)) (i32.const 6)) +(assert_return (invoke "as-if-else" (i32.const 0) (i32.const 6)) (i32.const 4)) +(assert_return (invoke "as-if-else" (i32.const 1) (i32.const 6)) (i32.const 6)) + +(assert_return (invoke "as-select-first" (i32.const 0) (i32.const 6)) (i32.const 5)) +(assert_return (invoke "as-select-first" (i32.const 1) (i32.const 6)) (i32.const 5)) +(assert_return (invoke "as-select-second" (i32.const 0) (i32.const 6)) (i32.const 6)) +(assert_return (invoke "as-select-second" (i32.const 1) (i32.const 6)) (i32.const 6)) +(assert_return (invoke "as-select-cond") (i32.const 7)) + +(assert_return (invoke "as-call-first") (i32.const 12)) +(assert_return (invoke "as-call-mid") (i32.const 13)) +(assert_return (invoke "as-call-last") (i32.const 14)) + +(assert_return (invoke "as-call_indirect-first") (i32.const 20)) +(assert_return (invoke "as-call_indirect-mid") (i32.const 21)) +(assert_return (invoke "as-call_indirect-last") (i32.const 22)) +(assert_return (invoke "as-call_indirect-func") (i32.const 23)) + +(assert_return (invoke "as-local.set-value") (i32.const 17)) +(assert_return (invoke "as-local.tee-value") (i32.const 1)) +(assert_return (invoke "as-global.set-value") (i32.const 1)) + +(assert_return (invoke "as-load-address") (f32.const 1.7)) +(assert_return (invoke "as-loadN-address") (i64.const 30)) + +(assert_return (invoke "as-store-address") (i32.const 30)) +(assert_return (invoke "as-store-value") (i32.const 31)) +(assert_return (invoke "as-storeN-address") (i32.const 32)) +(assert_return (invoke "as-storeN-value") (i32.const 33)) + +(assert_return (invoke "as-unary-operand") (f32.const 3.4)) + +(assert_return (invoke "as-binary-left") (i32.const 3)) +(assert_return (invoke "as-binary-right") (i64.const 45)) + +(assert_return (invoke "as-test-operand") (i32.const 44)) + +(assert_return (invoke "as-compare-left") (i32.const 43)) +(assert_return (invoke "as-compare-right") (i32.const 42)) + +(assert_return (invoke "as-convert-operand") (i32.const 41)) + +(assert_return (invoke "as-memory.grow-size") (i32.const 40)) + +(assert_return (invoke "nested-block-value" (i32.const 0)) (i32.const 19)) +(assert_return (invoke "nested-block-value" (i32.const 1)) (i32.const 17)) +(assert_return (invoke "nested-block-value" (i32.const 2)) (i32.const 16)) +(assert_return (invoke "nested-block-value" (i32.const 10)) (i32.const 16)) +(assert_return (invoke "nested-block-value" (i32.const -1)) (i32.const 16)) +(assert_return (invoke "nested-block-value" (i32.const 100000)) (i32.const 16)) + +(assert_return (invoke "nested-br-value" (i32.const 0)) (i32.const 8)) +(assert_return (invoke "nested-br-value" (i32.const 1)) (i32.const 9)) +(assert_return (invoke "nested-br-value" (i32.const 2)) (i32.const 17)) +(assert_return (invoke "nested-br-value" (i32.const 11)) (i32.const 17)) +(assert_return (invoke "nested-br-value" (i32.const -4)) (i32.const 17)) +(assert_return (invoke "nested-br-value" (i32.const 10213210)) (i32.const 17)) + +(assert_return (invoke "nested-br_if-value" (i32.const 0)) (i32.const 17)) +(assert_return (invoke "nested-br_if-value" (i32.const 1)) (i32.const 9)) +(assert_return (invoke "nested-br_if-value" (i32.const 2)) (i32.const 8)) +(assert_return (invoke "nested-br_if-value" (i32.const 9)) (i32.const 8)) +(assert_return (invoke "nested-br_if-value" (i32.const -9)) (i32.const 8)) +(assert_return (invoke "nested-br_if-value" (i32.const 999999)) (i32.const 8)) + +(assert_return (invoke "nested-br_if-value-cond" (i32.const 0)) (i32.const 9)) +(assert_return (invoke "nested-br_if-value-cond" (i32.const 1)) (i32.const 8)) +(assert_return (invoke "nested-br_if-value-cond" (i32.const 2)) (i32.const 9)) +(assert_return (invoke "nested-br_if-value-cond" (i32.const 3)) (i32.const 9)) +(assert_return (invoke "nested-br_if-value-cond" (i32.const -1000000)) (i32.const 9)) +(assert_return (invoke "nested-br_if-value-cond" (i32.const 9423975)) (i32.const 9)) + +(assert_return (invoke "nested-br_table-value" (i32.const 0)) (i32.const 17)) +(assert_return (invoke "nested-br_table-value" (i32.const 1)) (i32.const 9)) +(assert_return (invoke "nested-br_table-value" (i32.const 2)) (i32.const 8)) +(assert_return (invoke "nested-br_table-value" (i32.const 9)) (i32.const 8)) +(assert_return (invoke "nested-br_table-value" (i32.const -9)) (i32.const 8)) +(assert_return (invoke "nested-br_table-value" (i32.const 999999)) (i32.const 8)) + +(assert_return (invoke "nested-br_table-value-index" (i32.const 0)) (i32.const 9)) +(assert_return (invoke "nested-br_table-value-index" (i32.const 1)) (i32.const 8)) +(assert_return (invoke "nested-br_table-value-index" (i32.const 2)) (i32.const 9)) +(assert_return (invoke "nested-br_table-value-index" (i32.const 3)) (i32.const 9)) +(assert_return (invoke "nested-br_table-value-index" (i32.const -1000000)) (i32.const 9)) +(assert_return (invoke "nested-br_table-value-index" (i32.const 9423975)) (i32.const 9)) + +(assert_return (invoke "nested-br_table-loop-block" (i32.const 1)) (i32.const 3)) + +(assert_return (invoke "meet-externref" (i32.const 0) (ref.extern 1)) (ref.extern 1)) +(assert_return (invoke "meet-externref" (i32.const 1) (ref.extern 1)) (ref.extern 1)) +(assert_return (invoke "meet-externref" (i32.const 2) (ref.extern 1)) (ref.extern 1)) + +(assert_return (invoke "meet-funcref-1" (i32.const 0)) (ref.func)) +(assert_return (invoke "meet-funcref-1" (i32.const 1)) (ref.func)) +(assert_return (invoke "meet-funcref-1" (i32.const 2)) (ref.func)) +(assert_return (invoke "meet-funcref-2" (i32.const 0)) (ref.func)) +(assert_return (invoke "meet-funcref-2" (i32.const 1)) (ref.func)) +(assert_return (invoke "meet-funcref-2" (i32.const 2)) (ref.func)) +(assert_return (invoke "meet-funcref-3" (i32.const 0)) (ref.func)) +(assert_return (invoke "meet-funcref-3" (i32.const 1)) (ref.func)) +(assert_return (invoke "meet-funcref-3" (i32.const 2)) (ref.func)) +(assert_return (invoke "meet-funcref-4" (i32.const 0)) (ref.func)) +(assert_return (invoke "meet-funcref-4" (i32.const 1)) (ref.func)) +(assert_return (invoke "meet-funcref-4" (i32.const 2)) (ref.func)) + +(assert_invalid + (module (func $type-arg-void-vs-num (result i32) + (block (br_table 0 (i32.const 1)) (i32.const 1)) + )) + "type mismatch" +) + +(assert_invalid + (module (func $type-arg-empty-vs-num (result i32) + (block (br_table 0) (i32.const 1)) + )) + "type mismatch" +) + +(assert_invalid + (module (func $type-arg-void-vs-num (result i32) + (block (result i32) (br_table 0 (nop) (i32.const 1)) (i32.const 1)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-arg-num-vs-num (result i32) + (block (result i32) + (br_table 0 0 0 (i64.const 1) (i32.const 1)) (i32.const 1) + ) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-arg-num-vs-arg-num + (block + (block (result f32) + (br_table 0 1 (f32.const 0) (i32.const 0)) + ) + (drop) + ) + )) + "type mismatch" +) +(assert_invalid + (module (func + (block (result i32) + (block (result i64) + (br_table 0 1 (i32.const 0) (i32.const 0)) + ) + ) + )) + "type mismatch" +) + +(assert_invalid + (module (func $type-index-void-vs-i32 + (block (br_table 0 0 0 (nop))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-index-num-vs-i32 + (block (br_table 0 (i64.const 0))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-arg-index-void-vs-i32 (result i32) + (block (result i32) (br_table 0 0 (i32.const 0) (nop)) (i32.const 1)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-arg-void-vs-num-nested (result i32) + (block (result i32) (i32.const 0) (block (br_table 1 (i32.const 0)))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-arg-index-num-vs-i32 (result i32) + (block (result i32) + (br_table 0 0 (i32.const 0) (i64.const 0)) (i32.const 1) + ) + )) + "type mismatch" +) + +(assert_invalid + (module (func $type-arg-void-vs-num (result i32) + (block (br_table 0 (i32.const 1)) (i32.const 1)) + )) + "type mismatch" +) + +(assert_invalid + (module + (func $type-arg-index-empty-in-then + (block + (i32.const 0) (i32.const 0) + (if (result i32) (then (br_table 0))) + ) + (i32.eqz) (drop) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-arg-value-empty-in-then + (block + (i32.const 0) (i32.const 0) + (if (result i32) (then (br_table 0 (i32.const 1)))) + ) + (i32.eqz) (drop) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-arg-index-empty-in-return + (block (result i32) + (return (br_table 0)) + ) + (i32.eqz) (drop) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-arg-value-empty-in-return + (block (result i32) + (return (br_table 0 (i32.const 1))) + ) + (i32.eqz) (drop) + ) + ) + "type mismatch" +) + +(assert_invalid + (module + (func (param i32) (result i32) + (loop (result i32) + (block (result i32) + (br_table 0 1 (i32.const 1) (local.get 0)) + ) + ) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func (param i32) (result i32) + (block (result i32) + (loop (result i32) + (br_table 0 1 (i32.const 1) (local.get 0)) + ) + ) + ) + ) + "type mismatch" +) + + +(assert_invalid + (module (func $meet-bottom (param i32) (result externref) + (block $l1 (result externref) + (drop + (block $l2 (result i32) + (br_table $l2 $l1 $l2 (ref.null extern) (local.get 0)) + ) + ) + (ref.null extern) + ) + )) + "type mismatch" +) + +(assert_invalid + (module (func $unbound-label + (block (br_table 2 1 (i32.const 1))) + )) + "unknown label" +) +(assert_invalid + (module (func $unbound-nested-label + (block (block (br_table 0 5 (i32.const 1)))) + )) + "unknown label" +) +(assert_invalid + (module (func $large-label + (block (br_table 0 0x10000001 0 (i32.const 1))) + )) + "unknown label" +) + +(assert_invalid + (module (func $unbound-label-default + (block (br_table 1 2 (i32.const 1))) + )) + "unknown label" +) +(assert_invalid + (module (func $unbound-nested-label-default + (block (block (br_table 0 5 (i32.const 1)))) + )) + "unknown label" +) +(assert_invalid + (module (func $large-label-default + (block (br_table 0 0 0x10000001 (i32.const 1))) + )) + "unknown label" +) diff --git a/runtime/near-vm/tests/wast/spec/proposals/gc/call_ref.wast b/runtime/near-vm/tests/wast/spec/proposals/gc/call_ref.wast new file mode 100644 index 00000000000..503c4e8613b --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/proposals/gc/call_ref.wast @@ -0,0 +1,202 @@ +(module + (type $ii (func (param i32) (result i32))) + + (func $apply (param $f (ref $ii)) (param $x i32) (result i32) + (call_ref (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 (call_ref (local.get $x) (local.get $rf)) (local.get $rg)) + ) + + (func (export "null") (result i32) + (call_ref (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 (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 + (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 (i64.sub (local.get 0) (i64.const 2)) (global.get $fib)) + (call_ref (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 (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 (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 + (func (export "unreachable") (result i32) + (unreachable) + (call_ref) + ) +) +(assert_trap (invoke "unreachable") "unreachable") + +(module + (elem declare func $f) + (func $f (param i32) (result i32) (local.get 0)) + + (func (export "unreachable") (result i32) + (unreachable) + (ref.func $f) + (call_ref) + ) +) +(assert_trap (invoke "unreachable") "unreachable") + +(module + (elem declare func $f) + (func $f (param i32) (result i32) (local.get 0)) + + (func (export "unreachable") (result i32) + (unreachable) + (i32.const 0) + (ref.func $f) + (call_ref) + (drop) + (i32.const 0) + ) +) +(assert_trap (invoke "unreachable") "unreachable") + +(assert_invalid + (module + (elem declare func $f) + (func $f (param i32) (result i32) (local.get 0)) + + (func (export "unreachable") (result i32) + (unreachable) + (i64.const 0) + (ref.func $f) + (call_ref) + ) + ) + "type mismatch" +) + +(assert_invalid + (module + (elem declare func $f) + (func $f (param i32) (result i32) (local.get 0)) + + (func (export "unreachable") (result i32) + (unreachable) + (ref.func $f) + (call_ref) + (drop) + (i64.const 0) + ) + ) + "type mismatch" +) + +(assert_invalid + (module + (func $f (param $r externref) + (call_ref (local.get $r)) + ) + ) + "type mismatch" +) diff --git a/runtime/near-vm/tests/wast/spec/proposals/gc/func.wast b/runtime/near-vm/tests/wast/spec/proposals/gc/func.wast new file mode 100644 index 00000000000..a5e0ec7574d --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/proposals/gc/func.wast @@ -0,0 +1,988 @@ +;; Test `func` declarations, i.e. functions + +(module + ;; Auxiliary definition + (type $sig (func)) + (func $dummy) + + ;; Syntax + + (func) + (func (export "f")) + (func $f) + (func $h (export "g")) + + (func (local)) + (func (local) (local)) + (func (local i32)) + (func (local $x i32)) + (func (local i32 f64 i64)) + (func (local i32) (local f64)) + (func (local i32 f32) (local $x i64) (local) (local i32 f64)) + + (func (param)) + (func (param) (param)) + (func (param i32)) + (func (param $x i32)) + (func (param i32 f64 i64)) + (func (param i32) (param f64)) + (func (param i32 f32) (param $x i64) (param) (param i32 f64)) + + (func (result)) + (func (result) (result)) + (func (result i32) (unreachable)) + (func (result i32 f64 f32) (unreachable)) + (func (result i32) (result f64) (unreachable)) + (func (result i32 f32) (result i64) (result) (result i32 f64) (unreachable)) + + (type $sig-1 (func)) + (type $sig-2 (func (result i32))) + (type $sig-3 (func (param $x i32))) + (type $sig-4 (func (param i32 f64 i32) (result i32))) + + (func (export "type-use-1") (type $sig-1)) + (func (export "type-use-2") (type $sig-2) (i32.const 0)) + (func (export "type-use-3") (type $sig-3)) + (func (export "type-use-4") (type $sig-4) (i32.const 0)) + (func (export "type-use-5") (type $sig-2) (result i32) (i32.const 0)) + (func (export "type-use-6") (type $sig-3) (param i32)) + (func (export "type-use-7") + (type $sig-4) (param i32) (param f64 i32) (result i32) (i32.const 0) + ) + + (func (type $sig)) + (func (type $forward)) ;; forward reference + + (func $complex + (param i32 f32) (param $x i64) (param) (param i32) + (result) (result i32) (result) (result i64 i32) + (local f32) (local $y i32) (local i64 i32) (local) (local f64 i32) + (unreachable) (unreachable) + ) + (func $complex-sig + (type $sig) + (local f32) (local $y i32) (local i64 i32) (local) (local f64 i32) + (unreachable) (unreachable) + ) + + (type $forward (func)) + + ;; Typing of locals + + (func (export "local-first-i32") (result i32) (local i32 i32) (local.get 0)) + (func (export "local-first-i64") (result i64) (local i64 i64) (local.get 0)) + (func (export "local-first-f32") (result f32) (local f32 f32) (local.get 0)) + (func (export "local-first-f64") (result f64) (local f64 f64) (local.get 0)) + (func (export "local-second-i32") (result i32) (local i32 i32) (local.get 1)) + (func (export "local-second-i64") (result i64) (local i64 i64) (local.get 1)) + (func (export "local-second-f32") (result f32) (local f32 f32) (local.get 1)) + (func (export "local-second-f64") (result f64) (local f64 f64) (local.get 1)) + (func (export "local-mixed") (result f64) + (local f32) (local $x i32) (local i64 i32) (local) (local f64 i32) + (drop (f32.neg (local.get 0))) + (drop (i32.eqz (local.get 1))) + (drop (i64.eqz (local.get 2))) + (drop (i32.eqz (local.get 3))) + (drop (f64.neg (local.get 4))) + (drop (i32.eqz (local.get 5))) + (local.get 4) + ) + + ;; Typing of parameters + + (func (export "param-first-i32") (param i32 i32) (result i32) (local.get 0)) + (func (export "param-first-i64") (param i64 i64) (result i64) (local.get 0)) + (func (export "param-first-f32") (param f32 f32) (result f32) (local.get 0)) + (func (export "param-first-f64") (param f64 f64) (result f64) (local.get 0)) + (func (export "param-second-i32") (param i32 i32) (result i32) (local.get 1)) + (func (export "param-second-i64") (param i64 i64) (result i64) (local.get 1)) + (func (export "param-second-f32") (param f32 f32) (result f32) (local.get 1)) + (func (export "param-second-f64") (param f64 f64) (result f64) (local.get 1)) + (func (export "param-mixed") (param f32 i32) (param) (param $x i64) (param i32 f64 i32) + (result f64) + (drop (f32.neg (local.get 0))) + (drop (i32.eqz (local.get 1))) + (drop (i64.eqz (local.get 2))) + (drop (i32.eqz (local.get 3))) + (drop (f64.neg (local.get 4))) + (drop (i32.eqz (local.get 5))) + (local.get 4) + ) + + ;; Typing of results + + (func (export "empty")) + (func (export "value-void") (call $dummy)) + (func (export "value-i32") (result i32) (i32.const 77)) + (func (export "value-i64") (result i64) (i64.const 7777)) + (func (export "value-f32") (result f32) (f32.const 77.7)) + (func (export "value-f64") (result f64) (f64.const 77.77)) + (func (export "value-i32-f64") (result i32 f64) (i32.const 77) (f64.const 7)) + (func (export "value-i32-i32-i32") (result i32 i32 i32) + (i32.const 1) (i32.const 2) (i32.const 3) + ) + (func (export "value-block-void") (block (call $dummy) (call $dummy))) + (func (export "value-block-i32") (result i32) + (block (result i32) (call $dummy) (i32.const 77)) + ) + (func (export "value-block-i32-i64") (result i32 i64) + (block (result i32 i64) (call $dummy) (i32.const 1) (i64.const 2)) + ) + + (func (export "return-empty") (return)) + (func (export "return-i32") (result i32) (return (i32.const 78))) + (func (export "return-i64") (result i64) (return (i64.const 7878))) + (func (export "return-f32") (result f32) (return (f32.const 78.7))) + (func (export "return-f64") (result f64) (return (f64.const 78.78))) + (func (export "return-i32-f64") (result i32 f64) + (return (i32.const 78) (f64.const 78.78)) + ) + (func (export "return-i32-i32-i32") (result i32 i32 i32) + (return (i32.const 1) (i32.const 2) (i32.const 3)) + ) + (func (export "return-block-i32") (result i32) + (return (block (result i32) (call $dummy) (i32.const 77))) + ) + (func (export "return-block-i32-i64") (result i32 i64) + (return (block (result i32 i64) (call $dummy) (i32.const 1) (i64.const 2))) + ) + + (func (export "break-empty") (br 0)) + (func (export "break-i32") (result i32) (br 0 (i32.const 79))) + (func (export "break-i64") (result i64) (br 0 (i64.const 7979))) + (func (export "break-f32") (result f32) (br 0 (f32.const 79.9))) + (func (export "break-f64") (result f64) (br 0 (f64.const 79.79))) + (func (export "break-i32-f64") (result i32 f64) + (br 0 (i32.const 79) (f64.const 79.79)) + ) + (func (export "break-i32-i32-i32") (result i32 i32 i32) + (br 0 (i32.const 1) (i32.const 2) (i32.const 3)) + ) + (func (export "break-block-i32") (result i32) + (br 0 (block (result i32) (call $dummy) (i32.const 77))) + ) + (func (export "break-block-i32-i64") (result i32 i64) + (br 0 (block (result i32 i64) (call $dummy) (i32.const 1) (i64.const 2))) + ) + + (func (export "break-br_if-empty") (param i32) + (br_if 0 (local.get 0)) + ) + (func (export "break-br_if-num") (param i32) (result i32) + (drop (br_if 0 (i32.const 50) (local.get 0))) (i32.const 51) + ) + (func (export "break-br_if-num-num") (param i32) (result i32 i64) + (drop (drop (br_if 0 (i32.const 50) (i64.const 51) (local.get 0)))) + (i32.const 51) (i64.const 52) + ) + + (func (export "break-br_table-empty") (param i32) + (br_table 0 0 0 (local.get 0)) + ) + (func (export "break-br_table-num") (param i32) (result i32) + (br_table 0 0 (i32.const 50) (local.get 0)) (i32.const 51) + ) + (func (export "break-br_table-num-num") (param i32) (result f32 i64) + (br_table 0 0 (f32.const 50) (i64.const 51) (local.get 0)) + (f32.const 51) (i64.const 52) + ) + (func (export "break-br_table-nested-empty") (param i32) + (block (br_table 0 1 0 (local.get 0))) + ) + (func (export "break-br_table-nested-num") (param i32) (result i32) + (i32.add + (block (result i32) + (br_table 0 1 0 (i32.const 50) (local.get 0)) (i32.const 51) + ) + (i32.const 2) + ) + ) + (func (export "break-br_table-nested-num-num") (param i32) (result i32 i32) + (i32.add + (block (result i32 i32) + (br_table 0 1 0 (i32.const 50) (i32.const 51) (local.get 0)) + (i32.const 51) (i32.const -3) + ) + ) + (i32.const 52) + ) + + ;; Large signatures + + (func (export "large-sig") + (param i32 i64 f32 f32 i32 f64 f32 i32 i32 i32 f32 f64 f64 f64 i32 i32 f32) + (result f64 f32 i32 i32 i32 i64 f32 i32 i32 f32 f64 f64 i32 f32 i32 f64) + (local.get 5) + (local.get 2) + (local.get 0) + (local.get 8) + (local.get 7) + (local.get 1) + (local.get 3) + (local.get 9) + (local.get 4) + (local.get 6) + (local.get 13) + (local.get 11) + (local.get 15) + (local.get 16) + (local.get 14) + (local.get 12) + ) + + ;; Default initialization of locals + + (func (export "init-local-i32") (result i32) (local i32) (local.get 0)) + (func (export "init-local-i64") (result i64) (local i64) (local.get 0)) + (func (export "init-local-f32") (result f32) (local f32) (local.get 0)) + (func (export "init-local-f64") (result f64) (local f64) (local.get 0)) +) + +(assert_return (invoke "type-use-1")) +(assert_return (invoke "type-use-2") (i32.const 0)) +(assert_return (invoke "type-use-3" (i32.const 1))) +(assert_return + (invoke "type-use-4" (i32.const 1) (f64.const 1) (i32.const 1)) + (i32.const 0) +) +(assert_return (invoke "type-use-5") (i32.const 0)) +(assert_return (invoke "type-use-6" (i32.const 1))) +(assert_return + (invoke "type-use-7" (i32.const 1) (f64.const 1) (i32.const 1)) + (i32.const 0) +) + +(assert_return (invoke "local-first-i32") (i32.const 0)) +(assert_return (invoke "local-first-i64") (i64.const 0)) +(assert_return (invoke "local-first-f32") (f32.const 0)) +(assert_return (invoke "local-first-f64") (f64.const 0)) +(assert_return (invoke "local-second-i32") (i32.const 0)) +(assert_return (invoke "local-second-i64") (i64.const 0)) +(assert_return (invoke "local-second-f32") (f32.const 0)) +(assert_return (invoke "local-second-f64") (f64.const 0)) +(assert_return (invoke "local-mixed") (f64.const 0)) + +(assert_return + (invoke "param-first-i32" (i32.const 2) (i32.const 3)) (i32.const 2) +) +(assert_return + (invoke "param-first-i64" (i64.const 2) (i64.const 3)) (i64.const 2) +) +(assert_return + (invoke "param-first-f32" (f32.const 2) (f32.const 3)) (f32.const 2) +) +(assert_return + (invoke "param-first-f64" (f64.const 2) (f64.const 3)) (f64.const 2) +) +(assert_return + (invoke "param-second-i32" (i32.const 2) (i32.const 3)) (i32.const 3) +) +(assert_return + (invoke "param-second-i64" (i64.const 2) (i64.const 3)) (i64.const 3) +) +(assert_return + (invoke "param-second-f32" (f32.const 2) (f32.const 3)) (f32.const 3) +) +(assert_return + (invoke "param-second-f64" (f64.const 2) (f64.const 3)) (f64.const 3) +) + +(assert_return + (invoke "param-mixed" + (f32.const 1) (i32.const 2) (i64.const 3) + (i32.const 4) (f64.const 5.5) (i32.const 6) + ) + (f64.const 5.5) +) + +(assert_return (invoke "empty")) +(assert_return (invoke "value-void")) +(assert_return (invoke "value-i32") (i32.const 77)) +(assert_return (invoke "value-i64") (i64.const 7777)) +(assert_return (invoke "value-f32") (f32.const 77.7)) +(assert_return (invoke "value-f64") (f64.const 77.77)) +(assert_return (invoke "value-i32-f64") (i32.const 77) (f64.const 7)) +(assert_return (invoke "value-i32-i32-i32") + (i32.const 1) (i32.const 2) (i32.const 3) +) +(assert_return (invoke "value-block-void")) +(assert_return (invoke "value-block-i32") (i32.const 77)) +(assert_return (invoke "value-block-i32-i64") (i32.const 1) (i64.const 2)) + +(assert_return (invoke "return-empty")) +(assert_return (invoke "return-i32") (i32.const 78)) +(assert_return (invoke "return-i64") (i64.const 7878)) +(assert_return (invoke "return-f32") (f32.const 78.7)) +(assert_return (invoke "return-f64") (f64.const 78.78)) +(assert_return (invoke "return-i32-f64") (i32.const 78) (f64.const 78.78)) +(assert_return (invoke "return-i32-i32-i32") + (i32.const 1) (i32.const 2) (i32.const 3) +) +(assert_return (invoke "return-block-i32") (i32.const 77)) +(assert_return (invoke "return-block-i32-i64") (i32.const 1) (i64.const 2)) + +(assert_return (invoke "break-empty")) +(assert_return (invoke "break-i32") (i32.const 79)) +(assert_return (invoke "break-i64") (i64.const 7979)) +(assert_return (invoke "break-f32") (f32.const 79.9)) +(assert_return (invoke "break-f64") (f64.const 79.79)) +(assert_return (invoke "break-i32-f64") (i32.const 79) (f64.const 79.79)) +(assert_return (invoke "break-i32-i32-i32") + (i32.const 1) (i32.const 2) (i32.const 3) +) +(assert_return (invoke "break-block-i32") (i32.const 77)) +(assert_return (invoke "break-block-i32-i64") (i32.const 1) (i64.const 2)) + +(assert_return (invoke "break-br_if-empty" (i32.const 0))) +(assert_return (invoke "break-br_if-empty" (i32.const 2))) +(assert_return (invoke "break-br_if-num" (i32.const 0)) (i32.const 51)) +(assert_return (invoke "break-br_if-num" (i32.const 1)) (i32.const 50)) +(assert_return (invoke "break-br_if-num-num" (i32.const 0)) + (i32.const 51) (i64.const 52) +) +(assert_return (invoke "break-br_if-num-num" (i32.const 1)) + (i32.const 50) (i64.const 51) +) + +(assert_return (invoke "break-br_table-empty" (i32.const 0))) +(assert_return (invoke "break-br_table-empty" (i32.const 1))) +(assert_return (invoke "break-br_table-empty" (i32.const 5))) +(assert_return (invoke "break-br_table-empty" (i32.const -1))) +(assert_return (invoke "break-br_table-num" (i32.const 0)) (i32.const 50)) +(assert_return (invoke "break-br_table-num" (i32.const 1)) (i32.const 50)) +(assert_return (invoke "break-br_table-num" (i32.const 10)) (i32.const 50)) +(assert_return (invoke "break-br_table-num" (i32.const -100)) (i32.const 50)) +(assert_return (invoke "break-br_table-num-num" (i32.const 0)) + (f32.const 50) (i64.const 51) +) +(assert_return (invoke "break-br_table-num-num" (i32.const 1)) + (f32.const 50) (i64.const 51) +) +(assert_return (invoke "break-br_table-num-num" (i32.const 10)) + (f32.const 50) (i64.const 51) +) +(assert_return (invoke "break-br_table-num-num" (i32.const -100)) + (f32.const 50) (i64.const 51) +) +(assert_return (invoke "break-br_table-nested-empty" (i32.const 0))) +(assert_return (invoke "break-br_table-nested-empty" (i32.const 1))) +(assert_return (invoke "break-br_table-nested-empty" (i32.const 3))) +(assert_return (invoke "break-br_table-nested-empty" (i32.const -2))) +(assert_return + (invoke "break-br_table-nested-num" (i32.const 0)) (i32.const 52) +) +(assert_return + (invoke "break-br_table-nested-num" (i32.const 1)) (i32.const 50) +) +(assert_return + (invoke "break-br_table-nested-num" (i32.const 2)) (i32.const 52) +) +(assert_return + (invoke "break-br_table-nested-num" (i32.const -3)) (i32.const 52) +) +(assert_return + (invoke "break-br_table-nested-num-num" (i32.const 0)) + (i32.const 101) (i32.const 52) +) +(assert_return + (invoke "break-br_table-nested-num-num" (i32.const 1)) + (i32.const 50) (i32.const 51) +) +(assert_return + (invoke "break-br_table-nested-num-num" (i32.const 2)) + (i32.const 101) (i32.const 52) +) +(assert_return + (invoke "break-br_table-nested-num-num" (i32.const -3)) + (i32.const 101) (i32.const 52) +) + +(assert_return + (invoke "large-sig" + (i32.const 0) (i64.const 1) (f32.const 2) (f32.const 3) + (i32.const 4) (f64.const 5) (f32.const 6) (i32.const 7) + (i32.const 8) (i32.const 9) (f32.const 10) (f64.const 11) + (f64.const 12) (f64.const 13) (i32.const 14) (i32.const 15) + (f32.const 16) + ) + (f64.const 5) (f32.const 2) (i32.const 0) (i32.const 8) + (i32.const 7) (i64.const 1) (f32.const 3) (i32.const 9) + (i32.const 4) (f32.const 6) (f64.const 13) (f64.const 11) + (i32.const 15) (f32.const 16) (i32.const 14) (f64.const 12) +) + +(assert_return (invoke "init-local-i32") (i32.const 0)) +(assert_return (invoke "init-local-i64") (i64.const 0)) +(assert_return (invoke "init-local-f32") (f32.const 0)) +(assert_return (invoke "init-local-f64") (f64.const 0)) + + +;; Expansion of inline function types + +(module + (func $f (result f64) (f64.const 0)) ;; adds implicit type definition + (func $g (param i32)) ;; reuses explicit type definition + (type $t (func (param i32))) + + (func $i32->void (type 0)) ;; (param i32) + (func $void->f64 (type 1) (f64.const 0)) ;; (result f64) + (func $check + (call $i32->void (i32.const 0)) + (drop (call $void->f64)) + ) +) + +(assert_invalid + (module + (func $f (result f64) (f64.const 0)) ;; adds implicit type definition + (func $g (param i32)) ;; reuses explicit type definition + (func $h (result f64) (f64.const 1)) ;; reuses implicit type definition + (type $t (func (param i32))) + + (func (type 2)) ;; does not exist + ) + "unknown type" +) + +(assert_malformed + (module quote + "(func $f (result f64) (f64.const 0))" ;; adds implicit type definition + "(func $g (param i32))" ;; reuses explicit type definition + "(func $h (result f64) (f64.const 1))" ;; reuses implicit type definition + "(type $t (func (param i32)))" + + "(func (type 2) (param i32))" ;; does not exist + ) + "unknown type" +) + +(module + (type $proc (func (result i32))) + (type $sig (func (param i32) (result i32))) + + (func (export "f") (type $sig) + (local $var i32) + (local.get $var) + ) + + (func $g (type $sig) + (local $var i32) + (local.get $var) + ) + (func (export "g") (type $sig) + (call $g (local.get 0)) + ) + + (func (export "p") (type $proc) + (local $var i32) + (local.set 0 (i32.const 42)) + (local.get $var) + ) +) + +(assert_return (invoke "f" (i32.const 42)) (i32.const 0)) +(assert_return (invoke "g" (i32.const 42)) (i32.const 0)) +(assert_return (invoke "p") (i32.const 42)) + + +(module + (type $sig (func)) + + (func $empty-sig-1) ;; should be assigned type $sig + (func $complex-sig-1 (param f64 i64 f64 i64 f64 i64 f32 i32)) + (func $empty-sig-2) ;; should be assigned type $sig + (func $complex-sig-2 (param f64 i64 f64 i64 f64 i64 f32 i32)) + (func $complex-sig-3 (param f64 i64 f64 i64 f64 i64 f32 i32)) + (func $complex-sig-4 (param i64 i64 f64 i64 f64 i64 f32 i32)) + (func $complex-sig-5 (param i64 i64 f64 i64 f64 i64 f32 i32)) + + (type $empty-sig-duplicate (func)) + (type $complex-sig-duplicate (func (param i64 i64 f64 i64 f64 i64 f32 i32))) + (table funcref + (elem + $complex-sig-3 $empty-sig-2 $complex-sig-1 $complex-sig-3 $empty-sig-1 + $complex-sig-4 $complex-sig-5 + ) + ) + + (func (export "signature-explicit-reused") + (call_indirect (type $sig) (i32.const 1)) + (call_indirect (type $sig) (i32.const 4)) + ) + + (func (export "signature-implicit-reused") + ;; The implicit index 3 in this test depends on the function and + ;; type definitions, and may need adapting if they change. + (call_indirect (type 3) + (f64.const 0) (i64.const 0) (f64.const 0) (i64.const 0) + (f64.const 0) (i64.const 0) (f32.const 0) (i32.const 0) + (i32.const 0) + ) + (call_indirect (type 3) + (f64.const 0) (i64.const 0) (f64.const 0) (i64.const 0) + (f64.const 0) (i64.const 0) (f32.const 0) (i32.const 0) + (i32.const 2) + ) + (call_indirect (type 3) + (f64.const 0) (i64.const 0) (f64.const 0) (i64.const 0) + (f64.const 0) (i64.const 0) (f32.const 0) (i32.const 0) + (i32.const 3) + ) + ) + + (func (export "signature-explicit-duplicate") + (call_indirect (type $empty-sig-duplicate) (i32.const 1)) + ) + + (func (export "signature-implicit-duplicate") + (call_indirect (type $complex-sig-duplicate) + (i64.const 0) (i64.const 0) (f64.const 0) (i64.const 0) + (f64.const 0) (i64.const 0) (f32.const 0) (i32.const 0) + (i32.const 5) + ) + (call_indirect (type $complex-sig-duplicate) + (i64.const 0) (i64.const 0) (f64.const 0) (i64.const 0) + (f64.const 0) (i64.const 0) (f32.const 0) (i32.const 0) + (i32.const 6) + ) + ) +) + +(assert_return (invoke "signature-explicit-reused")) +(assert_return (invoke "signature-implicit-reused")) +(assert_return (invoke "signature-explicit-duplicate")) +(assert_return (invoke "signature-implicit-duplicate")) + + +;; Malformed type use + +(assert_malformed + (module quote + "(type $sig (func (param i32) (result i32)))" + "(func (type $sig) (result i32) (param i32) (i32.const 0))" + ) + "unexpected token" +) +(assert_malformed + (module quote + "(type $sig (func (param i32) (result i32)))" + "(func (param i32) (type $sig) (result i32) (i32.const 0))" + ) + "unexpected token" +) +(assert_malformed + (module quote + "(type $sig (func (param i32) (result i32)))" + "(func (param i32) (result i32) (type $sig) (i32.const 0))" + ) + "unexpected token" +) +(assert_malformed + (module quote + "(type $sig (func (param i32) (result i32)))" + "(func (result i32) (type $sig) (param i32) (i32.const 0))" + ) + "unexpected token" +) +(assert_malformed + (module quote + "(type $sig (func (param i32) (result i32)))" + "(func (result i32) (param i32) (type $sig) (i32.const 0))" + ) + "unexpected token" +) +(assert_malformed + (module quote + "(func (result i32) (param i32) (i32.const 0))" + ) + "unexpected token" +) + +(assert_malformed + (module quote + "(type $sig (func))" + "(func (type $sig) (result i32) (i32.const 0))" + ) + "inline function type" +) +(assert_malformed + (module quote + "(type $sig (func (param i32) (result i32)))" + "(func (type $sig) (result i32) (i32.const 0))" + ) + "inline function type" +) +(assert_malformed + (module quote + "(type $sig (func (param i32) (result i32)))" + "(func (type $sig) (param i32) (i32.const 0))" + ) + "inline function type" +) +(assert_malformed + (module quote + "(type $sig (func (param i32 i32) (result i32)))" + "(func (type $sig) (param i32) (result i32) (unreachable))" + ) + "inline function type" +) + +(assert_invalid + (module (func $g (type 4))) + "unknown type" +) +(assert_invalid + (module + (func $f (drop (ref.func $g))) + (func $g (type 4)) + (elem declare func $g) + ) + "unknown type" +) +(assert_invalid + (module + (type $t (func)) + (func $f (drop (let (result (ref $t)) (ref.func $g)))) + (func $g (type 4)) + (elem declare func $g) + ) + "unknown type" +) + + +;; Invalid typing of locals + +(assert_invalid + (module (func $type-local-num-vs-num (result i64) (local i32) (local.get 0))) + "type mismatch" +) +(assert_invalid + (module (func $type-local-num-vs-num (local f32) (i32.eqz (local.get 0)))) + "type mismatch" +) +(assert_invalid + (module (func $type-local-num-vs-num (local f64 i64) (f64.neg (local.get 1)))) + "type mismatch" +) + +(assert_invalid + (module (type $t (func)) (func $type-local-no-default (local (ref $t)))) + "non-defaultable local type" +) + + +;; Invalid typing of 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" +) + + +;; Invalid typing of result + +(assert_invalid + (module (func $type-empty-i32 (result i32))) + "type mismatch" +) +(assert_invalid + (module (func $type-empty-i64 (result i64))) + "type mismatch" +) +(assert_invalid + (module (func $type-empty-f32 (result f32))) + "type mismatch" +) +(assert_invalid + (module (func $type-empty-f64 (result f64))) + "type mismatch" +) +(assert_invalid + (module (func $type-empty-f64-i32 (result f64 i32))) + "type mismatch" +) + +(assert_invalid + (module (func $type-value-void-vs-num (result i32) + (nop) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-value-void-vs-nums (result i32 i32) + (nop) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-value-num-vs-void + (i32.const 0) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-value-nums-vs-void + (i32.const 0) (i64.const 0) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-value-num-vs-num (result i32) + (f32.const 0) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-value-num-vs-nums (result f32 f32) + (f32.const 0) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-value-nums-vs-num (result f32) + (f32.const 0) (f32.const 0) + )) + "type mismatch" +) + +(assert_invalid + (module (func $type-return-last-empty-vs-num (result i32) + (return) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-return-last-empty-vs-nums (result i32 i32) + (return) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-return-last-void-vs-num (result i32) + (return (nop)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-return-last-void-vs-nums (result i32 i64) + (return (nop)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-return-last-num-vs-num (result i32) + (return (i64.const 0)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-return-last-num-vs-nums (result i64 i64) + (return (i64.const 0)) + )) + "type mismatch" +) + +(assert_invalid + (module (func $type-return-empty-vs-num (result i32) + (return) (i32.const 1) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-return-empty-vs-nums (result i32 i32) + (return) (i32.const 1) (i32.const 2) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-return-partial-vs-nums (result i32 i32) + (i32.const 1) (return) (i32.const 2) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-return-void-vs-num (result i32) + (return (nop)) (i32.const 1) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-return-void-vs-nums (result i32 i32) + (return (nop)) (i32.const 1) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-return-num-vs-num (result i32) + (return (i64.const 1)) (i32.const 1) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-return-num-vs-nums (result i32 i32) + (return (i64.const 1)) (i32.const 1) (i32.const 2) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-return-first-num-vs-num (result i32) + (return (i64.const 1)) (return (i32.const 1)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-return-first-num-vs-nums (result i32 i32) + (return (i32.const 1)) (return (i32.const 1) (i32.const 2)) + )) + "type mismatch" +) + +(assert_invalid + (module (func $type-break-last-void-vs-num (result i32) + (br 0) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-last-void-vs-nums (result i32 i32) + (br 0) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-last-num-vs-num (result i32) + (br 0 (f32.const 0)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-last-num-vs-nums (result i32 i32) + (br 0 (i32.const 0)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-void-vs-num (result i32) + (br 0) (i32.const 1) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-void-vs-nums (result i32 i32) + (br 0) (i32.const 1) (i32.const 2) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-num-vs-num (result i32) + (br 0 (i64.const 1)) (i32.const 1) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-num-vs-nums (result i32 i32) + (br 0 (i32.const 1)) (i32.const 1) (i32.const 2) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-first-num-vs-num (result i32) + (br 0 (i64.const 1)) (br 0 (i32.const 1)) + )) + "type mismatch" +) + +(assert_invalid + (module (func $type-break-nested-empty-vs-num (result i32) + (block (br 1)) (br 0 (i32.const 1)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-nested-empty-vs-nums (result i32 i32) + (block (br 1)) (br 0 (i32.const 1) (i32.const 2)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-nested-void-vs-num (result i32) + (block (br 1 (nop))) (br 0 (i32.const 1)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-nested-void-vs-nums (result i32 i32) + (block (br 1 (nop))) (br 0 (i32.const 1) (i32.const 2)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-nested-num-vs-num (result i32) + (block (br 1 (i64.const 1))) (br 0 (i32.const 1)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-nested-num-vs-nums (result i32 i32) + (block (result i32) (br 1 (i32.const 1))) (br 0 (i32.const 1) (i32.const 2)) + )) + "type mismatch" +) + + +;; Syntax errors + +(assert_malformed + (module quote "(func (nop) (local i32))") + "unexpected token" +) +(assert_malformed + (module quote "(func (nop) (param i32))") + "unexpected token" +) +(assert_malformed + (module quote "(func (nop) (result i32))") + "unexpected token" +) +(assert_malformed + (module quote "(func (local i32) (param i32))") + "unexpected token" +) +(assert_malformed + (module quote "(func (local i32) (result i32) (local.get 0))") + "unexpected token" +) +(assert_malformed + (module quote "(func (result i32) (param i32) (local.get 0))") + "unexpected token" +) + +;; Duplicate name errors + +(assert_malformed (module quote + "(func $foo)" + "(func $foo)") + "duplicate func") +(assert_malformed (module quote + "(import \"\" \"\" (func $foo))" + "(func $foo)") + "duplicate func") +(assert_malformed (module quote + "(import \"\" \"\" (func $foo))" + "(import \"\" \"\" (func $foo))") + "duplicate func") + +(assert_malformed (module quote "(func (param $foo i32) (param $foo i32))") + "duplicate local") +(assert_malformed (module quote "(func (param $foo i32) (local $foo i32))") + "duplicate local") +(assert_malformed (module quote "(func (local $foo i32) (local $foo i32))") + "duplicate local") diff --git a/runtime/near-vm/tests/wast/spec/proposals/gc/func_bind.wast b/runtime/near-vm/tests/wast/spec/proposals/gc/func_bind.wast new file mode 100644 index 00000000000..18743219f44 --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/proposals/gc/func_bind.wast @@ -0,0 +1,540 @@ +(module + (type $unop (func (param i32) (result i32))) + + (elem func $add) + (func $add (param i32 i32) (result i32) (i32.add (local.get 0) (local.get 1))) + + (func $mk-adder (param $i i32) (result (ref $unop)) + (func.bind (type $unop) (local.get $i) (ref.func $add)) + ) + + (global $f (mut (ref null $unop)) (ref.null $unop)) + + (func (export "make") (param $i i32) + (global.set $f (call $mk-adder (local.get $i))) + ) + + (func (export "call") (param $j i32) (result i32) + (call_ref (local.get $j) (global.get $f)) + ) + + (func (export "call2") (param $i i32) (param $j i32) (param $k i32) (result i32) + (call $mk-adder (local.get $k)) + (let (result i32) (local $f (ref $unop)) ;; binds $f to top of stack + (i32.mul + (call_ref (local.get $i) (local.get $f)) + (call_ref (local.get $j) (local.get $f)) + ) + ) + ) + + (func (export "null") (result i32) + (func.bind (type $unop) (i32.const 1) (ref.null $unop)) + (drop) + ) +) + +(assert_trap (invoke "call" (i32.const 0)) "null function") + +(assert_return (invoke "make" (i32.const 3))) +(assert_return (invoke "call" (i32.const 2)) (i32.const 5)) +(assert_return (invoke "call" (i32.const 10)) (i32.const 13)) + +(assert_return (invoke "make" (i32.const 0))) +(assert_return (invoke "call" (i32.const 10)) (i32.const 10)) + +(assert_return (invoke "make" (i32.const -3))) +(assert_return (invoke "call" (i32.const 10)) (i32.const 7)) + +(assert_return (invoke "call2" (i32.const 2) (i32.const 3) (i32.const 0)) (i32.const 6)) +(assert_return (invoke "call2" (i32.const 2) (i32.const 5) (i32.const 1)) (i32.const 18)) +(assert_return (invoke "call2" (i32.const 2) (i32.const 5) (i32.const 7)) (i32.const 108)) + +(assert_trap (invoke "null") "null function") + +(module + (elem declare func $p $f) + (func $p (import "spectest" "print_f64_f64") (param f64 f64)) + (func $f (param f64 f64 f64 f64) (result f64) + (f64.const 0) + (f64.add (f64.mul (local.get 0) (f64.const 1000))) + (f64.add (f64.mul (local.get 1) (f64.const 100))) + (f64.add (f64.mul (local.get 2) (f64.const 10))) + (f64.add (f64.mul (local.get 3) (f64.const 1))) + ) + + (type $p0 (func (param))) + (type $p1 (func (param f64))) + (type $p2 (func (param f64 f64))) + (type $f0 (func (param) (result f64))) + (type $f1 (func (param f64) (result f64))) + (type $f2 (func (param f64 f64) (result f64))) + (type $f3 (func (param f64 f64 f64) (result f64))) + (type $f4 (func (param f64 f64 f64 f64) (result f64))) + + (table $tp 30 funcref) + (table $tf 50 funcref) + + (func (export "call-p0") (param $i i32) + (call_indirect $tp (type $p0) (local.get $i)) + ) + (func (export "call-p1") (param $i i32) (param f64) + (call_indirect $tp (type $p1) (local.get 1) (local.get $i)) + ) + (func (export "call-p2") (param $i i32) (param f64 f64) + (call_indirect $tp (type $p2) (local.get 1) (local.get 2) (local.get $i)) + ) + + (func (export "call-f0") (param $i i32) (result f64) + (call_indirect $tf (type $f0) (local.get $i)) + ) + (func (export "call-f1") (param $i i32) (param f64) (result f64) + (call_indirect $tf (type $f1) (local.get 1) (local.get $i)) + ) + (func (export "call-f2") (param $i i32) (param f64 f64) (result f64) + (call_indirect $tf (type $f2) (local.get 1) (local.get 2) (local.get $i)) + ) + (func (export "call-f3") (param $i i32) (param f64 f64 f64) (result f64) + (call_indirect $tf (type $f3) (local.get 1) (local.get 2) (local.get 3) (local.get $i)) + ) + (func (export "call-f4") (param $i i32) (param f64 f64 f64 f64) (result f64) + (call_indirect $tf (type $f4) (local.get 1) (local.get 2) (local.get 3) (local.get 4) (local.get $i)) + ) + + (func (export "init") + ;; Host closures with arity 2 + (table.set $tp (i32.const 20) + (ref.func $p) + ) + (table.set $tp (i32.const 21) + (func.bind (type $p2) + (ref.func $p)) + ) + + ;; Host closures with arity 1 + (table.set $tp (i32.const 10) + (func.bind (type $p1) (f64.const 1) + (ref.func $p)) + ) + (table.set $tp (i32.const 11) + (func.bind (type $p1) (f64.const 1) + (func.bind (type $p2) + (ref.func $p))) + ) + (table.set $tp (i32.const 12) + (func.bind (type $p1) + (func.bind (type $p1) (f64.const 1) + (func.bind (type $p2) + (ref.func $p)))) + ) + + ;; Host closures with arity 0 + (table.set $tp (i32.const 00) + (func.bind (type $p0) (f64.const 1) (f64.const 2) + (ref.func $p)) + ) + (table.set $tp (i32.const 01) + (func.bind (type $p0) (f64.const 2) + (func.bind (type $p1) (f64.const 1) + (ref.func $p))) + ) + (table.set $tp (i32.const 02) + (func.bind (type $p0) + (func.bind (type $p0) (f64.const 2) + (func.bind (type $p1) + (func.bind (type $p1) (f64.const 1) + (func.bind (type $p2) + (func.bind (type $p2) + (ref.func $p))))))) + ) + + ;; Wasm closures with arity 4 + (table.set $tf (i32.const 40) + (ref.func $f) + ) + (table.set $tf (i32.const 41) + (func.bind (type $f4) + (ref.func $f)) + ) + + ;; Wasm closures with arity 3 + (table.set $tf (i32.const 30) + (func.bind (type $f3) (f64.const 1) + (ref.func $f)) + ) + (table.set $tf (i32.const 31) + (func.bind (type $f3) (f64.const 1) + (func.bind (type $f4) + (ref.func $f))) + ) + (table.set $tf (i32.const 32) + (func.bind (type $f3) + (func.bind (type $f3) (f64.const 1) + (func.bind (type $f4) + (ref.func $f)))) + ) + + ;; Wasm closures with arity 2 + (table.set $tf (i32.const 20) + (func.bind (type $f2) (f64.const 1) (f64.const 2) + (ref.func $f)) + ) + (table.set $tf (i32.const 21) + (func.bind (type $f2) (f64.const 2) + (func.bind (type $f3) (f64.const 1) + (ref.func $f))) + ) + (table.set $tf (i32.const 22) + (func.bind (type $f2) + (func.bind (type $f2) (f64.const 2) + (func.bind (type $f3) + (func.bind (type $f3) (f64.const 1) + (func.bind (type $f4) + (func.bind (type $f4) + (ref.func $f))))))) + ) + + ;; Wasm closures with arity 1 + (table.set $tf (i32.const 10) + (func.bind (type $f1) (f64.const 1) (f64.const 2) (f64.const 3) + (ref.func $f)) + ) + (table.set $tf (i32.const 11) + (func.bind (type $f1) (f64.const 2) (f64.const 3) + (func.bind (type $f3) (f64.const 1) + (ref.func $f))) + ) + (table.set $tf (i32.const 12) + (func.bind (type $f1) (f64.const 3) + (func.bind (type $f2) (f64.const 1) (f64.const 2) + (ref.func $f))) + ) + (table.set $tf (i32.const 13) + (func.bind (type $f1) (f64.const 3) + (func.bind (type $f2) (f64.const 2) + (func.bind (type $f3) (f64.const 1) + (ref.func $f)))) + ) + (table.set $tf (i32.const 14) + (func.bind (type $f1) + (func.bind (type $f1) + (func.bind (type $f1) (f64.const 3) + (func.bind (type $f2) + (func.bind (type $f2) + (func.bind (type $f2) (f64.const 2) + (func.bind (type $f3) + (func.bind (type $f3) + (func.bind (type $f3) (f64.const 1) + (func.bind (type $f4) + (func.bind (type $f4) + (ref.func $f)))))))))))) + ) + + ;; Wasm closures with arity 0 + (table.set $tf (i32.const 00) + (func.bind (type $f0) (f64.const 1) (f64.const 2) (f64.const 3) (f64.const 4) + (ref.func $f)) + ) + (table.set $tf (i32.const 01) + (func.bind (type $f0) (f64.const 2) (f64.const 3) (f64.const 4) + (func.bind (type $f3) (f64.const 1) + (ref.func $f))) + ) + (table.set $tf (i32.const 02) + (func.bind (type $f0) (f64.const 3) (f64.const 4) + (func.bind (type $f2) (f64.const 1) (f64.const 2) + (ref.func $f))) + ) + (table.set $tf (i32.const 03) + (func.bind (type $f0) (f64.const 4) + (func.bind (type $f1) (f64.const 1) (f64.const 2) (f64.const 3) + (ref.func $f))) + ) + (table.set $tf (i32.const 04) + (func.bind (type $f0) (f64.const 3) (f64.const 4) + (func.bind (type $f2) (f64.const 2) + (func.bind (type $f3) (f64.const 1) + (ref.func $f)))) + ) + (table.set $tf (i32.const 05) + (func.bind (type $f0) (f64.const 4) + (func.bind (type $f1) (f64.const 2) (f64.const 3) + (func.bind (type $f3) (f64.const 1) + (ref.func $f)))) + ) + (table.set $tf (i32.const 06) + (func.bind (type $f0) (f64.const 4) + (func.bind (type $f1) (f64.const 3) + (func.bind (type $f2) (f64.const 1) (f64.const 2) + (ref.func $f)))) + ) + (table.set $tf (i32.const 07) + (func.bind (type $f0) (f64.const 4) + (func.bind (type $f1) (f64.const 3) + (func.bind (type $f2) (f64.const 2) + (func.bind (type $f3) (f64.const 1) + (func.bind (type $f4) + (ref.func $f)))))) + ) + (table.set $tf (i32.const 08) + (func.bind (type $f0) + (func.bind (type $f0) + (func.bind (type $f0) (f64.const 4) + (func.bind (type $f1) + (func.bind (type $f1) + (func.bind (type $f1) (f64.const 2) (f64.const 3) + (func.bind (type $f3) + (func.bind (type $f3) + (func.bind (type $f3) (f64.const 1) + (func.bind (type $f4) + (func.bind (type $f4) + (ref.func $f)))))))))))) + ) + ) +) + +(invoke "init") + +(assert_return (invoke "call-p0" (i32.const 00))) +(assert_return (invoke "call-p0" (i32.const 01))) +(assert_return (invoke "call-p0" (i32.const 02))) +(assert_return (invoke "call-p1" (i32.const 10) (f64.const 2))) +(assert_return (invoke "call-p1" (i32.const 11) (f64.const 2))) +(assert_return (invoke "call-p1" (i32.const 12) (f64.const 2))) +(assert_return (invoke "call-p2" (i32.const 20) (f64.const 1) (f64.const 2))) +(assert_return (invoke "call-p2" (i32.const 21) (f64.const 1) (f64.const 2))) + +(assert_return (invoke "call-f0" (i32.const 00)) (f64.const 1234)) +(assert_return (invoke "call-f0" (i32.const 01)) (f64.const 1234)) +(assert_return (invoke "call-f0" (i32.const 02)) (f64.const 1234)) +(assert_return (invoke "call-f0" (i32.const 03)) (f64.const 1234)) +(assert_return (invoke "call-f0" (i32.const 04)) (f64.const 1234)) +(assert_return (invoke "call-f0" (i32.const 05)) (f64.const 1234)) +(assert_return (invoke "call-f0" (i32.const 06)) (f64.const 1234)) +(assert_return (invoke "call-f0" (i32.const 07)) (f64.const 1234)) +(assert_return (invoke "call-f0" (i32.const 08)) (f64.const 1234)) +(assert_return (invoke "call-f1" (i32.const 10) (f64.const 4)) (f64.const 1234)) +(assert_return (invoke "call-f1" (i32.const 11) (f64.const 4)) (f64.const 1234)) +(assert_return (invoke "call-f1" (i32.const 12) (f64.const 4)) (f64.const 1234)) +(assert_return (invoke "call-f1" (i32.const 13) (f64.const 4)) (f64.const 1234)) +(assert_return (invoke "call-f1" (i32.const 14) (f64.const 4)) (f64.const 1234)) +(assert_return (invoke "call-f2" (i32.const 20) (f64.const 3) (f64.const 4)) (f64.const 1234)) +(assert_return (invoke "call-f2" (i32.const 21) (f64.const 3) (f64.const 4)) (f64.const 1234)) +(assert_return (invoke "call-f2" (i32.const 22) (f64.const 3) (f64.const 4)) (f64.const 1234)) +(assert_return (invoke "call-f3" (i32.const 30) (f64.const 2) (f64.const 3) (f64.const 4)) (f64.const 1234)) +(assert_return (invoke "call-f3" (i32.const 31) (f64.const 2) (f64.const 3) (f64.const 4)) (f64.const 1234)) +(assert_return (invoke "call-f3" (i32.const 32) (f64.const 2) (f64.const 3) (f64.const 4)) (f64.const 1234)) +(assert_return (invoke "call-f4" (i32.const 40) (f64.const 1) (f64.const 2) (f64.const 3) (f64.const 4)) (f64.const 1234)) +(assert_return (invoke "call-f4" (i32.const 41) (f64.const 1) (f64.const 2) (f64.const 3) (f64.const 4)) (f64.const 1234)) + + +(; Once we allow subtyping on function types: +;; The runtime type of a closure is its internal one, +;; not the static bind annotation. +(module + (type $ii (func (param i32) (result i32))) + (type $fl (func (param i32 anyref) (result (ref null $ii)))) + (type $fu (func (param i32 (ref $ii)) (result anyref))) + (type $fl' (func (param anyref) (result (ref null $ii)))) + (type $fu' (func (param (ref $ii)) (result anyref))) + + (elem declare func $sqr $f) + (func $sqr (param i32) (result i32) (i32.mul (local.get 0) (local.get 0))) + (func $f (type $fl) (ref.func $sqr)) + + (table $t 10 funcref) + + (func (export "run") (result i32) + (table.set $t (i32.const 0) (func.bind (type $fu) (ref.func $f))) + (table.set $t (i32.const 1) (func.bind (type $fu') (i32.const 0) (ref.func $f))) + + (i32.add + (call_ref (i32.const 2) + (call_indirect $t (type $fl) (i32.const 0) (ref.null $fl) (i32.const 0)) + ) + (call_ref (i32.const 3) + (call_indirect $t (type $fl') (ref.null $fl') (i32.const 1)) + ) + ) + ) +) + +(assert_return (invoke "run") (i32.const 13)) +;) + +(; Instead, for now: ;) +(assert_invalid + (module + (type $ii (func (param i32) (result i32))) + (type $fl (func (param i32 funcref) (result (ref null $ii)))) + (type $fu (func (param i32 (ref $ii)) (result funcref))) + + (elem declare func $sqr $f) + (func $sqr (param i32) (result i32) (i32.mul (local.get 0) (local.get 0))) + (func $f (type $fl) (ref.func $sqr)) + + (func (drop (func.bind (type $fu) (ref.func $f)))) + ) + "type mismatch" +) + +(assert_invalid + (module + (type $ii (func (param i32) (result i32))) + (type $fl (func (param i32 funcref) (result (ref null $ii)))) + (type $fu' (func (param (ref $ii)) (result funcref))) + + (elem declare func $sqr $f) + (func $sqr (param i32) (result i32) (i32.mul (local.get 0) (local.get 0))) + (func $f (type $fl) (ref.func $sqr)) + + (func (drop (func.bind (type $fu') (i32.const 0) (ref.func $f)))) + ) + "type mismatch" +) + + +;; Null and unreachable typing. + +(module + (type $t (func)) + (func (export "null") (result (ref $t)) + (ref.null $t) + (func.bind) + ) +) +(assert_trap (invoke "null") "null function") + +(module + (type $t (func (param f32))) + (func (export "null") (result (ref $t)) + (ref.null $t) + (func.bind (type $t)) + ) +) +(assert_trap (invoke "null") "null function") + +(module + (type $t0 (func)) + (type $t1 (func (param i64))) + (func (export "null") (result (ref $t0)) + (i64.const 0) + (ref.null $t1) + (func.bind) + ) +) +(assert_trap (invoke "null") "null function") + +(module + (type $t0 (func)) + (type $t1 (func (param i64))) + (func (export "null") (result (ref $t0)) + (i64.const 0) + (ref.null $t1) + (func.bind (type $t0)) + ) +) +(assert_trap (invoke "null") "null function") + +(assert_invalid + (module + (type $t (func (result f32))) + (func (export "null") (result i32) + (ref.null $t) + (func.bind) + ) + ) + "type mismatch" +) + + +(module + (type $t (func (param f32))) + (func (export "unreachable") (result (ref $t)) + (unreachable) + (func.bind (type $t)) + ) +) +(assert_trap (invoke "unreachable") "unreachable") + +(module + (type $t (func (param f32) (result i32))) + (elem declare func $f) + (func $f (param i32 f32) (result i32) (local.get 0)) + + (func (export "unreachable") (result (ref $t)) + (unreachable) + (ref.func $f) + (func.bind (type $t)) + ) +) +(assert_trap (invoke "unreachable") "unreachable") + +(assert_invalid + (module + (type $t (func (param f32))) + (elem declare func $f) + (func $f (param i32 f32) (result i32) (local.get 0)) + + (func (export "unreachable") (result (ref $t)) + (unreachable) + (i64.const 0) + (ref.func $f) + (func.bind (type $t)) + ) + ) + "type mismatch" +) + +(assert_invalid + (module + (type $t (func)) + (elem declare func $f) + (func $f (param i32) (result i32) (local.get 0)) + + (func (export "unreachable") (result (ref $t)) + (unreachable) + (ref.func $f) + (func.bind (type $t)) + (drop) + (i64.const 0) + ) + ) + "type mismatch" +) + +(assert_invalid + (module + (func (export "null") (result i32) + (unreachable) + (func.bind) + ) + ) + "type mismatch" +) + +(assert_invalid + (module + (type $t (func (param f32))) + (elem declare func $f) + (func $f (param i32 i32) (result i32) (local.get 0)) + + (func (export "unreachable") (result (ref $t)) + (unreachable) + (ref.func $f) + (func.bind (type $t)) + ) + ) + "type mismatch" +) + +(assert_invalid + (module + (type $t (func)) + (func $f (param $r externref) + (func.bind (type $t) (local.get $r)) + (drop) + ) + ) + "type mismatch" +) diff --git a/runtime/near-vm/tests/wast/spec/proposals/gc/i31.wast b/runtime/near-vm/tests/wast/spec/proposals/gc/i31.wast new file mode 100644 index 00000000000..ade957fc41a --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/proposals/gc/i31.wast @@ -0,0 +1,32 @@ +(module + (func (export "new") (param $i i32) (result (ref i31)) + (i31.new (local.get $i)) + ) + + (func (export "get_u") (param $i i32) (result i32) + (i31.get_u (i31.new (local.get $i))) + ) + (func (export "get_s") (param $i i32) (result i32) + (i31.get_s (i31.new (local.get $i))) + ) +) + +(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)) diff --git a/runtime/near-vm/tests/wast/spec/proposals/gc/if.wast b/runtime/near-vm/tests/wast/spec/proposals/gc/if.wast new file mode 100644 index 00000000000..553f90d20ec --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/proposals/gc/if.wast @@ -0,0 +1,1550 @@ +;; Test `if` operator + +(module + ;; Auxiliary definition + (memory 1) + + (func $dummy) + + (func (export "empty") (param i32) + (if (local.get 0) (then)) + (if (local.get 0) (then) (else)) + (if $l (local.get 0) (then)) + (if $l (local.get 0) (then) (else)) + ) + + (func (export "singular") (param i32) (result i32) + (if (local.get 0) (then (nop))) + (if (local.get 0) (then (nop)) (else (nop))) + (if (result i32) (local.get 0) (then (i32.const 7)) (else (i32.const 8))) + ) + + (func (export "multi") (param i32) (result i32 i32) + (if (local.get 0) (then (call $dummy) (call $dummy) (call $dummy))) + (if (local.get 0) (then) (else (call $dummy) (call $dummy) (call $dummy))) + (if (result i32) (local.get 0) + (then (call $dummy) (call $dummy) (i32.const 8) (call $dummy)) + (else (call $dummy) (call $dummy) (i32.const 9) (call $dummy)) + ) + (if (result i32 i64 i32) (local.get 0) + (then + (call $dummy) (call $dummy) (i32.const 1) (call $dummy) + (call $dummy) (call $dummy) (i64.const 2) (call $dummy) + (call $dummy) (call $dummy) (i32.const 3) (call $dummy) + ) + (else + (call $dummy) (call $dummy) (i32.const -1) (call $dummy) + (call $dummy) (call $dummy) (i64.const -2) (call $dummy) + (call $dummy) (call $dummy) (i32.const -3) (call $dummy) + ) + ) + (drop) (drop) + ) + + (func (export "nested") (param i32 i32) (result i32) + (if (result i32) (local.get 0) + (then + (if (local.get 1) (then (call $dummy) (block) (nop))) + (if (local.get 1) (then) (else (call $dummy) (block) (nop))) + (if (result i32) (local.get 1) + (then (call $dummy) (i32.const 9)) + (else (call $dummy) (i32.const 10)) + ) + ) + (else + (if (local.get 1) (then (call $dummy) (block) (nop))) + (if (local.get 1) (then) (else (call $dummy) (block) (nop))) + (if (result i32) (local.get 1) + (then (call $dummy) (i32.const 10)) + (else (call $dummy) (i32.const 11)) + ) + ) + ) + ) + + (func (export "as-select-first") (param i32) (result i32) + (select + (if (result i32) (local.get 0) + (then (call $dummy) (i32.const 1)) + (else (call $dummy) (i32.const 0)) + ) + (i32.const 2) (i32.const 3) + ) + ) + (func (export "as-select-mid") (param i32) (result i32) + (select + (i32.const 2) + (if (result i32) (local.get 0) + (then (call $dummy) (i32.const 1)) + (else (call $dummy) (i32.const 0)) + ) + (i32.const 3) + ) + ) + (func (export "as-select-last") (param i32) (result i32) + (select + (i32.const 2) (i32.const 3) + (if (result i32) (local.get 0) + (then (call $dummy) (i32.const 1)) + (else (call $dummy) (i32.const 0)) + ) + ) + ) + + (func (export "as-loop-first") (param i32) (result i32) + (loop (result i32) + (if (result i32) (local.get 0) + (then (call $dummy) (i32.const 1)) + (else (call $dummy) (i32.const 0)) + ) + (call $dummy) (call $dummy) + ) + ) + (func (export "as-loop-mid") (param i32) (result i32) + (loop (result i32) + (call $dummy) + (if (result i32) (local.get 0) + (then (call $dummy) (i32.const 1)) + (else (call $dummy) (i32.const 0)) + ) + (call $dummy) + ) + ) + (func (export "as-loop-last") (param i32) (result i32) + (loop (result i32) + (call $dummy) (call $dummy) + (if (result i32) (local.get 0) + (then (call $dummy) (i32.const 1)) + (else (call $dummy) (i32.const 0)) + ) + ) + ) + + (func (export "as-if-condition") (param i32) (result i32) + (if (result i32) + (if (result i32) (local.get 0) + (then (i32.const 1)) (else (i32.const 0)) + ) + (then (call $dummy) (i32.const 2)) + (else (call $dummy) (i32.const 3)) + ) + ) + + (func (export "as-br_if-first") (param i32) (result i32) + (block (result i32) + (br_if 0 + (if (result i32) (local.get 0) + (then (call $dummy) (i32.const 1)) + (else (call $dummy) (i32.const 0)) + ) + (i32.const 2) + ) + (return (i32.const 3)) + ) + ) + (func (export "as-br_if-last") (param i32) (result i32) + (block (result i32) + (br_if 0 + (i32.const 2) + (if (result i32) (local.get 0) + (then (call $dummy) (i32.const 1)) + (else (call $dummy) (i32.const 0)) + ) + ) + (return (i32.const 3)) + ) + ) + + (func (export "as-br_table-first") (param i32) (result i32) + (block (result i32) + (if (result i32) (local.get 0) + (then (call $dummy) (i32.const 1)) + (else (call $dummy) (i32.const 0)) + ) + (i32.const 2) + (br_table 0 0) + ) + ) + (func (export "as-br_table-last") (param i32) (result i32) + (block (result i32) + (i32.const 2) + (if (result i32) (local.get 0) + (then (call $dummy) (i32.const 1)) + (else (call $dummy) (i32.const 0)) + ) + (br_table 0 0) + ) + ) + + (func $func (param i32 i32) (result i32) (local.get 0)) + (type $check (func (param i32 i32) (result i32))) + (table funcref (elem $func)) + (func (export "as-call_indirect-first") (param i32) (result i32) + (block (result i32) + (call_indirect (type $check) + (if (result i32) (local.get 0) + (then (call $dummy) (i32.const 1)) + (else (call $dummy) (i32.const 0)) + ) + (i32.const 2) (i32.const 0) + ) + ) + ) + (func (export "as-call_indirect-mid") (param i32) (result i32) + (block (result i32) + (call_indirect (type $check) + (i32.const 2) + (if (result i32) (local.get 0) + (then (call $dummy) (i32.const 1)) + (else (call $dummy) (i32.const 0)) + ) + (i32.const 0) + ) + ) + ) + (func (export "as-call_indirect-last") (param i32) (result i32) + (block (result i32) + (call_indirect (type $check) + (i32.const 2) (i32.const 0) + (if (result i32) (local.get 0) + (then (call $dummy) (i32.const 1)) + (else (call $dummy) (i32.const 0)) + ) + ) + ) + ) + + (func (export "as-store-first") (param i32) + (if (result i32) (local.get 0) + (then (call $dummy) (i32.const 1)) + (else (call $dummy) (i32.const 0)) + ) + (i32.const 2) + (i32.store) + ) + (func (export "as-store-last") (param i32) + (i32.const 2) + (if (result i32) (local.get 0) + (then (call $dummy) (i32.const 1)) + (else (call $dummy) (i32.const 0)) + ) + (i32.store) + ) + + (func (export "as-memory.grow-value") (param i32) (result i32) + (memory.grow + (if (result i32) (local.get 0) + (then (i32.const 1)) + (else (i32.const 0)) + ) + ) + ) + + (func $f (param i32) (result i32) (local.get 0)) + + (func (export "as-call-value") (param i32) (result i32) + (call $f + (if (result i32) (local.get 0) + (then (i32.const 1)) + (else (i32.const 0)) + ) + ) + ) + (func (export "as-return-value") (param i32) (result i32) + (if (result i32) (local.get 0) + (then (i32.const 1)) + (else (i32.const 0))) + (return) + ) + (func (export "as-drop-operand") (param i32) + (drop + (if (result i32) (local.get 0) + (then (i32.const 1)) + (else (i32.const 0)) + ) + ) + ) + (func (export "as-br-value") (param i32) (result i32) + (block (result i32) + (br 0 + (if (result i32) (local.get 0) + (then (i32.const 1)) + (else (i32.const 0)) + ) + ) + ) + ) + (func (export "as-local.set-value") (param i32) (result i32) + (local i32) + (local.set 0 + (if (result i32) (local.get 0) + (then (i32.const 1)) + (else (i32.const 0)) + ) + ) + (local.get 0) + ) + (func (export "as-local.tee-value") (param i32) (result i32) + (local.tee 0 + (if (result i32) (local.get 0) + (then (i32.const 1)) + (else (i32.const 0)) + ) + ) + ) + (global $a (mut i32) (i32.const 10)) + (func (export "as-global.set-value") (param i32) (result i32) + (global.set $a + (if (result i32) (local.get 0) + (then (i32.const 1)) + (else (i32.const 0)) + ) + ) (global.get $a) + ) + (func (export "as-load-operand") (param i32) (result i32) + (i32.load + (if (result i32) (local.get 0) + (then (i32.const 11)) + (else (i32.const 10)) + ) + ) + ) + + (func (export "as-unary-operand") (param i32) (result i32) + (i32.ctz + (if (result i32) (local.get 0) + (then (call $dummy) (i32.const 13)) + (else (call $dummy) (i32.const -13)) + ) + ) + ) + (func (export "as-binary-operand") (param i32 i32) (result i32) + (i32.mul + (if (result i32) (local.get 0) + (then (call $dummy) (i32.const 3)) + (else (call $dummy) (i32.const -3)) + ) + (if (result i32) (local.get 1) + (then (call $dummy) (i32.const 4)) + (else (call $dummy) (i32.const -5)) + ) + ) + ) + (func (export "as-test-operand") (param i32) (result i32) + (i32.eqz + (if (result i32) (local.get 0) + (then (call $dummy) (i32.const 13)) + (else (call $dummy) (i32.const 0)) + ) + ) + ) + (func (export "as-compare-operand") (param i32 i32) (result i32) + (f32.gt + (if (result f32) (local.get 0) + (then (call $dummy) (f32.const 3)) + (else (call $dummy) (f32.const -3)) + ) + (if (result f32) (local.get 1) + (then (call $dummy) (f32.const 4)) + (else (call $dummy) (f32.const -4)) + ) + ) + ) + (func (export "as-binary-operands") (param i32) (result i32) + (i32.mul + (if (result i32 i32) (local.get 0) + (then (call $dummy) (i32.const 3) (call $dummy) (i32.const 4)) + (else (call $dummy) (i32.const 3) (call $dummy) (i32.const -4)) + ) + ) + ) + (func (export "as-compare-operands") (param i32) (result i32) + (f32.gt + (if (result f32 f32) (local.get 0) + (then (call $dummy) (f32.const 3) (call $dummy) (f32.const 3)) + (else (call $dummy) (f32.const -2) (call $dummy) (f32.const -3)) + ) + ) + ) + (func (export "as-mixed-operands") (param i32) (result i32) + (if (result i32 i32) (local.get 0) + (then (call $dummy) (i32.const 3) (call $dummy) (i32.const 4)) + (else (call $dummy) (i32.const -3) (call $dummy) (i32.const -4)) + ) + (i32.const 5) + (i32.add) + (i32.mul) + ) + + (func (export "break-bare") (result i32) + (if (i32.const 1) (then (br 0) (unreachable))) + (if (i32.const 1) (then (br 0) (unreachable)) (else (unreachable))) + (if (i32.const 0) (then (unreachable)) (else (br 0) (unreachable))) + (if (i32.const 1) (then (br_if 0 (i32.const 1)) (unreachable))) + (if (i32.const 1) (then (br_if 0 (i32.const 1)) (unreachable)) (else (unreachable))) + (if (i32.const 0) (then (unreachable)) (else (br_if 0 (i32.const 1)) (unreachable))) + (if (i32.const 1) (then (br_table 0 (i32.const 0)) (unreachable))) + (if (i32.const 1) (then (br_table 0 (i32.const 0)) (unreachable)) (else (unreachable))) + (if (i32.const 0) (then (unreachable)) (else (br_table 0 (i32.const 0)) (unreachable))) + (i32.const 19) + ) + + (func (export "break-value") (param i32) (result i32) + (if (result i32) (local.get 0) + (then (br 0 (i32.const 18)) (i32.const 19)) + (else (br 0 (i32.const 21)) (i32.const 20)) + ) + ) + (func (export "break-multi-value") (param i32) (result i32 i32 i64) + (if (result i32 i32 i64) (local.get 0) + (then + (br 0 (i32.const 18) (i32.const -18) (i64.const 18)) + (i32.const 19) (i32.const -19) (i64.const 19) + ) + (else + (br 0 (i32.const -18) (i32.const 18) (i64.const -18)) + (i32.const -19) (i32.const 19) (i64.const -19) + ) + ) + ) + + (func (export "param") (param i32) (result i32) + (i32.const 1) + (if (param i32) (result i32) (local.get 0) + (then (i32.const 2) (i32.add)) + (else (i32.const -2) (i32.add)) + ) + ) + (func (export "params") (param i32) (result i32) + (i32.const 1) + (i32.const 2) + (if (param i32 i32) (result i32) (local.get 0) + (then (i32.add)) + (else (i32.sub)) + ) + ) + (func (export "params-id") (param i32) (result i32) + (i32.const 1) + (i32.const 2) + (if (param i32 i32) (result i32 i32) (local.get 0) (then)) + (i32.add) + ) + (func (export "param-break") (param i32) (result i32) + (i32.const 1) + (if (param i32) (result i32) (local.get 0) + (then (i32.const 2) (i32.add) (br 0)) + (else (i32.const -2) (i32.add) (br 0)) + ) + ) + (func (export "params-break") (param i32) (result i32) + (i32.const 1) + (i32.const 2) + (if (param i32 i32) (result i32) (local.get 0) + (then (i32.add) (br 0)) + (else (i32.sub) (br 0)) + ) + ) + (func (export "params-id-break") (param i32) (result i32) + (i32.const 1) + (i32.const 2) + (if (param i32 i32) (result i32 i32) (local.get 0) (then (br 0))) + (i32.add) + ) + + (func (export "effects") (param i32) (result i32) + (local i32) + (if + (block (result i32) (local.set 1 (i32.const 1)) (local.get 0)) + (then + (local.set 1 (i32.mul (local.get 1) (i32.const 3))) + (local.set 1 (i32.sub (local.get 1) (i32.const 5))) + (local.set 1 (i32.mul (local.get 1) (i32.const 7))) + (br 0) + (local.set 1 (i32.mul (local.get 1) (i32.const 100))) + ) + (else + (local.set 1 (i32.mul (local.get 1) (i32.const 5))) + (local.set 1 (i32.sub (local.get 1) (i32.const 7))) + (local.set 1 (i32.mul (local.get 1) (i32.const 3))) + (br 0) + (local.set 1 (i32.mul (local.get 1) (i32.const 1000))) + ) + ) + (local.get 1) + ) + + ;; Examples + + (func $add64_u_with_carry (export "add64_u_with_carry") + (param $i i64) (param $j i64) (param $c i32) (result i64 i32) + (local $k i64) + (local.set $k + (i64.add + (i64.add (local.get $i) (local.get $j)) + (i64.extend_i32_u (local.get $c)) + ) + ) + (return (local.get $k) (i64.lt_u (local.get $k) (local.get $i))) + ) + + (func $add64_u_saturated (export "add64_u_saturated") + (param i64 i64) (result i64) + (call $add64_u_with_carry (local.get 0) (local.get 1) (i32.const 0)) + (if (param i64) (result i64) + (then (drop) (i64.const -1)) + ) + ) + + ;; Block signature syntax + + (type $block-sig-1 (func)) + (type $block-sig-2 (func (result i32))) + (type $block-sig-3 (func (param $x i32))) + (type $block-sig-4 (func (param i32 f64 i32) (result i32 f64 i32))) + + (func (export "type-use") + (if (type $block-sig-1) (i32.const 1) (then)) + (if (type $block-sig-2) (i32.const 1) + (then (i32.const 0)) (else (i32.const 2)) + ) + (if (type $block-sig-3) (i32.const 1) (then (drop)) (else (drop))) + (i32.const 0) (f64.const 0) (i32.const 0) + (if (type $block-sig-4) (i32.const 1) (then)) + (drop) (drop) (drop) + (if (type $block-sig-2) (result i32) (i32.const 1) + (then (i32.const 0)) (else (i32.const 2)) + ) + (if (type $block-sig-3) (param i32) (i32.const 1) + (then (drop)) (else (drop)) + ) + (i32.const 0) (f64.const 0) (i32.const 0) + (if (type $block-sig-4) + (param i32) (param f64 i32) (result i32 f64) (result i32) + (i32.const 1) (then) + ) + (drop) (drop) (drop) + ) +) + +(assert_return (invoke "empty" (i32.const 0))) +(assert_return (invoke "empty" (i32.const 1))) +(assert_return (invoke "empty" (i32.const 100))) +(assert_return (invoke "empty" (i32.const -2))) + +(assert_return (invoke "singular" (i32.const 0)) (i32.const 8)) +(assert_return (invoke "singular" (i32.const 1)) (i32.const 7)) +(assert_return (invoke "singular" (i32.const 10)) (i32.const 7)) +(assert_return (invoke "singular" (i32.const -10)) (i32.const 7)) + +(assert_return (invoke "multi" (i32.const 0)) (i32.const 9) (i32.const -1)) +(assert_return (invoke "multi" (i32.const 1)) (i32.const 8) (i32.const 1)) +(assert_return (invoke "multi" (i32.const 13)) (i32.const 8) (i32.const 1)) +(assert_return (invoke "multi" (i32.const -5)) (i32.const 8) (i32.const 1)) + +(assert_return (invoke "nested" (i32.const 0) (i32.const 0)) (i32.const 11)) +(assert_return (invoke "nested" (i32.const 1) (i32.const 0)) (i32.const 10)) +(assert_return (invoke "nested" (i32.const 0) (i32.const 1)) (i32.const 10)) +(assert_return (invoke "nested" (i32.const 3) (i32.const 2)) (i32.const 9)) +(assert_return (invoke "nested" (i32.const 0) (i32.const -100)) (i32.const 10)) +(assert_return (invoke "nested" (i32.const 10) (i32.const 10)) (i32.const 9)) +(assert_return (invoke "nested" (i32.const 0) (i32.const -1)) (i32.const 10)) +(assert_return (invoke "nested" (i32.const -111) (i32.const -2)) (i32.const 9)) + +(assert_return (invoke "as-select-first" (i32.const 0)) (i32.const 0)) +(assert_return (invoke "as-select-first" (i32.const 1)) (i32.const 1)) +(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 3)) +(assert_return (invoke "as-select-last" (i32.const 1)) (i32.const 2)) + +(assert_return (invoke "as-loop-first" (i32.const 0)) (i32.const 0)) +(assert_return (invoke "as-loop-first" (i32.const 1)) (i32.const 1)) +(assert_return (invoke "as-loop-mid" (i32.const 0)) (i32.const 0)) +(assert_return (invoke "as-loop-mid" (i32.const 1)) (i32.const 1)) +(assert_return (invoke "as-loop-last" (i32.const 0)) (i32.const 0)) +(assert_return (invoke "as-loop-last" (i32.const 1)) (i32.const 1)) + +(assert_return (invoke "as-if-condition" (i32.const 0)) (i32.const 3)) +(assert_return (invoke "as-if-condition" (i32.const 1)) (i32.const 2)) + +(assert_return (invoke "as-br_if-first" (i32.const 0)) (i32.const 0)) +(assert_return (invoke "as-br_if-first" (i32.const 1)) (i32.const 1)) +(assert_return (invoke "as-br_if-last" (i32.const 0)) (i32.const 3)) +(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 0)) +(assert_return (invoke "as-br_table-first" (i32.const 1)) (i32.const 1)) +(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 0)) +(assert_return (invoke "as-call_indirect-first" (i32.const 1)) (i32.const 1)) +(assert_return (invoke "as-call_indirect-mid" (i32.const 0)) (i32.const 2)) +(assert_return (invoke "as-call_indirect-mid" (i32.const 1)) (i32.const 2)) +(assert_return (invoke "as-call_indirect-last" (i32.const 0)) (i32.const 2)) +(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 1)) + +(assert_return (invoke "as-call-value" (i32.const 0)) (i32.const 0)) +(assert_return (invoke "as-call-value" (i32.const 1)) (i32.const 1)) + +(assert_return (invoke "as-return-value" (i32.const 0)) (i32.const 0)) +(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 0)) +(assert_return (invoke "as-br-value" (i32.const 1)) (i32.const 1)) + +(assert_return (invoke "as-local.set-value" (i32.const 0)) (i32.const 0)) +(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 0)) +(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 0)) +(assert_return (invoke "as-global.set-value" (i32.const 1)) (i32.const 1)) + +(assert_return (invoke "as-load-operand" (i32.const 0)) (i32.const 0)) +(assert_return (invoke "as-load-operand" (i32.const 1)) (i32.const 0)) + +(assert_return (invoke "as-unary-operand" (i32.const 0)) (i32.const 0)) +(assert_return (invoke "as-unary-operand" (i32.const 1)) (i32.const 0)) +(assert_return (invoke "as-unary-operand" (i32.const -1)) (i32.const 0)) + +(assert_return (invoke "as-binary-operand" (i32.const 0) (i32.const 0)) (i32.const 15)) +(assert_return (invoke "as-binary-operand" (i32.const 0) (i32.const 1)) (i32.const -12)) +(assert_return (invoke "as-binary-operand" (i32.const 1) (i32.const 0)) (i32.const -15)) +(assert_return (invoke "as-binary-operand" (i32.const 1) (i32.const 1)) (i32.const 12)) + +(assert_return (invoke "as-test-operand" (i32.const 0)) (i32.const 1)) +(assert_return (invoke "as-test-operand" (i32.const 1)) (i32.const 0)) + +(assert_return (invoke "as-compare-operand" (i32.const 0) (i32.const 0)) (i32.const 1)) +(assert_return (invoke "as-compare-operand" (i32.const 0) (i32.const 1)) (i32.const 0)) +(assert_return (invoke "as-compare-operand" (i32.const 1) (i32.const 0)) (i32.const 1)) +(assert_return (invoke "as-compare-operand" (i32.const 1) (i32.const 1)) (i32.const 0)) + +(assert_return (invoke "as-binary-operands" (i32.const 0)) (i32.const -12)) +(assert_return (invoke "as-binary-operands" (i32.const 1)) (i32.const 12)) + +(assert_return (invoke "as-compare-operands" (i32.const 0)) (i32.const 1)) +(assert_return (invoke "as-compare-operands" (i32.const 1)) (i32.const 0)) + +(assert_return (invoke "as-mixed-operands" (i32.const 0)) (i32.const -3)) +(assert_return (invoke "as-mixed-operands" (i32.const 1)) (i32.const 27)) + +(assert_return (invoke "break-bare") (i32.const 19)) +(assert_return (invoke "break-value" (i32.const 1)) (i32.const 18)) +(assert_return (invoke "break-value" (i32.const 0)) (i32.const 21)) +(assert_return (invoke "break-multi-value" (i32.const 0)) + (i32.const -18) (i32.const 18) (i64.const -18) +) +(assert_return (invoke "break-multi-value" (i32.const 1)) + (i32.const 18) (i32.const -18) (i64.const 18) +) + +(assert_return (invoke "param" (i32.const 0)) (i32.const -1)) +(assert_return (invoke "param" (i32.const 1)) (i32.const 3)) +(assert_return (invoke "params" (i32.const 0)) (i32.const -1)) +(assert_return (invoke "params" (i32.const 1)) (i32.const 3)) +(assert_return (invoke "params-id" (i32.const 0)) (i32.const 3)) +(assert_return (invoke "params-id" (i32.const 1)) (i32.const 3)) +(assert_return (invoke "param-break" (i32.const 0)) (i32.const -1)) +(assert_return (invoke "param-break" (i32.const 1)) (i32.const 3)) +(assert_return (invoke "params-break" (i32.const 0)) (i32.const -1)) +(assert_return (invoke "params-break" (i32.const 1)) (i32.const 3)) +(assert_return (invoke "params-id-break" (i32.const 0)) (i32.const 3)) +(assert_return (invoke "params-id-break" (i32.const 1)) (i32.const 3)) + +(assert_return (invoke "effects" (i32.const 1)) (i32.const -14)) +(assert_return (invoke "effects" (i32.const 0)) (i32.const -6)) + +(assert_return + (invoke "add64_u_with_carry" (i64.const 0) (i64.const 0) (i32.const 0)) + (i64.const 0) (i32.const 0) +) +(assert_return + (invoke "add64_u_with_carry" (i64.const 100) (i64.const 124) (i32.const 0)) + (i64.const 224) (i32.const 0) +) +(assert_return + (invoke "add64_u_with_carry" (i64.const -1) (i64.const 0) (i32.const 0)) + (i64.const -1) (i32.const 0) +) +(assert_return + (invoke "add64_u_with_carry" (i64.const -1) (i64.const 1) (i32.const 0)) + (i64.const 0) (i32.const 1) +) +(assert_return + (invoke "add64_u_with_carry" (i64.const -1) (i64.const -1) (i32.const 0)) + (i64.const -2) (i32.const 1) +) +(assert_return + (invoke "add64_u_with_carry" (i64.const -1) (i64.const 0) (i32.const 1)) + (i64.const 0) (i32.const 1) +) +(assert_return + (invoke "add64_u_with_carry" (i64.const -1) (i64.const 1) (i32.const 1)) + (i64.const 1) (i32.const 1) +) +(assert_return + (invoke "add64_u_with_carry" (i64.const 0x8000000000000000) (i64.const 0x8000000000000000) (i32.const 0)) + (i64.const 0) (i32.const 1) +) + +(assert_return + (invoke "add64_u_saturated" (i64.const 0) (i64.const 0)) (i64.const 0) +) +(assert_return + (invoke "add64_u_saturated" (i64.const 1230) (i64.const 23)) (i64.const 1253) +) +(assert_return + (invoke "add64_u_saturated" (i64.const -1) (i64.const 0)) (i64.const -1) +) +(assert_return + (invoke "add64_u_saturated" (i64.const -1) (i64.const 1)) (i64.const -1) +) +(assert_return + (invoke "add64_u_saturated" (i64.const -1) (i64.const -1)) (i64.const -1) +) +(assert_return + (invoke "add64_u_saturated" (i64.const 0x8000000000000000) (i64.const 0x8000000000000000)) (i64.const -1) +) + +(assert_return (invoke "type-use")) + +(assert_malformed + (module quote + "(type $sig (func (param i32) (result i32)))" + "(func (i32.const 0)" + " (if (type $sig) (result i32) (param i32) (i32.const 1) (then))" + ")" + ) + "unexpected token" +) +(assert_malformed + (module quote + "(type $sig (func (param i32) (result i32)))" + "(func (i32.const 0)" + " (if (param i32) (type $sig) (result i32) (i32.const 1) (then))" + ")" + ) + "unexpected token" +) +(assert_malformed + (module quote + "(type $sig (func (param i32) (result i32)))" + "(func (i32.const 0)" + " (if (param i32) (result i32) (type $sig) (i32.const 1) (then))" + ")" + ) + "unexpected token" +) +(assert_malformed + (module quote + "(type $sig (func (param i32) (result i32)))" + "(func (i32.const 0)" + " (if (result i32) (type $sig) (param i32) (i32.const 1) (then))" + ")" + ) + "unexpected token" +) +(assert_malformed + (module quote + "(type $sig (func (param i32) (result i32)))" + "(func (i32.const 0)" + " (if (result i32) (param i32) (type $sig) (i32.const 1) (then))" + ")" + ) + "unexpected token" +) +(assert_malformed + (module quote + "(func (i32.const 0) (if (result i32) (param i32) (i32.const 1) (then)))" + ) + "unexpected token" +) + +(assert_malformed + (module quote + "(func (i32.const 0) (i32.const 1)" + " (if (param $x i32) (then (drop)) (else (drop)))" + ")" + ) + "unexpected token" +) +(assert_malformed + (module quote + "(type $sig (func))" + "(func (i32.const 1)" + " (if (type $sig) (result i32) (then (i32.const 0)) (else (i32.const 2)))" + " (unreachable)" + ")" + ) + "inline function type" +) +(assert_malformed + (module quote + "(type $sig (func (param i32) (result i32)))" + "(func (i32.const 1)" + " (if (type $sig) (result i32) (then (i32.const 0)) (else (i32.const 2)))" + " (unreachable)" + ")" + ) + "inline function type" +) +(assert_malformed + (module quote + "(type $sig (func (param i32) (result i32)))" + "(func (i32.const 0) (i32.const 1)" + " (if (type $sig) (param i32) (then (drop)) (else (drop)))" + " (unreachable)" + ")" + ) + "inline function type" +) +(assert_malformed + (module quote + "(type $sig (func (param i32 i32) (result i32)))" + "(func (i32.const 0) (i32.const 1)" + " (if (type $sig) (param i32) (result i32) (then)) (unreachable)" + ")" + ) + "inline function type" +) + +(assert_invalid + (module + (type $sig (func)) + (func (i32.const 1) (if (type $sig) (i32.const 0) (then))) + ) + "type mismatch" +) + +(assert_invalid + (module (func $type-empty-i32 (result i32) (if (i32.const 0) (then)))) + "type mismatch" +) +(assert_invalid + (module (func $type-empty-i64 (result i64) (if (i32.const 0) (then)))) + "type mismatch" +) +(assert_invalid + (module (func $type-empty-f32 (result f32) (if (i32.const 0) (then)))) + "type mismatch" +) +(assert_invalid + (module (func $type-empty-f64 (result f64) (if (i32.const 0) (then)))) + "type mismatch" +) + +(assert_invalid + (module (func $type-empty-i32 (result i32) (if (i32.const 0) (then) (else)))) + "type mismatch" +) +(assert_invalid + (module (func $type-empty-i64 (result i64) (if (i32.const 0) (then) (else)))) + "type mismatch" +) +(assert_invalid + (module (func $type-empty-f32 (result f32) (if (i32.const 0) (then) (else)))) + "type mismatch" +) +(assert_invalid + (module (func $type-empty-f64 (result f64) (if (i32.const 0) (then) (else)))) + "type mismatch" +) + +(assert_invalid + (module (func $type-then-value-num-vs-void + (if (i32.const 1) (then (i32.const 1))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-then-value-num-vs-void-else + (if (i32.const 1) (then (i32.const 1)) (else)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-else-value-num-vs-void + (if (i32.const 1) (then) (else (i32.const 1))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-both-value-num-vs-void + (if (i32.const 1) (then (i32.const 1)) (else (i32.const 1))) + )) + "type mismatch" +) + +(assert_invalid + (module (func $type-then-value-nums-vs-void + (if (i32.const 1) (then (i32.const 1) (i32.const 2))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-then-value-nums-vs-void-else + (if (i32.const 1) (then (i32.const 1) (i32.const 2)) (else)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-else-value-nums-vs-void + (if (i32.const 1) (then) (else (i32.const 1) (i32.const 2))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-both-value-nums-vs-void + (if (i32.const 1) (then (i32.const 1) (i32.const 2)) (else (i32.const 2) (i32.const 1))) + )) + "type mismatch" +) + +(assert_invalid + (module (func $type-then-value-empty-vs-num (result i32) + (if (result i32) (i32.const 1) (then) (else (i32.const 0))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-else-value-empty-vs-num (result i32) + (if (result i32) (i32.const 1) (then (i32.const 0)) (else)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-both-value-empty-vs-num (result i32) + (if (result i32) (i32.const 1) (then) (else)) + )) + "type mismatch" +) + +(assert_invalid + (module (func $type-then-value-empty-vs-nums (result i32 i32) + (if (result i32 i32) (i32.const 1) (then) (else (i32.const 0) (i32.const 2))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-else-value-empty-vs-nums (result i32 i32) + (if (result i32 i32) (i32.const 1) (then (i32.const 0) (i32.const 1)) (else)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-both-value-empty-vs-nums (result i32 i32) + (if (result i32 i32) (i32.const 1) (then) (else)) + )) + "type mismatch" +) + +(assert_invalid + (module (func $type-no-else-vs-num (result i32) + (if (result i32) (i32.const 1) (then (i32.const 1))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-no-else-vs-nums (result i32 i32) + (if (result i32 i32) (i32.const 1) (then (i32.const 1) (i32.const 1))) + )) + "type mismatch" +) + +(assert_invalid + (module (func $type-then-value-void-vs-num (result i32) + (if (result i32) (i32.const 1) (then (nop)) (else (i32.const 0))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-else-value-void-vs-num (result i32) + (if (result i32) (i32.const 1) (then (i32.const 0)) (else (nop))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-both-value-void-vs-num (result i32) + (if (result i32) (i32.const 1) (then (nop)) (else (nop))) + )) + "type mismatch" +) + +(assert_invalid + (module (func $type-then-value-void-vs-nums (result i32 i32) + (if (result i32 i32) (i32.const 1) (then (nop)) (else (i32.const 0) (i32.const 0))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-else-value-void-vs-nums (result i32 i32) + (if (result i32 i32) (i32.const 1) (then (i32.const 0) (i32.const 0)) (else (nop))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-both-value-void-vs-nums (result i32 i32) + (if (result i32 i32) (i32.const 1) (then (nop)) (else (nop))) + )) + "type mismatch" +) + +(assert_invalid + (module (func $type-then-value-num-vs-num (result i32) + (if (result i32) (i32.const 1) (then (i64.const 1)) (else (i32.const 1))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-else-value-num-vs-num (result i32) + (if (result i32) (i32.const 1) (then (i32.const 1)) (else (i64.const 1))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-both-value-num-vs-num (result i32) + (if (result i32) (i32.const 1) (then (i64.const 1)) (else (i64.const 1))) + )) + "type mismatch" +) + +(assert_invalid + (module (func $type-then-value-num-vs-nums (result i32 i32) + (if (result i32 i32) (i32.const 1) (then (i32.const 1)) (else (i32.const 1) (i32.const 1))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-else-value-num-vs-nums (result i32 i32) + (if (result i32 i32) (i32.const 1) (then (i32.const 1) (i32.const 1)) (else (i32.const 1))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-both-value-num-vs-nums (result i32 i32) + (if (result i32 i32) (i32.const 1) (then (i32.const 1)) (else (i32.const 1))) + )) + "type mismatch" +) + +(assert_invalid + (module (func $type-then-value-partial-vs-nums (result i32 i32) + (i32.const 0) + (if (result i32 i32) (i32.const 1) (then (i32.const 1)) (else (i32.const 1) (i32.const 1))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-else-value-partial-vs-nums (result i32 i32) + (i32.const 0) + (if (result i32 i32) (i32.const 1) (then (i32.const 1) (i32.const 1)) (else (i32.const 1))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-both-value-partial-vs-nums (result i32 i32) + (i32.const 0) + (if (result i32 i32) (i32.const 1) (then (i32.const 1)) (else (i32.const 1))) + )) + "type mismatch" +) + +(assert_invalid + (module (func $type-then-value-nums-vs-num (result i32) + (if (result i32) (i32.const 1) (then (i32.const 1) (i32.const 1)) (else (i32.const 1))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-else-value-nums-vs-num (result i32) + (if (result i32) (i32.const 1) (then (i32.const 1)) (else (i32.const 1) (i32.const 1))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-both-value-nums-vs-num (result i32) + (if (result i32) (i32.const 1) (then (i32.const 1) (i32.const 1)) (else (i32.const 1) (i32.const 1))) + )) + "type mismatch" +) + +(assert_invalid + (module (func $type-both-different-value-num-vs-num (result i32) + (if (result i32) (i32.const 1) (then (i64.const 1)) (else (f64.const 1))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-both-different-value-nums-vs-nums (result i32 i32) + (if (result i32 i32) (i32.const 1) (then (i32.const 1) (i32.const 1) (i32.const 1)) (else (i32.const 1))) + )) + "type mismatch" +) + +(assert_invalid + (module (func $type-then-value-unreached-select (result i32) + (if (result i64) + (i32.const 0) + (then (select (unreachable) (unreachable) (unreachable))) + (else (i64.const 0)) + ) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-else-value-unreached-select (result i32) + (if (result i64) + (i32.const 1) + (then (i64.const 0)) + (else (select (unreachable) (unreachable) (unreachable))) + ) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-else-value-unreached-select (result i32) + (if (result i64) + (i32.const 1) + (then (select (unreachable) (unreachable) (unreachable))) + (else (select (unreachable) (unreachable) (unreachable))) + ) + )) + "type mismatch" +) + +(assert_invalid + (module (func $type-then-break-last-void-vs-num (result i32) + (if (result i32) (i32.const 1) (then (br 0)) (else (i32.const 1))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-else-break-last-void-vs-num (result i32) + (if (result i32) (i32.const 1) (then (i32.const 1)) (else (br 0))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-then-break-last-void-vs-nums (result i32 i32) + (if (result i32 i32) (i32.const 1) (then (br 0)) (else (i32.const 1) (i32.const 1))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-else-break-last-void-vs-nums (result i32 i32) + (if (result i32 i32) (i32.const 1) (then (i32.const 1) (i32.const 1)) (else (br 0))) + )) + "type mismatch" +) + +(assert_invalid + (module (func $type-then-break-empty-vs-num (result i32) + (if (result i32) (i32.const 1) + (then (br 0) (i32.const 1)) + (else (i32.const 1)) + ) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-else-break-empty-vs-num (result i32) + (if (result i32) (i32.const 1) + (then (i32.const 1)) + (else (br 0) (i32.const 1)) + ) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-then-break-empty-vs-nums (result i32 i32) + (if (result i32 i32) (i32.const 1) + (then (br 0) (i32.const 1) (i32.const 1)) + (else (i32.const 1) (i32.const 1)) + ) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-else-break-empty-vs-nums (result i32 i32) + (if (result i32 i32) (i32.const 1) + (then (i32.const 1) (i32.const 1)) + (else (br 0) (i32.const 1) (i32.const 1)) + ) + )) + "type mismatch" +) + +(assert_invalid + (module (func $type-then-break-void-vs-num (result i32) + (if (result i32) (i32.const 1) + (then (br 0 (nop)) (i32.const 1)) + (else (i32.const 1)) + ) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-else-break-void-vs-num (result i32) + (if (result i32) (i32.const 1) + (then (i32.const 1)) + (else (br 0 (nop)) (i32.const 1)) + ) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-then-break-void-vs-nums (result i32 i32) + (if (result i32 i32) (i32.const 1) + (then (br 0 (nop)) (i32.const 1) (i32.const 1)) + (else (i32.const 1) (i32.const 1)) + ) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-else-break-void-vs-nums (result i32 i32) + (if (result i32 i32) (i32.const 1) + (then (i32.const 1) (i32.const 1)) + (else (br 0 (nop)) (i32.const 1) (i32.const 1)) + ) + )) + "type mismatch" +) + +(assert_invalid + (module (func $type-then-break-num-vs-num (result i32) + (if (result i32) (i32.const 1) + (then (br 0 (i64.const 1)) (i32.const 1)) + (else (i32.const 1)) + ) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-else-break-num-vs-num (result i32) + (if (result i32) (i32.const 1) + (then (i32.const 1)) + (else (br 0 (i64.const 1)) (i32.const 1)) + ) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-then-break-num-vs-nums (result i32 i32) + (if (result i32 i32) (i32.const 1) + (then (br 0 (i64.const 1)) (i32.const 1) (i32.const 1)) + (else (i32.const 1) (i32.const 1)) + ) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-else-break-num-vs-nums (result i32 i32) + (if (result i32 i32) (i32.const 1) + (then (i32.const 1) (i32.const 1)) + (else (br 0 (i64.const 1)) (i32.const 1) (i32.const 1)) + ) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-then-break-partial-vs-nums (result i32 i32) + (i32.const 1) + (if (result i32 i32) (i32.const 1) + (then (br 0 (i64.const 1)) (i32.const 1)) + (else (i32.const 1)) + ) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-else-break-partial-vs-nums (result i32 i32) + (i32.const 1) + (if (result i32 i32) (i32.const 1) + (then (i32.const 1)) + (else (br 0 (i64.const 1)) (i32.const 1)) + ) + )) + "type mismatch" +) + +(assert_invalid + (module + (func $type-condition-empty + (if (then)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-condition-empty-in-block + (i32.const 0) + (block (if (then))) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-condition-empty-in-loop + (i32.const 0) + (loop (if (then))) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-condition-empty-in-then + (i32.const 0) (i32.const 0) + (if (then (if (then)))) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-condition-empty-in-else + (i32.const 0) (i32.const 0) + (if (result i32) (then (i32.const 0)) (else (if (then)) (i32.const 0))) + (drop) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-condition-empty-in-br + (i32.const 0) + (block (br 0 (if(then))) (drop)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-condition-empty-in-br_if + (i32.const 0) + (block (br_if 0 (if(then)) (i32.const 1)) (drop)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-condition-empty-in-br_table + (i32.const 0) + (block (br_table 0 (if(then))) (drop)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-condition-empty-in-return + (return (if(then))) (drop) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-condition-empty-in-select + (select (if(then)) (i32.const 1) (i32.const 2)) (drop) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-condition-empty-in-call + (call 1 (if(then))) (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-condition-empty-in-call_indirect + (block (result i32) + (call_indirect (type $sig) + (if(then)) (i32.const 0) + ) + (drop) + ) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-condition-empty-in-local.set + (local i32) + (local.set 0 (if(then))) (local.get 0) (drop) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-condition-empty-in-local.tee + (local i32) + (local.tee 0 (if(then))) (drop) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (global $x (mut i32) (i32.const 0)) + (func $type-condition-empty-in-global.set + (global.set $x (if(then))) (global.get $x) (drop) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (memory 0) + (func $type-condition-empty-in-memory.grow + (memory.grow (if(then))) (drop) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (memory 0) + (func $type-condition-empty-in-load + (i32.load (if(then))) (drop) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (memory 1) + (func $type-condition-empty-in-store + (i32.store (if(then)) (i32.const 1)) + ) + ) + "type mismatch" +) + +(assert_invalid + (module (func $type-param-void-vs-num + (if (param i32) (i32.const 1) (then (drop))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-param-void-vs-nums + (if (param i32 f64) (i32.const 1) (then (drop) (drop))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-param-num-vs-num + (f32.const 0) (if (param i32) (i32.const 1) (then (drop))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-param-num-vs-nums + (f32.const 0) (if (param f32 i32) (i32.const 1) (then (drop) (drop))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-param-nested-void-vs-num + (block (if (param i32) (i32.const 1) (then (drop)))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-param-void-vs-nums + (block (if (param i32 f64) (i32.const 1) (then (drop) (drop)))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-param-num-vs-num + (block (f32.const 0) (if (param i32) (i32.const 1) (then (drop)))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-param-num-vs-nums + (block (f32.const 0) (if (param f32 i32) (i32.const 1) (then (drop) (drop)))) + )) + "type mismatch" +) + +(assert_malformed + (module quote "(func (param i32) (result i32) if (param $x i32) end)") + "unexpected token" +) +(assert_malformed + (module quote "(func (param i32) (result i32) (if (param $x i32) (then)))") + "unexpected token" +) + +(assert_malformed + (module quote "(func i32.const 0 if end $l)") + "mismatching label" +) +(assert_malformed + (module quote "(func i32.const 0 if $a end $l)") + "mismatching label" +) +(assert_malformed + (module quote "(func i32.const 0 if else $l end)") + "mismatching label" +) +(assert_malformed + (module quote "(func i32.const 0 if $a else $l end)") + "mismatching label" +) +(assert_malformed + (module quote "(func i32.const 0 if else end $l)") + "mismatching label" +) +(assert_malformed + (module quote "(func i32.const 0 if else $l end $l)") + "mismatching label" +) +(assert_malformed + (module quote "(func i32.const 0 if else $l1 end $l2)") + "mismatching label" +) +(assert_malformed + (module quote "(func i32.const 0 if $a else end $l)") + "mismatching label" +) +(assert_malformed + (module quote "(func i32.const 0 if $a else $a end $l)") + "mismatching label" +) +(assert_malformed + (module quote "(func i32.const 0 if $a else $l end $l)") + "mismatching label" +) diff --git a/runtime/near-vm/tests/wast/spec/proposals/gc/let.wast b/runtime/near-vm/tests/wast/spec/proposals/gc/let.wast new file mode 100644 index 00000000000..451bc5d6fd3 --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/proposals/gc/let.wast @@ -0,0 +1,302 @@ +(module + ;; Auxiliary + (type $dummy (func)) + (elem declare func $dummy) + (func $dummy) + (func $consume (param i32)) + (func $produce (result i32) (i32.const 7)) + + (func (export "syntax") (param $x1 i32) (param $x2 i64) + (local $y1 i64) + (local $y2 i32) + (local.set $y2 (i32.const 5)) + + (let) + (let $l) + (let (local)) + (let $l (local)) + + (let (result) (local)) + (let $l (result) (local)) + + (let (call $dummy) (call $consume (local.get $x1))) + (let $l (call $dummy) (call $consume (local.get $y2))) + (let (local) (call $dummy) (call $consume (local.get $y2))) + (let $l (local) (call $dummy) (call $consume (local.get $x1))) + + (let (call $dummy) (call $dummy) (br 0)) + (let $l (call $dummy) (call $dummy) (br $l)) + (let (local) (call $dummy) (call $dummy) (br 0)) + (let $l (local) (call $dummy) (call $dummy) (br $l)) + + (i32.const 1) + (f32.const 2) + (let $l (param i32) (result i64) (local f32) (br $l (i64.const 3))) + (drop) + + (let (result i32) (call $dummy) (call $produce) (call $dummy)) + (drop) + (let $l (result i32) (call $dummy) (call $produce) (call $dummy)) + (drop) + (let (result i32) (local) (call $dummy) (call $produce) (call $dummy)) + (drop) + (let $l (result i32) (local) (call $dummy) (call $produce) (call $dummy)) + (drop) + + (i32.const 1) + (let (local i32) (call $dummy) (call $consume (local.get 0))) + (i32.const 2) + (let $l (local i32) (call $dummy) (call $consume (local.get 0))) + (i32.const 3) + (let (local i32) (call $dummy) (call $consume (local.get 0))) + (i32.const 4) + (let $l (local i32) (call $dummy) (call $consume (local.get 0))) + + (i32.const 1) (f32.const 2) (i32.const 3) (i64.const 4) + (let (local i32 f32) (local) (local $z i32) (local i64) + (call $consume (local.get 0)) + (call $consume (local.get 2)) ;; $z + (call $consume (local.get 4)) ;; $x1 + (call $consume (local.get 7)) ;; $y2 + (call $consume (local.get $z)) + (call $consume (local.get $x1)) + (call $consume (local.get $y2)) + ) + + (f32.const 1) (i32.const 2) (i64.const 3) (i32.const 4) + (let (result i32) (local $z1 f32) (local $z2 i32) (local) (local i64 i32) + (call $produce) + (call $consume (local.get 1)) ;; $z2 + (call $consume (local.get 3)) + (call $consume (local.get 4)) ;; $x1 + (call $consume (local.get 7)) ;; $y2 + (call $consume (local.get $z2)) + (call $consume (local.get $x1)) + (call $consume (local.get $y2)) + ) + (drop) + + (ref.func $dummy) + (let (local (ref $dummy))) + ) + + (func $pow (export "pow") (param $x i64) (param $n i32) (result i64) + (local $y i64) + (local.set $y + (if (result i64) (i32.and (local.get $n) (i32.const 1)) + (then (local.get $x)) (else (i64.const 1)) + ) + ) + (i64.mul + (local.get $y) + (if (result i64) (i32.le_u (local.get $n) (i32.const 1)) + (then (i64.const 1)) + (else + (call $pow + (i64.mul (local.get $x) (local.get $x)) + (i32.shr_u (local.get $n) (i32.const 1)) + ) + ) + ) + ) + ) + + (func (export "semantics-idx") (param i64 i64) (result i64) + (local i64 i64) + (local.set 2 (i64.const 5)) + (local.set 3 (i64.const 7)) + + (i64.const 11) (i64.const 13) + (let (result i64) (local i64 i64) + (i64.const 17) (i64.const 19) + (let (result i64) (local i64 i64) + (i64.const 0) + (i64.add (call $pow (local.get 0) (i32.const 0))) ;; 17^0 = 1 + (i64.add (call $pow (local.get 1) (i32.const 1))) ;; 19^1 = 19 + (i64.add (call $pow (local.get 2) (i32.const 2))) ;; 11^2 = 121 + (i64.add (call $pow (local.get 3) (i32.const 3))) ;; 13^3 = 2197 + (i64.add (call $pow (local.get 4) (i32.const 4))) ;; 2^4 = 16 + (i64.add (call $pow (local.get 5) (i32.const 5))) ;; 3^5 = 243 + (i64.add (call $pow (local.get 6) (i32.const 6))) ;; 5^6 = 15625 + (i64.add (call $pow (local.get 7) (i32.const 7))) ;; 7^7 = 823543 + ) + ) + ) + + (func (export "semantics-sym") (param $x1 i64) (param $x2 i64) (result i64) + (local $y1 i64) + (local $y2 i64) + (local.set $y1 (i64.const 5)) + (local.set $y2 (i64.const 7)) + + (i64.const 11) (i64.const 13) + (let (result i64) (local $z1 i64) (local $z2 i64) + (i64.const 17) (i64.const 19) + (let (result i64) (local $u1 i64) (local $u2 i64) + (i64.const 0) + (i64.add (call $pow (local.get $u1) (i32.const 0))) ;; 17^0 = 1 + (i64.add (call $pow (local.get $u2) (i32.const 1))) ;; 19^1 = 19 + (i64.add (call $pow (local.get $z1) (i32.const 2))) ;; 11^2 = 121 + (i64.add (call $pow (local.get $z2) (i32.const 3))) ;; 13^3 = 2197 + (i64.add (call $pow (local.get $x1) (i32.const 4))) ;; 2^4 = 16 + (i64.add (call $pow (local.get $x2) (i32.const 5))) ;; 3^5 = 243 + (i64.add (call $pow (local.get $y1) (i32.const 6))) ;; 5^6 = 15625 + (i64.add (call $pow (local.get $y2) (i32.const 7))) ;; 7^7 = 823543 + ) + ) + ) + + (func (export "mutate") (param $x1 i64) (param $x2 i64) (result i64) + (local $y1 i64) + (local $y2 i64) + + (i64.const 0) (i64.const 0) + (let (result i64) (local $z1 i64) (local $z2 i64) + (i64.const 0) (i64.const 0) + (let (result i64) (local $u1 i64) (local $u2 i64) + (local.set $y1 (i64.const 5)) + (local.set $y2 (i64.const 7)) + (local.set $z1 (i64.const 11)) + (local.set $z2 (i64.const 13)) + (local.set $u1 (i64.const 17)) + (local.set $u2 (i64.const 19)) + (i64.const 0) + (i64.add (call $pow (local.get $u1) (i32.const 0))) ;; 17^0 = 1 + (i64.add (call $pow (local.get $u2) (i32.const 1))) ;; 19^1 = 19 + (i64.add (call $pow (local.get $z1) (i32.const 2))) ;; 11^2 = 121 + (i64.add (call $pow (local.get $z2) (i32.const 3))) ;; 13^3 = 2197 + (i64.add (call $pow (local.get $x1) (i32.const 4))) ;; 2^4 = 16 + (i64.add (call $pow (local.get $x2) (i32.const 5))) ;; 3^5 = 243 + (i64.add (call $pow (local.get $y1) (i32.const 6))) ;; 5^6 = 15625 + (i64.add (call $pow (local.get $y2) (i32.const 7))) ;; 7^7 = 823543 + ) + ) + ) +) + +(assert_return (invoke "syntax" (i32.const 1) (i64.const 2))) + +(assert_return (invoke "pow" (i64.const 17) (i32.const 0)) (i64.const 1)) +(assert_return (invoke "pow" (i64.const 19) (i32.const 1)) (i64.const 19)) +(assert_return (invoke "pow" (i64.const 11) (i32.const 2)) (i64.const 121)) +(assert_return (invoke "pow" (i64.const 13) (i32.const 3)) (i64.const 2197)) +(assert_return (invoke "pow" (i64.const 2) (i32.const 4)) (i64.const 16)) +(assert_return (invoke "pow" (i64.const 3) (i32.const 5)) (i64.const 243)) +(assert_return (invoke "pow" (i64.const 5) (i32.const 6)) (i64.const 15625)) +(assert_return (invoke "pow" (i64.const 7) (i32.const 7)) (i64.const 823543)) + +(assert_return (invoke "semantics-idx" (i64.const 2) (i64.const 3)) (i64.const 841_765)) +(assert_return (invoke "semantics-sym" (i64.const 2) (i64.const 3)) (i64.const 841_765)) +(assert_return (invoke "mutate" (i64.const 2) (i64.const 3)) (i64.const 841_765)) + + +;; Shadowing. + +;; Shadowing is fine across nested let blocks (analogous to labels). +(module + (func (export "f1") (param $x i32) (result i32) + (i32.const 1) + (let (local $x i32) (return (local.get $x))) + (unreachable) + ) + (func (export "f2") (result i32) + (local $x i32) + (i32.const 1) + (let (local $x i32) (return (local.get $x))) + (unreachable) + ) + (func (export "f3") (result i32) + (i32.const 0) + (let (local $x i32) + (i32.const 1) + (let (local $x i32) (return (local.get $x))) + ) + (unreachable) + ) + (func (export "f4") (result i32) + (local $x i32) + (i32.const 1) + (let (local $x i32) + (i32.const 2) + (let (local $x i32) (return (local.get $x))) + ) + (unreachable) + ) +) + +(assert_return (invoke "f1" (i32.const 0)) (i32.const 1)) +(assert_return (invoke "f2") (i32.const 1)) +(assert_return (invoke "f3") (i32.const 1)) +(assert_return (invoke "f4") (i32.const 2)) + +;; Duplicate labels within a single let block are still disallowed. +(assert_malformed + (module quote "(func (let (local $x i32) (local $x i64)))") + "duplicate local" +) + + +;; Syntax + +(assert_malformed + (module quote "(func (let (local) (param)))") + "unexpected token" +) +(assert_malformed + (module quote + "(func" + " (i32.const 0) (i32.const 0)" + " (let (local i32) (param i32) (drop))" + ")" + ) + "unexpected token" +) + +(assert_malformed + (module quote "(func (let (local) (result)))") + "unexpected token" +) +(assert_malformed + (module quote + "(func (result i32)" + " (i32.const 0)" + " (let (local i32) (result i32) (local.get 0))" + ")" + ) + "unexpected token" +) +(assert_malformed + (module quote + "(func (result i32)" + " (let (local $x i32) (result i32) (local.get 0))" + ")" + ) + "unexpected token" +) + +(assert_malformed + (module quote "(func (let (result) (param)))") + "unexpected token" +) +(assert_malformed + (module quote + "(func (result i32)" + " (i32.const 0)" + " (let (result i32) (param i32))" + ")" + ) + "unexpected token" +) + +(assert_malformed + (module quote "(func (let (param) $l))") + "unexpected token" +) +(assert_malformed + (module quote "(func (let (result) $l))") + "unexpected token" +) +(assert_malformed + (module quote "(func (let (local) $l))") + "unexpected token" +) diff --git a/runtime/near-vm/tests/wast/spec/proposals/gc/linking.wast b/runtime/near-vm/tests/wast/spec/proposals/gc/linking.wast new file mode 100644 index 00000000000..85de43d8f9e --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/proposals/gc/linking.wast @@ -0,0 +1,627 @@ +;; Functions + +(module $Mf + (func (export "call") (result i32) (call $g)) + (func $g (result i32) (i32.const 2)) +) +(register "Mf" $Mf) + +(module $Nf + (func $f (import "Mf" "call") (result i32)) + (export "Mf.call" (func $f)) + (func (export "call Mf.call") (result i32) (call $f)) + (func (export "call") (result i32) (call $g)) + (func $g (result i32) (i32.const 3)) +) + +(assert_return (invoke $Mf "call") (i32.const 2)) +(assert_return (invoke $Nf "Mf.call") (i32.const 2)) +(assert_return (invoke $Nf "call") (i32.const 3)) +(assert_return (invoke $Nf "call Mf.call") (i32.const 2)) + +(module + (import "spectest" "print_i32" (func $f (param i32))) + (export "print" (func $f)) +) +(register "reexport_f") +(assert_unlinkable + (module (import "reexport_f" "print" (func (param i64)))) + "incompatible import type" +) +(assert_unlinkable + (module (import "reexport_f" "print" (func (param i32) (result i32)))) + "incompatible import type" +) + + +;; Globals + +(module $Mg + (global $glob (export "glob") i32 (i32.const 42)) + (func (export "get") (result i32) (global.get $glob)) + + ;; export mutable globals + (global $mut_glob (export "mut_glob") (mut i32) (i32.const 142)) + (func (export "get_mut") (result i32) (global.get $mut_glob)) + (func (export "set_mut") (param i32) (global.set $mut_glob (local.get 0))) +) +(register "Mg" $Mg) + +(module $Ng + (global $x (import "Mg" "glob") i32) + (global $mut_glob (import "Mg" "mut_glob") (mut i32)) + (func $f (import "Mg" "get") (result i32)) + (func $get_mut (import "Mg" "get_mut") (result i32)) + (func $set_mut (import "Mg" "set_mut") (param i32)) + + (export "Mg.glob" (global $x)) + (export "Mg.get" (func $f)) + (global $glob (export "glob") i32 (i32.const 43)) + (func (export "get") (result i32) (global.get $glob)) + + (export "Mg.mut_glob" (global $mut_glob)) + (export "Mg.get_mut" (func $get_mut)) + (export "Mg.set_mut" (func $set_mut)) +) + +(assert_return (get $Mg "glob") (i32.const 42)) +(assert_return (get $Ng "Mg.glob") (i32.const 42)) +(assert_return (get $Ng "glob") (i32.const 43)) +(assert_return (invoke $Mg "get") (i32.const 42)) +(assert_return (invoke $Ng "Mg.get") (i32.const 42)) +(assert_return (invoke $Ng "get") (i32.const 43)) + +(assert_return (get $Mg "mut_glob") (i32.const 142)) +(assert_return (get $Ng "Mg.mut_glob") (i32.const 142)) +(assert_return (invoke $Mg "get_mut") (i32.const 142)) +(assert_return (invoke $Ng "Mg.get_mut") (i32.const 142)) + +(assert_return (invoke $Mg "set_mut" (i32.const 241))) +(assert_return (get $Mg "mut_glob") (i32.const 241)) +(assert_return (get $Ng "Mg.mut_glob") (i32.const 241)) +(assert_return (invoke $Mg "get_mut") (i32.const 241)) +(assert_return (invoke $Ng "Mg.get_mut") (i32.const 241)) + + +(assert_unlinkable + (module (import "Mg" "mut_glob" (global i32))) + "incompatible import type" +) +(assert_unlinkable + (module (import "Mg" "glob" (global (mut i32)))) + "incompatible import type" +) + + +(module $Mref_ex + (type $t (func)) + (func $f) (elem declare func $f) + (global (export "g-const-funcnull") (ref null func) (ref.null func)) + (global (export "g-const-func") (ref func) (ref.func $f)) + (global (export "g-const-refnull") (ref null $t) (ref.null $t)) + (global (export "g-const-ref") (ref $t) (ref.func $f)) + (global (export "g-const-extern") externref (ref.null extern)) + (global (export "g-var-funcnull") (mut (ref null func)) (ref.null func)) + (global (export "g-var-func") (mut (ref func)) (ref.func $f)) + (global (export "g-var-refnull") (mut (ref null $t)) (ref.null $t)) + (global (export "g-var-ref") (mut (ref $t)) (ref.func $f)) + (global (export "g-var-extern") (mut externref) (ref.null extern)) +) +(register "Mref_ex" $Mref_ex) + +(module $Mref_im + (type $t (func)) + (global (import "Mref_ex" "g-const-funcnull") (ref null func)) + (global (import "Mref_ex" "g-const-func") (ref null func)) + (global (import "Mref_ex" "g-const-refnull") (ref null func)) + (global (import "Mref_ex" "g-const-ref") (ref null func)) + (global (import "Mref_ex" "g-const-func") (ref func)) + (global (import "Mref_ex" "g-const-ref") (ref func)) + (global (import "Mref_ex" "g-const-refnull") (ref null $t)) + (global (import "Mref_ex" "g-const-ref") (ref null $t)) + (global (import "Mref_ex" "g-const-ref") (ref $t)) + (global (import "Mref_ex" "g-const-extern") externref) + + (global (import "Mref_ex" "g-var-funcnull") (mut (ref null func))) + (global (import "Mref_ex" "g-var-func") (mut (ref func))) + (global (import "Mref_ex" "g-var-refnull") (mut (ref null $t))) + (global (import "Mref_ex" "g-var-ref") (mut (ref $t))) + (global (import "Mref_ex" "g-var-extern") (mut externref)) +) + +(assert_unlinkable + (module (global (import "Mref_ex" "g-const-extern") (ref null func))) + "incompatible import type" +) + +(assert_unlinkable + (module (type $t (func)) (global (import "Mref_ex" "g-const-funcnull") (ref func))) + "incompatible import type" +) +(assert_unlinkable + (module (type $t (func)) (global (import "Mref_ex" "g-const-refnull") (ref func))) + "incompatible import type" +) +(assert_unlinkable + (module (type $t (func)) (global (import "Mref_ex" "g-const-extern") (ref func))) + "incompatible import type" +) + +(assert_unlinkable + (module (type $t (func)) (global (import "Mref_ex" "g-const-funcnull") (ref null $t))) + "incompatible import type" +) +(assert_unlinkable + (module (type $t (func)) (global (import "Mref_ex" "g-const-func") (ref null $t))) + "incompatible import type" +) +(assert_unlinkable + (module (type $t (func)) (global (import "Mref_ex" "g-const-extern") (ref null $t))) + "incompatible import type" +) + +(assert_unlinkable + (module (type $t (func)) (global (import "Mref_ex" "g-const-funcnull") (ref $t))) + "incompatible import type" +) +(assert_unlinkable + (module (type $t (func)) (global (import "Mref_ex" "g-const-func") (ref $t))) + "incompatible import type" +) +(assert_unlinkable + (module (type $t (func)) (global (import "Mref_ex" "g-const-refnull") (ref $t))) + "incompatible import type" +) +(assert_unlinkable + (module (type $t (func)) (global (import "Mref_ex" "g-const-extern") (ref $t))) + "incompatible import type" +) + +(assert_unlinkable + (module (global (import "Mref_ex" "g-const-funcnull") externref)) + "incompatible import type" +) +(assert_unlinkable + (module (global (import "Mref_ex" "g-const-func") externref)) + "incompatible import type" +) +(assert_unlinkable + (module (global (import "Mref_ex" "g-const-refnull") externref)) + "incompatible import type" +) +(assert_unlinkable + (module (global (import "Mref_ex" "g-const-ref") externref)) + "incompatible import type" +) + + +(assert_unlinkable + (module (global (import "Mref_ex" "g-var-func") (mut (ref null func)))) + "incompatible import type" +) +(assert_unlinkable + (module (global (import "Mref_ex" "g-var-refnull") (mut (ref null func)))) + "incompatible import type" +) +(assert_unlinkable + (module (global (import "Mref_ex" "g-var-ref") (mut (ref null func)))) + "incompatible import type" +) +(assert_unlinkable + (module (global (import "Mref_ex" "g-var-extern") (mut (ref null func)))) + "incompatible import type" +) + +(assert_unlinkable + (module (global (import "Mref_ex" "g-var-funcnull") (mut (ref func)))) + "incompatible import type" +) +(assert_unlinkable + (module (global (import "Mref_ex" "g-var-refnull") (mut (ref func)))) + "incompatible import type" +) +(assert_unlinkable + (module (global (import "Mref_ex" "g-var-ref") (mut (ref func)))) + "incompatible import type" +) +(assert_unlinkable + (module (global (import "Mref_ex" "g-var-extern") (mut (ref func)))) + "incompatible import type" +) + +(assert_unlinkable + (module (type $t (func)) (global (import "Mref_ex" "g-var-funcnull") (mut (ref null $t)))) + "incompatible import type" +) +(assert_unlinkable + (module (type $t (func)) (global (import "Mref_ex" "g-var-func") (mut (ref null $t)))) + "incompatible import type" +) +(assert_unlinkable + (module (type $t (func)) (global (import "Mref_ex" "g-var-ref") (mut (ref null $t)))) + "incompatible import type" +) +(assert_unlinkable + (module (type $t (func)) (global (import "Mref_ex" "g-var-extern") (mut (ref null $t)))) + "incompatible import type" +) + +(assert_unlinkable + (module (type $t (func)) (global (import "Mref_ex" "g-var-funcnull") (mut (ref $t)))) + "incompatible import type" +) +(assert_unlinkable + (module (type $t (func)) (global (import "Mref_ex" "g-var-func") (mut (ref $t)))) + "incompatible import type" +) +(assert_unlinkable + (module (type $t (func)) (global (import "Mref_ex" "g-var-refnull") (mut (ref $t)))) + "incompatible import type" +) +(assert_unlinkable + (module (type $t (func)) (global (import "Mref_ex" "g-var-extern") (mut (ref $t)))) + "incompatible import type" +) + +(assert_unlinkable + (module (global (import "Mref_ex" "g-var-funcnull") (mut externref))) + "incompatible import type" +) +(assert_unlinkable + (module (global (import "Mref_ex" "g-var-func") (mut externref))) + "incompatible import type" +) +(assert_unlinkable + (module (global (import "Mref_ex" "g-var-refnull") (mut externref))) + "incompatible import type" +) +(assert_unlinkable + (module (global (import "Mref_ex" "g-var-ref") (mut externref))) + "incompatible import type" +) + + +;; Tables + +(module $Mt + (type (func (result i32))) + (type (func)) + + (table (export "tab") 10 funcref) + (elem (i32.const 2) $g $g $g $g) + (func $g (result i32) (i32.const 4)) + (func (export "h") (result i32) (i32.const -4)) + + (func (export "call") (param i32) (result i32) + (call_indirect (type 0) (local.get 0)) + ) +) +(register "Mt" $Mt) + +(module $Nt + (type (func)) + (type (func (result i32))) + + (func $f (import "Mt" "call") (param i32) (result i32)) + (func $h (import "Mt" "h") (result i32)) + + (table funcref (elem $g $g $g $h $f)) + (func $g (result i32) (i32.const 5)) + + (export "Mt.call" (func $f)) + (func (export "call Mt.call") (param i32) (result i32) + (call $f (local.get 0)) + ) + (func (export "call") (param i32) (result i32) + (call_indirect (type 1) (local.get 0)) + ) +) + +(assert_return (invoke $Mt "call" (i32.const 2)) (i32.const 4)) +(assert_return (invoke $Nt "Mt.call" (i32.const 2)) (i32.const 4)) +(assert_return (invoke $Nt "call" (i32.const 2)) (i32.const 5)) +(assert_return (invoke $Nt "call Mt.call" (i32.const 2)) (i32.const 4)) + +(assert_trap (invoke $Mt "call" (i32.const 1)) "uninitialized element") +(assert_trap (invoke $Nt "Mt.call" (i32.const 1)) "uninitialized element") +(assert_return (invoke $Nt "call" (i32.const 1)) (i32.const 5)) +(assert_trap (invoke $Nt "call Mt.call" (i32.const 1)) "uninitialized element") + +(assert_trap (invoke $Mt "call" (i32.const 0)) "uninitialized element") +(assert_trap (invoke $Nt "Mt.call" (i32.const 0)) "uninitialized element") +(assert_return (invoke $Nt "call" (i32.const 0)) (i32.const 5)) +(assert_trap (invoke $Nt "call Mt.call" (i32.const 0)) "uninitialized element") + +(assert_trap (invoke $Mt "call" (i32.const 20)) "undefined element") +(assert_trap (invoke $Nt "Mt.call" (i32.const 20)) "undefined element") +(assert_trap (invoke $Nt "call" (i32.const 7)) "undefined element") +(assert_trap (invoke $Nt "call Mt.call" (i32.const 20)) "undefined element") + +(assert_return (invoke $Nt "call" (i32.const 3)) (i32.const -4)) +(assert_trap (invoke $Nt "call" (i32.const 4)) "indirect call type mismatch") + +(module $Ot + (type (func (result i32))) + + (func $h (import "Mt" "h") (result i32)) + (table (import "Mt" "tab") 5 funcref) + (elem (i32.const 1) $i $h) + (func $i (result i32) (i32.const 6)) + + (func (export "call") (param i32) (result i32) + (call_indirect (type 0) (local.get 0)) + ) +) + +(assert_return (invoke $Mt "call" (i32.const 3)) (i32.const 4)) +(assert_return (invoke $Nt "Mt.call" (i32.const 3)) (i32.const 4)) +(assert_return (invoke $Nt "call Mt.call" (i32.const 3)) (i32.const 4)) +(assert_return (invoke $Ot "call" (i32.const 3)) (i32.const 4)) + +(assert_return (invoke $Mt "call" (i32.const 2)) (i32.const -4)) +(assert_return (invoke $Nt "Mt.call" (i32.const 2)) (i32.const -4)) +(assert_return (invoke $Nt "call" (i32.const 2)) (i32.const 5)) +(assert_return (invoke $Nt "call Mt.call" (i32.const 2)) (i32.const -4)) +(assert_return (invoke $Ot "call" (i32.const 2)) (i32.const -4)) + +(assert_return (invoke $Mt "call" (i32.const 1)) (i32.const 6)) +(assert_return (invoke $Nt "Mt.call" (i32.const 1)) (i32.const 6)) +(assert_return (invoke $Nt "call" (i32.const 1)) (i32.const 5)) +(assert_return (invoke $Nt "call Mt.call" (i32.const 1)) (i32.const 6)) +(assert_return (invoke $Ot "call" (i32.const 1)) (i32.const 6)) + +(assert_trap (invoke $Mt "call" (i32.const 0)) "uninitialized element") +(assert_trap (invoke $Nt "Mt.call" (i32.const 0)) "uninitialized element") +(assert_return (invoke $Nt "call" (i32.const 0)) (i32.const 5)) +(assert_trap (invoke $Nt "call Mt.call" (i32.const 0)) "uninitialized element") +(assert_trap (invoke $Ot "call" (i32.const 0)) "uninitialized element") + +(assert_trap (invoke $Ot "call" (i32.const 20)) "undefined element") + +(module + (table (import "Mt" "tab") 0 funcref) + (elem (i32.const 9) $f) + (func $f) +) + +(module $G1 (global (export "g") i32 (i32.const 5))) +(register "G1" $G1) +(module $G2 + (global (import "G1" "g") i32) + (global (export "g") i32 (global.get 0)) +) +(assert_return (get $G2 "g") (i32.const 5)) + +(assert_trap + (module + (table (import "Mt" "tab") 0 funcref) + (elem (i32.const 10) $f) + (func $f) + ) + "out of bounds table access" +) + +(assert_unlinkable + (module + (table (import "Mt" "tab") 10 funcref) + (memory (import "Mt" "mem") 1) ;; does not exist + (func $f (result i32) (i32.const 0)) + (elem (i32.const 7) $f) + (elem (i32.const 9) $f) + ) + "unknown import" +) +(assert_trap (invoke $Mt "call" (i32.const 7)) "uninitialized element") + +;; Unlike in the v1 spec, active element segments stored before an +;; out-of-bounds access persist after the instantiation failure. +(assert_trap + (module + (table (import "Mt" "tab") 10 funcref) + (func $f (result i32) (i32.const 0)) + (elem (i32.const 7) $f) + (elem (i32.const 8) $f $f $f $f $f) ;; (partially) out of bounds + ) + "out of bounds table access" +) +(assert_return (invoke $Mt "call" (i32.const 7)) (i32.const 0)) +(assert_trap (invoke $Mt "call" (i32.const 8)) "uninitialized element") + +(assert_trap + (module + (table (import "Mt" "tab") 10 funcref) + (func $f (result i32) (i32.const 0)) + (elem (i32.const 7) $f) + (memory 1) + (data (i32.const 0x10000) "d") ;; out of bounds + ) + "out of bounds memory access" +) +(assert_return (invoke $Mt "call" (i32.const 7)) (i32.const 0)) + + +(module $Mtable_ex + (type $t (func)) + (table (export "t-funcnull") 1 (ref null func)) + (table (export "t-refnull") 1 (ref null $t)) + (table (export "t-extern") 1 externref) +) +(register "Mtable_ex" $Mtable_ex) + +(module + (type $t (func)) + (table (import "Mtable_ex" "t-funcnull") 1 (ref null func)) + (table (import "Mtable_ex" "t-refnull") 1 (ref null $t)) + (table (import "Mtable_ex" "t-extern") 1 externref) +) + +(assert_unlinkable + (module (table (import "Mtable_ex" "t-refnull") 1 (ref null func))) + "incompatible import type" +) +(assert_unlinkable + (module (table (import "Mtable_ex" "t-extern") 1 (ref null func))) + "incompatible import type" +) + +(assert_unlinkable + (module (type $t (func)) (table (import "Mtable_ex" "t-funcnull") 1 (ref null $t))) + "incompatible import type" +) +(assert_unlinkable + (module (type $t (func)) (table (import "Mtable_ex" "t-extern") 1 (ref null $t))) + "incompatible import type" +) + +(assert_unlinkable + (module (table (import "Mtable_ex" "t-funcnull") 1 externref)) + "incompatible import type" +) +(assert_unlinkable + (module (table (import "Mtable_ex" "t-refnull") 1 externref)) + "incompatible import type" +) + + +;; Memories + +(module $Mm + (memory (export "mem") 1 5) + (data (i32.const 10) "\00\01\02\03\04\05\06\07\08\09") + + (func (export "load") (param $a i32) (result i32) + (i32.load8_u (local.get 0)) + ) +) +(register "Mm" $Mm) + +(module $Nm + (func $loadM (import "Mm" "load") (param i32) (result i32)) + + (memory 1) + (data (i32.const 10) "\f0\f1\f2\f3\f4\f5") + + (export "Mm.load" (func $loadM)) + (func (export "load") (param $a i32) (result i32) + (i32.load8_u (local.get 0)) + ) +) + +(assert_return (invoke $Mm "load" (i32.const 12)) (i32.const 2)) +(assert_return (invoke $Nm "Mm.load" (i32.const 12)) (i32.const 2)) +(assert_return (invoke $Nm "load" (i32.const 12)) (i32.const 0xf2)) + +(module $Om + (memory (import "Mm" "mem") 1) + (data (i32.const 5) "\a0\a1\a2\a3\a4\a5\a6\a7") + + (func (export "load") (param $a i32) (result i32) + (i32.load8_u (local.get 0)) + ) +) + +(assert_return (invoke $Mm "load" (i32.const 12)) (i32.const 0xa7)) +(assert_return (invoke $Nm "Mm.load" (i32.const 12)) (i32.const 0xa7)) +(assert_return (invoke $Nm "load" (i32.const 12)) (i32.const 0xf2)) +(assert_return (invoke $Om "load" (i32.const 12)) (i32.const 0xa7)) + +(module + (memory (import "Mm" "mem") 0) + (data (i32.const 0xffff) "a") +) + +(assert_trap + (module + (memory (import "Mm" "mem") 0) + (data (i32.const 0x10000) "a") + ) + "out of bounds memory access" +) + +(module $Pm + (memory (import "Mm" "mem") 1 8) + + (func (export "grow") (param $a i32) (result i32) + (memory.grow (local.get 0)) + ) +) + +(assert_return (invoke $Pm "grow" (i32.const 0)) (i32.const 1)) +(assert_return (invoke $Pm "grow" (i32.const 2)) (i32.const 1)) +(assert_return (invoke $Pm "grow" (i32.const 0)) (i32.const 3)) +(assert_return (invoke $Pm "grow" (i32.const 1)) (i32.const 3)) +(assert_return (invoke $Pm "grow" (i32.const 1)) (i32.const 4)) +(assert_return (invoke $Pm "grow" (i32.const 0)) (i32.const 5)) +(assert_return (invoke $Pm "grow" (i32.const 1)) (i32.const -1)) +(assert_return (invoke $Pm "grow" (i32.const 0)) (i32.const 5)) + +(assert_unlinkable + (module + (func $host (import "spectest" "print")) + (memory (import "Mm" "mem") 1) + (table (import "Mm" "tab") 0 funcref) ;; does not exist + (data (i32.const 0) "abc") + ) + "unknown import" +) +(assert_return (invoke $Mm "load" (i32.const 0)) (i32.const 0)) + +;; Unlike in v1 spec, active data segments written before an +;; out-of-bounds access persist after the instantiation failure. +(assert_trap + (module + ;; Note: the memory is 5 pages large by the time we get here. + (memory (import "Mm" "mem") 1) + (data (i32.const 0) "abc") + (data (i32.const 327670) "zzzzzzzzzzzzzzzzzz") ;; (partially) out of bounds + ) + "out of bounds memory access" +) +(assert_return (invoke $Mm "load" (i32.const 0)) (i32.const 97)) +(assert_return (invoke $Mm "load" (i32.const 327670)) (i32.const 0)) + +(assert_trap + (module + (memory (import "Mm" "mem") 1) + (data (i32.const 0) "abc") + (table 0 funcref) + (func) + (elem (i32.const 0) 0) ;; out of bounds + ) + "out of bounds table access" +) +(assert_return (invoke $Mm "load" (i32.const 0)) (i32.const 97)) + +;; Store is modified if the start function traps. +(module $Ms + (type $t (func (result i32))) + (memory (export "memory") 1) + (table (export "table") 1 funcref) + (func (export "get memory[0]") (type $t) + (i32.load8_u (i32.const 0)) + ) + (func (export "get table[0]") (type $t) + (call_indirect (type $t) (i32.const 0)) + ) +) +(register "Ms" $Ms) + +(assert_trap + (module + (import "Ms" "memory" (memory 1)) + (import "Ms" "table" (table 1 funcref)) + (data (i32.const 0) "hello") + (elem (i32.const 0) $f) + (func $f (result i32) + (i32.const 0xdead) + ) + (func $main + (unreachable) + ) + (start $main) + ) + "unreachable" +) + +(assert_return (invoke $Ms "get memory[0]") (i32.const 104)) ;; 'h' +(assert_return (invoke $Ms "get table[0]") (i32.const 0xdead)) diff --git a/runtime/near-vm/tests/wast/spec/proposals/gc/ref.wast b/runtime/near-vm/tests/wast/spec/proposals/gc/ref.wast new file mode 100644 index 00000000000..aef1b392ca2 --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/proposals/gc/ref.wast @@ -0,0 +1,80 @@ +;; Syntax + +(module + (type $t (func)) + + (func + (param + funcref + externref + (ref func) + (ref extern) + (ref 0) + (ref $t) + (ref 0) + (ref $t) + (ref null func) + (ref null extern) + (ref null 0) + (ref null $t) + ) + ) +) + + +;; Undefined type index. + +(assert_invalid + (module (type $type-func-param-invalid (func (param (ref 1))))) + "unknown type" +) +(assert_invalid + (module (type $type-func-result-invalid (func (result (ref 1))))) + "unknown type" +) + +(assert_invalid + (module (global $global-invalid (ref null 1) (ref.null 1))) + "unknown type" +) + +(assert_invalid + (module (table $table-invalid 10 (ref null 1))) + "unknown type" +) + +(assert_invalid + (module (elem $elem-invalid (ref 1))) + "unknown type" +) + +(assert_invalid + (module (func $func-param-invalid (param (ref 1)))) + "unknown type" +) +(assert_invalid + (module (func $func-result-invalid (result (ref 1)))) + "unknown type" +) +(assert_invalid + (module (func $func-local-invalid (local (ref null 1)))) + "unknown type" +) + +(assert_invalid + (module (func $block-result-invalid (drop (block (result (ref 1)) (unreachable))))) + "unknown type" +) +(assert_invalid + (module (func $loop-result-invalid (drop (loop (result (ref 1)) (unreachable))))) + "unknown type" +) +(assert_invalid + (module (func $if-invalid (drop (if (result (ref 1)) (then) (else))))) + "unknown type" +) + +(assert_invalid + (module (func $select-result-invalid (drop (select (result (ref 1)) (unreachable))))) + "unknown type" +) diff --git a/runtime/near-vm/tests/wast/spec/proposals/gc/ref_as.wast b/runtime/near-vm/tests/wast/spec/proposals/gc/ref_as.wast new file mode 100644 index 00000000000..47064c328a1 --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/proposals/gc/ref_as.wast @@ -0,0 +1,67 @@ +(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) (i31.new (i32.const 7))) + (table.set (i32.const 2) (struct.new_default $st (rtt.canon $st))) + (table.set (i32.const 3) (array.new_default $at (i32.const 0) (rtt.canon $at))) + (table.set (i32.const 4) (ref.func $f)) + (table.set (i32.const 5) (rtt.canon $ft)) + (table.set (i32.const 6) (local.get $x)) + ) + + (func (export "ref_as_non_null") (param $i i32) + (drop (ref.as_non_null (table.get (local.get $i)))) + ) + (func (export "ref_as_i31") (param $i i32) + (drop (ref.as_i31 (table.get (local.get $i)))) + ) + (func (export "ref_as_data") (param $i i32) + (drop (ref.as_data (table.get (local.get $i)))) + ) + (func (export "ref_as_func") (param $i i32) + (drop (ref.as_func (table.get (local.get $i)))) + ) +) + +(invoke "init" (ref.extern 0)) + +(assert_trap (invoke "ref_as_non_null" (i32.const 0)) "null reference") +(assert_return (invoke "ref_as_non_null" (i32.const 1))) +(assert_return (invoke "ref_as_non_null" (i32.const 2))) +(assert_return (invoke "ref_as_non_null" (i32.const 3))) +(assert_return (invoke "ref_as_non_null" (i32.const 4))) +(assert_return (invoke "ref_as_non_null" (i32.const 5))) +(assert_return (invoke "ref_as_non_null" (i32.const 6))) + +(assert_trap (invoke "ref_as_i31" (i32.const 0)) "cast failure") +(assert_return (invoke "ref_as_i31" (i32.const 1))) +(assert_trap (invoke "ref_as_i31" (i32.const 2)) "cast failure") +(assert_trap (invoke "ref_as_i31" (i32.const 3)) "cast failure") +(assert_trap (invoke "ref_as_i31" (i32.const 4)) "cast failure") +(assert_trap (invoke "ref_as_i31" (i32.const 5)) "cast failure") +(assert_trap (invoke "ref_as_i31" (i32.const 6)) "cast failure") + +(assert_trap (invoke "ref_as_data" (i32.const 0)) "cast failure") +(assert_trap (invoke "ref_as_data" (i32.const 1)) "cast failure") +(assert_return (invoke "ref_as_data" (i32.const 2))) +(assert_return (invoke "ref_as_data" (i32.const 3))) +(assert_trap (invoke "ref_as_data" (i32.const 4)) "cast failure") +(assert_trap (invoke "ref_as_data" (i32.const 5)) "cast failure") +(assert_trap (invoke "ref_as_data" (i32.const 6)) "cast failure") + +(assert_trap (invoke "ref_as_func" (i32.const 0)) "cast failure") +(assert_trap (invoke "ref_as_func" (i32.const 1)) "cast failure") +(assert_trap (invoke "ref_as_func" (i32.const 2)) "cast failure") +(assert_trap (invoke "ref_as_func" (i32.const 3)) "cast failure") +(assert_return (invoke "ref_as_func" (i32.const 4))) +(assert_trap (invoke "ref_as_func" (i32.const 5)) "cast failure") +(assert_trap (invoke "ref_as_func" (i32.const 6)) "cast failure") diff --git a/runtime/near-vm/tests/wast/spec/proposals/gc/ref_as_non_null.wast b/runtime/near-vm/tests/wast/spec/proposals/gc/ref_as_non_null.wast new file mode 100644 index 00000000000..ba5c454701b --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/proposals/gc/ref_as_non_null.wast @@ -0,0 +1,46 @@ +(module + (type $t (func (result i32))) + + (func $nn (param $r (ref $t)) (result i32) + (call_ref (ref.as_non_null (local.get $r))) + ) + (func $n (param $r (ref null $t)) (result i32) + (call_ref (ref.as_non_null (local.get $r))) + ) + + (elem func $f) + (func $f (result i32) (i32.const 7)) + + (func (export "nullable-null") (result i32) (call $n (ref.null $t))) + (func (export "nonnullable-f") (result i32) (call $nn (ref.func $f))) + (func (export "nullable-f") (result i32) (call $n (ref.func $f))) + + (func (export "unreachable") (result i32) + (unreachable) + (ref.as_non_null) + (call $nn) + ) +) + +(assert_trap (invoke "unreachable") "unreachable") + +(assert_trap (invoke "nullable-null") "null reference") +(assert_return (invoke "nonnullable-f") (i32.const 7)) +(assert_return (invoke "nullable-f") (i32.const 7)) + +(assert_invalid + (module + (type $t (func (result i32))) + (func $g (param $r (ref $t)) (drop (ref.as_non_null (local.get $r)))) + (func (call $g (ref.null $t))) + ) + "type mismatch" +) + + +(module + (type $t (func)) + (func (param $r (ref $t)) (drop (ref.as_non_null (local.get $r)))) + (func (param $r (ref func)) (drop (ref.as_non_null (local.get $r)))) + (func (param $r (ref extern)) (drop (ref.as_non_null (local.get $r)))) +) diff --git a/runtime/near-vm/tests/wast/spec/proposals/gc/ref_cast.wast b/runtime/near-vm/tests/wast/spec/proposals/gc/ref_cast.wast new file mode 100644 index 00000000000..9a74a2800e6 --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/proposals/gc/ref_cast.wast @@ -0,0 +1,81 @@ +(module + (type $t0 (struct)) + (type $t1 (struct (field i32))) + (type $t1' (struct (field i32))) + (type $t2 (struct (field i32 i32))) + (type $t2' (struct (field i32 i32))) + (type $t3 (struct (field i32 i32))) + + (global $t0 (rtt $t0) (rtt.canon $t0)) + (global $t0' (rtt $t0) (rtt.canon $t0)) + (global $t1 (rtt $t1) (rtt.sub $t1 (global.get $t0))) + (global $t1' (rtt $t1') (rtt.sub $t1' (global.get $t0))) + (global $t2 (rtt $t2) (rtt.sub $t2 (global.get $t1))) + (global $t2' (rtt $t2') (rtt.sub $t2' (global.get $t1'))) + (global $t3 (rtt $t3) (rtt.sub $t3 (global.get $t0))) + (global $t4 (rtt $t3) (rtt.sub $t3 (rtt.sub $t0 (global.get $t0)))) + + (table 20 dataref) + + (func $init + (table.set (i32.const 0) (struct.new_default $t0 (global.get $t0))) + (table.set (i32.const 10) (struct.new_default $t0 (global.get $t0'))) + (table.set (i32.const 1) (struct.new_default $t1 (global.get $t1))) + (table.set (i32.const 11) (struct.new_default $t1' (global.get $t1'))) + (table.set (i32.const 2) (struct.new_default $t2 (global.get $t2))) + (table.set (i32.const 12) (struct.new_default $t2' (global.get $t2'))) + (table.set (i32.const 3) (struct.new_default $t3 (global.get $t3))) + (table.set (i32.const 4) (struct.new_default $t3 (global.get $t4))) + ) + + (func (export "test-sub") + (call $init) + + (drop (ref.cast (ref.null data) (global.get $t0))) + (drop (ref.cast (table.get (i32.const 0)) (global.get $t0))) + (drop (ref.cast (table.get (i32.const 1)) (global.get $t0))) + (drop (ref.cast (table.get (i32.const 2)) (global.get $t0))) + (drop (ref.cast (table.get (i32.const 3)) (global.get $t0))) + (drop (ref.cast (table.get (i32.const 4)) (global.get $t0))) + + (drop (ref.cast (ref.null data) (global.get $t0))) + (drop (ref.cast (table.get (i32.const 1)) (global.get $t1))) + (drop (ref.cast (table.get (i32.const 2)) (global.get $t1))) + + (drop (ref.cast (ref.null data) (global.get $t0))) + (drop (ref.cast (table.get (i32.const 2)) (global.get $t2))) + + (drop (ref.cast (ref.null data) (global.get $t0))) + (drop (ref.cast (table.get (i32.const 3)) (global.get $t3))) + + (drop (ref.cast (ref.null data) (global.get $t0))) + (drop (ref.cast (table.get (i32.const 4)) (global.get $t4))) + ) + + (func (export "test-canon") + (call $init) + + (drop (ref.cast (table.get (i32.const 0)) (global.get $t0'))) + (drop (ref.cast (table.get (i32.const 1)) (global.get $t0'))) + (drop (ref.cast (table.get (i32.const 2)) (global.get $t0'))) + (drop (ref.cast (table.get (i32.const 3)) (global.get $t0'))) + (drop (ref.cast (table.get (i32.const 4)) (global.get $t0'))) + + (drop (ref.cast (table.get (i32.const 10)) (global.get $t0))) + (drop (ref.cast (table.get (i32.const 11)) (global.get $t0))) + (drop (ref.cast (table.get (i32.const 12)) (global.get $t0))) + + (drop (ref.cast (table.get (i32.const 1)) (global.get $t1'))) + (drop (ref.cast (table.get (i32.const 2)) (global.get $t1'))) + + (drop (ref.cast (table.get (i32.const 11)) (global.get $t1))) + (drop (ref.cast (table.get (i32.const 12)) (global.get $t1))) + + (drop (ref.cast (table.get (i32.const 2)) (global.get $t2'))) + + (drop (ref.cast (table.get (i32.const 12)) (global.get $t2))) + ) +) + +(invoke "test-sub") +(invoke "test-canon") diff --git a/runtime/near-vm/tests/wast/spec/proposals/gc/ref_eq.wast b/runtime/near-vm/tests/wast/spec/proposals/gc/ref_eq.wast new file mode 100644 index 00000000000..5542f264ae4 --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/proposals/gc/ref_eq.wast @@ -0,0 +1,353 @@ +(module + (type $st (struct)) + (type $st' (struct (field i32))) + (type $at (array i8)) + + (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) (i31.new (i32.const 7))) + (table.set (i32.const 3) (i31.new (i32.const 7))) + (table.set (i32.const 4) (i31.new (i32.const 8))) + (table.set (i32.const 5) (struct.new_default $st (rtt.canon $st))) + (table.set (i32.const 6) (struct.new_default $st (rtt.canon $st))) + (table.set (i32.const 7) (array.new_default $at (i32.const 0) (rtt.canon $at))) + (table.set (i32.const 8) (array.new_default $at (i32.const 0) (rtt.canon $at))) + (table.set (i32.const 9) (rtt.canon $st)) + (table.set (i32.const 10) (rtt.canon $st)) + (table.set (i32.const 11) (rtt.canon $at)) + (table.set (i32.const 12) (rtt.sub $st (rtt.canon $st))) + (table.set (i32.const 13) (rtt.sub $st (rtt.canon $st))) + (table.set (i32.const 14) (rtt.sub $st' (rtt.canon $st))) + (table.set (i32.const 15) (rtt.sub $st' (rtt.canon $st))) + ) + + (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 0) (i32.const 9)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 0) (i32.const 10)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 0) (i32.const 11)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 0) (i32.const 12)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 0) (i32.const 13)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 0) (i32.const 14)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 0) (i32.const 15)) (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 1) (i32.const 9)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 1) (i32.const 10)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 1) (i32.const 11)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 1) (i32.const 12)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 1) (i32.const 13)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 1) (i32.const 14)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 1) (i32.const 15)) (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 2) (i32.const 9)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 2) (i32.const 10)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 2) (i32.const 11)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 2) (i32.const 12)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 2) (i32.const 13)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 2) (i32.const 14)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 2) (i32.const 15)) (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 3) (i32.const 9)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 3) (i32.const 10)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 3) (i32.const 11)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 3) (i32.const 12)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 3) (i32.const 13)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 3) (i32.const 14)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 3) (i32.const 15)) (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 4) (i32.const 9)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 4) (i32.const 10)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 4) (i32.const 11)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 4) (i32.const 12)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 4) (i32.const 13)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 4) (i32.const 14)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 4) (i32.const 15)) (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 5) (i32.const 9)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 5) (i32.const 10)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 5) (i32.const 11)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 5) (i32.const 12)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 5) (i32.const 13)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 5) (i32.const 14)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 5) (i32.const 15)) (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 6) (i32.const 9)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 6) (i32.const 10)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 6) (i32.const 11)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 6) (i32.const 12)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 6) (i32.const 13)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 6) (i32.const 14)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 6) (i32.const 15)) (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 7) (i32.const 9)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 7) (i32.const 10)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 7) (i32.const 11)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 7) (i32.const 12)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 7) (i32.const 13)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 7) (i32.const 14)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 7) (i32.const 15)) (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_return (invoke "eq" (i32.const 8) (i32.const 9)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 8) (i32.const 10)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 8) (i32.const 11)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 8) (i32.const 12)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 8) (i32.const 13)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 8) (i32.const 14)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 8) (i32.const 15)) (i32.const 0)) + +(assert_return (invoke "eq" (i32.const 9) (i32.const 0)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 9) (i32.const 1)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 9) (i32.const 2)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 9) (i32.const 3)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 9) (i32.const 4)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 9) (i32.const 5)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 9) (i32.const 6)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 9) (i32.const 7)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 9) (i32.const 8)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 9) (i32.const 9)) (i32.const 1)) +(assert_return (invoke "eq" (i32.const 9) (i32.const 10)) (i32.const 1)) +(assert_return (invoke "eq" (i32.const 9) (i32.const 11)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 9) (i32.const 12)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 9) (i32.const 13)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 9) (i32.const 14)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 9) (i32.const 15)) (i32.const 0)) + +(assert_return (invoke "eq" (i32.const 10) (i32.const 0)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 10) (i32.const 1)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 10) (i32.const 2)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 10) (i32.const 3)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 10) (i32.const 4)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 10) (i32.const 5)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 10) (i32.const 6)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 10) (i32.const 7)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 10) (i32.const 8)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 10) (i32.const 9)) (i32.const 1)) +(assert_return (invoke "eq" (i32.const 10) (i32.const 10)) (i32.const 1)) +(assert_return (invoke "eq" (i32.const 10) (i32.const 11)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 10) (i32.const 12)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 10) (i32.const 13)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 10) (i32.const 14)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 10) (i32.const 15)) (i32.const 0)) + +(assert_return (invoke "eq" (i32.const 11) (i32.const 0)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 11) (i32.const 1)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 11) (i32.const 2)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 11) (i32.const 3)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 11) (i32.const 4)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 11) (i32.const 5)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 11) (i32.const 6)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 11) (i32.const 7)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 11) (i32.const 8)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 11) (i32.const 9)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 11) (i32.const 10)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 11) (i32.const 11)) (i32.const 1)) +(assert_return (invoke "eq" (i32.const 11) (i32.const 12)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 11) (i32.const 13)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 11) (i32.const 14)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 11) (i32.const 15)) (i32.const 0)) + +(assert_return (invoke "eq" (i32.const 12) (i32.const 0)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 12) (i32.const 1)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 12) (i32.const 2)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 12) (i32.const 3)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 12) (i32.const 4)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 12) (i32.const 5)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 12) (i32.const 6)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 12) (i32.const 7)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 12) (i32.const 8)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 12) (i32.const 9)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 12) (i32.const 10)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 12) (i32.const 11)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 12) (i32.const 12)) (i32.const 1)) +(assert_return (invoke "eq" (i32.const 12) (i32.const 13)) (i32.const 1)) +(assert_return (invoke "eq" (i32.const 12) (i32.const 14)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 12) (i32.const 15)) (i32.const 0)) + +(assert_return (invoke "eq" (i32.const 13) (i32.const 0)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 13) (i32.const 1)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 13) (i32.const 2)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 13) (i32.const 3)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 13) (i32.const 4)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 13) (i32.const 5)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 13) (i32.const 6)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 13) (i32.const 7)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 13) (i32.const 8)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 13) (i32.const 9)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 13) (i32.const 10)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 13) (i32.const 11)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 13) (i32.const 12)) (i32.const 1)) +(assert_return (invoke "eq" (i32.const 13) (i32.const 13)) (i32.const 1)) +(assert_return (invoke "eq" (i32.const 13) (i32.const 14)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 13) (i32.const 15)) (i32.const 0)) + +(assert_return (invoke "eq" (i32.const 14) (i32.const 0)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 14) (i32.const 1)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 14) (i32.const 2)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 14) (i32.const 3)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 14) (i32.const 4)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 14) (i32.const 5)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 14) (i32.const 6)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 14) (i32.const 7)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 14) (i32.const 8)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 14) (i32.const 9)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 14) (i32.const 10)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 14) (i32.const 11)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 14) (i32.const 12)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 14) (i32.const 13)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 14) (i32.const 14)) (i32.const 1)) +(assert_return (invoke "eq" (i32.const 14) (i32.const 15)) (i32.const 1)) + +(assert_return (invoke "eq" (i32.const 15) (i32.const 0)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 15) (i32.const 1)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 15) (i32.const 2)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 15) (i32.const 3)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 15) (i32.const 4)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 15) (i32.const 5)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 15) (i32.const 6)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 15) (i32.const 7)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 15) (i32.const 8)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 15) (i32.const 9)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 15) (i32.const 10)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 15) (i32.const 11)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 15) (i32.const 12)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 15) (i32.const 13)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 15) (i32.const 14)) (i32.const 1)) +(assert_return (invoke "eq" (i32.const 15) (i32.const 15)) (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/runtime/near-vm/tests/wast/spec/proposals/gc/ref_is.wast b/runtime/near-vm/tests/wast/spec/proposals/gc/ref_is.wast new file mode 100644 index 00000000000..bfdc728e090 --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/proposals/gc/ref_is.wast @@ -0,0 +1,67 @@ +(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) (i31.new (i32.const 7))) + (table.set (i32.const 2) (struct.new_default $st (rtt.canon $st))) + (table.set (i32.const 3) (array.new_default $at (i32.const 0) (rtt.canon $at))) + (table.set (i32.const 4) (ref.func $f)) + (table.set (i32.const 5) (rtt.canon $ft)) + (table.set (i32.const 6) (local.get $x)) + ) + + (func (export "ref_is_null") (param $i i32) (result i32) + (ref.is_null (table.get (local.get $i))) + ) + (func (export "ref_is_i31") (param $i i32) (result i32) + (ref.is_i31 (table.get (local.get $i))) + ) + (func (export "ref_is_data") (param $i i32) (result i32) + (ref.is_data (table.get (local.get $i))) + ) + (func (export "ref_is_func") (param $i i32) (result i32) + (ref.is_func (table.get (local.get $i))) + ) +) + +(invoke "init" (ref.extern 0)) + +(assert_return (invoke "ref_is_null" (i32.const 0)) (i32.const 1)) +(assert_return (invoke "ref_is_null" (i32.const 1)) (i32.const 0)) +(assert_return (invoke "ref_is_null" (i32.const 2)) (i32.const 0)) +(assert_return (invoke "ref_is_null" (i32.const 3)) (i32.const 0)) +(assert_return (invoke "ref_is_null" (i32.const 4)) (i32.const 0)) +(assert_return (invoke "ref_is_null" (i32.const 5)) (i32.const 0)) +(assert_return (invoke "ref_is_null" (i32.const 6)) (i32.const 0)) + +(assert_return (invoke "ref_is_i31" (i32.const 0)) (i32.const 0)) +(assert_return (invoke "ref_is_i31" (i32.const 1)) (i32.const 1)) +(assert_return (invoke "ref_is_i31" (i32.const 2)) (i32.const 0)) +(assert_return (invoke "ref_is_i31" (i32.const 3)) (i32.const 0)) +(assert_return (invoke "ref_is_i31" (i32.const 4)) (i32.const 0)) +(assert_return (invoke "ref_is_i31" (i32.const 5)) (i32.const 0)) +(assert_return (invoke "ref_is_i31" (i32.const 6)) (i32.const 0)) + +(assert_return (invoke "ref_is_data" (i32.const 0)) (i32.const 0)) +(assert_return (invoke "ref_is_data" (i32.const 1)) (i32.const 0)) +(assert_return (invoke "ref_is_data" (i32.const 2)) (i32.const 1)) +(assert_return (invoke "ref_is_data" (i32.const 3)) (i32.const 1)) +(assert_return (invoke "ref_is_data" (i32.const 4)) (i32.const 0)) +(assert_return (invoke "ref_is_data" (i32.const 5)) (i32.const 0)) +(assert_return (invoke "ref_is_data" (i32.const 6)) (i32.const 0)) + +(assert_return (invoke "ref_is_func" (i32.const 0)) (i32.const 0)) +(assert_return (invoke "ref_is_func" (i32.const 1)) (i32.const 0)) +(assert_return (invoke "ref_is_func" (i32.const 2)) (i32.const 0)) +(assert_return (invoke "ref_is_func" (i32.const 3)) (i32.const 0)) +(assert_return (invoke "ref_is_func" (i32.const 4)) (i32.const 1)) +(assert_return (invoke "ref_is_func" (i32.const 5)) (i32.const 0)) +(assert_return (invoke "ref_is_func" (i32.const 6)) (i32.const 0)) diff --git a/runtime/near-vm/tests/wast/spec/proposals/gc/ref_is_null.wast b/runtime/near-vm/tests/wast/spec/proposals/gc/ref_is_null.wast new file mode 100644 index 00000000000..730170df459 --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/proposals/gc/ref_is_null.wast @@ -0,0 +1,85 @@ +(module + (type $t (func)) + (func $dummy) + + (func $f1 (export "funcref") (param $x funcref) (result i32) + (ref.is_null (local.get $x)) + ) + (func $f2 (export "externref") (param $x externref) (result i32) + (ref.is_null (local.get $x)) + ) + (func $f3 (param $x (ref null $t)) (result i32) + (ref.is_null (local.get $x)) + ) + (func $f3' (export "ref-null") (result i32) + (call $f3 (ref.null $t)) + ) + + (table $t1 2 funcref) + (table $t2 2 externref) + (table $t3 2 (ref null $t)) + (elem (table $t1) (i32.const 1) func $dummy) + (elem (table $t3) (i32.const 1) (ref $t) (ref.func $dummy)) + + (func (export "init") (param $r externref) + (table.set $t2 (i32.const 1) (local.get $r)) + ) + (func (export "deinit") + (table.set $t1 (i32.const 1) (ref.null func)) + (table.set $t2 (i32.const 1) (ref.null extern)) + (table.set $t3 (i32.const 1) (ref.null $t)) + ) + + (func (export "funcref-elem") (param $x i32) (result i32) + (call $f1 (table.get $t1 (local.get $x))) + ) + (func (export "externref-elem") (param $x i32) (result i32) + (call $f2 (table.get $t2 (local.get $x))) + ) + (func (export "ref-elem") (param $x i32) (result i32) + (call $f3 (table.get $t3 (local.get $x))) + ) +) + +(assert_return (invoke "funcref" (ref.null func)) (i32.const 1)) +(assert_return (invoke "externref" (ref.null extern)) (i32.const 1)) +(assert_return (invoke "ref-null") (i32.const 1)) + +(assert_return (invoke "externref" (ref.extern 1)) (i32.const 0)) + +(invoke "init" (ref.extern 0)) + +(assert_return (invoke "funcref-elem" (i32.const 0)) (i32.const 1)) +(assert_return (invoke "externref-elem" (i32.const 0)) (i32.const 1)) +(assert_return (invoke "ref-elem" (i32.const 0)) (i32.const 1)) + +(assert_return (invoke "funcref-elem" (i32.const 1)) (i32.const 0)) +(assert_return (invoke "externref-elem" (i32.const 1)) (i32.const 0)) +(assert_return (invoke "ref-elem" (i32.const 1)) (i32.const 0)) + +(invoke "deinit") + +(assert_return (invoke "funcref-elem" (i32.const 0)) (i32.const 1)) +(assert_return (invoke "externref-elem" (i32.const 0)) (i32.const 1)) +(assert_return (invoke "ref-elem" (i32.const 0)) (i32.const 1)) + +(assert_return (invoke "funcref-elem" (i32.const 1)) (i32.const 1)) +(assert_return (invoke "externref-elem" (i32.const 1)) (i32.const 1)) +(assert_return (invoke "ref-elem" (i32.const 1)) (i32.const 1)) + + +(module + (type $t (func)) + (func (param $r (ref $t)) (drop (ref.is_null (local.get $r)))) + (func (param $r (ref func)) (drop (ref.is_null (local.get $r)))) + (func (param $r (ref extern)) (drop (ref.is_null (local.get $r)))) +) + +(assert_invalid + (module (func $ref-vs-num (param i32) (ref.is_null (local.get 0)))) + "type mismatch" +) +(assert_invalid + (module (func $ref-vs-empty (ref.is_null))) + "type mismatch" +) diff --git a/runtime/near-vm/tests/wast/spec/proposals/gc/ref_null.wast b/runtime/near-vm/tests/wast/spec/proposals/gc/ref_null.wast new file mode 100644 index 00000000000..ab3a8b4ea06 --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/proposals/gc/ref_null.wast @@ -0,0 +1,14 @@ +(module + (type $t (func)) + (func (export "externref") (result externref) (ref.null extern)) + (func (export "funcref") (result funcref) (ref.null func)) + (func (export "ref") (result (ref null $t)) (ref.null $t)) + + (global externref (ref.null extern)) + (global funcref (ref.null func)) + (global (ref null $t) (ref.null $t)) +) + +(assert_return (invoke "externref") (ref.null extern)) +(assert_return (invoke "funcref") (ref.null func)) +(assert_return (invoke "ref") (ref.null)) diff --git a/runtime/near-vm/tests/wast/spec/proposals/gc/ref_test.wast b/runtime/near-vm/tests/wast/spec/proposals/gc/ref_test.wast new file mode 100644 index 00000000000..70129395751 --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/proposals/gc/ref_test.wast @@ -0,0 +1,111 @@ +(module + (type $t0 (struct)) + (type $t1 (struct (field i32))) + (type $t1' (struct (field i32))) + (type $t2 (struct (field i32 i32))) + (type $t2' (struct (field i32 i32))) + (type $t3 (struct (field i32 i32))) + + (global $t0 (rtt $t0) (rtt.canon $t0)) + (global $t0' (rtt $t0) (rtt.canon $t0)) + (global $t1 (rtt $t1) (rtt.sub $t1 (global.get $t0))) + (global $t1' (rtt $t1') (rtt.sub $t1' (global.get $t0))) + (global $t2 (rtt $t2) (rtt.sub $t2 (global.get $t1))) + (global $t2' (rtt $t2') (rtt.sub $t2' (global.get $t1'))) + (global $t3 (rtt $t3) (rtt.sub $t3 (global.get $t0))) + (global $t4 (rtt $t3) (rtt.sub $t3 (rtt.sub $t0 (global.get $t0)))) + + (table 20 dataref) + + (func $init + (table.set (i32.const 0) (struct.new_default $t0 (global.get $t0))) + (table.set (i32.const 10) (struct.new_default $t0 (global.get $t0'))) + (table.set (i32.const 1) (struct.new_default $t1 (global.get $t1))) + (table.set (i32.const 11) (struct.new_default $t1' (global.get $t1'))) + (table.set (i32.const 2) (struct.new_default $t2 (global.get $t2))) + (table.set (i32.const 12) (struct.new_default $t2' (global.get $t2'))) + (table.set (i32.const 3) (struct.new_default $t3 (global.get $t3))) + (table.set (i32.const 4) (struct.new_default $t3 (global.get $t4))) + ) + + (func (export "test-sub") + (call $init) + (block $l + ;; must hold + (br_if $l (i32.eqz (ref.test (table.get (i32.const 0)) (global.get $t0)))) + (br_if $l (i32.eqz (ref.test (table.get (i32.const 1)) (global.get $t0)))) + (br_if $l (i32.eqz (ref.test (table.get (i32.const 2)) (global.get $t0)))) + (br_if $l (i32.eqz (ref.test (table.get (i32.const 3)) (global.get $t0)))) + (br_if $l (i32.eqz (ref.test (table.get (i32.const 4)) (global.get $t0)))) + + (br_if $l (i32.eqz (ref.test (table.get (i32.const 1)) (global.get $t1)))) + (br_if $l (i32.eqz (ref.test (table.get (i32.const 2)) (global.get $t1)))) + + (br_if $l (i32.eqz (ref.test (table.get (i32.const 2)) (global.get $t2)))) + + (br_if $l (i32.eqz (ref.test (table.get (i32.const 3)) (global.get $t3)))) + + (br_if $l (i32.eqz (ref.test (table.get (i32.const 4)) (global.get $t4)))) + + ;; must not hold + (br_if $l (ref.test (ref.null data) (global.get $t0))) + (br_if $l (ref.test (ref.null data) (global.get $t1))) + (br_if $l (ref.test (ref.null data) (global.get $t2))) + (br_if $l (ref.test (ref.null data) (global.get $t3))) + (br_if $l (ref.test (ref.null data) (global.get $t4))) + + (br_if $l (ref.test (table.get (i32.const 0)) (global.get $t1))) + (br_if $l (ref.test (table.get (i32.const 3)) (global.get $t1))) + (br_if $l (ref.test (table.get (i32.const 4)) (global.get $t1))) + + (br_if $l (ref.test (table.get (i32.const 0)) (global.get $t2))) + (br_if $l (ref.test (table.get (i32.const 1)) (global.get $t2))) + (br_if $l (ref.test (table.get (i32.const 3)) (global.get $t2))) + (br_if $l (ref.test (table.get (i32.const 4)) (global.get $t2))) + + (br_if $l (ref.test (table.get (i32.const 0)) (global.get $t3))) + (br_if $l (ref.test (table.get (i32.const 1)) (global.get $t3))) + (br_if $l (ref.test (table.get (i32.const 2)) (global.get $t3))) + (br_if $l (ref.test (table.get (i32.const 4)) (global.get $t3))) + + (br_if $l (ref.test (table.get (i32.const 0)) (global.get $t4))) + (br_if $l (ref.test (table.get (i32.const 1)) (global.get $t4))) + (br_if $l (ref.test (table.get (i32.const 2)) (global.get $t4))) + (br_if $l (ref.test (table.get (i32.const 3)) (global.get $t4))) + + (return) + ) + (unreachable) + ) + + (func (export "test-canon") + (call $init) + (block $l + (br_if $l (i32.eqz (ref.test (table.get (i32.const 0)) (global.get $t0')))) + (br_if $l (i32.eqz (ref.test (table.get (i32.const 1)) (global.get $t0')))) + (br_if $l (i32.eqz (ref.test (table.get (i32.const 2)) (global.get $t0')))) + (br_if $l (i32.eqz (ref.test (table.get (i32.const 3)) (global.get $t0')))) + (br_if $l (i32.eqz (ref.test (table.get (i32.const 4)) (global.get $t0')))) + + (br_if $l (i32.eqz (ref.test (table.get (i32.const 10)) (global.get $t0)))) + (br_if $l (i32.eqz (ref.test (table.get (i32.const 11)) (global.get $t0)))) + (br_if $l (i32.eqz (ref.test (table.get (i32.const 12)) (global.get $t0)))) + + (br_if $l (i32.eqz (ref.test (table.get (i32.const 1)) (global.get $t1')))) + (br_if $l (i32.eqz (ref.test (table.get (i32.const 2)) (global.get $t1')))) + + (br_if $l (i32.eqz (ref.test (table.get (i32.const 11)) (global.get $t1)))) + (br_if $l (i32.eqz (ref.test (table.get (i32.const 12)) (global.get $t1)))) + + (br_if $l (i32.eqz (ref.test (table.get (i32.const 2)) (global.get $t2')))) + + (br_if $l (i32.eqz (ref.test (table.get (i32.const 12)) (global.get $t2)))) + + (return) + ) + (unreachable) + ) +) + +(invoke "test-sub") +(invoke "test-canon") diff --git a/runtime/near-vm/tests/wast/spec/proposals/gc/return_call_ref.wast b/runtime/near-vm/tests/wast/spec/proposals/gc/return_call_ref.wast new file mode 100644 index 00000000000..8e7aac82111 --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/proposals/gc/return_call_ref.wast @@ -0,0 +1,360 @@ +;; 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 (global.get $const-i32)) + ) + (func (export "type-i64") (result i64) + (return_call_ref (global.get $const-i64)) + ) + (func (export "type-f32") (result f32) + (return_call_ref (global.get $const-f32)) + ) + (func (export "type-f64") (result f64) + (return_call_ref (global.get $const-f64)) + ) + + (func (export "type-first-i32") (result i32) + (return_call_ref (i32.const 32) (global.get $id-i32)) + ) + (func (export "type-first-i64") (result i64) + (return_call_ref (i64.const 64) (global.get $id-i64)) + ) + (func (export "type-first-f32") (result f32) + (return_call_ref (f32.const 1.32) (global.get $id-f32)) + ) + (func (export "type-first-f64") (result f64) + (return_call_ref (f64.const 1.64) (global.get $id-f64)) + ) + + (func (export "type-second-i32") (result i32) + (return_call_ref (f32.const 32.1) (i32.const 32) (global.get $f32-i32)) + ) + (func (export "type-second-i64") (result i64) + (return_call_ref (i32.const 32) (i64.const 64) (global.get $i32-i64)) + ) + (func (export "type-second-f32") (result f32) + (return_call_ref (f64.const 64) (f32.const 32) (global.get $f64-f32)) + ) + (func (export "type-second-f64") (result f64) + (return_call_ref (i64.const 64) (f64.const 64.1) (global.get $i64-f64)) + ) + + ;; Null + + (func (export "null") + (return_call_ref (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 + (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.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.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.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 1_000_000)) (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 1_000_000)) (i64.const 44)) +(assert_return (invoke "even" (i64.const 1_000_001)) (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 1_000_000)) (i64.const 99)) +(assert_return (invoke "odd" (i64.const 999_999)) (i64.const 44)) + + +;; More typing + +(module + (type $t (func)) + (elem declare func $f11 $f22 $f33 $f44) + (func $f11 (result (ref $t)) (return_call_ref (ref.func $f11))) + (func $f21 (result (ref null $t)) (return_call_ref (ref.func $f11))) + (func $f22 (result (ref null $t)) (return_call_ref (ref.func $f22))) + (func $f31 (result (ref func)) (return_call_ref (ref.func $f11))) + (func $f33 (result (ref func)) (return_call_ref (ref.func $f33))) + (func $f41 (result (ref null func)) (return_call_ref (ref.func $f11))) + (func $f42 (result (ref null func)) (return_call_ref (ref.func $f22))) + (func $f43 (result (ref null func)) (return_call_ref (ref.func $f33))) + (func $f44 (result (ref null func)) (return_call_ref (ref.func $f44))) +) + +(assert_invalid + (module + (type $t (func)) + (elem declare func $f22) + (func $f12 (result (ref $t)) (return_call_ref (ref.func $f22))) + (func $f22 (result (ref null $t)) (return_call_ref (ref.func $f22))) + ) + "type mismatch" +) + +(assert_invalid + (module + (type $t (func)) + (elem declare func $f33) + (func $f13 (result (ref $t)) (return_call_ref (ref.func $f33))) + (func $f33 (result (ref func)) (return_call_ref (ref.func $f33))) + ) + "type mismatch" +) + +(assert_invalid + (module + (type $t (func)) + (elem declare func $f44) + (func $f14 (result (ref $t)) (return_call_ref (ref.func $f44))) + (func $f44 (result (ref null func)) (return_call_ref (ref.func $f44))) + ) + "type mismatch" +) + +(assert_invalid + (module + (type $t (func)) + (elem declare func $f33) + (func $f23 (result (ref null $t)) (return_call_ref (ref.func $f33))) + (func $f33 (result (ref func)) (return_call_ref (ref.func $f33))) + ) + "type mismatch" +) + +(assert_invalid + (module + (type $t (func)) + (elem declare func $f44) + (func $f24 (result (ref null $t)) (return_call_ref (ref.func $f44))) + (func $f44 (result (ref null func)) (return_call_ref (ref.func $f44))) + ) + "type mismatch" +) + +(assert_invalid + (module + (elem declare func $f44) + (func $f34 (result (ref func)) (return_call_ref (ref.func $f44))) + (func $f44 (result (ref null func)) (return_call_ref (ref.func $f44))) + ) + "type mismatch" +) + + +;; Unreachable typing. + +(module + (func (export "unreachable") (result i32) + (unreachable) + (return_call_ref) + ) +) +(assert_trap (invoke "unreachable") "unreachable") + +(module + (elem declare func $f) + (func $f (param i32) (result i32) (local.get 0)) + + (func (export "unreachable") (result i32) + (unreachable) + (ref.func $f) + (return_call_ref) + ) +) +(assert_trap (invoke "unreachable") "unreachable") + +(module + (elem declare func $f) + (func $f (param i32) (result i32) (local.get 0)) + + (func (export "unreachable") (result i32) + (unreachable) + (i32.const 0) + (ref.func $f) + (return_call_ref) + (i32.const 0) + ) +) +(assert_trap (invoke "unreachable") "unreachable") + +(assert_invalid + (module + (elem declare func $f) + (func $f (param i32) (result i32) (local.get 0)) + + (func (export "unreachable") (result i32) + (unreachable) + (i64.const 0) + (ref.func $f) + (return_call_ref) + ) + ) + "type mismatch" +) + +(assert_invalid + (module + (elem declare func $f) + (func $f (param i32) (result i32) (local.get 0)) + + (func (export "unreachable") (result i32) + (unreachable) + (ref.func $f) + (return_call_ref) + (i64.const 0) + ) + ) + "type mismatch" +) + +(assert_invalid + (module + (func $f (param $r externref) + (return_call_ref (local.get $r)) + ) + ) + "type mismatch" +) diff --git a/runtime/near-vm/tests/wast/spec/proposals/gc/select.wast b/runtime/near-vm/tests/wast/spec/proposals/gc/select.wast new file mode 100644 index 00000000000..e8130ba9b89 --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/proposals/gc/select.wast @@ -0,0 +1,625 @@ +(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))) + ) + ) + + (func (export "unreachable-num") + (unreachable) + (select) + (i32.eqz) + (drop) + ) + (func (export "unreachable-ref") + (unreachable) + (select) + (ref.is_null) + (drop) + ) +) + +(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)) + +(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" +) + +(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" +) + +;; Validation after unreachable + +;; The first two operands should have the same type as each other +(assert_invalid + (module (func (unreachable) (select (i32.const 1) (i64.const 1) (i32.const 1)) (drop))) + "type mismatch" +) + +(assert_invalid + (module (func (unreachable) (select (i64.const 1) (i32.const 1) (i32.const 1)) (drop))) + "type mismatch" +) + +;; Third operand must be i32 +(assert_invalid + (module (func (unreachable) (select (i32.const 1) (i32.const 1) (i64.const 1)) (drop))) + "type mismatch" +) + +(assert_invalid + (module (func (unreachable) (select (i32.const 1) (i64.const 1)) (drop))) + "type mismatch" +) + +(assert_invalid + (module (func (unreachable) (select (i64.const 1)) (drop))) + "type mismatch" +) + +;; Result of select has type of first two operands (type of second operand when first one is omitted) +(assert_invalid + (module (func (result i32) (unreachable) (select (i64.const 1) (i32.const 1)))) + "type mismatch" +) + +;; select always has non-empty result +(assert_invalid + (module (func (unreachable) (select))) + "type mismatch" +) + diff --git a/runtime/near-vm/tests/wast/spec/proposals/gc/struct.wast b/runtime/near-vm/tests/wast/spec/proposals/gc/struct.wast new file mode 100644 index 00000000000..50a0e1d5cfc --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/proposals/gc/struct.wast @@ -0,0 +1,127 @@ +;; 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" +) +(assert_malformed + (module quote + "(type (struct (field $x i32)))" + "(type (struct (field $x i32)))" + ) + "duplicate field" +) + + +;; Binding structure + +(module + (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" +) + + +;; Basic instructions + +(module + (type $vec (struct (field f32) (field $y (mut f32)) (field $z f32))) + + (func $get_0 (param $v (ref $vec)) (result f32) + (struct.get $vec 0 (local.get $v)) + ) + (func (export "get_0") (result f32) + (call $get_0 (struct.new_default $vec (rtt.canon $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 (rtt.canon $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 (rtt.canon $vec)) (local.get $y)) + ) +) + +(assert_return (invoke "get_0") (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") + +(assert_invalid + (module + (type $t (struct (field i32 (mut i32)))) + (func (export "struct.new-null") + (local (ref null (rtt $t))) (drop (struct.new $t (i32.const 1) (i32.const 2) (local.get 0))) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (type $t (struct (field i32 (mut i32)))) + (func (export "struct.new_default-null") + (local (ref null (rtt $t))) (drop (struct.new_default $t (local.get 0))) + ) + ) + "type mismatch" +) diff --git a/runtime/near-vm/tests/wast/spec/proposals/gc/table-sub.wast b/runtime/near-vm/tests/wast/spec/proposals/gc/table-sub.wast new file mode 100644 index 00000000000..c3a7440cec7 --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/proposals/gc/table-sub.wast @@ -0,0 +1,32 @@ +(module + (type $t (func)) + (table $t1 10 (ref null func)) + (table $t2 10 (ref null $t)) + (elem $el funcref) + (func $f + (table.init $t1 $el (i32.const 0) (i32.const 1) (i32.const 2)) + (table.copy $t1 $t2 (i32.const 0) (i32.const 1) (i32.const 2)) + ) +) + +(assert_invalid + (module + (table $t1 10 funcref) + (table $t2 10 externref) + (func $f + (table.copy $t1 $t2 (i32.const 0) (i32.const 1) (i32.const 2)) + ) + ) + "type mismatch" +) + +(assert_invalid + (module + (table $t 10 funcref) + (elem $el externref) + (func $f + (table.init $t $el (i32.const 0) (i32.const 1) (i32.const 2)) + ) + ) + "type mismatch" +) diff --git a/runtime/near-vm/tests/wast/spec/proposals/gc/table.wast b/runtime/near-vm/tests/wast/spec/proposals/gc/table.wast new file mode 100644 index 00000000000..532c13d09ac --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/proposals/gc/table.wast @@ -0,0 +1,70 @@ +;; Test table section structure + +(module (table 0 funcref)) +(module (table 1 funcref)) +(module (table 0 0 funcref)) +(module (table 0 1 funcref)) +(module (table 1 256 funcref)) +(module (table 0 65536 funcref)) +(module (table 0 0xffff_ffff funcref)) + +(module (table 1 (ref null func))) +(module (table 1 (ref null extern))) +(module (table 1 (ref null $t)) (type $t (func))) + +(module (table 0 funcref) (table 0 funcref)) +(module (table (import "spectest" "table") 0 funcref) (table 0 funcref)) + +(assert_invalid (module (elem (i32.const 0))) "unknown table") +(assert_invalid (module (elem (i32.const 0) $f) (func $f)) "unknown table") + + +(assert_invalid + (module (table 1 0 funcref)) + "size minimum must not be greater than maximum" +) +(assert_invalid + (module (table 0xffff_ffff 0 funcref)) + "size minimum must not be greater than maximum" +) + +(assert_malformed + (module quote "(table 0x1_0000_0000 funcref)") + "i32 constant out of range" +) +(assert_malformed + (module quote "(table 0x1_0000_0000 0x1_0000_0000 funcref)") + "i32 constant out of range" +) +(assert_malformed + (module quote "(table 0 0x1_0000_0000 funcref)") + "i32 constant out of range" +) + +(assert_invalid + (module (table 0 (ref func))) + "non-defaultable element type" +) +(assert_invalid + (module (table 0 (ref extern))) + "non-defaultable element type" +) +(assert_invalid + (module (type $t (func)) (table 0 (ref $t))) + "non-defaultable element type" +) + +;; Duplicate table identifiers + +(assert_malformed (module quote + "(table $foo 1 funcref)" + "(table $foo 1 funcref)") + "duplicate table") +(assert_malformed (module quote + "(import \"\" \"\" (table $foo 1 funcref))" + "(table $foo 1 funcref)") + "duplicate table") +(assert_malformed (module quote + "(import \"\" \"\" (table $foo 1 funcref))" + "(import \"\" \"\" (table $foo 1 funcref))") + "duplicate table") diff --git a/runtime/near-vm/tests/wast/spec/proposals/gc/type-equivalence.wast b/runtime/near-vm/tests/wast/spec/proposals/gc/type-equivalence.wast new file mode 100644 index 00000000000..e43871a3666 --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/proposals/gc/type-equivalence.wast @@ -0,0 +1,447 @@ +;; Syntactic types (validation time) + +;; Simple types. + +(module + (type $t1 (func (param f32 f32) (result f32))) + (type $t2 (func (param $x f32) (param $y f32) (result f32))) + + (func $f1 (param $r (ref $t1)) (call $f2 (local.get $r))) + (func $f2 (param $r (ref $t2)) (call $f1 (local.get $r))) +) + + +;; Indirect types. + +(module + (type $s0 (func (param i32) (result f32))) + (type $s1 (func (param i32 (ref $s0)) (result (ref $s0)))) + (type $s2 (func (param i32 (ref $s0)) (result (ref $s0)))) + (type $t1 (func (param (ref $s1)) (result (ref $s2)))) + (type $t2 (func (param (ref $s2)) (result (ref $s1)))) + + (func $f1 (param $r (ref $t1)) (call $f2 (local.get $r))) + (func $f2 (param $r (ref $t2)) (call $f1 (local.get $r))) +) + + +;; Recursive types. + +(module + (type $t1 (func (param i32 (ref $t1)))) + (type $t2 (func (param i32 (ref $t2)))) + + (func $f1 (param $r (ref $t1)) (call $f2 (local.get $r))) + (func $f2 (param $r (ref $t2)) (call $f1 (local.get $r))) +) + + +;; Isomorphic recursive types. + +(module + (type $t1 (func (param i32 (ref $t1)))) + (type $t2 (func (param i32 (ref $t3)))) + (type $t3 (func (param i32 (ref $t2)))) + + (func $f1 (param $r (ref $t1)) + (call $f2 (local.get $r)) + (call $f3 (local.get $r)) + ) + (func $f2 (param $r (ref $t2)) + (call $f1 (local.get $r)) + (call $f3 (local.get $r)) + ) + (func $f3 (param $r (ref $t3)) + (call $f1 (local.get $r)) + (call $f2 (local.get $r)) + ) +) + +(module + (type $t1 (func (param i32 (ref $t3)))) + (type $t2 (func (param i32 (ref $t1)))) + (type $t3 (func (param i32 (ref $t2)))) + + (func $f1 (param $r (ref $t1)) + (call $f2 (local.get $r)) + (call $f3 (local.get $r)) + ) + (func $f2 (param $r (ref $t2)) + (call $f1 (local.get $r)) + (call $f3 (local.get $r)) + ) + (func $f3 (param $r (ref $t3)) + (call $f1 (local.get $r)) + (call $f2 (local.get $r)) + ) +) + +(module + (type $t1 (func (param i32 (ref $u1)))) + (type $u1 (func (param f32 (ref $t1)))) + + (type $t2 (func (param i32 (ref $u3)))) + (type $u2 (func (param f32 (ref $t3)))) + (type $t3 (func (param i32 (ref $u2)))) + (type $u3 (func (param f32 (ref $t2)))) + + (func $f1 (param $r (ref $t1)) + (call $f2 (local.get $r)) + (call $f3 (local.get $r)) + ) + (func $f2 (param $r (ref $t2)) + (call $f1 (local.get $r)) + (call $f3 (local.get $r)) + ) + (func $f3 (param $r (ref $t3)) + (call $f1 (local.get $r)) + (call $f2 (local.get $r)) + ) +) + + +;; Semantic types (run time) + +;; Simple types. + +(module + (type $t1 (func (param f32 f32))) + (type $t2 (func (param $x f32) (param $y f32))) + + (func $f1 (type $t1)) + (func $f2 (type $t2)) + (table funcref (elem $f1 $f2)) + + (func (export "run") + (call_indirect (type $t1) (f32.const 1) (f32.const 2) (i32.const 1)) + (call_indirect (type $t2) (f32.const 1) (f32.const 2) (i32.const 0)) + ) +) +(assert_return (invoke "run")) + + +;; Indirect types. + +(module + (type $s0 (func (param i32))) + (type $s1 (func (param i32 (ref $s0)))) + (type $s2 (func (param i32 (ref $s0)))) + (type $t1 (func (param (ref $s1)))) + (type $t2 (func (param (ref $s2)))) + + (func $s1 (type $s1)) + (func $s2 (type $s2)) + (func $f1 (type $t1)) + (func $f2 (type $t2)) + (table funcref (elem $f1 $f2 $s1 $s2)) + + (func (export "run") + (call_indirect (type $t1) (ref.func $s1) (i32.const 0)) + (call_indirect (type $t1) (ref.func $s1) (i32.const 1)) + (call_indirect (type $t1) (ref.func $s2) (i32.const 0)) + (call_indirect (type $t1) (ref.func $s2) (i32.const 1)) + (call_indirect (type $t2) (ref.func $s1) (i32.const 0)) + (call_indirect (type $t2) (ref.func $s1) (i32.const 1)) + (call_indirect (type $t2) (ref.func $s2) (i32.const 0)) + (call_indirect (type $t2) (ref.func $s2) (i32.const 1)) + ) +) +(assert_return (invoke "run")) + + +;; Recursive types. + +(module + (type $t1 (func (param i32 (ref $t1)))) + (type $t2 (func (param i32 (ref $t2)))) + + (func $f1 (type $t1)) + (func $f2 (type $t2)) + (table funcref (elem $f1 $f2)) + + (func (export "run") + (call_indirect (type $t1) (i32.const 1) (ref.func $f1) (i32.const 0)) + (call_indirect (type $t1) (i32.const 1) (ref.func $f1) (i32.const 1)) + (call_indirect (type $t1) (i32.const 1) (ref.func $f2) (i32.const 0)) + (call_indirect (type $t1) (i32.const 1) (ref.func $f2) (i32.const 1)) + (call_indirect (type $t2) (i32.const 1) (ref.func $f1) (i32.const 0)) + (call_indirect (type $t2) (i32.const 1) (ref.func $f1) (i32.const 1)) + (call_indirect (type $t2) (i32.const 1) (ref.func $f2) (i32.const 0)) + (call_indirect (type $t2) (i32.const 1) (ref.func $f2) (i32.const 1)) + ) +) +(assert_return (invoke "run")) + + +;; Isomorphic recursive types. + +(module + (type $t1 (func (param i32 (ref $t1)))) + (type $t2 (func (param i32 (ref $t3)))) + (type $t3 (func (param i32 (ref $t2)))) + + (func $f1 (type $t1)) + (func $f2 (type $t2)) + (func $f3 (type $t3)) + (table funcref (elem $f1 $f2 $f3)) + + (func (export "run") + (call_indirect (type $t1) (i32.const 1) (ref.func $f1) (i32.const 0)) + (call_indirect (type $t1) (i32.const 1) (ref.func $f1) (i32.const 1)) + (call_indirect (type $t1) (i32.const 1) (ref.func $f1) (i32.const 2)) + (call_indirect (type $t1) (i32.const 1) (ref.func $f2) (i32.const 0)) + (call_indirect (type $t1) (i32.const 1) (ref.func $f2) (i32.const 1)) + (call_indirect (type $t1) (i32.const 1) (ref.func $f2) (i32.const 2)) + (call_indirect (type $t1) (i32.const 1) (ref.func $f3) (i32.const 0)) + (call_indirect (type $t1) (i32.const 1) (ref.func $f3) (i32.const 1)) + (call_indirect (type $t1) (i32.const 1) (ref.func $f3) (i32.const 2)) + (call_indirect (type $t2) (i32.const 1) (ref.func $f1) (i32.const 0)) + (call_indirect (type $t2) (i32.const 1) (ref.func $f1) (i32.const 1)) + (call_indirect (type $t2) (i32.const 1) (ref.func $f1) (i32.const 2)) + (call_indirect (type $t2) (i32.const 1) (ref.func $f2) (i32.const 0)) + (call_indirect (type $t2) (i32.const 1) (ref.func $f2) (i32.const 1)) + (call_indirect (type $t2) (i32.const 1) (ref.func $f2) (i32.const 2)) + (call_indirect (type $t2) (i32.const 1) (ref.func $f3) (i32.const 0)) + (call_indirect (type $t2) (i32.const 1) (ref.func $f3) (i32.const 1)) + (call_indirect (type $t2) (i32.const 1) (ref.func $f3) (i32.const 2)) + (call_indirect (type $t3) (i32.const 1) (ref.func $f1) (i32.const 0)) + (call_indirect (type $t3) (i32.const 1) (ref.func $f1) (i32.const 1)) + (call_indirect (type $t3) (i32.const 1) (ref.func $f1) (i32.const 2)) + (call_indirect (type $t3) (i32.const 1) (ref.func $f2) (i32.const 0)) + (call_indirect (type $t3) (i32.const 1) (ref.func $f2) (i32.const 1)) + (call_indirect (type $t3) (i32.const 1) (ref.func $f2) (i32.const 2)) + (call_indirect (type $t3) (i32.const 1) (ref.func $f3) (i32.const 0)) + (call_indirect (type $t3) (i32.const 1) (ref.func $f3) (i32.const 1)) + (call_indirect (type $t3) (i32.const 1) (ref.func $f3) (i32.const 2)) + ) +) +(assert_return (invoke "run")) + +(module + (type $t1 (func (param i32 (ref $t3)))) + (type $t2 (func (param i32 (ref $t1)))) + (type $t3 (func (param i32 (ref $t2)))) + + (func $f1 (type $t1)) + (func $f2 (type $t2)) + (func $f3 (type $t3)) + (table funcref (elem $f1 $f2 $f3)) + + (func (export "run") + (call_indirect (type $t1) (i32.const 1) (ref.func $f1) (i32.const 0)) + (call_indirect (type $t1) (i32.const 1) (ref.func $f1) (i32.const 1)) + (call_indirect (type $t1) (i32.const 1) (ref.func $f1) (i32.const 2)) + (call_indirect (type $t1) (i32.const 1) (ref.func $f2) (i32.const 0)) + (call_indirect (type $t1) (i32.const 1) (ref.func $f2) (i32.const 1)) + (call_indirect (type $t1) (i32.const 1) (ref.func $f2) (i32.const 2)) + (call_indirect (type $t1) (i32.const 1) (ref.func $f3) (i32.const 0)) + (call_indirect (type $t1) (i32.const 1) (ref.func $f3) (i32.const 1)) + (call_indirect (type $t1) (i32.const 1) (ref.func $f3) (i32.const 2)) + (call_indirect (type $t2) (i32.const 1) (ref.func $f1) (i32.const 0)) + (call_indirect (type $t2) (i32.const 1) (ref.func $f1) (i32.const 1)) + (call_indirect (type $t2) (i32.const 1) (ref.func $f1) (i32.const 2)) + (call_indirect (type $t2) (i32.const 1) (ref.func $f2) (i32.const 0)) + (call_indirect (type $t2) (i32.const 1) (ref.func $f2) (i32.const 1)) + (call_indirect (type $t2) (i32.const 1) (ref.func $f2) (i32.const 2)) + (call_indirect (type $t2) (i32.const 1) (ref.func $f3) (i32.const 0)) + (call_indirect (type $t2) (i32.const 1) (ref.func $f3) (i32.const 1)) + (call_indirect (type $t2) (i32.const 1) (ref.func $f3) (i32.const 2)) + (call_indirect (type $t3) (i32.const 1) (ref.func $f1) (i32.const 0)) + (call_indirect (type $t3) (i32.const 1) (ref.func $f1) (i32.const 1)) + (call_indirect (type $t3) (i32.const 1) (ref.func $f1) (i32.const 2)) + (call_indirect (type $t3) (i32.const 1) (ref.func $f2) (i32.const 0)) + (call_indirect (type $t3) (i32.const 1) (ref.func $f2) (i32.const 1)) + (call_indirect (type $t3) (i32.const 1) (ref.func $f2) (i32.const 2)) + (call_indirect (type $t3) (i32.const 1) (ref.func $f3) (i32.const 0)) + (call_indirect (type $t3) (i32.const 1) (ref.func $f3) (i32.const 1)) + (call_indirect (type $t3) (i32.const 1) (ref.func $f3) (i32.const 2)) + ) +) +(assert_return (invoke "run")) + +(module + (type $t1 (func (param i32 (ref $u1)))) + (type $u1 (func (param f32 (ref $t1)))) + + (type $t2 (func (param i32 (ref $u3)))) + (type $u2 (func (param f32 (ref $t3)))) + (type $t3 (func (param i32 (ref $u2)))) + (type $u3 (func (param f32 (ref $t2)))) + + (func $f1 (type $t1)) + (func $f2 (type $t2)) + (func $f3 (type $t3)) + (func $g1 (type $u1)) + (func $g2 (type $u2)) + (func $g3 (type $u3)) + (table funcref (elem $f1 $f2 $f3 $g1 $g2 $g3)) + + (func (export "run") + (call_indirect (type $t1) (i32.const 1) (ref.func $g1) (i32.const 0)) + (call_indirect (type $t1) (i32.const 1) (ref.func $g1) (i32.const 1)) + (call_indirect (type $t1) (i32.const 1) (ref.func $g1) (i32.const 2)) + (call_indirect (type $t1) (i32.const 1) (ref.func $g2) (i32.const 0)) + (call_indirect (type $t1) (i32.const 1) (ref.func $g2) (i32.const 1)) + (call_indirect (type $t1) (i32.const 1) (ref.func $g2) (i32.const 2)) + (call_indirect (type $t1) (i32.const 1) (ref.func $g3) (i32.const 0)) + (call_indirect (type $t1) (i32.const 1) (ref.func $g3) (i32.const 1)) + (call_indirect (type $t1) (i32.const 1) (ref.func $g3) (i32.const 2)) + (call_indirect (type $t2) (i32.const 1) (ref.func $g1) (i32.const 0)) + (call_indirect (type $t2) (i32.const 1) (ref.func $g1) (i32.const 1)) + (call_indirect (type $t2) (i32.const 1) (ref.func $g1) (i32.const 2)) + (call_indirect (type $t2) (i32.const 1) (ref.func $g2) (i32.const 0)) + (call_indirect (type $t2) (i32.const 1) (ref.func $g2) (i32.const 1)) + (call_indirect (type $t2) (i32.const 1) (ref.func $g2) (i32.const 2)) + (call_indirect (type $t2) (i32.const 1) (ref.func $g3) (i32.const 0)) + (call_indirect (type $t2) (i32.const 1) (ref.func $g3) (i32.const 1)) + (call_indirect (type $t2) (i32.const 1) (ref.func $g3) (i32.const 2)) + (call_indirect (type $t3) (i32.const 1) (ref.func $g1) (i32.const 0)) + (call_indirect (type $t3) (i32.const 1) (ref.func $g1) (i32.const 1)) + (call_indirect (type $t3) (i32.const 1) (ref.func $g1) (i32.const 2)) + (call_indirect (type $t3) (i32.const 1) (ref.func $g2) (i32.const 0)) + (call_indirect (type $t3) (i32.const 1) (ref.func $g2) (i32.const 1)) + (call_indirect (type $t3) (i32.const 1) (ref.func $g2) (i32.const 2)) + (call_indirect (type $t3) (i32.const 1) (ref.func $g3) (i32.const 0)) + (call_indirect (type $t3) (i32.const 1) (ref.func $g3) (i32.const 1)) + (call_indirect (type $t3) (i32.const 1) (ref.func $g3) (i32.const 2)) + ) +) +(assert_return (invoke "run")) + + +;; Semantic types (link time) + +;; Simple types. + +(module + (type $t1 (func (param f32 f32) (result f32))) + (func (export "f") (param (ref $t1))) +) +(register "M") +(module + (type $t2 (func (param $x f32) (param $y f32) (result f32))) + (func (import "M" "f") (param (ref $t2))) +) + + +;; Indirect types. + +(module + (type $s0 (func (param i32) (result f32))) + (type $s1 (func (param i32 (ref $s0)) (result (ref $s0)))) + (type $s2 (func (param i32 (ref $s0)) (result (ref $s0)))) + (type $t1 (func (param (ref $s1)) (result (ref $s2)))) + (type $t2 (func (param (ref $s2)) (result (ref $s1)))) + (func (export "f1") (param (ref $t1))) + (func (export "f2") (param (ref $t1))) +) +(register "M") +(module + (type $s0 (func (param i32) (result f32))) + (type $s1 (func (param i32 (ref $s0)) (result (ref $s0)))) + (type $s2 (func (param i32 (ref $s0)) (result (ref $s0)))) + (type $t1 (func (param (ref $s1)) (result (ref $s2)))) + (type $t2 (func (param (ref $s2)) (result (ref $s1)))) + (func (import "M" "f1") (param (ref $t1))) + (func (import "M" "f1") (param (ref $t2))) + (func (import "M" "f2") (param (ref $t1))) + (func (import "M" "f2") (param (ref $t1))) +) + + +;; Recursive types. + +(module + (type $t1 (func (param i32 (ref $t1)))) + (func (export "f") (param (ref $t1))) +) +(register "M") +(module + (type $t2 (func (param i32 (ref $t2)))) + (func (import "M" "f") (param (ref $t2))) +) + + +;; Isomorphic recursive types. + +(module + (type $t1 (func (param i32 (ref $t1)))) + (type $t2 (func (param i32 (ref $t3)))) + (type $t3 (func (param i32 (ref $t2)))) + (func (export "f1") (param (ref $t1))) + (func (export "f2") (param (ref $t2))) + (func (export "f3") (param (ref $t3))) +) +(register "M") +(module + (type $t1 (func (param i32 (ref $t1)))) + (type $t2 (func (param i32 (ref $t3)))) + (type $t3 (func (param i32 (ref $t2)))) + (func (import "M" "f1") (param (ref $t1))) + (func (import "M" "f1") (param (ref $t2))) + (func (import "M" "f1") (param (ref $t3))) + (func (import "M" "f2") (param (ref $t1))) + (func (import "M" "f2") (param (ref $t2))) + (func (import "M" "f2") (param (ref $t3))) + (func (import "M" "f3") (param (ref $t1))) + (func (import "M" "f3") (param (ref $t2))) + (func (import "M" "f3") (param (ref $t3))) +) + +(module + (type $t1 (func (param i32 (ref $t3)))) + (type $t2 (func (param i32 (ref $t1)))) + (type $t3 (func (param i32 (ref $t2)))) + (func (export "f1") (param (ref $t1))) + (func (export "f2") (param (ref $t2))) + (func (export "f3") (param (ref $t3))) +) +(register "M") +(module + (type $t1 (func (param i32 (ref $t3)))) + (type $t2 (func (param i32 (ref $t1)))) + (type $t3 (func (param i32 (ref $t2)))) + (func (import "M" "f1") (param (ref $t1))) + (func (import "M" "f1") (param (ref $t2))) + (func (import "M" "f1") (param (ref $t3))) + (func (import "M" "f2") (param (ref $t1))) + (func (import "M" "f2") (param (ref $t2))) + (func (import "M" "f2") (param (ref $t3))) + (func (import "M" "f3") (param (ref $t1))) + (func (import "M" "f3") (param (ref $t2))) + (func (import "M" "f3") (param (ref $t3))) +) + +(module + (type $t1 (func (param i32 (ref $u1)))) + (type $u1 (func (param f32 (ref $t1)))) + + (type $t2 (func (param i32 (ref $u3)))) + (type $u2 (func (param f32 (ref $t3)))) + (type $t3 (func (param i32 (ref $u2)))) + (type $u3 (func (param f32 (ref $t2)))) + + (func (export "f1") (param (ref $t1))) + (func (export "f2") (param (ref $t2))) + (func (export "f3") (param (ref $t3))) +) +(register "M") +(module + (type $t1 (func (param i32 (ref $u1)))) + (type $u1 (func (param f32 (ref $t1)))) + + (type $t2 (func (param i32 (ref $u3)))) + (type $u2 (func (param f32 (ref $t3)))) + (type $t3 (func (param i32 (ref $u2)))) + (type $u3 (func (param f32 (ref $t2)))) + + (func (import "M" "f1") (param (ref $t1))) + (func (import "M" "f1") (param (ref $t2))) + (func (import "M" "f1") (param (ref $t3))) + (func (import "M" "f2") (param (ref $t1))) + (func (import "M" "f2") (param (ref $t2))) + (func (import "M" "f2") (param (ref $t3))) + (func (import "M" "f3") (param (ref $t1))) + (func (import "M" "f3") (param (ref $t2))) + (func (import "M" "f3") (param (ref $t3))) +) diff --git a/runtime/near-vm/tests/wast/spec/proposals/gc/unreached-invalid.wast b/runtime/near-vm/tests/wast/spec/proposals/gc/unreached-invalid.wast new file mode 100644 index 00000000000..519656399f5 --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/proposals/gc/unreached-invalid.wast @@ -0,0 +1,706 @@ +;; Failures in unreachable code. + +(assert_invalid + (module (func $local-index (unreachable) (drop (local.get 0)))) + "unknown local" +) +(assert_invalid + (module (func $global-index (unreachable) (drop (global.get 0)))) + "unknown global" +) +(assert_invalid + (module (func $func-index (unreachable) (call 1))) + "unknown function" +) +(assert_invalid + (module (func $label-index (unreachable) (br 1))) + "unknown label" +) + +(assert_invalid + (module (func $type-num-vs-num + (unreachable) (drop (i64.eqz (i32.const 0)))) + ) + "type mismatch" +) +(assert_invalid + (module (func $type-poly-num-vs-num (result i32) + (unreachable) (i64.const 0) (i32.const 0) (select) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-poly-transitive-num-vs-num (result i32) + (unreachable) + (i64.const 0) (i32.const 0) (select) + (i32.const 0) (i32.const 0) (select) + )) + "type mismatch" +) + +(assert_invalid + (module (func $type-unconsumed-const (unreachable) (i32.const 0))) + "type mismatch" +) +(assert_invalid + (module (func $type-unconsumed-result (unreachable) (i32.eqz))) + "type mismatch" +) +(assert_invalid + (module (func $type-unconsumed-result2 + (unreachable) (i32.const 0) (i32.add) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-unconsumed-poly0 (unreachable) (select))) + "type mismatch" +) +(assert_invalid + (module (func $type-unconsumed-poly1 (unreachable) (i32.const 0) (select))) + "type mismatch" +) +(assert_invalid + (module (func $type-unconsumed-poly2 + (unreachable) (i32.const 0) (i32.const 0) (select) + )) + "type mismatch" +) + +(assert_invalid + (module (func $type-unary-num-vs-void-after-break + (block (br 0) (block (drop (i32.eqz (nop))))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-unary-num-vs-num-after-break + (block (br 0) (drop (i32.eqz (f32.const 1)))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-binary-num-vs-void-after-break + (block (br 0) (block (drop (f32.eq (i32.const 1))))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-binary-num-vs-num-after-break + (block (br 0) (drop (f32.eq (i32.const 1) (f32.const 0)))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-block-value-num-vs-void-after-break + (block (br 0) (i32.const 1)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-block-value-num-vs-num-after-break (result i32) + (block (result i32) (i32.const 1) (br 0) (f32.const 0)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-loop-value-num-vs-void-after-break + (block (loop (br 1) (i32.const 1))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-loop-value-num-vs-num-after-break (result i32) + (loop (result i32) (br 1 (i32.const 1)) (f32.const 0)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-func-value-num-vs-void-after-break + (br 0) (i32.const 1) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-func-value-num-vs-num-after-break (result i32) + (br 0 (i32.const 1)) (f32.const 0) + )) + "type mismatch" +) + +(assert_invalid + (module (func $type-unary-num-vs-void-after-return + (return) (block (drop (i32.eqz (nop)))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-unary-num-vs-num-after-return + (return) (drop (i32.eqz (f32.const 1))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-binary-num-vs-void-after-return + (return) (block (drop (f32.eq (i32.const 1)))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-binary-num-vs-num-after-return + (return) (drop (f32.eq (i32.const 1) (f32.const 0))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-block-value-num-vs-void-after-return + (block (return) (i32.const 1)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-block-value-num-vs-num-after-return (result i32) + (block (result i32) (i32.const 1) (return (i32.const 0)) (f32.const 0)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-loop-value-num-vs-void-after-return + (block (loop (return) (i32.const 1))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-loop-value-num-vs-num-after-return (result i32) + (loop (result i32) (return (i32.const 1)) (f32.const 0)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-func-value-num-vs-void-after-return + (return) (i32.const 1) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-func-value-num-vs-num-after-return (result i32) + (return (i32.const 1)) (f32.const 0) + )) + "type mismatch" +) + +(assert_invalid + (module (func $type-unary-num-vs-void-after-unreachable + (unreachable) (block (drop (i32.eqz (nop)))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-unary-num-vs-void-in-loop-after-unreachable + (unreachable) (loop (drop (i32.eqz (nop)))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-unary-num-vs-void-in-i32-loop-after-unreachable + (unreachable) (loop (result i32) (i32.eqz (nop))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-unary-num-vs-num-after-unreachable + (unreachable) (drop (i32.eqz (f32.const 1))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-binary-num-vs-void-after-unreachable + (unreachable) (block (drop (f32.eq (i32.const 1)))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-binary-num-vs-num-after-unreachable + (unreachable) (drop (f32.eq (i32.const 1) (f32.const 0))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-block-value-num-vs-void-after-unreachable + (block (unreachable) (i32.const 1)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-block-value-num-vs-num-after-unreachable (result i32) + (block (result i32) (i32.const 1) (unreachable) (f32.const 0)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-loop-value-num-vs-void-after-unreachable + (block (loop (unreachable) (i32.const 1))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-loop-value-num-vs-num-after-unreachable (result i32) + (loop (result i32) (unreachable) (f32.const 0)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-func-value-num-vs-void-after-unreachable + (unreachable) (i32.const 1) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-func-value-num-vs-num-after-unreachable (result i32) + (unreachable) (f32.const 0) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-unary-num-vs-void-in-if-after-unreachable + (unreachable) (if (i32.const 0) (then (drop (i32.eqz (nop))))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-unary-num-vs-void-in-else-after-unreachable + (unreachable) (if (i32.const 0) (then (nop)) (else (drop (i32.eqz (nop))))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-unary-num-vs-void-in-else-after-unreachable-if + (if (i32.const 0) (then (unreachable)) (else (drop (i32.eqz (nop))))) + )) + "type mismatch" +) + +(assert_invalid + (module (func $type-unary-num-vs-void-after-nested-unreachable + (block (unreachable)) (block (drop (i32.eqz (nop)))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-unary-num-vs-num-after-nested-unreachable + (block (unreachable)) (drop (i32.eqz (f32.const 1))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-binary-num-vs-void-after-nested-unreachable + (block (unreachable)) (block (drop (f32.eq (i32.const 1)))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-binary-num-vs-num-after-nested-unreachable + (block (unreachable)) (drop (f32.eq (i32.const 1) (f32.const 0))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-block-value-num-vs-void-after-nested-unreachable + (block (block (unreachable)) (i32.const 1)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-block-value-num-vs-num-after-nested-unreachable + (result i32) + (block (result i32) (i32.const 1) (block (unreachable)) (f32.const 0)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-loop-value-num-vs-void-after-nested-unreachable + (block (loop (block (unreachable)) (i32.const 1))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-loop-value-num-vs-num-after-nested-unreachable + (result i32) + (loop (result i32) (block (unreachable)) (f32.const 0)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-func-value-num-vs-void-after-nested-unreachable + (block (unreachable)) (i32.const 1) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-func-value-num-vs-num-after-nested-unreachable + (result i32) + (block (unreachable)) (f32.const 0) + )) + "type mismatch" +) + +(assert_invalid + (module (func $type-unary-num-vs-void-after-infinite-loop + (loop (br 0)) (block (drop (i32.eqz (nop)))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-unary-num-vs-num-after-infinite-loop + (loop (br 0)) (drop (i32.eqz (f32.const 1))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-binary-num-vs-void-after-infinite-loop + (loop (br 0)) (block (drop (f32.eq (i32.const 1)))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-binary-num-vs-num-after-infinite-loop + (loop (br 0)) (drop (f32.eq (i32.const 1) (f32.const 0))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-block-value-num-vs-void-after-infinite-loop + (block (loop (br 0)) (i32.const 1)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-block-value-num-vs-num-after-infinite-loop (result i32) + (block (result i32) (i32.const 1) (loop (br 0)) (f32.const 0)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-loop-value-num-vs-void-after-infinite-loop + (block (loop (loop (br 0)) (i32.const 1))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-loop-value-num-vs-num-after-infinite-loop (result i32) + (loop (result i32) (loop (br 0)) (f32.const 0)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-func-value-num-vs-void-after-infinite-loop + (loop (br 0)) (i32.const 1) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-func-value-num-vs-num-after-infinite-loop (result i32) + (loop (br 0)) (f32.const 0) + )) + "type mismatch" +) + +(assert_invalid + (module (func $type-unary-num-vs-void-in-dead-body + (if (i32.const 0) (then (drop (i32.eqz (nop))))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-unary-num-vs-num-in-dead-body + (if (i32.const 0) (then (drop (i32.eqz (f32.const 1))))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-binary-num-vs-void-in-dead-body + (if (i32.const 0) (then (drop (f32.eq (i32.const 1))))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-binary-num-vs-num-in-dead-body + (if (i32.const 0) (then (drop (f32.eq (i32.const 1) (f32.const 0))))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-if-value-num-vs-void-in-dead-body + (if (i32.const 0) (then (i32.const 1))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-if-value-num-vs-num-in-dead-body (result i32) + (if (result i32) (i32.const 0) (then (f32.const 0))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-block-value-num-vs-void-in-dead-body + (if (i32.const 0) (then (block (i32.const 1)))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-block-value-num-vs-num-in-dead-body (result i32) + (if (result i32) (i32.const 0) (then (block (result i32) (f32.const 0)))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-block-value-num-vs-void-in-dead-body + (if (i32.const 0) (then (loop (i32.const 1)))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-block-value-num-vs-num-in-dead-body (result i32) + (if (result i32) (i32.const 0) (then (loop (result i32) (f32.const 0)))) + )) + "type mismatch" +) + +(assert_invalid + (module (func $type-return-second-num-vs-num (result i32) + (return (i32.const 1)) (return (f64.const 1)) + )) + "type mismatch" +) + +(assert_invalid + (module (func $type-br-second-num-vs-num (result i32) + (block (result i32) (br 0 (i32.const 1)) (br 0 (f64.const 1))) + )) + "type mismatch" +) + +(assert_invalid + (module (func $type-br_if-cond-num-vs-num-after-unreachable + (block (br_if 0 (unreachable) (f32.const 0))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-br_if-num-vs-void-after-unreachable (result i32) + (block (result i32) + (block (unreachable) (br_if 1 (i32.const 0) (i32.const 0))) + ) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-br_if-num-vs-num-after-unreachable (result i32) + (block (result i32) + (block (result f32) (unreachable) (br_if 1 (i32.const 0) (i32.const 0))) + (drop) (i32.const 0) + ) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-br_if-num2-vs-num-after-unreachable (result i32) + (block (result i32) + (unreachable) (br_if 0 (i32.const 0) (i32.const 0)) (i32.const 0) + ) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-br_table-num-vs-num-after-unreachable + (block (br_table 0 (unreachable) (f32.const 1))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-br_table-label-num-vs-num-after-unreachable (result i32) + (block (result i32) (unreachable) (br_table 0 (f32.const 0) (i32.const 1))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-br_table-label-num-vs-label-void-after-unreachable + (block + (block (result f32) + (unreachable) + (br_table 0 1 0 (i32.const 1)) + ) + (drop) + ) + )) + "type mismatch" +) + +(assert_invalid + (module (func $type-block-value-nested-unreachable-num-vs-void + (block (i32.const 3) (block (unreachable))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-block-value-nested-unreachable-void-vs-num (result i32) + (block (block (unreachable))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-block-value-nested-unreachable-num-vs-num (result i32) + (block (result i64) (i64.const 0) (block (unreachable))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-block-value-nested-unreachable-num2-vs-void (result i32) + (block (i32.const 3) (block (i64.const 1) (unreachable))) (i32.const 9) + )) + "type mismatch" +) + +(assert_invalid + (module (func $type-block-value-nested-br-num-vs-void + (block (i32.const 3) (block (br 1))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-block-value-nested-br-void-vs-num (result i32) + (block (result i32) (block (br 1 (i32.const 0)))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-block-value-nested-br-num-vs-num (result i32) + (block (result i32) (i64.const 0) (block (br 1 (i32.const 0)))) + )) + "type mismatch" +) + +(assert_invalid + (module (func $type-block-value-nested2-br-num-vs-void + (block (block (i32.const 3) (block (br 2)))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-block-value-nested2-br-void-vs-num (result i32) + (block (result i32) (block (block (br 2 (i32.const 0))))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-block-value-nested2-br-num-vs-num (result i32) + (block (result i32) + (block (result i64) (i64.const 0) (block (br 2 (i32.const 0)))) + ) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-block-value-nested2-br-num2-vs-void (result i32) + (block (i32.const 3) (block (i64.const 1) (br 1))) (i32.const 9) + )) + "type mismatch" +) + +(assert_invalid + (module (func $type-block-value-nested-return-num-vs-void + (block (i32.const 3) (block (return))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-block-value-nested-return-void-vs-num (result i32) + (block (block (return (i32.const 0)))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-block-value-nested-return-num-vs-num (result i32) + (block (result i64) (i64.const 0) (block (return (i32.const 0)))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-block-value-nested-return-num2-vs-void (result i32) + (block (i32.const 3) (block (i64.const 1) (return (i32.const 0)))) + (i32.const 9) + )) + "type mismatch" +) + +(assert_invalid + (module (func $type-loop-value-nested-unreachable-num-vs-void + (loop (i32.const 3) (block (unreachable))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-loop-value-nested-unreachable-void-vs-num (result i32) + (loop (block (unreachable))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-loop-value-nested-unreachable-num-vs-num (result i32) + (loop (result i64) (i64.const 0) (block (unreachable))) + )) + "type mismatch" +) + +(assert_invalid + (module (func $type-cont-last-void-vs-empty (result i32) + (loop (br 0 (nop))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-cont-last-num-vs-empty (result i32) + (loop (br 0 (i32.const 0))) + )) + "type mismatch" +) + +(assert_invalid + (module (func $tee-local-unreachable-value + (local i32) + (local.tee 0 (unreachable)) + )) + "type mismatch" +) +(assert_invalid + (module (func $br_if-unreachable (result i32) + (block (result i32) + (block + (br_if 1 (unreachable) (i32.const 0)) + ) + (i32.const 0) + ) + )) + "type mismatch" +) +(assert_invalid + (module + (func $type-br_if-after-unreachable (result i64) + (unreachable) + (br_if 0) + (i64.extend_i32_u) + ) + ) + "type mismatch" +) + +(assert_invalid + (module + (func $type-after-ref.as_non_null + (unreachable) + (ref.as_non_null) + (f32.abs) + ) + ) + "type mismatch" +) diff --git a/runtime/near-vm/tests/wast/spec/proposals/multi-value/binary.wast b/runtime/near-vm/tests/wast/spec/proposals/multi-value/binary.wast new file mode 100644 index 00000000000..de625bf28b2 --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/proposals/multi-value/binary.wast @@ -0,0 +1,811 @@ +(module binary "\00asm\01\00\00\00") +(module binary "\00asm" "\01\00\00\00") +(module $M1 binary "\00asm\01\00\00\00") +(module $M2 binary "\00asm" "\01\00\00\00") + +(assert_malformed (module binary "") "unexpected end") +(assert_malformed (module binary "\01") "unexpected end") +(assert_malformed (module binary "\00as") "unexpected end") +(assert_malformed (module binary "asm\00") "magic header not detected") +(assert_malformed (module binary "msa\00") "magic header not detected") +(assert_malformed (module binary "msa\00\01\00\00\00") "magic header not detected") +(assert_malformed (module binary "msa\00\00\00\00\01") "magic header not detected") +(assert_malformed (module binary "asm\01\00\00\00\00") "magic header not detected") +(assert_malformed (module binary "wasm\01\00\00\00") "magic header not detected") +(assert_malformed (module binary "\7fasm\01\00\00\00") "magic header not detected") +(assert_malformed (module binary "\80asm\01\00\00\00") "magic header not detected") +(assert_malformed (module binary "\82asm\01\00\00\00") "magic header not detected") +(assert_malformed (module binary "\ffasm\01\00\00\00") "magic header not detected") + +;; 8-byte endian-reversed. +(assert_malformed (module binary "\00\00\00\01msa\00") "magic header not detected") + +;; Middle-endian byte orderings. +(assert_malformed (module binary "a\00ms\00\01\00\00") "magic header not detected") +(assert_malformed (module binary "sm\00a\00\00\01\00") "magic header not detected") + +;; Upper-cased. +(assert_malformed (module binary "\00ASM\01\00\00\00") "magic header not detected") + +;; EBCDIC-encoded magic. +(assert_malformed (module binary "\00\81\a2\94\01\00\00\00") "magic header not detected") + +;; Leading UTF-8 BOM. +(assert_malformed (module binary "\ef\bb\bf\00asm\01\00\00\00") "magic header not detected") + +;; Malformed binary version. +(assert_malformed (module binary "\00asm") "unexpected end") +(assert_malformed (module binary "\00asm\01") "unexpected end") +(assert_malformed (module binary "\00asm\01\00\00") "unexpected end") +(assert_malformed (module binary "\00asm\00\00\00\00") "unknown binary version") +(assert_malformed (module binary "\00asm\0d\00\00\00") "unknown binary version") +(assert_malformed (module binary "\00asm\0e\00\00\00") "unknown binary version") +(assert_malformed (module binary "\00asm\00\01\00\00") "unknown binary version") +(assert_malformed (module binary "\00asm\00\00\01\00") "unknown binary version") +(assert_malformed (module binary "\00asm\00\00\00\01") "unknown binary version") + + +;; call_indirect reserved byte equal to zero. +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01\60\00\00" ;; Type section + "\03\02\01\00" ;; Function section + "\04\04\01\70\00\00" ;; Table section + "\0a\09\01" ;; Code section + + ;; function 0 + "\07\00" + "\41\00" ;; i32.const 0 + "\11\00" ;; call_indirect (type 0) + "\01" ;; call_indirect reserved byte is not equal to zero! + "\0b" ;; end + ) + "zero flag expected" +) + +;; call_indirect reserved byte should not be a "long" LEB128 zero. +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01\60\00\00" ;; Type section + "\03\02\01\00" ;; Function section + "\04\04\01\70\00\00" ;; Table section + "\0a\0a\01" ;; Code section + + ;; function 0 + "\07\00" + "\41\00" ;; i32.const 0 + "\11\00" ;; call_indirect (type 0) + "\80\00" ;; call_indirect reserved byte + "\0b" ;; end + ) + "zero flag expected" +) + +;; Same as above for 3, 4, and 5-byte zero encodings. +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01\60\00\00" ;; Type section + "\03\02\01\00" ;; Function section + "\04\04\01\70\00\00" ;; Table section + "\0a\0b\01" ;; Code section + + ;; function 0 + "\08\00" + "\41\00" ;; i32.const 0 + "\11\00" ;; call_indirect (type 0) + "\80\80\00" ;; call_indirect reserved byte + "\0b" ;; end + ) + "zero flag expected" +) + +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01\60\00\00" ;; Type section + "\03\02\01\00" ;; Function section + "\04\04\01\70\00\00" ;; Table section + "\0a\0c\01" ;; Code section + + ;; function 0 + "\09\00" + "\41\00" ;; i32.const 0 + "\11\00" ;; call_indirect (type 0) + "\80\80\80\00" ;; call_indirect reserved byte + "\0b" ;; end + ) + "zero flag expected" +) + +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01\60\00\00" ;; Type section + "\03\02\01\00" ;; Function section + "\04\04\01\70\00\00" ;; Table section + "\0a\0d\01" ;; Code section + + ;; function 0 + "\0a\00" + "\41\00" ;; i32.const 0 + "\11\00" ;; call_indirect (type 0) + "\80\80\80\80\00" ;; call_indirect reserved byte + "\0b" ;; end + ) + "zero flag expected" +) + +;; memory.grow reserved byte equal to zero. +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01\60\00\00" ;; Type section + "\03\02\01\00" ;; Function section + "\05\03\01\00\00" ;; Memory section + "\0a\09\01" ;; Code section + + ;; function 0 + "\07\00" + "\41\00" ;; i32.const 0 + "\40" ;; memory.grow + "\01" ;; memory.grow reserved byte is not equal to zero! + "\1a" ;; drop + "\0b" ;; end + ) + "zero flag expected" +) + +;; memory.grow reserved byte should not be a "long" LEB128 zero. +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01\60\00\00" ;; Type section + "\03\02\01\00" ;; Function section + "\05\03\01\00\00" ;; Memory section + "\0a\0a\01" ;; Code section + + ;; function 0 + "\08\00" + "\41\00" ;; i32.const 0 + "\40" ;; memory.grow + "\80\00" ;; memory.grow reserved byte + "\1a" ;; drop + "\0b" ;; end + ) + "zero flag expected" +) + +;; Same as above for 3, 4, and 5-byte zero encodings. +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01\60\00\00" ;; Type section + "\03\02\01\00" ;; Function section + "\05\03\01\00\00" ;; Memory section + "\0a\0b\01" ;; Code section + + ;; function 0 + "\09\00" + "\41\00" ;; i32.const 0 + "\40" ;; memory.grow + "\80\80\00" ;; memory.grow reserved byte + "\1a" ;; drop + "\0b" ;; end + ) + "zero flag expected" +) + +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01\60\00\00" ;; Type section + "\03\02\01\00" ;; Function section + "\05\03\01\00\00" ;; Memory section + "\0a\0c\01" ;; Code section + + ;; function 0 + "\0a\00" + "\41\00" ;; i32.const 0 + "\40" ;; memory.grow + "\80\80\80\00" ;; memory.grow reserved byte + "\1a" ;; drop + "\0b" ;; end + ) + "zero flag expected" +) + +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01\60\00\00" ;; Type section + "\03\02\01\00" ;; Function section + "\05\03\01\00\00" ;; Memory section + "\0a\0d\01" ;; Code section + + ;; function 0 + "\0b\00" + "\41\00" ;; i32.const 0 + "\40" ;; memory.grow + "\80\80\80\80\00" ;; memory.grow reserved byte + "\1a" ;; drop + "\0b" ;; end + ) + "zero flag expected" +) + +;; memory.size reserved byte equal to zero. +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01\60\00\00" ;; Type section + "\03\02\01\00" ;; Function section + "\05\03\01\00\00" ;; Memory section + "\0a\07\01" ;; Code section + + ;; function 0 + "\05\00" + "\3f" ;; memory.size + "\01" ;; memory.size reserved byte is not equal to zero! + "\1a" ;; drop + "\0b" ;; end + ) + "zero flag expected" +) + +;; memory.size reserved byte should not be a "long" LEB128 zero. +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01\60\00\00" ;; Type section + "\03\02\01\00" ;; Function section + "\05\03\01\00\00" ;; Memory section + "\0a\08\01" ;; Code section + + ;; function 0 + "\06\00" + "\3f" ;; memory.size + "\80\00" ;; memory.size reserved byte + "\1a" ;; drop + "\0b" ;; end + ) + "zero flag expected" +) + +;; Same as above for 3, 4, and 5-byte zero encodings. +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01\60\00\00" ;; Type section + "\03\02\01\00" ;; Function section + "\05\03\01\00\00" ;; Memory section + "\0a\09\01" ;; Code section + + ;; function 0 + "\07\00" + "\3f" ;; memory.size + "\80\80\00" ;; memory.size reserved byte + "\1a" ;; drop + "\0b" ;; end + ) + "zero flag expected" +) + +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01\60\00\00" ;; Type section + "\03\02\01\00" ;; Function section + "\05\03\01\00\00" ;; Memory section + "\0a\0a\01" ;; Code section + + ;; function 0 + "\08\00" + "\3f" ;; memory.size + "\80\80\80\00" ;; memory.size reserved byte + "\1a" ;; drop + "\0b" ;; end + ) + "zero flag expected" +) + +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01\60\00\00" ;; Type section + "\03\02\01\00" ;; Function section + "\05\03\01\00\00" ;; Memory section + "\0a\0b\01" ;; Code section + + ;; function 0 + "\09\00" + "\3f" ;; memory.size + "\80\80\80\80\00" ;; memory.size reserved byte + "\1a" ;; drop + "\0b" ;; end + ) + "zero flag expected" +) + +;; No more than 2^32 locals. +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01\60\00\00" ;; Type section + "\03\02\01\00" ;; Function section + "\0a\0c\01" ;; Code section + + ;; function 0 + "\0a\02" + "\ff\ff\ff\ff\0f\7f" ;; 0xFFFFFFFF i32 + "\02\7e" ;; 0x00000002 i64 + "\0b" ;; end + ) + "too many locals" +) + +;; Local count can be 0. +(module binary + "\00asm" "\01\00\00\00" + "\01\04\01\60\00\00" ;; Type section + "\03\02\01\00" ;; Function section + "\0a\0a\01" ;; Code section + + ;; function 0 + "\08\03" + "\00\7f" ;; 0 i32 + "\00\7e" ;; 0 i64 + "\02\7d" ;; 2 f32 + "\0b" ;; end +) + +;; Function section has non-zero count, but code section is absent. +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01\60\00\00" ;; Type section + "\03\03\02\00\00" ;; Function section with 2 functions + ) + "function and code section have inconsistent lengths" +) + +;; Code section has non-zero count, but function section is absent. +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\0a\04\01\02\00\0b" ;; Code section with 1 empty function + ) + "function and code section have inconsistent lengths" +) + +;; Function section count > code section count +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01\60\00\00" ;; Type section + "\03\03\02\00\00" ;; Function section with 2 functions + "\0a\04\01\02\00\0b" ;; Code section with 1 empty function + ) + "function and code section have inconsistent lengths" +) + +;; Function section count < code section count +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01\60\00\00" ;; Type section + "\03\02\01\00" ;; Function section with 1 function + "\0a\07\02\02\00\0b\02\00\0b" ;; Code section with 2 empty functions + ) + "function and code section have inconsistent lengths" +) + +;; Function section has zero count, and code section is absent. +(module binary + "\00asm" "\01\00\00\00" + "\03\01\00" ;; Function section with 0 functions +) + +;; Code section has zero count, and function section is absent. +(module binary + "\00asm" "\01\00\00\00" + "\0a\01\00" ;; Code section with 0 functions +) + +;; Type count can be zero +(module binary + "\00asm" "\01\00\00\00" + "\01\01\00" ;; type count can be zero +) + +;; 2 type declared, 1 given +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\07\02" ;; type section with inconsistent count (2 declared, 1 given) + "\60\00\00" ;; 1st type + ;; "\60\00\00" ;; 2nd type (missed) + ) + "unexpected end of section or function" +) + +;; 1 type declared, 2 given +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\07\01" ;; type section with inconsistent count (1 declared, 2 given) + "\60\00\00" ;; 1st type + "\60\00\00" ;; 2nd type (redundant) + ) + "section size mismatch" +) + +;; Import count can be zero +(module binary + "\00asm" "\01\00\00\00" + "\01\05\01" ;; type section + "\60\01\7f\00" ;; type 0 + "\02\01\00" ;; import count can be zero +) + +;; 2 import declared, 1 given +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\05\01" ;; type section + "\60\01\7f\00" ;; type 0 + "\02\16\02" ;; import section with inconsistent count (2 declared, 1 given) + ;; 1st import + "\08" ;; string length + "\73\70\65\63\74\65\73\74" ;; spectest + "\09" ;; string length + "\70\72\69\6e\74\5f\69\33\32" ;; print_i32 + "\00\00" ;; import kind, import signature index + ;; 2nd import + ;; (missed) + ) + "unexpected end of section or function" +) + +;; 1 import declared, 2 given +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\09\02" ;; type section + "\60\01\7f\00" ;; type 0 + "\60\01\7d\00" ;; type 1 + "\02\2b\01" ;; import section with inconsistent count (1 declared, 2 given) + ;; 1st import + "\08" ;; string length + "\73\70\65\63\74\65\73\74" ;; spectest + "\09" ;; string length + "\70\72\69\6e\74\5f\69\33\32" ;; print_i32 + "\00\00" ;; import kind, import signature index + ;; 2nd import + ;; (redundant) + "\08" ;; string length + "\73\70\65\63\74\65\73\74" ;; spectest + "\09" ;; string length + "\70\72\69\6e\74\5f\66\33\32" ;; print_f32 + "\00\01" ;; import kind, import signature index + ) + "section size mismatch" +) + +;; Table count can be zero +(module binary + "\00asm" "\01\00\00\00" + "\04\01\00" ;; table count can be zero +) + +;; 1 table declared, 0 given +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\04\01\01" ;; table section with inconsistent count (1 declared, 0 given) + ;; "\70\01\00\00" ;; table entity + ) + "unexpected end of section or function" +) + +;; Memory count can be zero +(module binary + "\00asm" "\01\00\00\00" + "\05\01\00" ;; memory count can be zero +) + +;; 1 memory declared, 0 given +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\05\01\01" ;; memory section with inconsistent count (1 declared, 0 given) + ;; "\00\00" ;; memory 0 (missed) + ) + "unexpected end of section or function" +) + +;; Global count can be zero +(module binary + "\00asm" "\01\00\00\00" + "\06\01\00" ;; global count can be zero +) + +;; 2 global declared, 1 given +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\06\06\02" ;; global section with inconsistent count (2 declared, 1 given) + "\7f\00\41\00\0b" ;; global 0 + ;; "\7f\00\41\00\0b" ;; global 1 (missed) + ) + "unexpected end of section or function" +) + +;; 1 global declared, 2 given +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\06\0b\01" ;; global section with inconsistent count (1 declared, 2 given) + "\7f\00\41\00\0b" ;; global 0 + "\7f\00\41\00\0b" ;; global 1 (redundant) + ) + "section size mismatch" +) + +;; Export count can be 0 +(module binary + "\00asm" "\01\00\00\00" + "\01\04\01" ;; type section + "\60\00\00" ;; type 0 + "\03\03\02\00\00" ;; func section + "\07\01\00" ;; export count can be zero + "\0a\07\02" ;; code section + "\02\00\0b" ;; function body 0 + "\02\00\0b" ;; function body 1 +) + +;; 2 export declared, 1 given +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01" ;; type section + "\60\00\00" ;; type 0 + "\03\03\02\00\00" ;; func section + "\07\06\02" ;; export section with inconsistent count (2 declared, 1 given) + "\02" ;; export 0 + "\66\31" ;; export name + "\00\00" ;; export kind, export func index + ;; "\02" ;; export 1 (missed) + ;; "\66\32" ;; export name + ;; "\00\01" ;; export kind, export func index + "\0a\07\02" ;; code section + "\02\00\0b" ;; function body 0 + "\02\00\0b" ;; function body 1 + ) + "unexpected end of section or function" +) + +;; 1 export declared, 2 given +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01" ;; type section + "\60\00\00" ;; type 0 + "\03\03\02\00\00" ;; func section + "\07\0b\01" ;; export section with inconsistent count (1 declared, 2 given) + "\02" ;; export 0 + "\66\31" ;; export name + "\00\00" ;; export kind, export func index + "\02" ;; export 1 (redundant) + "\66\32" ;; export name + "\00\01" ;; export kind, export func index + "\0a\07\02" ;; code section + "\02\00\0b" ;; function body 0 + "\02\00\0b" ;; function body 1 + ) + "section size mismatch" +) + +;; elem segment count can be zero +(module binary + "\00asm" "\01\00\00\00" + "\01\04\01" ;; type section + "\60\00\00" ;; type 0 + "\03\02\01\00" ;; func section + "\04\04\01" ;; table section + "\70\00\01" ;; table 0 + "\09\01\00" ;; elem segment count can be zero + "\0a\04\01" ;; code section + "\02\00\0b" ;; function body +) + +;; 2 elem segment declared, 1 given +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01" ;; type section + "\60\00\00" ;; type 0 + "\03\02\01\00" ;; func section + "\04\04\01" ;; table section + "\70\00\01" ;; table 0 + "\09\07\02" ;; elem with inconsistent segment count (2 declared, 1 given) + "\00\41\00\0b\01\00" ;; elem 0 + ;; "\00\41\00\0b\01\00" ;; elem 1 (missed) + "\0a\04\01" ;; code section + "\02\00\0b" ;; function body + ) + "unexpected end" +) + +;; 1 elem segment declared, 2 given +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01" ;; type section + "\60\00\00" ;; type 0 + "\03\02\01\00" ;; func section + "\04\04\01" ;; table section + "\70\00\01" ;; table 0 + "\09\0d\01" ;; elem with inconsistent segment count (1 declared, 2 given) + "\00\41\00\0b\01\00" ;; elem 0 + "\00\41\00\0b\01\00" ;; elem 1 (redundant) + "\0a\04\01" ;; code section + "\02\00\0b" ;; function body + ) + "section size mismatch" +) + +;; data segment count can be zero +(module binary + "\00asm" "\01\00\00\00" + "\05\03\01" ;; memory section + "\00\01" ;; memory 0 + "\0b\01\00" ;; data segment count can be zero +) + +;; 2 data segment declared, 1 given +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\05\03\01" ;; memory section + "\00\01" ;; memory 0 + "\0b\07\02" ;; data with inconsistent segment count (2 declared, 1 given) + "\00\41\00\0b\01\61" ;; data 0 + ;; "\00\41\01\0b\01\62" ;; data 1 (missed) + ) + "unexpected end of section or function" +) + +;; 1 data segment declared, 2 given +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\05\03\01" ;; memory section + "\00\01" ;; memory 0 + "\0b\0d\01" ;; data with inconsistent segment count (1 declared, 2 given) + "\00\41\00\0b\01\61" ;; data 0 + "\00\41\01\0b\01\62" ;; data 1 (redundant) + ) + "section size mismatch" +) + +;; data segment has 7 bytes declared, but 6 bytes given +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\05\03\01" ;; memory section + "\00\01" ;; memory 0 + "\0b\0c\01" ;; data section + "\00\41\03\0b" ;; data segment 0 + "\07" ;; data segment size with inconsistent lengths (7 declared, 6 given) + "\61\62\63\64\65\66" ;; 6 bytes given + ) + "unexpected end of section or function" +) + +;; data segment has 5 bytes declared, but 6 bytes given +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\05\03\01" ;; memory section + "\00\01" ;; memory 0 + "\0b\0c\01" ;; data section + "\00\41\00\0b" ;; data segment 0 + "\05" ;; data segment size with inconsistent lengths (5 declared, 6 given) + "\61\62\63\64\65\66" ;; 6 bytes given + ) + "section size mismatch" +) + +;; br_table target count can be zero +(module binary + "\00asm" "\01\00\00\00" + "\01\04\01" ;; type section + "\60\00\00" ;; type 0 + "\03\02\01\00" ;; func section + "\0a\11\01" ;; code section + "\0f\00" ;; func 0 + "\02\40" ;; block 0 + "\41\01" ;; condition of if 0 + "\04\40" ;; if 0 + "\41\01" ;; index of br_table element + "\0e\00" ;; br_table target count can be zero + "\02" ;; break depth for default + "\0b\0b\0b" ;; end +) + +;; 2 br_table target declared, 1 given +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01" ;; type section + "\60\00\00" ;; type 0 + "\03\02\01\00" ;; func section + "\0a\12\01" ;; code section + "\10\00" ;; func 0 + "\02\40" ;; block 0 + "\41\01" ;; condition of if 0 + "\04\40" ;; if 0 + "\41\01" ;; index of br_table element + "\0e\02" ;; br_table with inconsistent target count (2 declared, 1 given) + "\00" ;; break depth 0 + ;; "\01" ;; break depth 1 (missed) + "\02" ;; break depth for default + "\0b\0b\0b" ;; end + ) + "unexpected end of section or function" +) + +;; 1 br_table target declared, 2 given +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01" ;; type section + "\60\00\00" ;; type 0 + "\03\02\01\00" ;; func section + "\0a\12\01" ;; code section + "\11\00" ;; func 0 + "\02\40" ;; block 0 + "\41\01" ;; condition of if 0 + "\04\40" ;; if 0 + "\41\01" ;; index of br_table element + "\0e\01" ;; br_table with inconsistent target count (1 declared, 2 given) + "\00" ;; break depth 0 + "\01" ;; break depth 1 + "\02" ;; break depth for default + "\0b\0b\0b" ;; end + ) + "unexpected end" +) + +;; Start section +(module binary + "\00asm" "\01\00\00\00" + "\01\04\01\60\00\00" ;; Type section + "\03\02\01\00" ;; Function section + "\08\01\00" ;; Start section: function 0 + + "\0a\04\01" ;; Code section + ;; function 0 + "\02\00" + "\0b" ;; end +) + +;; Multiple start sections +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01\60\00\00" ;; Type section + "\03\02\01\00" ;; Function section + "\08\01\00" ;; Start section: function 0 + "\08\01\00" ;; Start section: function 0 + + "\0a\04\01" ;; Code section + ;; function 0 + "\02\00" + "\0b" ;; end + ) + "junk after last section" +) diff --git a/runtime/near-vm/tests/wast/spec/proposals/multi-value/block.wast b/runtime/near-vm/tests/wast/spec/proposals/multi-value/block.wast new file mode 100644 index 00000000000..44915b991b6 --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/proposals/multi-value/block.wast @@ -0,0 +1,1491 @@ +;; Test `block` operator + +(module + ;; Auxiliary definition + (memory 1) + + (func $dummy) + + (func (export "empty") + (block) + (block $l) + ) + + (func (export "singular") (result i32) + (block (nop)) + (block (result i32) (i32.const 7)) + ) + + (func (export "multi") (result i32) + (block (call $dummy) (call $dummy) (call $dummy) (call $dummy)) + (block (result i32) + (call $dummy) (call $dummy) (call $dummy) (i32.const 7) (call $dummy) + ) + (drop) + (block (result i32 i64 i32) + (call $dummy) (call $dummy) (call $dummy) (i32.const 8) (call $dummy) + (call $dummy) (call $dummy) (call $dummy) (i64.const 7) (call $dummy) + (call $dummy) (call $dummy) (call $dummy) (i32.const 9) (call $dummy) + ) + (drop) (drop) + ) + + (func (export "nested") (result i32) + (block (result i32) + (block (call $dummy) (block) (nop)) + (block (result i32) (call $dummy) (i32.const 9)) + ) + ) + + (func (export "deep") (result i32) + (block (result i32) (block (result i32) + (block (result i32) (block (result i32) + (block (result i32) (block (result i32) + (block (result i32) (block (result i32) + (block (result i32) (block (result i32) + (block (result i32) (block (result i32) + (block (result i32) (block (result i32) + (block (result i32) (block (result i32) + (block (result i32) (block (result i32) + (block (result i32) (block (result i32) + (block (result i32) (block (result i32) + (block (result i32) (block (result i32) + (block (result i32) (block (result i32) + (block (result i32) (block (result i32) + (block (result i32) (block (result i32) + (block (result i32) (block (result i32) + (block (result i32) (block (result i32) + (block (result i32) (block (result i32) + (block (result i32) (block (result i32) + (call $dummy) (i32.const 150) + )) + )) + )) + )) + )) + )) + )) + )) + )) + )) + )) + )) + )) + )) + )) + )) + )) + )) + )) + ) + + (func (export "as-select-first") (result i32) + (select (block (result i32) (i32.const 1)) (i32.const 2) (i32.const 3)) + ) + (func (export "as-select-mid") (result i32) + (select (i32.const 2) (block (result i32) (i32.const 1)) (i32.const 3)) + ) + (func (export "as-select-last") (result i32) + (select (i32.const 2) (i32.const 3) (block (result i32) (i32.const 1))) + ) + + (func (export "as-loop-first") (result i32) + (loop (result i32) (block (result i32) (i32.const 1)) (call $dummy) (call $dummy)) + ) + (func (export "as-loop-mid") (result i32) + (loop (result i32) (call $dummy) (block (result i32) (i32.const 1)) (call $dummy)) + ) + (func (export "as-loop-last") (result i32) + (loop (result i32) (call $dummy) (call $dummy) (block (result i32) (i32.const 1))) + ) + + (func (export "as-if-condition") + (block (result i32) (i32.const 1)) (if (then (call $dummy))) + ) + (func (export "as-if-then") (result i32) + (if (result i32) (i32.const 1) (then (block (result i32) (i32.const 1))) (else (i32.const 2))) + ) + (func (export "as-if-else") (result i32) + (if (result i32) (i32.const 1) (then (i32.const 2)) (else (block (result i32) (i32.const 1)))) + ) + + (func (export "as-br_if-first") (result i32) + (block (result i32) (br_if 0 (block (result i32) (i32.const 1)) (i32.const 2))) + ) + (func (export "as-br_if-last") (result i32) + (block (result i32) (br_if 0 (i32.const 2) (block (result i32) (i32.const 1)))) + ) + + (func (export "as-br_table-first") (result i32) + (block (result i32) (block (result i32) (i32.const 1)) (i32.const 2) (br_table 0 0)) + ) + (func (export "as-br_table-last") (result i32) + (block (result i32) (i32.const 2) (block (result i32) (i32.const 1)) (br_table 0 0)) + ) + + (func $func (param i32 i32) (result i32) (local.get 0)) + (type $check (func (param i32 i32) (result i32))) + (table funcref (elem $func)) + (func (export "as-call_indirect-first") (result i32) + (block (result i32) + (call_indirect (type $check) + (block (result i32) (i32.const 1)) (i32.const 2) (i32.const 0) + ) + ) + ) + (func (export "as-call_indirect-mid") (result i32) + (block (result i32) + (call_indirect (type $check) + (i32.const 2) (block (result i32) (i32.const 1)) (i32.const 0) + ) + ) + ) + (func (export "as-call_indirect-last") (result i32) + (block (result i32) + (call_indirect (type $check) + (i32.const 1) (i32.const 2) (block (result i32) (i32.const 0)) + ) + ) + ) + + (func (export "as-store-first") + (block (result i32) (i32.const 1)) (i32.const 1) (i32.store) + ) + (func (export "as-store-last") + (i32.const 10) (block (result i32) (i32.const 1)) (i32.store) + ) + + (func (export "as-memory.grow-value") (result i32) + (memory.grow (block (result i32) (i32.const 1))) + ) + + (func $f (param i32) (result i32) (local.get 0)) + + (func (export "as-call-value") (result i32) + (call $f (block (result i32) (i32.const 1))) + ) + (func (export "as-return-value") (result i32) + (block (result i32) (i32.const 1)) (return) + ) + (func (export "as-drop-operand") + (drop (block (result i32) (i32.const 1))) + ) + (func (export "as-br-value") (result i32) + (block (result i32) (br 0 (block (result i32) (i32.const 1)))) + ) + (func (export "as-local.set-value") (result i32) + (local i32) (local.set 0 (block (result i32) (i32.const 1))) (local.get 0) + ) + (func (export "as-local.tee-value") (result i32) + (local i32) (local.tee 0 (block (result i32) (i32.const 1))) + ) + (global $a (mut i32) (i32.const 10)) + (func (export "as-global.set-value") (result i32) + (global.set $a (block (result i32) (i32.const 1))) + (global.get $a) + ) + + (func (export "as-load-operand") (result i32) + (i32.load (block (result i32) (i32.const 1))) + ) + + (func (export "as-unary-operand") (result i32) + (i32.ctz (block (result i32) (call $dummy) (i32.const 13))) + ) + (func (export "as-binary-operand") (result i32) + (i32.mul + (block (result i32) (call $dummy) (i32.const 3)) + (block (result i32) (call $dummy) (i32.const 4)) + ) + ) + (func (export "as-test-operand") (result i32) + (i32.eqz (block (result i32) (call $dummy) (i32.const 13))) + ) + (func (export "as-compare-operand") (result i32) + (f32.gt + (block (result f32) (call $dummy) (f32.const 3)) + (block (result f32) (call $dummy) (f32.const 3)) + ) + ) + (func (export "as-binary-operands") (result i32) + (i32.mul + (block (result i32 i32) + (call $dummy) (i32.const 3) (call $dummy) (i32.const 4) + ) + ) + ) + (func (export "as-compare-operands") (result i32) + (f32.gt + (block (result f32 f32) + (call $dummy) (f32.const 3) (call $dummy) (f32.const 3) + ) + ) + ) + (func (export "as-mixed-operands") (result i32) + (block (result i32 i32) + (call $dummy) (i32.const 3) (call $dummy) (i32.const 4) + ) + (i32.const 5) + (i32.add) + (i32.mul) + ) + + (func (export "break-bare") (result i32) + (block (br 0) (unreachable)) + (block (br_if 0 (i32.const 1)) (unreachable)) + (block (br_table 0 (i32.const 0)) (unreachable)) + (block (br_table 0 0 0 (i32.const 1)) (unreachable)) + (i32.const 19) + ) + (func (export "break-value") (result i32) + (block (result i32) (br 0 (i32.const 18)) (i32.const 19)) + ) + (func (export "break-multi-value") (result i32 i32 i64) + (block (result i32 i32 i64) + (br 0 (i32.const 18) (i32.const -18) (i64.const 18)) + (i32.const 19) (i32.const -19) (i64.const 19) + ) + ) + (func (export "break-repeated") (result i32) + (block (result i32) + (br 0 (i32.const 18)) + (br 0 (i32.const 19)) + (drop (br_if 0 (i32.const 20) (i32.const 0))) + (drop (br_if 0 (i32.const 20) (i32.const 1))) + (br 0 (i32.const 21)) + (br_table 0 (i32.const 22) (i32.const 4)) + (br_table 0 0 0 (i32.const 23) (i32.const 1)) + (i32.const 21) + ) + ) + (func (export "break-inner") (result i32) + (local i32) + (local.set 0 (i32.const 0)) + (local.set 0 (i32.add (local.get 0) (block (result i32) (block (result i32) (br 1 (i32.const 0x1)))))) + (local.set 0 (i32.add (local.get 0) (block (result i32) (block (br 0)) (i32.const 0x2)))) + (local.set 0 + (i32.add (local.get 0) (block (result i32) (i32.ctz (br 0 (i32.const 0x4))))) + ) + (local.set 0 + (i32.add (local.get 0) (block (result i32) (i32.ctz (block (result i32) (br 1 (i32.const 0x8)))))) + ) + (local.get 0) + ) + + (func (export "param") (result i32) + (i32.const 1) + (block (param i32) (result i32) + (i32.const 2) + (i32.add) + ) + ) + (func (export "params") (result i32) + (i32.const 1) + (i32.const 2) + (block (param i32 i32) (result i32) + (i32.add) + ) + ) + (func (export "params-id") (result i32) + (i32.const 1) + (i32.const 2) + (block (param i32 i32) (result i32 i32)) + (i32.add) + ) + (func (export "param-break") (result i32) + (i32.const 1) + (block (param i32) (result i32) + (i32.const 2) + (i32.add) + (br 0) + ) + ) + (func (export "params-break") (result i32) + (i32.const 1) + (i32.const 2) + (block (param i32 i32) (result i32) + (i32.add) + (br 0) + ) + ) + (func (export "params-id-break") (result i32) + (i32.const 1) + (i32.const 2) + (block (param i32 i32) (result i32 i32) (br 0)) + (i32.add) + ) + + (func (export "effects") (result i32) + (local i32) + (block + (local.set 0 (i32.const 1)) + (local.set 0 (i32.mul (local.get 0) (i32.const 3))) + (local.set 0 (i32.sub (local.get 0) (i32.const 5))) + (local.set 0 (i32.mul (local.get 0) (i32.const 7))) + (br 0) + (local.set 0 (i32.mul (local.get 0) (i32.const 100))) + ) + (i32.eq (local.get 0) (i32.const -14)) + ) + + (type $block-sig-1 (func)) + (type $block-sig-2 (func (result i32))) + (type $block-sig-3 (func (param $x i32))) + (type $block-sig-4 (func (param i32 f64 i32) (result i32 f64 i32))) + + (func (export "type-use") + (block (type $block-sig-1)) + (block (type $block-sig-2) (i32.const 0)) + (block (type $block-sig-3) (drop)) + (i32.const 0) (f64.const 0) (i32.const 0) + (block (type $block-sig-4)) + (drop) (drop) (drop) + (block (type $block-sig-2) (result i32) (i32.const 0)) + (block (type $block-sig-3) (param i32) (drop)) + (i32.const 0) (f64.const 0) (i32.const 0) + (block (type $block-sig-4) + (param i32) (param f64 i32) (result i32 f64) (result i32) + ) + (drop) (drop) (drop) + ) +) + +(assert_return (invoke "empty")) +(assert_return (invoke "singular") (i32.const 7)) +(assert_return (invoke "multi") (i32.const 8)) +(assert_return (invoke "nested") (i32.const 9)) +(assert_return (invoke "deep") (i32.const 150)) + +(assert_return (invoke "as-select-first") (i32.const 1)) +(assert_return (invoke "as-select-mid") (i32.const 2)) +(assert_return (invoke "as-select-last") (i32.const 2)) + +(assert_return (invoke "as-loop-first") (i32.const 1)) +(assert_return (invoke "as-loop-mid") (i32.const 1)) +(assert_return (invoke "as-loop-last") (i32.const 1)) + +(assert_return (invoke "as-if-condition")) +(assert_return (invoke "as-if-then") (i32.const 1)) +(assert_return (invoke "as-if-else") (i32.const 2)) + +(assert_return (invoke "as-br_if-first") (i32.const 1)) +(assert_return (invoke "as-br_if-last") (i32.const 2)) + +(assert_return (invoke "as-br_table-first") (i32.const 1)) +(assert_return (invoke "as-br_table-last") (i32.const 2)) + +(assert_return (invoke "as-call_indirect-first") (i32.const 1)) +(assert_return (invoke "as-call_indirect-mid") (i32.const 2)) +(assert_return (invoke "as-call_indirect-last") (i32.const 1)) + +(assert_return (invoke "as-store-first")) +(assert_return (invoke "as-store-last")) + +(assert_return (invoke "as-memory.grow-value") (i32.const 1)) +(assert_return (invoke "as-call-value") (i32.const 1)) +(assert_return (invoke "as-return-value") (i32.const 1)) +(assert_return (invoke "as-drop-operand")) +(assert_return (invoke "as-br-value") (i32.const 1)) +(assert_return (invoke "as-local.set-value") (i32.const 1)) +(assert_return (invoke "as-local.tee-value") (i32.const 1)) +(assert_return (invoke "as-global.set-value") (i32.const 1)) +(assert_return (invoke "as-load-operand") (i32.const 1)) + +(assert_return (invoke "as-unary-operand") (i32.const 0)) +(assert_return (invoke "as-binary-operand") (i32.const 12)) +(assert_return (invoke "as-test-operand") (i32.const 0)) +(assert_return (invoke "as-compare-operand") (i32.const 0)) +(assert_return (invoke "as-binary-operands") (i32.const 12)) +(assert_return (invoke "as-compare-operands") (i32.const 0)) +(assert_return (invoke "as-mixed-operands") (i32.const 27)) + +(assert_return (invoke "break-bare") (i32.const 19)) +(assert_return (invoke "break-value") (i32.const 18)) +(assert_return (invoke "break-multi-value") + (i32.const 18) (i32.const -18) (i64.const 18) +) +(assert_return (invoke "break-repeated") (i32.const 18)) +(assert_return (invoke "break-inner") (i32.const 0xf)) + +(assert_return (invoke "param") (i32.const 3)) +(assert_return (invoke "params") (i32.const 3)) +(assert_return (invoke "params-id") (i32.const 3)) +(assert_return (invoke "param-break") (i32.const 3)) +(assert_return (invoke "params-break") (i32.const 3)) +(assert_return (invoke "params-id-break") (i32.const 3)) + +(assert_return (invoke "effects") (i32.const 1)) + +(assert_return (invoke "type-use")) + +(assert_malformed + (module quote + "(type $sig (func (param i32) (result i32)))" + "(func (i32.const 0) (block (type $sig) (result i32) (param i32)))" + ) + "unexpected token" +) +(assert_malformed + (module quote + "(type $sig (func (param i32) (result i32)))" + "(func (i32.const 0) (block (param i32) (type $sig) (result i32)))" + ) + "unexpected token" +) +(assert_malformed + (module quote + "(type $sig (func (param i32) (result i32)))" + "(func (i32.const 0) (block (param i32) (result i32) (type $sig)))" + ) + "unexpected token" +) +(assert_malformed + (module quote + "(type $sig (func (param i32) (result i32)))" + "(func (i32.const 0) (block (result i32) (type $sig) (param i32)))" + ) + "unexpected token" +) +(assert_malformed + (module quote + "(type $sig (func (param i32) (result i32)))" + "(func (i32.const 0) (block (result i32) (param i32) (type $sig)))" + ) + "unexpected token" +) +(assert_malformed + (module quote + "(func (i32.const 0) (block (result i32) (param i32)))" + ) + "unexpected token" +) + +(assert_malformed + (module quote "(func (i32.const 0) (block (param $x i32) (drop)))") + "unexpected token" +) +(assert_malformed + (module quote + "(type $sig (func))" + "(func (block (type $sig) (result i32) (i32.const 0)) (unreachable))" + ) + "inline function type" +) +(assert_malformed + (module quote + "(type $sig (func (param i32) (result i32)))" + "(func (block (type $sig) (result i32) (i32.const 0)) (unreachable))" + ) + "inline function type" +) +(assert_malformed + (module quote + "(type $sig (func (param i32) (result i32)))" + "(func (i32.const 0) (block (type $sig) (param i32) (drop)) (unreachable))" + ) + "inline function type" +) +(assert_malformed + (module quote + "(type $sig (func (param i32 i32) (result i32)))" + "(func (i32.const 0) (block (type $sig) (param i32) (result i32)) (unreachable))" + ) + "inline function type" +) + +(assert_invalid + (module + (type $sig (func)) + (func (block (type $sig) (i32.const 0))) + ) + "type mismatch" +) + +(assert_invalid + (module (func $type-empty-i32 (result i32) (block))) + "type mismatch" +) +(assert_invalid + (module (func $type-empty-i64 (result i64) (block))) + "type mismatch" +) +(assert_invalid + (module (func $type-empty-f32 (result f32) (block))) + "type mismatch" +) +(assert_invalid + (module (func $type-empty-f64 (result f64) (block))) + "type mismatch" +) + +(assert_invalid + (module (func $type-value-i32-vs-void + (block (i32.const 1)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-value-i64-vs-void + (block (i64.const 1)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-value-f32-vs-void + (block (f32.const 1.0)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-value-f64-vs-void + (block (f64.const 1.0)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-value-nums-vs-void + (block (i32.const 1) (i32.const 2)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-value-empty-vs-i32 (result i32) + (block (result i32)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-value-empty-vs-i64 (result i64) + (block (result i64)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-value-empty-vs-f32 (result f32) + (block (result f32)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-value-empty-vs-f64 (result f64) + (block (result f64)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-value-empty-vs-nums (result i32 i32) + (block (result i32 i32)) + )) + "type mismatch" +) + +(assert_invalid + (module + (func $type-value-empty-in-block + (i32.const 0) + (block (block (result i32)) (drop)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-value-empty-in-loop + (i32.const 0) + (loop (block (result i32)) (drop)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-value-empty-in-then + (i32.const 0) (i32.const 0) + (if (then (block (result i32)) (drop))) + ) + ) + "type mismatch" +) + +(assert_invalid + (module (func $type-value-void-vs-i32 (result i32) + (block (result i32) (nop)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-value-void-vs-i64 (result i64) + (block (result i64) (nop)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-value-void-vs-f32 (result f32) + (block (result f32) (nop)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-value-void-vs-f64 (result f64) + (block (result f64) (nop)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-value-void-vs-nums (result i32 i32) + (block (result i32 i32) (nop)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-value-i32-vs-i64 (result i32) + (block (result i32) (i64.const 0)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-value-i32-vs-f32 (result i32) + (block (result i32) (f32.const 0.0)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-value-i32-vs-f64 (result i32) + (block (result i32) (f64.const 0.0)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-value-i64-vs-i32 (result i64) + (block (result i64) (i32.const 0)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-value-i64-vs-f32 (result i64) + (block (result i64) (f32.const 0.0)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-value-i64-vs-f64 (result i64) + (block (result i64) (f64.const 0.0)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-value-f32-vs-i32 (result f32) + (block (result f32) (i32.const 0)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-value-f32-vs-i64 (result f32) + (block (result f32) (i64.const 0)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-value-f32-vs-f64 (result f32) + (block (result f32) (f64.const 0.0)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-value-f64-vs-i32 (result f64) + (block (result f64) (i32.const 0)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-value-f64-vs-i64 (result f64) + (block (result f64) (i64.const 0)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-value-f64-vs-f32 (result f32) + (block (result f64) (f32.const 0.0)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-value-num-vs-nums (result i32 i32) + (block (result i32 i32) (i32.const 0)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-value-partial-vs-nums (result i32 i32) + (i32.const 1) (block (result i32 i32) (i32.const 2)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-value-nums-vs-num (result i32) + (block (result i32) (i32.const 1) (i32.const 2)) + )) + "type mismatch" +) + +(assert_invalid + (module (func $type-value-unreached-select-i32-i64 (result i32) + (block (result i64) (select (unreachable) (unreachable) (unreachable))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-value-unreached-select-i32-f32 (result i32) + (block (result f32) (select (unreachable) (unreachable) (unreachable))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-value-unreached-select-i32-f64 (result i32) + (block (result f64) (select (unreachable) (unreachable) (unreachable))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-value-unreached-select-i64-i32 (result i64) + (block (result i32) (select (unreachable) (unreachable) (unreachable))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-value-unreached-select-i64-f32 (result i64) + (block (result f32) (select (unreachable) (unreachable) (unreachable))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-value-unreached-select-i64-f64 (result i64) + (block (result f64) (select (unreachable) (unreachable) (unreachable))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-value-unreached-select-f32-i32 (result f32) + (block (result i32) (select (unreachable) (unreachable) (unreachable))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-value-unreached-select-f32-i64 (result f32) + (block (result i64) (select (unreachable) (unreachable) (unreachable))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-value-unreached-select-f32-f64 (result f32) + (block (result f64) (select (unreachable) (unreachable) (unreachable))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-value-unreached-select-f64-i32 (result f64) + (block (result i32) (select (unreachable) (unreachable) (unreachable))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-value-unreached-select-f64-i64 (result f64) + (block (result i64) (select (unreachable) (unreachable) (unreachable))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-value-unreached-select-f64-f32 (result f64) + (block (result f32) (select (unreachable) (unreachable) (unreachable))) + )) + "type mismatch" +) + +(assert_invalid + (module (func $type-break-last-void-vs-i32 (result i32) + (block (result i32) (br 0)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-last-void-vs-i64 (result i64) + (block (result i64) (br 0)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-last-void-vs-f32 (result f32) + (block (result f32) (br 0)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-last-void-vs-f64 (result f64) + (block (result f64) (br 0)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-last-void-vs-nums (result i32 i32) + (block (result i32 i32) (br 0)) + )) + "type mismatch" +) + +(assert_invalid + (module (func $type-break-empty-vs-i32 (result i32) + (block (result i32) (br 0) (i32.const 1)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-empty-vs-i64 (result i64) + (block (result i64) (br 0) (i64.const 1)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-empty-vs-f32 (result f32) + (block (result f32) (br 0) (f32.const 1.0)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-empty-vs-f64 (result f64) + (block (result f64) (br 0) (f64.const 1.0)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-empty-vs-nums (result i32 i32) + (block (result i32 i32) (br 0) (i32.const 1) (i32.const 2)) + )) + "type mismatch" +) + +(assert_invalid + (module (func $type-break-void-vs-i32 (result i32) + (block (result i32) (br 0 (nop)) (i32.const 1)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-void-vs-i64 (result i64) + (block (result i64) (br 0 (nop)) (i64.const 1)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-void-vs-f32 (result f32) + (block (result f32) (br 0 (nop)) (f32.const 1.0)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-void-vs-f64 (result f64) + (block (result f64) (br 0 (nop)) (f64.const 1.0)) + )) + "type mismatch" +) + +(assert_invalid + (module (func $type-break-i32-vs-i64 (result i32) + (block (result i32) (br 0 (i64.const 1)) (i32.const 1)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-i32-vs-f32 (result i32) + (block (result i32) (br 0 (f32.const 1.0)) (i32.const 1)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-i32-vs-f64 (result i32) + (block (result i32) (br 0 (f64.const 1.0)) (i32.const 1)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-i64-vs-i32 (result i64) + (block (result i64) (br 0 (i32.const 1)) (i64.const 1)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-i64-vs-f32 (result i64) + (block (result i64) (br 0 (f32.const 1.0)) (i64.const 1)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-i64-vs-f64 (result i64) + (block (result i64) (br 0 (f64.const 1.0)) (i64.const 1)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-f32-vs-i32 (result f32) + (block (result f32) (br 0 (i32.const 1)) (f32.const 1.0)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-f32-vs-i64 (result f32) + (block (result f32) (br 0 (i64.const 1)) (f32.const 1.0)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-f32-vs-f64 (result f32) + (block (result f32) (br 0 (f64.const 1.0)) (f32.const 1.0)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-f64-vs-i32 (result f64) + (block (result i64) (br 0 (i32.const 1)) (f64.const 1.0)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-f64-vs-i64 (result f64) + (block (result f64) (br 0 (i64.const 1)) (f64.const 1.0)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-f64-vs-f32 (result f64) + (block (result f64) (br 0 (f32.const 1.0)) (f64.const 1)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-num-vs-nums (result i32 i32) + (block (result i32 i32) (br 0 (i32.const 0)) (i32.const 1) (i32.const 2)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-partial-vs-nums (result i32 i32) + (i32.const 1) (block (result i32 i32) (br 0 (i32.const 0)) (i32.const 2)) + )) + "type mismatch" +) + +(assert_invalid + (module (func $type-break-first-void-vs-i32 (result i32) + (block (result i32) (br 0 (nop)) (br 0 (i32.const 1))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-first-void-vs-i64 (result i64) + (block (result i64) (br 0 (nop)) (br 0 (i64.const 1))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-first-void-vs-f32 (result f32) + (block (result f32) (br 0 (nop)) (br 0 (f32.const 1.0))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-first-void-vs-f64 (result f64) + (block (result f64) (br 0 (nop)) (br 0 (f64.const 1.0))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-first-void-vs-nums (result i32 i32) + (block (result i32 i32) (br 0 (nop)) (br 0 (i32.const 1) (i32.const 2))) + )) + "type mismatch" +) + +(assert_invalid + (module (func $type-break-first-i32-vs-i64 (result i32) + (block (result i32) (br 0 (i64.const 1)) (br 0 (i32.const 1))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-first-i32-vs-f32 (result i32) + (block (result i32) (br 0 (f32.const 1.0)) (br 0 (i32.const 1))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-first-i32-vs-f64 (result i32) + (block (result i32) (br 0 (f64.const 1.0)) (br 0 (i32.const 1))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-first-i64-vs-i32 (result i64) + (block (result i64) (br 0 (i32.const 1)) (br 0 (i64.const 1))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-first-i64-vs-f32 (result i64) + (block (result i64) (br 0 (f32.const 1.0)) (br 0 (i64.const 1))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-first-i64-vs-f64 (result i64) + (block (result i64) (br 0 (f64.const 1.0)) (br 0 (i64.const 1))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-first-f32-vs-i32 (result f32) + (block (result f32) (br 0 (i32.const 1)) (br 0 (f32.const 1.0))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-first-f32-vs-i64 (result f32) + (block (result f32) (br 0 (i64.const 1)) (br 0 (f32.const 1.0))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-first-f32-vs-f64 (result f32) + (block (result f32) (br 0 (f64.const 1.0)) (br 0 (f32.const 1.0))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-first-f64-vs-i32 (result f64) + (block (result f64) (br 0 (i32.const 1)) (br 0 (f64.const 1.0))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-first-f64-vs-i64 (result f64) + (block (result f64) (br 0 (i64.const 1)) (br 0 (f64.const 1.0))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-first-f64-vs-f32 (result f64) + (block (result f64) (br 0 (f32.const 1.0)) (br 0 (f64.const 1.0))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-first-num-vs-nums (result i32 i32) + (block (result i32 i32) (br 0 (i32.const 0)) (br 0 (i32.const 1) (i32.const 2))) + )) + "type mismatch" +) + +(assert_invalid + (module (func $type-break-nested-i32-vs-void + (block (result i32) (block (result i32) (br 1 (i32.const 1))) (br 0)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-nested-i64-vs-void + (block (result i64) (block (result i64) (br 1 (i64.const 1))) (br 0)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-nested-f32-vs-void + (block (result f32) (block (result f32) (br 1 (f32.const 1.0))) (br 0)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-nested-f64-vs-void + (block (result f64) (block (result f64) (br 1 (f64.const 1.0))) (br 0)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-nested-nums-vs-void + (block (result i32 i32) (block (result i32 i32) (br 1 (i32.const 1) (i32.const 2))) (br 0)) + )) + "type mismatch" +) + +(assert_invalid + (module (func $type-break-nested-empty-vs-i32 (result i32) + (block (result i32) (block (br 1)) (br 0 (i32.const 1))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-nested-empty-vs-i64 (result i64) + (block (result i64) (block (br 1)) (br 0 (i64.const 1))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-nested-empty-vs-f32 (result f32) + (block (result f32) (block (br 1)) (br 0 (f32.const 1.0))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-nested-empty-vs-f64 (result f64) + (block (result f64) (block (br 1)) (br 0 (f64.const 1))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-nested-empty-vs-nums (result i32 i32) + (block (result i32 i32) (block (br 1)) (br 0 (i32.const 1) (i32.const 2))) + )) + "type mismatch" +) + +(assert_invalid + (module (func $type-break-nested-void-vs-i32 (result i32) + (block (result i32) (block (result i32) (br 1 (nop))) (br 0 (i32.const 1))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-nested-void-vs-i64 (result i64) + (block (result i64) (block (result i64) (br 1 (nop))) (br 0 (i64.const 1))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-nested-void-vs-f32 (result f32) + (block (result f32) (block (result f32) (br 1 (nop))) (br 0 (f32.const 1.0))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-nested-void-vs-f64 (result f64) + (block (result f64) (block (result f64) (br 1 (nop))) (br 0 (f64.const 1.0))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-nested-void-vs-nums (result i32 i32) + (block (result i32 i32) (block (result i32 i32) (br 1 (nop))) (br 0 (i32.const 1) (i32.const 2))) + )) + "type mismatch" +) + +(assert_invalid + (module (func $type-break-nested-i32-vs-i64 (result i32) + (block (result i32) + (block (result i32) (br 1 (i64.const 1))) (br 0 (i32.const 1)) + ) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-nested-i32-vs-f32 (result i32) + (block (result i32) + (block (result i32) (br 1 (f32.const 1.0))) (br 0 (i32.const 1)) + ) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-nested-i32-vs-f64 (result i32) + (block (result i32) + (block (result i32) (br 1 (f64.const 1.0))) (br 0 (i32.const 1)) + ) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-nested-i64-vs-i32 (result i64) + (block (result i64) + (block (result i64) (br 1 (i32.const 1))) (br 0 (i64.const 1)) + ) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-nested-i64-vs-f32 (result i64) + (block (result i64) + (block (result i64) (br 1 (f32.const 1.0))) (br 0 (i64.const 1)) + ) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-nested-i64-vs-f64 (result i64) + (block (result i64) + (block (result i64) (br 1 (f64.const 1.0))) (br 0 (i64.const 1)) + ) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-nested-f32-vs-i32 (result f32) + (block (result f32) + (block (result f32) (br 1 (i32.const 1))) (br 0 (f32.const 1.0)) + ) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-nested-f32-vs-i64 (result f32) + (block (result f32) + (block (result f32) (br 1 (i64.const 1))) (br 0 (f32.const 1.0)) + ) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-nested-f32-vs-f64 (result f32) + (block (result f32) + (block (result f32) (br 1 (f64.const 1.0))) (br 0 (f32.const 1.0)) + ) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-nested-f64-vs-i32 (result f64) + (block (result f64) + (block (result f64) (br 1 (i32.const 1))) (br 0 (f64.const 1.0)) + ) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-nested-f64-vs-i64 (result f64) + (block (result f64) + (block (result f64) (br 1 (i64.const 1))) (br 0 (f64.const 1.0)) + ) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-nested-f64-vs-f32 (result f64) + (block (result f64) + (block (result f64) (br 1 (f32.const 1.0))) (br 0 (f64.const 1.0)) + ) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-nested-num-vs-nums (result i32 i32) + (block (result i32 i32) + (block (result i32 i32) (br 1 (i32.const 0))) (br 0 (i32.const 1) (i32.const 2)) + ) + )) + "type mismatch" +) + +(assert_invalid + (module (func $type-break-operand-empty-vs-i32 (result i32) + (i32.ctz (block (br 0))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-operand-empty-vs-i64 (result i64) + (i64.ctz (block (br 0))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-operand-empty-vs-f32 (result f32) + (f32.floor (block (br 0))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-operand-empty-vs-f64 (result f64) + (f64.floor (block (br 0))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-operand-empty-vs-nums (result i32) + (i32.add (block (br 0))) + )) + "type mismatch" +) + +(assert_invalid + (module (func $type-break-operand-void-vs-i32 (result i32) + (i32.ctz (block (br 0 (nop)))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-operand-void-vs-i64 (result i64) + (i64.ctz (block (br 0 (nop)))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-operand-void-vs-f32 (result f32) + (f32.floor (block (br 0 (nop)))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-operand-void-vs-f64 (result f64) + (f64.floor (block (br 0 (nop)))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-operand-void-vs-nums (result i32) + (i32.add (block (br 0 (nop)))) + )) + "type mismatch" +) + +(assert_invalid + (module (func $type-break-operand-i32-vs-i64 (result i32) + (i64.ctz (block (br 0 (i64.const 9)))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-operand-i32-vs-f32 (result i32) + (f32.floor (block (br 0 (f32.const 9.0)))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-operand-i32-vs-f64 (result i32) + (f64.floor (block (br 0 (f64.const 9.0)))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-operand-i64-vs-i32 (result i64) + (i32.ctz (block (br 0 (i32.const 9)))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-operand-i64-vs-f32 (result i64) + (f32.floor (block (br 0 (f32.const 9.0)))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-operand-i64-vs-f64 (result i64) + (f64.floor (block (br 0 (f64.const 9.0)))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-operand-f32-vs-i32 (result f32) + (i32.ctz (block (br 0 (i32.const 9)))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-operand-f32-vs-i64 (result f32) + (i64.ctz (block (br 0 (i64.const 9)))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-operand-f32-vs-f64 (result f32) + (f64.floor (block (br 0 (f64.const 9.0)))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-operand-f64-vs-i32 (result f64) + (i32.ctz (block (br 0 (i32.const 9)))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-operand-f64-vs-i64 (result f64) + (i64.ctz (block (br 0 (i64.const 9)))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-operand-f64-vs-f32 (result f64) + (f32.floor (block (br 0 (f32.const 9.0)))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-operand-num-vs-nums (result i32) + (i32.add (block (br 0 (i64.const 9) (i32.const 10)))) + )) + "type mismatch" +) + +(assert_invalid + (module (func $type-param-void-vs-num + (block (param i32) (drop)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-param-void-vs-nums + (block (param i32 f64) (drop) (drop)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-param-num-vs-num + (f32.const 0) (block (param i32) (drop)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-param-num-vs-nums + (f32.const 0) (block (param f32 i32) (drop) (drop)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-param-nested-void-vs-num + (block (block (param i32) (drop))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-param-void-vs-nums + (block (block (param i32 f64) (drop) (drop))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-param-num-vs-num + (block (f32.const 0) (block (param i32) (drop))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-param-num-vs-nums + (block (f32.const 0) (block (param f32 i32) (drop) (drop))) + )) + "type mismatch" +) + +(assert_malformed + (module quote "(func (param i32) (result i32) block (param $x i32) end)") + "unexpected token" +) +(assert_malformed + (module quote "(func (param i32) (result i32) (block (param $x i32)))") + "unexpected token" +) + + +(assert_malformed + (module quote "(func block end $l)") + "mismatching label" +) +(assert_malformed + (module quote "(func block $a end $l)") + "mismatching label" +) diff --git a/runtime/near-vm/tests/wast/spec/proposals/multi-value/br.wast b/runtime/near-vm/tests/wast/spec/proposals/multi-value/br.wast new file mode 100644 index 00000000000..35f707c9222 --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/proposals/multi-value/br.wast @@ -0,0 +1,657 @@ +;; Test `br` operator + +(module + ;; Auxiliary definition + (func $dummy) + + (func (export "type-i32") (block (drop (i32.ctz (br 0))))) + (func (export "type-i64") (block (drop (i64.ctz (br 0))))) + (func (export "type-f32") (block (drop (f32.neg (br 0))))) + (func (export "type-f64") (block (drop (f64.neg (br 0))))) + (func (export "type-i32-i32") (block (drop (i32.add (br 0))))) + (func (export "type-i64-i64") (block (drop (i64.add (br 0))))) + (func (export "type-f32-f32") (block (drop (f32.add (br 0))))) + (func (export "type-f64-f64") (block (drop (f64.add (br 0))))) + + (func (export "type-i32-value") (result i32) + (block (result i32) (i32.ctz (br 0 (i32.const 1)))) + ) + (func (export "type-i64-value") (result i64) + (block (result i64) (i64.ctz (br 0 (i64.const 2)))) + ) + (func (export "type-f32-value") (result f32) + (block (result f32) (f32.neg (br 0 (f32.const 3)))) + ) + (func (export "type-f64-value") (result f64) + (block (result f64) (f64.neg (br 0 (f64.const 4)))) + ) + (func (export "type-f64-f64-value") (result f64 f64) + (block (result f64 f64) + (f64.add (br 0 (f64.const 4) (f64.const 5))) (f64.const 6) + ) + ) + + (func (export "as-block-first") + (block (br 0) (call $dummy)) + ) + (func (export "as-block-mid") + (block (call $dummy) (br 0) (call $dummy)) + ) + (func (export "as-block-last") + (block (nop) (call $dummy) (br 0)) + ) + (func (export "as-block-value") (result i32) + (block (result i32) (nop) (call $dummy) (br 0 (i32.const 2))) + ) + + (func (export "as-loop-first") (result i32) + (block (result i32) (loop (result i32) (br 1 (i32.const 3)) (i32.const 2))) + ) + (func (export "as-loop-mid") (result i32) + (block (result i32) + (loop (result i32) (call $dummy) (br 1 (i32.const 4)) (i32.const 2)) + ) + ) + (func (export "as-loop-last") (result i32) + (block (result i32) + (loop (result i32) (nop) (call $dummy) (br 1 (i32.const 5))) + ) + ) + + (func (export "as-br-value") (result i32) + (block (result i32) (br 0 (br 0 (i32.const 9)))) + ) + + (func (export "as-br_if-cond") + (block (br_if 0 (br 0))) + ) + (func (export "as-br_if-value") (result i32) + (block (result i32) + (drop (br_if 0 (br 0 (i32.const 8)) (i32.const 1))) (i32.const 7) + ) + ) + (func (export "as-br_if-value-cond") (result i32) + (block (result i32) + (drop (br_if 0 (i32.const 6) (br 0 (i32.const 9)))) (i32.const 7) + ) + ) + + (func (export "as-br_table-index") + (block (br_table 0 0 0 (br 0))) + ) + (func (export "as-br_table-value") (result i32) + (block (result i32) + (br_table 0 0 0 (br 0 (i32.const 10)) (i32.const 1)) (i32.const 7) + ) + ) + (func (export "as-br_table-value-index") (result i32) + (block (result i32) + (br_table 0 0 (i32.const 6) (br 0 (i32.const 11))) (i32.const 7) + ) + ) + + (func (export "as-return-value") (result i64) + (block (result i64) (return (br 0 (i64.const 7)))) + ) + (func (export "as-return-values") (result i32 i64) + (i32.const 2) + (block (result i64) (return (br 0 (i32.const 1) (i64.const 7)))) + ) + + (func (export "as-if-cond") (result i32) + (block (result i32) + (if (result i32) (br 0 (i32.const 2)) + (then (i32.const 0)) + (else (i32.const 1)) + ) + ) + ) + (func (export "as-if-then") (param i32 i32) (result i32) + (block (result i32) + (if (result i32) (local.get 0) + (then (br 1 (i32.const 3))) + (else (local.get 1)) + ) + ) + ) + (func (export "as-if-else") (param i32 i32) (result i32) + (block (result i32) + (if (result i32) (local.get 0) + (then (local.get 1)) + (else (br 1 (i32.const 4))) + ) + ) + ) + + (func (export "as-select-first") (param i32 i32) (result i32) + (block (result i32) + (select (br 0 (i32.const 5)) (local.get 0) (local.get 1)) + ) + ) + (func (export "as-select-second") (param i32 i32) (result i32) + (block (result i32) + (select (local.get 0) (br 0 (i32.const 6)) (local.get 1)) + ) + ) + (func (export "as-select-cond") (result i32) + (block (result i32) + (select (i32.const 0) (i32.const 1) (br 0 (i32.const 7))) + ) + ) + (func (export "as-select-all") (result i32) + (block (result i32) (select (br 0 (i32.const 8)))) + ) + + (func $f (param i32 i32 i32) (result i32) (i32.const -1)) + (func (export "as-call-first") (result i32) + (block (result i32) + (call $f (br 0 (i32.const 12)) (i32.const 2) (i32.const 3)) + ) + ) + (func (export "as-call-mid") (result i32) + (block (result i32) + (call $f (i32.const 1) (br 0 (i32.const 13)) (i32.const 3)) + ) + ) + (func (export "as-call-last") (result i32) + (block (result i32) + (call $f (i32.const 1) (i32.const 2) (br 0 (i32.const 14))) + ) + ) + (func (export "as-call-all") (result i32) + (block (result i32) (call $f (br 0 (i32.const 15)))) + ) + + (type $sig (func (param i32 i32 i32) (result i32))) + (table funcref (elem $f)) + (func (export "as-call_indirect-func") (result i32) + (block (result i32) + (call_indirect (type $sig) + (br 0 (i32.const 20)) + (i32.const 1) (i32.const 2) (i32.const 3) + ) + ) + ) + (func (export "as-call_indirect-first") (result i32) + (block (result i32) + (call_indirect (type $sig) + (i32.const 0) + (br 0 (i32.const 21)) (i32.const 2) (i32.const 3) + ) + ) + ) + (func (export "as-call_indirect-mid") (result i32) + (block (result i32) + (call_indirect (type $sig) + (i32.const 0) + (i32.const 1) (br 0 (i32.const 22)) (i32.const 3) + ) + ) + ) + (func (export "as-call_indirect-last") (result i32) + (block (result i32) + (call_indirect (type $sig) + (i32.const 0) + (i32.const 1) (i32.const 2) (br 0 (i32.const 23)) + ) + ) + ) + (func (export "as-call_indirect-all") (result i32) + (block (result i32) (call_indirect (type $sig) (br 0 (i32.const 24)))) + ) + + (func (export "as-local.set-value") (result i32) (local f32) + (block (result i32) (local.set 0 (br 0 (i32.const 17))) (i32.const -1)) + ) + (func (export "as-local.tee-value") (result i32) (local i32) + (block (result i32) (local.tee 0 (br 0 (i32.const 1)))) + ) + (global $a (mut i32) (i32.const 10)) + (func (export "as-global.set-value") (result i32) + (block (result i32) (global.set $a (br 0 (i32.const 1)))) + ) + + (memory 1) + (func (export "as-load-address") (result f32) + (block (result f32) (f32.load (br 0 (f32.const 1.7)))) + ) + (func (export "as-loadN-address") (result i64) + (block (result i64) (i64.load8_s (br 0 (i64.const 30)))) + ) + + (func (export "as-store-address") (result i32) + (block (result i32) + (f64.store (br 0 (i32.const 30)) (f64.const 7)) (i32.const -1) + ) + ) + (func (export "as-store-value") (result i32) + (block (result i32) + (i64.store (i32.const 2) (br 0 (i32.const 31))) (i32.const -1) + ) + ) + (func (export "as-store-both") (result i32) + (block (result i32) + (i64.store (br 0 (i32.const 32))) (i32.const -1) + ) + ) + + (func (export "as-storeN-address") (result i32) + (block (result i32) + (i32.store8 (br 0 (i32.const 32)) (i32.const 7)) (i32.const -1) + ) + ) + (func (export "as-storeN-value") (result i32) + (block (result i32) + (i64.store16 (i32.const 2) (br 0 (i32.const 33))) (i32.const -1) + ) + ) + (func (export "as-storeN-both") (result i32) + (block (result i32) + (i64.store16 (br 0 (i32.const 34))) (i32.const -1) + ) + ) + + (func (export "as-unary-operand") (result f32) + (block (result f32) (f32.neg (br 0 (f32.const 3.4)))) + ) + + (func (export "as-binary-left") (result i32) + (block (result i32) (i32.add (br 0 (i32.const 3)) (i32.const 10))) + ) + (func (export "as-binary-right") (result i64) + (block (result i64) (i64.sub (i64.const 10) (br 0 (i64.const 45)))) + ) + (func (export "as-binary-both") (result i32) + (block (result i32) (i32.add (br 0 (i32.const 46)))) + ) + + (func (export "as-test-operand") (result i32) + (block (result i32) (i32.eqz (br 0 (i32.const 44)))) + ) + + (func (export "as-compare-left") (result i32) + (block (result i32) (f64.le (br 0 (i32.const 43)) (f64.const 10))) + ) + (func (export "as-compare-right") (result i32) + (block (result i32) (f32.ne (f32.const 10) (br 0 (i32.const 42)))) + ) + (func (export "as-compare-both") (result i32) + (block (result i32) (f64.le (br 0 (i32.const 44)))) + ) + + (func (export "as-convert-operand") (result i32) + (block (result i32) (i32.wrap_i64 (br 0 (i32.const 41)))) + ) + + (func (export "as-memory.grow-size") (result i32) + (block (result i32) (memory.grow (br 0 (i32.const 40)))) + ) + + (func (export "nested-block-value") (result i32) + (i32.add + (i32.const 1) + (block (result i32) + (call $dummy) + (i32.add (i32.const 4) (br 0 (i32.const 8))) + ) + ) + ) + + (func (export "nested-br-value") (result i32) + (i32.add + (i32.const 1) + (block (result i32) + (drop (i32.const 2)) + (drop + (block (result i32) + (drop (i32.const 4)) + (br 0 (br 1 (i32.const 8))) + ) + ) + (i32.const 16) + ) + ) + ) + + (func (export "nested-br_if-value") (result i32) + (i32.add + (i32.const 1) + (block (result i32) + (drop (i32.const 2)) + (drop + (block (result i32) + (drop (i32.const 4)) + (drop (br_if 0 (br 1 (i32.const 8)) (i32.const 1))) + (i32.const 32) + ) + ) + (i32.const 16) + ) + ) + ) + + (func (export "nested-br_if-value-cond") (result i32) + (i32.add + (i32.const 1) + (block (result i32) + (drop (i32.const 2)) + (drop (br_if 0 (i32.const 4) (br 0 (i32.const 8)))) + (i32.const 16) + ) + ) + ) + + (func (export "nested-br_table-value") (result i32) + (i32.add + (i32.const 1) + (block (result i32) + (drop (i32.const 2)) + (drop + (block (result i32) + (drop (i32.const 4)) + (br_table 0 (br 1 (i32.const 8)) (i32.const 1)) + ) + ) + (i32.const 16) + ) + ) + ) + + (func (export "nested-br_table-value-index") (result i32) + (i32.add + (i32.const 1) + (block (result i32) + (drop (i32.const 2)) + (br_table 0 (i32.const 4) (br 0 (i32.const 8))) + (i32.const 16) + ) + ) + ) +) + +(assert_return (invoke "type-i32")) +(assert_return (invoke "type-i64")) +(assert_return (invoke "type-f32")) +(assert_return (invoke "type-f64")) +(assert_return (invoke "type-i32-i32")) +(assert_return (invoke "type-i64-i64")) +(assert_return (invoke "type-f32-f32")) +(assert_return (invoke "type-f64-f64")) + +(assert_return (invoke "type-i32-value") (i32.const 1)) +(assert_return (invoke "type-i64-value") (i64.const 2)) +(assert_return (invoke "type-f32-value") (f32.const 3)) +(assert_return (invoke "type-f64-value") (f64.const 4)) +(assert_return (invoke "type-f64-f64-value") (f64.const 4) (f64.const 5)) + +(assert_return (invoke "as-block-first")) +(assert_return (invoke "as-block-mid")) +(assert_return (invoke "as-block-last")) +(assert_return (invoke "as-block-value") (i32.const 2)) + +(assert_return (invoke "as-loop-first") (i32.const 3)) +(assert_return (invoke "as-loop-mid") (i32.const 4)) +(assert_return (invoke "as-loop-last") (i32.const 5)) + +(assert_return (invoke "as-br-value") (i32.const 9)) + +(assert_return (invoke "as-br_if-cond")) +(assert_return (invoke "as-br_if-value") (i32.const 8)) +(assert_return (invoke "as-br_if-value-cond") (i32.const 9)) + +(assert_return (invoke "as-br_table-index")) +(assert_return (invoke "as-br_table-value") (i32.const 10)) +(assert_return (invoke "as-br_table-value-index") (i32.const 11)) + +(assert_return (invoke "as-return-value") (i64.const 7)) +(assert_return (invoke "as-return-values") (i32.const 2) (i64.const 7)) + +(assert_return (invoke "as-if-cond") (i32.const 2)) +(assert_return (invoke "as-if-then" (i32.const 1) (i32.const 6)) (i32.const 3)) +(assert_return (invoke "as-if-then" (i32.const 0) (i32.const 6)) (i32.const 6)) +(assert_return (invoke "as-if-else" (i32.const 0) (i32.const 6)) (i32.const 4)) +(assert_return (invoke "as-if-else" (i32.const 1) (i32.const 6)) (i32.const 6)) + +(assert_return (invoke "as-select-first" (i32.const 0) (i32.const 6)) (i32.const 5)) +(assert_return (invoke "as-select-first" (i32.const 1) (i32.const 6)) (i32.const 5)) +(assert_return (invoke "as-select-second" (i32.const 0) (i32.const 6)) (i32.const 6)) +(assert_return (invoke "as-select-second" (i32.const 1) (i32.const 6)) (i32.const 6)) +(assert_return (invoke "as-select-cond") (i32.const 7)) +(assert_return (invoke "as-select-all") (i32.const 8)) + +(assert_return (invoke "as-call-first") (i32.const 12)) +(assert_return (invoke "as-call-mid") (i32.const 13)) +(assert_return (invoke "as-call-last") (i32.const 14)) +(assert_return (invoke "as-call-all") (i32.const 15)) + +(assert_return (invoke "as-call_indirect-func") (i32.const 20)) +(assert_return (invoke "as-call_indirect-first") (i32.const 21)) +(assert_return (invoke "as-call_indirect-mid") (i32.const 22)) +(assert_return (invoke "as-call_indirect-last") (i32.const 23)) +(assert_return (invoke "as-call_indirect-all") (i32.const 24)) + +(assert_return (invoke "as-local.set-value") (i32.const 17)) +(assert_return (invoke "as-local.tee-value") (i32.const 1)) +(assert_return (invoke "as-global.set-value") (i32.const 1)) + +(assert_return (invoke "as-load-address") (f32.const 1.7)) +(assert_return (invoke "as-loadN-address") (i64.const 30)) + +(assert_return (invoke "as-store-address") (i32.const 30)) +(assert_return (invoke "as-store-value") (i32.const 31)) +(assert_return (invoke "as-store-both") (i32.const 32)) +(assert_return (invoke "as-storeN-address") (i32.const 32)) +(assert_return (invoke "as-storeN-value") (i32.const 33)) +(assert_return (invoke "as-storeN-both") (i32.const 34)) + +(assert_return (invoke "as-unary-operand") (f32.const 3.4)) + +(assert_return (invoke "as-binary-left") (i32.const 3)) +(assert_return (invoke "as-binary-right") (i64.const 45)) +(assert_return (invoke "as-binary-both") (i32.const 46)) + +(assert_return (invoke "as-test-operand") (i32.const 44)) + +(assert_return (invoke "as-compare-left") (i32.const 43)) +(assert_return (invoke "as-compare-right") (i32.const 42)) +(assert_return (invoke "as-compare-both") (i32.const 44)) + +(assert_return (invoke "as-convert-operand") (i32.const 41)) + +(assert_return (invoke "as-memory.grow-size") (i32.const 40)) + +(assert_return (invoke "nested-block-value") (i32.const 9)) +(assert_return (invoke "nested-br-value") (i32.const 9)) +(assert_return (invoke "nested-br_if-value") (i32.const 9)) +(assert_return (invoke "nested-br_if-value-cond") (i32.const 9)) +(assert_return (invoke "nested-br_table-value") (i32.const 9)) +(assert_return (invoke "nested-br_table-value-index") (i32.const 9)) + +(assert_invalid + (module (func $type-arg-empty-vs-num (result i32) + (block (result i32) (br 0) (i32.const 1)) + )) + "type mismatch" +) + +(assert_invalid + (module (func $type-arg-void-vs-num (result i32) + (block (result i32) (br 0 (nop)) (i32.const 1)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-arg-void-vs-num-nested (result i32) + (block (result i32) (i32.const 0) (block (br 1))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-arg-num-vs-num (result i32) + (block (result i32) (br 0 (i64.const 1)) (i32.const 1)) + )) + "type mismatch" +) + +(assert_invalid + (module + (func $type-arg-empty-in-br + (i32.const 0) + (block (result i32) (br 0 (br 0))) (i32.eqz) (drop) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-arg-empty-in-br_if + (i32.const 0) + (block (result i32) (br_if 0 (br 0) (i32.const 1))) (i32.eqz) (drop) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-arg-empty-in-br_table + (i32.const 0) + (block (result i32) (br_table 0 (br 0))) (i32.eqz) (drop) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-arg-empty-in-return + (block (result i32) + (return (br 0)) + ) + (i32.eqz) (drop) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-arg-empty-in-select + (block (result i32) + (select (br 0) (i32.const 1) (i32.const 2)) + ) + (i32.eqz) (drop) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-arg-empty-in-call + (block (result i32) + (call 1 (br 0)) + ) + (i32.eqz) (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-arg-empty-in-call_indirect + (block (result i32) + (call_indirect (type $sig) + (br 0) (i32.const 0) + ) + ) + (i32.eqz) (drop) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-arg-empty-in-local.set + (local i32) + (block (result i32) + (local.set 0 (br 0)) (local.get 0) + ) + (i32.eqz) (drop) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-arg-empty-in-local.tee + (local i32) + (block (result i32) + (local.tee 0 (br 0)) + ) + (i32.eqz) (drop) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (global $x (mut i32) (i32.const 0)) + (func $type-arg-empty-in-global.set + (block (result i32) + (global.set $x (br 0)) (global.get $x) + ) + (i32.eqz) (drop) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (memory 0) + (func $type-arg-empty-in-memory.grow + (block (result i32) + (memory.grow (br 0)) + ) + (i32.eqz) (drop) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (memory 1) + (func $type-arg-empty-in-load + (block (result i32) + (i32.load (br 0)) + ) + (i32.eqz) (drop) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (memory 1) + (func $type-arg-empty-in-store + (block (result i32) + (i32.store (br 0) (i32.const 0)) + ) + (i32.eqz) (drop) + ) + ) + "type mismatch" +) + +(assert_invalid + (module (func $unbound-label (br 1))) + "unknown label" +) +(assert_invalid + (module (func $unbound-nested-label (block (block (br 5))))) + "unknown label" +) +(assert_invalid + (module (func $large-label (br 0x10000001))) + "unknown label" +) diff --git a/runtime/near-vm/tests/wast/spec/proposals/multi-value/call.wast b/runtime/near-vm/tests/wast/spec/proposals/multi-value/call.wast new file mode 100644 index 00000000000..e4f854f7a55 --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/proposals/multi-value/call.wast @@ -0,0 +1,518 @@ +;; Test `call` operator + +(module + ;; Auxiliary definitions + (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 $const-i32-i64 (result i32 i64) (i32.const 0x132) (i64.const 0x164)) + + (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 $id-i32-f64 (param i32 f64) (result i32 f64) + (local.get 0) (local.get 1) + ) + + (func $swap-i32-i32 (param i32 i32) (result i32 i32) + (local.get 1) (local.get 0) + ) + (func $swap-f32-f64 (param f32 f64) (result f64 f32) + (local.get 1) (local.get 0) + ) + (func $swap-f64-i32 (param f64 i32) (result i32 f64) + (local.get 1) (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)) + + ;; Typing + + (func (export "type-i32") (result i32) (call $const-i32)) + (func (export "type-i64") (result i64) (call $const-i64)) + (func (export "type-f32") (result f32) (call $const-f32)) + (func (export "type-f64") (result f64) (call $const-f64)) + (func (export "type-i32-i64") (result i32 i64) (call $const-i32-i64)) + + (func (export "type-first-i32") (result i32) (call $id-i32 (i32.const 32))) + (func (export "type-first-i64") (result i64) (call $id-i64 (i64.const 64))) + (func (export "type-first-f32") (result f32) (call $id-f32 (f32.const 1.32))) + (func (export "type-first-f64") (result f64) (call $id-f64 (f64.const 1.64))) + + (func (export "type-second-i32") (result i32) + (call $f32-i32 (f32.const 32.1) (i32.const 32)) + ) + (func (export "type-second-i64") (result i64) + (call $i32-i64 (i32.const 32) (i64.const 64)) + ) + (func (export "type-second-f32") (result f32) + (call $f64-f32 (f64.const 64) (f32.const 32)) + ) + (func (export "type-second-f64") (result f64) + (call $i64-f64 (i64.const 64) (f64.const 64.1)) + ) + + (func (export "type-all-i32-f64") (result i32 f64) + (call $id-i32-f64 (i32.const 32) (f64.const 1.64)) + ) + (func (export "type-all-i32-i32") (result i32 i32) + (call $swap-i32-i32 (i32.const 1) (i32.const 2)) + ) + (func (export "type-all-f32-f64") (result f64 f32) + (call $swap-f32-f64 (f32.const 1) (f64.const 2)) + ) + (func (export "type-all-f64-i32") (result i32 f64) + (call $swap-f64-i32 (f64.const 1) (i32.const 2)) + ) + + ;; Composition + + (func (export "as-binary-all-operands") (result i32) + (i32.add (call $swap-i32-i32 (i32.const 3) (i32.const 4))) + ) + + (func (export "as-mixed-operands") (result i32) + (call $swap-i32-i32 (i32.const 3) (i32.const 4)) + (i32.const 5) + (i32.add) + (i32.mul) + ) + + (func (export "as-call-all-operands") (result i32 i32) + (call $swap-i32-i32 (call $swap-i32-i32 (i32.const 3) (i32.const 4))) + ) + + ;; Recursion + + (func $fac (export "fac") (param i64) (result i64) + (if (result i64) (i64.eqz (local.get 0)) + (then (i64.const 1)) + (else + (i64.mul + (local.get 0) + (call $fac (i64.sub (local.get 0) (i64.const 1))) + ) + ) + ) + ) + + (func $fac-acc (export "fac-acc") (param i64 i64) (result i64) + (if (result i64) (i64.eqz (local.get 0)) + (then (local.get 1)) + (else + (call $fac-acc + (i64.sub (local.get 0) (i64.const 1)) + (i64.mul (local.get 0) (local.get 1)) + ) + ) + ) + ) + + (func $fib (export "fib") (param i64) (result i64) + (if (result i64) (i64.le_u (local.get 0) (i64.const 1)) + (then (i64.const 1)) + (else + (i64.add + (call $fib (i64.sub (local.get 0) (i64.const 2))) + (call $fib (i64.sub (local.get 0) (i64.const 1))) + ) + ) + ) + ) + + (func $even (export "even") (param i64) (result i32) + (if (result i32) (i64.eqz (local.get 0)) + (then (i32.const 44)) + (else (call $odd (i64.sub (local.get 0) (i64.const 1)))) + ) + ) + (func $odd (export "odd") (param i64) (result i32) + (if (result i32) (i64.eqz (local.get 0)) + (then (i32.const 99)) + (else (call $even (i64.sub (local.get 0) (i64.const 1)))) + ) + ) + + ;; Stack exhaustion + + ;; Implementations are required to have every call consume some abstract + ;; resource towards exhausting some abstract finite limit, such that + ;; infinitely recursive test cases reliably trap in finite time. This is + ;; because otherwise applications could come to depend on it on those + ;; implementations and be incompatible with implementations that don't do + ;; it (or don't do it under the same circumstances). + + (func $runaway (export "runaway") (call $runaway)) + + (func $mutual-runaway1 (export "mutual-runaway") (call $mutual-runaway2)) + (func $mutual-runaway2 (call $mutual-runaway1)) + + ;; As parameter of control constructs and instructions + + (memory 1) + + (func (export "as-select-first") (result i32) + (select (call $const-i32) (i32.const 2) (i32.const 3)) + ) + (func (export "as-select-mid") (result i32) + (select (i32.const 2) (call $const-i32) (i32.const 3)) + ) + (func (export "as-select-last") (result i32) + (select (i32.const 2) (i32.const 3) (call $const-i32)) + ) + + (func (export "as-if-condition") (result i32) + (if (result i32) (call $const-i32) (then (i32.const 1)) (else (i32.const 2))) + ) + + (func (export "as-br_if-first") (result i32) + (block (result i32) (br_if 0 (call $const-i32) (i32.const 2))) + ) + (func (export "as-br_if-last") (result i32) + (block (result i32) (br_if 0 (i32.const 2) (call $const-i32))) + ) + + (func (export "as-br_table-first") (result i32) + (block (result i32) (call $const-i32) (i32.const 2) (br_table 0 0)) + ) + (func (export "as-br_table-last") (result i32) + (block (result i32) (i32.const 2) (call $const-i32) (br_table 0 0)) + ) + + (func $func (param i32 i32) (result i32) (local.get 0)) + (type $check (func (param i32 i32) (result i32))) + (table funcref (elem $func)) + (func (export "as-call_indirect-first") (result i32) + (block (result i32) + (call_indirect (type $check) + (call $const-i32) (i32.const 2) (i32.const 0) + ) + ) + ) + (func (export "as-call_indirect-mid") (result i32) + (block (result i32) + (call_indirect (type $check) + (i32.const 2) (call $const-i32) (i32.const 0) + ) + ) + ) + (func (export "as-call_indirect-last") (result i32) + (block (result i32) + (call_indirect (type $check) + (i32.const 1) (i32.const 2) (call $const-i32) + ) + ) + ) + + (func (export "as-store-first") + (call $const-i32) (i32.const 1) (i32.store) + ) + (func (export "as-store-last") + (i32.const 10) (call $const-i32) (i32.store) + ) + + (func (export "as-memory.grow-value") (result i32) + (memory.grow (call $const-i32)) + ) + (func (export "as-return-value") (result i32) + (call $const-i32) (return) + ) + (func (export "as-drop-operand") + (call $const-i32) (drop) + ) + (func (export "as-br-value") (result i32) + (block (result i32) (br 0 (call $const-i32))) + ) + (func (export "as-local.set-value") (result i32) + (local i32) (local.set 0 (call $const-i32)) (local.get 0) + ) + (func (export "as-local.tee-value") (result i32) + (local i32) (local.tee 0 (call $const-i32)) + ) + (global $a (mut i32) (i32.const 10)) + (func (export "as-global.set-value") (result i32) + (global.set $a (call $const-i32)) + (global.get $a) + ) + (func (export "as-load-operand") (result i32) + (i32.load (call $const-i32)) + ) + + (func $dummy (param i32) (result i32) (local.get 0)) + (func $du (param f32) (result f32) (local.get 0)) + (func (export "as-unary-operand") (result f32) + (block (result f32) (f32.sqrt (call $du (f32.const 0x0p+0)))) + ) + + (func (export "as-binary-left") (result i32) + (block (result i32) (i32.add (call $dummy (i32.const 1)) (i32.const 10))) + ) + (func (export "as-binary-right") (result i32) + (block (result i32) (i32.sub (i32.const 10) (call $dummy (i32.const 1)))) + ) + + (func (export "as-test-operand") (result i32) + (block (result i32) (i32.eqz (call $dummy (i32.const 1)))) + ) + + (func (export "as-compare-left") (result i32) + (block (result i32) (i32.le_u (call $dummy (i32.const 1)) (i32.const 10))) + ) + (func (export "as-compare-right") (result i32) + (block (result i32) (i32.ne (i32.const 10) (call $dummy (i32.const 1)))) + ) + + (func (export "as-convert-operand") (result i64) + (block (result i64) (i64.extend_i32_s (call $dummy (i32.const 1)))) + ) + + ;; Test correct argument passing + + (func $return-from-long-argument-list-helper (param f32 i32 i32 f64 f32 f32 f32 f64 f32 i32 i32 f32 f64 i64 i64 i32 i64 i64 f32 i64 i64 i64 i32 f32 f32 f32 f64 f32 i32 i64 f32 f64 f64 f32 i32 f32 f32 f64 i64 f64 i32 i64 f32 f64 i32 i32 i32 i64 f64 i32 i64 i64 f64 f64 f64 f64 f64 f64 i32 f32 f64 f64 i32 i64 f32 f32 f32 i32 f64 f64 f64 f64 f64 f32 i64 i64 i32 i32 i32 f32 f64 i32 i64 f32 f32 f32 i32 i32 f32 f64 i64 f32 f64 f32 f32 f32 i32 f32 i64 i32) (result i32) + (local.get 99) + ) + + (func (export "return-from-long-argument-list") (param i32) (result i32) + (call $return-from-long-argument-list-helper (f32.const 0) (i32.const 0) (i32.const 0) (f64.const 0) (f32.const 0) (f32.const 0) (f32.const 0) (f64.const 0) (f32.const 0) (i32.const 0) (i32.const 0) (f32.const 0) (f64.const 0) (i64.const 0) (i64.const 0) (i32.const 0) (i64.const 0) (i64.const 0) (f32.const 0) (i64.const 0) (i64.const 0) (i64.const 0) (i32.const 0) (f32.const 0) (f32.const 0) (f32.const 0) (f64.const 0) (f32.const 0) (i32.const 0) (i64.const 0) (f32.const 0) (f64.const 0) (f64.const 0) (f32.const 0) (i32.const 0) (f32.const 0) (f32.const 0) (f64.const 0) (i64.const 0) (f64.const 0) (i32.const 0) (i64.const 0) (f32.const 0) (f64.const 0) (i32.const 0) (i32.const 0) (i32.const 0) (i64.const 0) (f64.const 0) (i32.const 0) (i64.const 0) (i64.const 0) (f64.const 0) (f64.const 0) (f64.const 0) (f64.const 0) (f64.const 0) (f64.const 0) (i32.const 0) (f32.const 0) (f64.const 0) (f64.const 0) (i32.const 0) (i64.const 0) (f32.const 0) (f32.const 0) (f32.const 0) (i32.const 0) (f64.const 0) (f64.const 0) (f64.const 0) (f64.const 0) (f64.const 0) (f32.const 0) (i64.const 0) (i64.const 0) (i32.const 0) (i32.const 0) (i32.const 0) (f32.const 0) (f64.const 0) (i32.const 0) (i64.const 0) (f32.const 0) (f32.const 0) (f32.const 0) (i32.const 0) (i32.const 0) (f32.const 0) (f64.const 0) (i64.const 0) (f32.const 0) (f64.const 0) (f32.const 0) (f32.const 0) (f32.const 0) (i32.const 0) (f32.const 0) (i64.const 0) (local.get 0)) + ) +) + +(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-i32-i64") (i32.const 0x132) (i64.const 0x164)) + +(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_return (invoke "type-all-i32-f64") (i32.const 32) (f64.const 1.64)) +(assert_return (invoke "type-all-i32-i32") (i32.const 2) (i32.const 1)) +(assert_return (invoke "type-all-f32-f64") (f64.const 2) (f32.const 1)) +(assert_return (invoke "type-all-f64-i32") (i32.const 2) (f64.const 1)) + +(assert_return (invoke "as-binary-all-operands") (i32.const 7)) +(assert_return (invoke "as-mixed-operands") (i32.const 32)) +(assert_return (invoke "as-call-all-operands") (i32.const 3) (i32.const 4)) + +(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)) (i32.const 44)) +(assert_return (invoke "even" (i64.const 1)) (i32.const 99)) +(assert_return (invoke "even" (i64.const 100)) (i32.const 44)) +(assert_return (invoke "even" (i64.const 77)) (i32.const 99)) +(assert_return (invoke "odd" (i64.const 0)) (i32.const 99)) +(assert_return (invoke "odd" (i64.const 1)) (i32.const 44)) +(assert_return (invoke "odd" (i64.const 200)) (i32.const 99)) +(assert_return (invoke "odd" (i64.const 77)) (i32.const 44)) + +(assert_exhaustion (invoke "runaway") "call stack exhausted") +(assert_exhaustion (invoke "mutual-runaway") "call stack exhausted") + +(assert_return (invoke "as-select-first") (i32.const 0x132)) +(assert_return (invoke "as-select-mid") (i32.const 2)) +(assert_return (invoke "as-select-last") (i32.const 2)) + +(assert_return (invoke "as-if-condition") (i32.const 1)) + +(assert_return (invoke "as-br_if-first") (i32.const 0x132)) +(assert_return (invoke "as-br_if-last") (i32.const 2)) + +(assert_return (invoke "as-br_table-first") (i32.const 0x132)) +(assert_return (invoke "as-br_table-last") (i32.const 2)) + +(assert_return (invoke "as-call_indirect-first") (i32.const 0x132)) +(assert_return (invoke "as-call_indirect-mid") (i32.const 2)) +(assert_trap (invoke "as-call_indirect-last") "undefined element") + +(assert_return (invoke "as-store-first")) +(assert_return (invoke "as-store-last")) + +(assert_return (invoke "as-memory.grow-value") (i32.const 1)) +(assert_return (invoke "as-return-value") (i32.const 0x132)) +(assert_return (invoke "as-drop-operand")) +(assert_return (invoke "as-br-value") (i32.const 0x132)) +(assert_return (invoke "as-local.set-value") (i32.const 0x132)) +(assert_return (invoke "as-local.tee-value") (i32.const 0x132)) +(assert_return (invoke "as-global.set-value") (i32.const 0x132)) +(assert_return (invoke "as-load-operand") (i32.const 1)) + +(assert_return (invoke "as-unary-operand") (f32.const 0x0p+0)) +(assert_return (invoke "as-binary-left") (i32.const 11)) +(assert_return (invoke "as-binary-right") (i32.const 9)) +(assert_return (invoke "as-test-operand") (i32.const 0)) +(assert_return (invoke "as-compare-left") (i32.const 1)) +(assert_return (invoke "as-compare-right") (i32.const 1)) +(assert_return (invoke "as-convert-operand") (i64.const 1)) + +(assert_return (invoke "return-from-long-argument-list" (i32.const 42)) (i32.const 42)) + +;; Invalid typing + +(assert_invalid + (module + (func $type-void-vs-num (i32.eqz (call 1))) + (func) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-num-vs-num (i32.eqz (call 1))) + (func (result i64) (i64.const 1)) + ) + "type mismatch" +) + +(assert_invalid + (module + (func $arity-0-vs-1 (call 1)) + (func (param i32)) + ) + "type mismatch" +) +(assert_invalid + (module + (func $arity-0-vs-2 (call 1)) + (func (param f64 i32)) + ) + "type mismatch" +) +(assert_invalid + (module + (func $arity-1-vs-0 (call 1 (i32.const 1))) + (func) + ) + "type mismatch" +) +(assert_invalid + (module + (func $arity-2-vs-0 (call 1 (f64.const 2) (i32.const 1))) + (func) + ) + "type mismatch" +) + +(assert_invalid + (module + (func $type-first-void-vs-num (call 1 (nop) (i32.const 1))) + (func (param i32 i32)) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-second-void-vs-num (call 1 (i32.const 1) (nop))) + (func (param i32 i32)) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-first-num-vs-num (call 1 (f64.const 1) (i32.const 1))) + (func (param i32 f64)) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-second-num-vs-num (call 1 (i32.const 1) (f64.const 1))) + (func (param f64 i32)) + ) + "type mismatch" +) + +(assert_invalid + (module + (func $type-first-empty-in-block + (block (call 1)) + ) + (func (param i32)) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-second-empty-in-block + (block (call 1 (i32.const 0))) + ) + (func (param i32 i32)) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-first-empty-in-loop + (loop (call 1)) + ) + (func (param i32)) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-second-empty-in-loop + (loop (call 1 (i32.const 0))) + ) + (func (param i32 i32)) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-first-empty-in-then + (if (i32.const 0) (then (call 1))) + ) + (func (param i32)) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-second-empty-in-then + (if (i32.const 0) (then (call 1 (i32.const 0)))) + ) + (func (param i32 i32)) + ) + "type mismatch" +) + + +;; Unbound function + +(assert_invalid + (module (func $unbound-func (call 1))) + "unknown function" +) +(assert_invalid + (module (func $large-func (call 1012321300))) + "unknown function" +) diff --git a/runtime/near-vm/tests/wast/spec/proposals/multi-value/call_indirect.wast b/runtime/near-vm/tests/wast/spec/proposals/multi-value/call_indirect.wast new file mode 100644 index 00000000000..224e3bef09f --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/proposals/multi-value/call_indirect.wast @@ -0,0 +1,971 @@ +;; Test `call_indirect` operator + +(module + ;; Auxiliary definitions + (type $proc (func)) + (type $out-i32 (func (result i32))) + (type $out-i64 (func (result i64))) + (type $out-f32 (func (result f32))) + (type $out-f64 (func (result f64))) + (type $out-f64-i32 (func (result f64 i32))) + (type $over-i32 (func (param i32) (result i32))) + (type $over-i64 (func (param i64) (result i64))) + (type $over-f32 (func (param f32) (result f32))) + (type $over-f64 (func (param f64) (result f64))) + (type $over-i32-f64 (func (param i32 f64) (result i32 f64))) + (type $swap-i32-i64 (func (param i32 i64) (result i64 i32))) + (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 $over-i32-duplicate (func (param i32) (result i32))) + (type $over-i64-duplicate (func (param i64) (result i64))) + (type $over-f32-duplicate (func (param f32) (result f32))) + (type $over-f64-duplicate (func (param f64) (result f64))) + + (func $const-i32 (type $out-i32) (i32.const 0x132)) + (func $const-i64 (type $out-i64) (i64.const 0x164)) + (func $const-f32 (type $out-f32) (f32.const 0xf32)) + (func $const-f64 (type $out-f64) (f64.const 0xf64)) + (func $const-f64-i32 (type $out-f64-i32) (f64.const 0xf64) (i32.const 32)) + + (func $id-i32 (type $over-i32) (local.get 0)) + (func $id-i64 (type $over-i64) (local.get 0)) + (func $id-f32 (type $over-f32) (local.get 0)) + (func $id-f64 (type $over-f64) (local.get 0)) + (func $id-i32-f64 (type $over-i32-f64) (local.get 0) (local.get 1)) + (func $swap-i32-i64 (type $swap-i32-i64) (local.get 1) (local.get 0)) + + (func $i32-i64 (type $i32-i64) (local.get 1)) + (func $i64-f64 (type $i64-f64) (local.get 1)) + (func $f32-i32 (type $f32-i32) (local.get 1)) + (func $f64-f32 (type $f64-f32) (local.get 1)) + + (func $over-i32-duplicate (type $over-i32-duplicate) (local.get 0)) + (func $over-i64-duplicate (type $over-i64-duplicate) (local.get 0)) + (func $over-f32-duplicate (type $over-f32-duplicate) (local.get 0)) + (func $over-f64-duplicate (type $over-f64-duplicate) (local.get 0)) + + (table funcref + (elem + $const-i32 $const-i64 $const-f32 $const-f64 ;; 0..3 + $id-i32 $id-i64 $id-f32 $id-f64 ;; 4..7 + $f32-i32 $i32-i64 $f64-f32 $i64-f64 ;; 9..11 + $fac-i64 $fib-i64 $even $odd ;; 12..15 + $runaway $mutual-runaway1 $mutual-runaway2 ;; 16..18 + $over-i32-duplicate $over-i64-duplicate ;; 19..20 + $over-f32-duplicate $over-f64-duplicate ;; 21..22 + $fac-i32 $fac-f32 $fac-f64 ;; 23..25 + $fib-i32 $fib-f32 $fib-f64 ;; 26..28 + $const-f64-i32 $id-i32-f64 $swap-i32-i64 ;; 29..31 + ) + ) + + ;; Syntax + + (func + (call_indirect (i32.const 0)) + (call_indirect (param i64) (i64.const 0) (i32.const 0)) + (call_indirect (param i64) (param) (param f64 i32 i64) + (i64.const 0) (f64.const 0) (i32.const 0) (i64.const 0) (i32.const 0) + ) + (call_indirect (result) (i32.const 0)) + (drop (i32.eqz (call_indirect (result i32) (i32.const 0)))) + (drop (i32.eqz (call_indirect (result i32) (result) (i32.const 0)))) + (drop (i32.eqz + (call_indirect (param i64) (result i32) (i64.const 0) (i32.const 0)) + )) + (drop (i32.eqz + (call_indirect + (param) (param i64) (param) (param f64 i32 i64) (param) (param) + (result) (result i32) (result) (result) + (i64.const 0) (f64.const 0) (i32.const 0) (i64.const 0) (i32.const 0) + ) + )) + (drop (i64.eqz + (call_indirect (type $over-i64) (param i64) (result i64) + (i64.const 0) (i32.const 0) + ) + )) + ) + + ;; Typing + + (func (export "type-i32") (result i32) + (call_indirect (type $out-i32) (i32.const 0)) + ) + (func (export "type-i64") (result i64) + (call_indirect (type $out-i64) (i32.const 1)) + ) + (func (export "type-f32") (result f32) + (call_indirect (type $out-f32) (i32.const 2)) + ) + (func (export "type-f64") (result f64) + (call_indirect (type $out-f64) (i32.const 3)) + ) + (func (export "type-f64-i32") (result f64 i32) + (call_indirect (type $out-f64-i32) (i32.const 29)) + ) + + (func (export "type-index") (result i64) + (call_indirect (type $over-i64) (i64.const 100) (i32.const 5)) + ) + + (func (export "type-first-i32") (result i32) + (call_indirect (type $over-i32) (i32.const 32) (i32.const 4)) + ) + (func (export "type-first-i64") (result i64) + (call_indirect (type $over-i64) (i64.const 64) (i32.const 5)) + ) + (func (export "type-first-f32") (result f32) + (call_indirect (type $over-f32) (f32.const 1.32) (i32.const 6)) + ) + (func (export "type-first-f64") (result f64) + (call_indirect (type $over-f64) (f64.const 1.64) (i32.const 7)) + ) + + (func (export "type-second-i32") (result i32) + (call_indirect (type $f32-i32) (f32.const 32.1) (i32.const 32) (i32.const 8)) + ) + (func (export "type-second-i64") (result i64) + (call_indirect (type $i32-i64) (i32.const 32) (i64.const 64) (i32.const 9)) + ) + (func (export "type-second-f32") (result f32) + (call_indirect (type $f64-f32) (f64.const 64) (f32.const 32) (i32.const 10)) + ) + (func (export "type-second-f64") (result f64) + (call_indirect (type $i64-f64) (i64.const 64) (f64.const 64.1) (i32.const 11)) + ) + + (func (export "type-all-f64-i32") (result f64 i32) + (call_indirect (type $out-f64-i32) (i32.const 29)) + ) + (func (export "type-all-i32-f64") (result i32 f64) + (call_indirect (type $over-i32-f64) + (i32.const 1) (f64.const 2) (i32.const 30) + ) + ) + (func (export "type-all-i32-i64") (result i64 i32) + (call_indirect (type $swap-i32-i64) + (i32.const 1) (i64.const 2) (i32.const 31) + ) + ) + + ;; Dispatch + + (func (export "dispatch") (param i32 i64) (result i64) + (call_indirect (type $over-i64) (local.get 1) (local.get 0)) + ) + + (func (export "dispatch-structural-i64") (param i32) (result i64) + (call_indirect (type $over-i64-duplicate) (i64.const 9) (local.get 0)) + ) + (func (export "dispatch-structural-i32") (param i32) (result i32) + (call_indirect (type $over-i32-duplicate) (i32.const 9) (local.get 0)) + ) + (func (export "dispatch-structural-f32") (param i32) (result f32) + (call_indirect (type $over-f32-duplicate) (f32.const 9.0) (local.get 0)) + ) + (func (export "dispatch-structural-f64") (param i32) (result f64) + (call_indirect (type $over-f64-duplicate) (f64.const 9.0) (local.get 0)) + ) + + ;; Recursion + + (func $fac-i64 (export "fac-i64") (type $over-i64) + (if (result i64) (i64.eqz (local.get 0)) + (then (i64.const 1)) + (else + (i64.mul + (local.get 0) + (call_indirect (type $over-i64) + (i64.sub (local.get 0) (i64.const 1)) + (i32.const 12) + ) + ) + ) + ) + ) + + (func $fib-i64 (export "fib-i64") (type $over-i64) + (if (result i64) (i64.le_u (local.get 0) (i64.const 1)) + (then (i64.const 1)) + (else + (i64.add + (call_indirect (type $over-i64) + (i64.sub (local.get 0) (i64.const 2)) + (i32.const 13) + ) + (call_indirect (type $over-i64) + (i64.sub (local.get 0) (i64.const 1)) + (i32.const 13) + ) + ) + ) + ) + ) + + (func $fac-i32 (export "fac-i32") (type $over-i32) + (if (result i32) (i32.eqz (local.get 0)) + (then (i32.const 1)) + (else + (i32.mul + (local.get 0) + (call_indirect (type $over-i32) + (i32.sub (local.get 0) (i32.const 1)) + (i32.const 23) + ) + ) + ) + ) + ) + + (func $fac-f32 (export "fac-f32") (type $over-f32) + (if (result f32) (f32.eq (local.get 0) (f32.const 0.0)) + (then (f32.const 1.0)) + (else + (f32.mul + (local.get 0) + (call_indirect (type $over-f32) + (f32.sub (local.get 0) (f32.const 1.0)) + (i32.const 24) + ) + ) + ) + ) + ) + + (func $fac-f64 (export "fac-f64") (type $over-f64) + (if (result f64) (f64.eq (local.get 0) (f64.const 0.0)) + (then (f64.const 1.0)) + (else + (f64.mul + (local.get 0) + (call_indirect (type $over-f64) + (f64.sub (local.get 0) (f64.const 1.0)) + (i32.const 25) + ) + ) + ) + ) + ) + + (func $fib-i32 (export "fib-i32") (type $over-i32) + (if (result i32) (i32.le_u (local.get 0) (i32.const 1)) + (then (i32.const 1)) + (else + (i32.add + (call_indirect (type $over-i32) + (i32.sub (local.get 0) (i32.const 2)) + (i32.const 26) + ) + (call_indirect (type $over-i32) + (i32.sub (local.get 0) (i32.const 1)) + (i32.const 26) + ) + ) + ) + ) + ) + + (func $fib-f32 (export "fib-f32") (type $over-f32) + (if (result f32) (f32.le (local.get 0) (f32.const 1.0)) + (then (f32.const 1.0)) + (else + (f32.add + (call_indirect (type $over-f32) + (f32.sub (local.get 0) (f32.const 2.0)) + (i32.const 27) + ) + (call_indirect (type $over-f32) + (f32.sub (local.get 0) (f32.const 1.0)) + (i32.const 27) + ) + ) + ) + ) + ) + + (func $fib-f64 (export "fib-f64") (type $over-f64) + (if (result f64) (f64.le (local.get 0) (f64.const 1.0)) + (then (f64.const 1.0)) + (else + (f64.add + (call_indirect (type $over-f64) + (f64.sub (local.get 0) (f64.const 2.0)) + (i32.const 28) + ) + (call_indirect (type $over-f64) + (f64.sub (local.get 0) (f64.const 1.0)) + (i32.const 28) + ) + ) + ) + ) + ) + + (func $even (export "even") (param i32) (result i32) + (if (result i32) (i32.eqz (local.get 0)) + (then (i32.const 44)) + (else + (call_indirect (type $over-i32) + (i32.sub (local.get 0) (i32.const 1)) + (i32.const 15) + ) + ) + ) + ) + (func $odd (export "odd") (param i32) (result i32) + (if (result i32) (i32.eqz (local.get 0)) + (then (i32.const 99)) + (else + (call_indirect (type $over-i32) + (i32.sub (local.get 0) (i32.const 1)) + (i32.const 14) + ) + ) + ) + ) + + ;; Stack exhaustion + + ;; Implementations are required to have every call consume some abstract + ;; resource towards exhausting some abstract finite limit, such that + ;; infinitely recursive test cases reliably trap in finite time. This is + ;; because otherwise applications could come to depend on it on those + ;; implementations and be incompatible with implementations that don't do + ;; it (or don't do it under the same circumstances). + + (func $runaway (export "runaway") (call_indirect (type $proc) (i32.const 16))) + + (func $mutual-runaway1 (export "mutual-runaway") (call_indirect (type $proc) (i32.const 18))) + (func $mutual-runaway2 (call_indirect (type $proc) (i32.const 17))) + + ;; As parameter of control constructs and instructions + + (memory 1) + + (func (export "as-select-first") (result i32) + (select (call_indirect (type $out-i32) (i32.const 0)) (i32.const 2) (i32.const 3)) + ) + (func (export "as-select-mid") (result i32) + (select (i32.const 2) (call_indirect (type $out-i32) (i32.const 0)) (i32.const 3)) + ) + (func (export "as-select-last") (result i32) + (select (i32.const 2) (i32.const 3) (call_indirect (type $out-i32) (i32.const 0))) + ) + + (func (export "as-if-condition") (result i32) + (if (result i32) (call_indirect (type $out-i32) (i32.const 0)) (then (i32.const 1)) (else (i32.const 2))) + ) + + (func (export "as-br_if-first") (result i64) + (block (result i64) (br_if 0 (call_indirect (type $out-i64) (i32.const 1)) (i32.const 2))) + ) + (func (export "as-br_if-last") (result i32) + (block (result i32) (br_if 0 (i32.const 2) (call_indirect (type $out-i32) (i32.const 0)))) + ) + + (func (export "as-br_table-first") (result f32) + (block (result f32) (call_indirect (type $out-f32) (i32.const 2)) (i32.const 2) (br_table 0 0)) + ) + (func (export "as-br_table-last") (result i32) + (block (result i32) (i32.const 2) (call_indirect (type $out-i32) (i32.const 0)) (br_table 0 0)) + ) + + (func (export "as-store-first") + (call_indirect (type $out-i32) (i32.const 0)) (i32.const 1) (i32.store) + ) + (func (export "as-store-last") + (i32.const 10) (call_indirect (type $out-f64) (i32.const 3)) (f64.store) + ) + + (func (export "as-memory.grow-value") (result i32) + (memory.grow (call_indirect (type $out-i32) (i32.const 0))) + ) + (func (export "as-return-value") (result i32) + (call_indirect (type $over-i32) (i32.const 1) (i32.const 4)) (return) + ) + (func (export "as-drop-operand") + (call_indirect (type $over-i64) (i64.const 1) (i32.const 5)) (drop) + ) + (func (export "as-br-value") (result f32) + (block (result f32) (br 0 (call_indirect (type $over-f32) (f32.const 1) (i32.const 6)))) + ) + (func (export "as-local.set-value") (result f64) + (local f64) (local.set 0 (call_indirect (type $over-f64) (f64.const 1) (i32.const 7))) (local.get 0) + ) + (func (export "as-local.tee-value") (result f64) + (local f64) (local.tee 0 (call_indirect (type $over-f64) (f64.const 1) (i32.const 7))) + ) + (global $a (mut f64) (f64.const 10.0)) + (func (export "as-global.set-value") (result f64) + (global.set $a (call_indirect (type $over-f64) (f64.const 1.0) (i32.const 7))) + (global.get $a) + ) + + (func (export "as-load-operand") (result i32) + (i32.load (call_indirect (type $out-i32) (i32.const 0))) + ) + + (func (export "as-unary-operand") (result f32) + (block (result f32) + (f32.sqrt + (call_indirect (type $over-f32) (f32.const 0x0p+0) (i32.const 6)) + ) + ) + ) + + (func (export "as-binary-left") (result i32) + (block (result i32) + (i32.add + (call_indirect (type $over-i32) (i32.const 1) (i32.const 4)) + (i32.const 10) + ) + ) + ) + (func (export "as-binary-right") (result i32) + (block (result i32) + (i32.sub + (i32.const 10) + (call_indirect (type $over-i32) (i32.const 1) (i32.const 4)) + ) + ) + ) + + (func (export "as-test-operand") (result i32) + (block (result i32) + (i32.eqz + (call_indirect (type $over-i32) (i32.const 1) (i32.const 4)) + ) + ) + ) + + (func (export "as-compare-left") (result i32) + (block (result i32) + (i32.le_u + (call_indirect (type $over-i32) (i32.const 1) (i32.const 4)) + (i32.const 10) + ) + ) + ) + (func (export "as-compare-right") (result i32) + (block (result i32) + (i32.ne + (i32.const 10) + (call_indirect (type $over-i32) (i32.const 1) (i32.const 4)) + ) + ) + ) + + (func (export "as-convert-operand") (result i64) + (block (result i64) + (i64.extend_i32_s + (call_indirect (type $over-i32) (i32.const 1) (i32.const 4)) + ) + ) + ) + +) + +(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-f64-i32") (f64.const 0xf64) (i32.const 32)) + +(assert_return (invoke "type-index") (i64.const 100)) + +(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_return (invoke "type-all-f64-i32") (f64.const 0xf64) (i32.const 32)) +(assert_return (invoke "type-all-i32-f64") (i32.const 1) (f64.const 2)) +(assert_return (invoke "type-all-i32-i64") (i64.const 2) (i32.const 1)) + +(assert_return (invoke "dispatch" (i32.const 5) (i64.const 2)) (i64.const 2)) +(assert_return (invoke "dispatch" (i32.const 5) (i64.const 5)) (i64.const 5)) +(assert_return (invoke "dispatch" (i32.const 12) (i64.const 5)) (i64.const 120)) +(assert_return (invoke "dispatch" (i32.const 13) (i64.const 5)) (i64.const 8)) +(assert_return (invoke "dispatch" (i32.const 20) (i64.const 2)) (i64.const 2)) +(assert_trap (invoke "dispatch" (i32.const 0) (i64.const 2)) "indirect call type mismatch") +(assert_trap (invoke "dispatch" (i32.const 15) (i64.const 2)) "indirect call type mismatch") +(assert_trap (invoke "dispatch" (i32.const 32) (i64.const 2)) "undefined element") +(assert_trap (invoke "dispatch" (i32.const -1) (i64.const 2)) "undefined element") +(assert_trap (invoke "dispatch" (i32.const 1213432423) (i64.const 2)) "undefined element") + +(assert_return (invoke "dispatch-structural-i64" (i32.const 5)) (i64.const 9)) +(assert_return (invoke "dispatch-structural-i64" (i32.const 12)) (i64.const 362880)) +(assert_return (invoke "dispatch-structural-i64" (i32.const 13)) (i64.const 55)) +(assert_return (invoke "dispatch-structural-i64" (i32.const 20)) (i64.const 9)) +(assert_trap (invoke "dispatch-structural-i64" (i32.const 11)) "indirect call type mismatch") +(assert_trap (invoke "dispatch-structural-i64" (i32.const 22)) "indirect call type mismatch") + +(assert_return (invoke "dispatch-structural-i32" (i32.const 4)) (i32.const 9)) +(assert_return (invoke "dispatch-structural-i32" (i32.const 23)) (i32.const 362880)) +(assert_return (invoke "dispatch-structural-i32" (i32.const 26)) (i32.const 55)) +(assert_return (invoke "dispatch-structural-i32" (i32.const 19)) (i32.const 9)) +(assert_trap (invoke "dispatch-structural-i32" (i32.const 9)) "indirect call type mismatch") +(assert_trap (invoke "dispatch-structural-i32" (i32.const 21)) "indirect call type mismatch") + +(assert_return (invoke "dispatch-structural-f32" (i32.const 6)) (f32.const 9.0)) +(assert_return (invoke "dispatch-structural-f32" (i32.const 24)) (f32.const 362880.0)) +(assert_return (invoke "dispatch-structural-f32" (i32.const 27)) (f32.const 55.0)) +(assert_return (invoke "dispatch-structural-f32" (i32.const 21)) (f32.const 9.0)) +(assert_trap (invoke "dispatch-structural-f32" (i32.const 8)) "indirect call type mismatch") +(assert_trap (invoke "dispatch-structural-f32" (i32.const 19)) "indirect call type mismatch") + +(assert_return (invoke "dispatch-structural-f64" (i32.const 7)) (f64.const 9.0)) +(assert_return (invoke "dispatch-structural-f64" (i32.const 25)) (f64.const 362880.0)) +(assert_return (invoke "dispatch-structural-f64" (i32.const 28)) (f64.const 55.0)) +(assert_return (invoke "dispatch-structural-f64" (i32.const 22)) (f64.const 9.0)) +(assert_trap (invoke "dispatch-structural-f64" (i32.const 10)) "indirect call type mismatch") +(assert_trap (invoke "dispatch-structural-f64" (i32.const 18)) "indirect call type mismatch") + +(assert_return (invoke "fac-i64" (i64.const 0)) (i64.const 1)) +(assert_return (invoke "fac-i64" (i64.const 1)) (i64.const 1)) +(assert_return (invoke "fac-i64" (i64.const 5)) (i64.const 120)) +(assert_return (invoke "fac-i64" (i64.const 25)) (i64.const 7034535277573963776)) + +(assert_return (invoke "fac-i32" (i32.const 0)) (i32.const 1)) +(assert_return (invoke "fac-i32" (i32.const 1)) (i32.const 1)) +(assert_return (invoke "fac-i32" (i32.const 5)) (i32.const 120)) +(assert_return (invoke "fac-i32" (i32.const 10)) (i32.const 3628800)) + +(assert_return (invoke "fac-f32" (f32.const 0.0)) (f32.const 1.0)) +(assert_return (invoke "fac-f32" (f32.const 1.0)) (f32.const 1.0)) +(assert_return (invoke "fac-f32" (f32.const 5.0)) (f32.const 120.0)) +(assert_return (invoke "fac-f32" (f32.const 10.0)) (f32.const 3628800.0)) + +(assert_return (invoke "fac-f64" (f64.const 0.0)) (f64.const 1.0)) +(assert_return (invoke "fac-f64" (f64.const 1.0)) (f64.const 1.0)) +(assert_return (invoke "fac-f64" (f64.const 5.0)) (f64.const 120.0)) +(assert_return (invoke "fac-f64" (f64.const 10.0)) (f64.const 3628800.0)) + +(assert_return (invoke "fib-i64" (i64.const 0)) (i64.const 1)) +(assert_return (invoke "fib-i64" (i64.const 1)) (i64.const 1)) +(assert_return (invoke "fib-i64" (i64.const 2)) (i64.const 2)) +(assert_return (invoke "fib-i64" (i64.const 5)) (i64.const 8)) +(assert_return (invoke "fib-i64" (i64.const 20)) (i64.const 10946)) + +(assert_return (invoke "fib-i32" (i32.const 0)) (i32.const 1)) +(assert_return (invoke "fib-i32" (i32.const 1)) (i32.const 1)) +(assert_return (invoke "fib-i32" (i32.const 2)) (i32.const 2)) +(assert_return (invoke "fib-i32" (i32.const 5)) (i32.const 8)) +(assert_return (invoke "fib-i32" (i32.const 20)) (i32.const 10946)) + +(assert_return (invoke "fib-f32" (f32.const 0.0)) (f32.const 1.0)) +(assert_return (invoke "fib-f32" (f32.const 1.0)) (f32.const 1.0)) +(assert_return (invoke "fib-f32" (f32.const 2.0)) (f32.const 2.0)) +(assert_return (invoke "fib-f32" (f32.const 5.0)) (f32.const 8.0)) +(assert_return (invoke "fib-f32" (f32.const 20.0)) (f32.const 10946.0)) + +(assert_return (invoke "fib-f64" (f64.const 0.0)) (f64.const 1.0)) +(assert_return (invoke "fib-f64" (f64.const 1.0)) (f64.const 1.0)) +(assert_return (invoke "fib-f64" (f64.const 2.0)) (f64.const 2.0)) +(assert_return (invoke "fib-f64" (f64.const 5.0)) (f64.const 8.0)) +(assert_return (invoke "fib-f64" (f64.const 20.0)) (f64.const 10946.0)) + +(assert_return (invoke "even" (i32.const 0)) (i32.const 44)) +(assert_return (invoke "even" (i32.const 1)) (i32.const 99)) +(assert_return (invoke "even" (i32.const 100)) (i32.const 44)) +(assert_return (invoke "even" (i32.const 77)) (i32.const 99)) +(assert_return (invoke "odd" (i32.const 0)) (i32.const 99)) +(assert_return (invoke "odd" (i32.const 1)) (i32.const 44)) +(assert_return (invoke "odd" (i32.const 200)) (i32.const 99)) +(assert_return (invoke "odd" (i32.const 77)) (i32.const 44)) + +(assert_exhaustion (invoke "runaway") "call stack exhausted") +(assert_exhaustion (invoke "mutual-runaway") "call stack exhausted") + +(assert_return (invoke "as-select-first") (i32.const 0x132)) +(assert_return (invoke "as-select-mid") (i32.const 2)) +(assert_return (invoke "as-select-last") (i32.const 2)) + +(assert_return (invoke "as-if-condition") (i32.const 1)) + +(assert_return (invoke "as-br_if-first") (i64.const 0x164)) +(assert_return (invoke "as-br_if-last") (i32.const 2)) + +(assert_return (invoke "as-br_table-first") (f32.const 0xf32)) +(assert_return (invoke "as-br_table-last") (i32.const 2)) + +(assert_return (invoke "as-store-first")) +(assert_return (invoke "as-store-last")) + +(assert_return (invoke "as-memory.grow-value") (i32.const 1)) +(assert_return (invoke "as-return-value") (i32.const 1)) +(assert_return (invoke "as-drop-operand")) +(assert_return (invoke "as-br-value") (f32.const 1)) +(assert_return (invoke "as-local.set-value") (f64.const 1)) +(assert_return (invoke "as-local.tee-value") (f64.const 1)) +(assert_return (invoke "as-global.set-value") (f64.const 1.0)) +(assert_return (invoke "as-load-operand") (i32.const 1)) + +(assert_return (invoke "as-unary-operand") (f32.const 0x0p+0)) +(assert_return (invoke "as-binary-left") (i32.const 11)) +(assert_return (invoke "as-binary-right") (i32.const 9)) +(assert_return (invoke "as-test-operand") (i32.const 0)) +(assert_return (invoke "as-compare-left") (i32.const 1)) +(assert_return (invoke "as-compare-right") (i32.const 1)) +(assert_return (invoke "as-convert-operand") (i64.const 1)) + +;; Invalid syntax + +(assert_malformed + (module quote + "(type $sig (func (param i32) (result i32)))" + "(table 0 funcref)" + "(func (result i32)" + " (call_indirect (type $sig) (result i32) (param i32)" + " (i32.const 0) (i32.const 0)" + " )" + ")" + ) + "unexpected token" +) +(assert_malformed + (module quote + "(type $sig (func (param i32) (result i32)))" + "(table 0 funcref)" + "(func (result i32)" + " (call_indirect (param i32) (type $sig) (result i32)" + " (i32.const 0) (i32.const 0)" + " )" + ")" + ) + "unexpected token" +) +(assert_malformed + (module quote + "(type $sig (func (param i32) (result i32)))" + "(table 0 funcref)" + "(func (result i32)" + " (call_indirect (param i32) (result i32) (type $sig)" + " (i32.const 0) (i32.const 0)" + " )" + ")" + ) + "unexpected token" +) +(assert_malformed + (module quote + "(type $sig (func (param i32) (result i32)))" + "(table 0 funcref)" + "(func (result i32)" + " (call_indirect (result i32) (type $sig) (param i32)" + " (i32.const 0) (i32.const 0)" + " )" + ")" + ) + "unexpected token" +) +(assert_malformed + (module quote + "(type $sig (func (param i32) (result i32)))" + "(table 0 funcref)" + "(func (result i32)" + " (call_indirect (result i32) (param i32) (type $sig)" + " (i32.const 0) (i32.const 0)" + " )" + ")" + ) + "unexpected token" +) +(assert_malformed + (module quote + "(table 0 funcref)" + "(func (result i32)" + " (call_indirect (result i32) (param i32) (i32.const 0) (i32.const 0))" + ")" + ) + "unexpected token" +) + +(assert_malformed + (module quote + "(table 0 funcref)" + "(func (call_indirect (param $x i32) (i32.const 0) (i32.const 0)))" + ) + "unexpected token" +) +(assert_malformed + (module quote + "(type $sig (func))" + "(table 0 funcref)" + "(func (result i32)" + " (call_indirect (type $sig) (result i32) (i32.const 0))" + ")" + ) + "inline function type" +) +(assert_malformed + (module quote + "(type $sig (func (param i32) (result i32)))" + "(table 0 funcref)" + "(func (result i32)" + " (call_indirect (type $sig) (result i32) (i32.const 0))" + ")" + ) + "inline function type" +) +(assert_malformed + (module quote + "(type $sig (func (param i32) (result i32)))" + "(table 0 funcref)" + "(func" + " (call_indirect (type $sig) (param i32) (i32.const 0) (i32.const 0))" + ")" + ) + "inline function type" +) +(assert_malformed + (module quote + "(type $sig (func (param i32 i32) (result i32)))" + "(table 0 funcref)" + "(func (result i32)" + " (call_indirect (type $sig) (param i32) (result i32)" + " (i32.const 0) (i32.const 0)" + " )" + ")" + ) + "inline function type" +) + +;; Invalid typing + +(assert_invalid + (module + (type (func)) + (func $no-table (call_indirect (type 0) (i32.const 0))) + ) + "unknown table" +) + +(assert_invalid + (module + (type (func)) + (table 0 funcref) + (func $type-void-vs-num (i32.eqz (call_indirect (type 0) (i32.const 0)))) + ) + "type mismatch" +) +(assert_invalid + (module + (type (func (result i64))) + (table 0 funcref) + (func $type-num-vs-num (i32.eqz (call_indirect (type 0) (i32.const 0)))) + ) + "type mismatch" +) + +(assert_invalid + (module + (type (func (param i32))) + (table 0 funcref) + (func $arity-0-vs-1 (call_indirect (type 0) (i32.const 0))) + ) + "type mismatch" +) +(assert_invalid + (module + (type (func (param f64 i32))) + (table 0 funcref) + (func $arity-0-vs-2 (call_indirect (type 0) (i32.const 0))) + ) + "type mismatch" +) +(assert_invalid + (module + (type (func)) + (table 0 funcref) + (func $arity-1-vs-0 (call_indirect (type 0) (i32.const 1) (i32.const 0))) + ) + "type mismatch" +) +(assert_invalid + (module + (type (func)) + (table 0 funcref) + (func $arity-2-vs-0 + (call_indirect (type 0) (f64.const 2) (i32.const 1) (i32.const 0)) + ) + ) + "type mismatch" +) + +(assert_invalid + (module + (type (func (param i32))) + (table 0 funcref) + (func $type-func-void-vs-i32 (call_indirect (type 0) (i32.const 1) (nop))) + ) + "type mismatch" +) +(assert_invalid + (module + (type (func (param i32))) + (table 0 funcref) + (func $type-func-num-vs-i32 (call_indirect (type 0) (i32.const 0) (i64.const 1))) + ) + "type mismatch" +) + +(assert_invalid + (module + (type (func (param i32 i32))) + (table 0 funcref) + (func $type-first-void-vs-num + (call_indirect (type 0) (nop) (i32.const 1) (i32.const 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (type (func (param i32 i32))) + (table 0 funcref) + (func $type-second-void-vs-num + (call_indirect (type 0) (i32.const 1) (nop) (i32.const 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (type (func (param i32 f64))) + (table 0 funcref) + (func $type-first-num-vs-num + (call_indirect (type 0) (f64.const 1) (i32.const 1) (i32.const 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (type (func (param f64 i32))) + (table 0 funcref) + (func $type-second-num-vs-num + (call_indirect (type 0) (i32.const 1) (f64.const 1) (i32.const 0)) + ) + ) + "type mismatch" +) + +(assert_invalid + (module + (func $f (param i32)) + (type $sig (func (param i32))) + (table funcref (elem $f)) + (func $type-first-empty-in-block + (block + (call_indirect (type $sig) (i32.const 0)) + ) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $f (param i32 i32)) + (type $sig (func (param i32 i32))) + (table funcref (elem $f)) + (func $type-second-empty-in-block + (block + (call_indirect (type $sig) (i32.const 0) (i32.const 0)) + ) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $f (param i32)) + (type $sig (func (param i32))) + (table funcref (elem $f)) + (func $type-first-empty-in-loop + (loop + (call_indirect (type $sig) (i32.const 0)) + ) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $f (param i32 i32)) + (type $sig (func (param i32 i32))) + (table funcref (elem $f)) + (func $type-second-empty-in-loop + (loop + (call_indirect (type $sig) (i32.const 0) (i32.const 0)) + ) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $f (param i32)) + (type $sig (func (param i32))) + (table funcref (elem $f)) + (func $type-first-empty-in-then + (i32.const 0) (i32.const 0) + (if + (then + (call_indirect (type $sig) (i32.const 0)) + ) + ) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $f (param i32 i32)) + (type $sig (func (param i32 i32))) + (table funcref (elem $f)) + (func $type-second-empty-in-then + (i32.const 0) (i32.const 0) + (if + (then + (call_indirect (type $sig) (i32.const 0) (i32.const 0)) + ) + ) + ) + ) + "type mismatch" +) + + +;; Unbound type + +(assert_invalid + (module + (table 0 funcref) + (func $unbound-type (call_indirect (type 1) (i32.const 0))) + ) + "unknown type" +) +(assert_invalid + (module + (table 0 funcref) + (func $large-type (call_indirect (type 1012321300) (i32.const 0))) + ) + "unknown type" +) + + +;; Unbound function in table + +(assert_invalid + (module (table funcref (elem 0 0))) + "unknown function" +) diff --git a/runtime/near-vm/tests/wast/spec/proposals/multi-value/fac.wast b/runtime/near-vm/tests/wast/spec/proposals/multi-value/fac.wast new file mode 100644 index 00000000000..0e61c1f9eee --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/proposals/multi-value/fac.wast @@ -0,0 +1,109 @@ +(module + ;; Recursive factorial + (func (export "fac-rec") (param i64) (result i64) + (if (result i64) (i64.eq (local.get 0) (i64.const 0)) + (then (i64.const 1)) + (else + (i64.mul (local.get 0) (call 0 (i64.sub (local.get 0) (i64.const 1)))) + ) + ) + ) + + ;; Recursive factorial named + (func $fac-rec-named (export "fac-rec-named") (param $n i64) (result i64) + (if (result i64) (i64.eq (local.get $n) (i64.const 0)) + (then (i64.const 1)) + (else + (i64.mul + (local.get $n) + (call $fac-rec-named (i64.sub (local.get $n) (i64.const 1))) + ) + ) + ) + ) + + ;; Iterative factorial + (func (export "fac-iter") (param i64) (result i64) + (local i64 i64) + (local.set 1 (local.get 0)) + (local.set 2 (i64.const 1)) + (block + (loop + (if + (i64.eq (local.get 1) (i64.const 0)) + (then (br 2)) + (else + (local.set 2 (i64.mul (local.get 1) (local.get 2))) + (local.set 1 (i64.sub (local.get 1) (i64.const 1))) + ) + ) + (br 0) + ) + ) + (local.get 2) + ) + + ;; Iterative factorial named + (func (export "fac-iter-named") (param $n i64) (result i64) + (local $i i64) + (local $res i64) + (local.set $i (local.get $n)) + (local.set $res (i64.const 1)) + (block $done + (loop $loop + (if + (i64.eq (local.get $i) (i64.const 0)) + (then (br $done)) + (else + (local.set $res (i64.mul (local.get $i) (local.get $res))) + (local.set $i (i64.sub (local.get $i) (i64.const 1))) + ) + ) + (br $loop) + ) + ) + (local.get $res) + ) + + ;; Optimized factorial. + (func (export "fac-opt") (param i64) (result i64) + (local i64) + (local.set 1 (i64.const 1)) + (block + (br_if 0 (i64.lt_s (local.get 0) (i64.const 2))) + (loop + (local.set 1 (i64.mul (local.get 1) (local.get 0))) + (local.set 0 (i64.add (local.get 0) (i64.const -1))) + (br_if 0 (i64.gt_s (local.get 0) (i64.const 1))) + ) + ) + (local.get 1) + ) + + ;; Iterative factorial without locals. + (func $pick0 (param i64) (result i64 i64) + (local.get 0) (local.get 0) + ) + (func $pick1 (param i64 i64) (result i64 i64 i64) + (local.get 0) (local.get 1) (local.get 0) + ) + (func (export "fac-ssa") (param i64) (result i64) + (i64.const 1) (local.get 0) + (loop $l (param i64 i64) (result i64) + (call $pick1) (call $pick1) (i64.mul) + (call $pick1) (i64.const 1) (i64.sub) + (call $pick0) (i64.const 0) (i64.gt_u) + (br_if $l) + (drop) (return) + ) + ) +) + +(assert_return (invoke "fac-rec" (i64.const 25)) (i64.const 7034535277573963776)) +(assert_return (invoke "fac-iter" (i64.const 25)) (i64.const 7034535277573963776)) +(assert_return (invoke "fac-rec-named" (i64.const 25)) (i64.const 7034535277573963776)) +(assert_return (invoke "fac-iter-named" (i64.const 25)) (i64.const 7034535277573963776)) +(assert_return (invoke "fac-opt" (i64.const 25)) (i64.const 7034535277573963776)) +(assert_return (invoke "fac-ssa" (i64.const 25)) (i64.const 7034535277573963776)) + +(assert_exhaustion (invoke "fac-rec" (i64.const 1073741824)) "call stack exhausted") diff --git a/runtime/near-vm/tests/wast/spec/proposals/multi-value/func.wast b/runtime/near-vm/tests/wast/spec/proposals/multi-value/func.wast new file mode 100644 index 00000000000..5cc5d743201 --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/proposals/multi-value/func.wast @@ -0,0 +1,899 @@ +;; Test `func` declarations, i.e. functions + +(module + ;; Auxiliary definition + (type $sig (func)) + (func $dummy) + + ;; Syntax + + (func) + (func (export "f")) + (func $f) + (func $h (export "g")) + + (func (local)) + (func (local) (local)) + (func (local i32)) + (func (local $x i32)) + (func (local i32 f64 i64)) + (func (local i32) (local f64)) + (func (local i32 f32) (local $x i64) (local) (local i32 f64)) + + (func (param)) + (func (param) (param)) + (func (param i32)) + (func (param $x i32)) + (func (param i32 f64 i64)) + (func (param i32) (param f64)) + (func (param i32 f32) (param $x i64) (param) (param i32 f64)) + + (func (result)) + (func (result) (result)) + (func (result i32) (unreachable)) + (func (result i32 f64 f32) (unreachable)) + (func (result i32) (result f64) (unreachable)) + (func (result i32 f32) (result i64) (result) (result i32 f64) (unreachable)) + + (type $sig-1 (func)) + (type $sig-2 (func (result i32))) + (type $sig-3 (func (param $x i32))) + (type $sig-4 (func (param i32 f64 i32) (result i32))) + + (func (export "type-use-1") (type $sig-1)) + (func (export "type-use-2") (type $sig-2) (i32.const 0)) + (func (export "type-use-3") (type $sig-3)) + (func (export "type-use-4") (type $sig-4) (i32.const 0)) + (func (export "type-use-5") (type $sig-2) (result i32) (i32.const 0)) + (func (export "type-use-6") (type $sig-3) (param i32)) + (func (export "type-use-7") + (type $sig-4) (param i32) (param f64 i32) (result i32) (i32.const 0) + ) + + (func (type $sig)) + (func (type $forward)) ;; forward reference + + (func $complex + (param i32 f32) (param $x i64) (param) (param i32) + (result) (result i32) (result) (result i64 i32) + (local f32) (local $y i32) (local i64 i32) (local) (local f64 i32) + (unreachable) (unreachable) + ) + (func $complex-sig + (type $sig) + (local f32) (local $y i32) (local i64 i32) (local) (local f64 i32) + (unreachable) (unreachable) + ) + + (type $forward (func)) + + ;; Typing of locals + + (func (export "local-first-i32") (result i32) (local i32 i32) (local.get 0)) + (func (export "local-first-i64") (result i64) (local i64 i64) (local.get 0)) + (func (export "local-first-f32") (result f32) (local f32 f32) (local.get 0)) + (func (export "local-first-f64") (result f64) (local f64 f64) (local.get 0)) + (func (export "local-second-i32") (result i32) (local i32 i32) (local.get 1)) + (func (export "local-second-i64") (result i64) (local i64 i64) (local.get 1)) + (func (export "local-second-f32") (result f32) (local f32 f32) (local.get 1)) + (func (export "local-second-f64") (result f64) (local f64 f64) (local.get 1)) + (func (export "local-mixed") (result f64) + (local f32) (local $x i32) (local i64 i32) (local) (local f64 i32) + (drop (f32.neg (local.get 0))) + (drop (i32.eqz (local.get 1))) + (drop (i64.eqz (local.get 2))) + (drop (i32.eqz (local.get 3))) + (drop (f64.neg (local.get 4))) + (drop (i32.eqz (local.get 5))) + (local.get 4) + ) + + ;; Typing of parameters + + (func (export "param-first-i32") (param i32 i32) (result i32) (local.get 0)) + (func (export "param-first-i64") (param i64 i64) (result i64) (local.get 0)) + (func (export "param-first-f32") (param f32 f32) (result f32) (local.get 0)) + (func (export "param-first-f64") (param f64 f64) (result f64) (local.get 0)) + (func (export "param-second-i32") (param i32 i32) (result i32) (local.get 1)) + (func (export "param-second-i64") (param i64 i64) (result i64) (local.get 1)) + (func (export "param-second-f32") (param f32 f32) (result f32) (local.get 1)) + (func (export "param-second-f64") (param f64 f64) (result f64) (local.get 1)) + (func (export "param-mixed") (param f32 i32) (param) (param $x i64) (param i32 f64 i32) + (result f64) + (drop (f32.neg (local.get 0))) + (drop (i32.eqz (local.get 1))) + (drop (i64.eqz (local.get 2))) + (drop (i32.eqz (local.get 3))) + (drop (f64.neg (local.get 4))) + (drop (i32.eqz (local.get 5))) + (local.get 4) + ) + + ;; Typing of results + + (func (export "empty")) + (func (export "value-void") (call $dummy)) + (func (export "value-i32") (result i32) (i32.const 77)) + (func (export "value-i64") (result i64) (i64.const 7777)) + (func (export "value-f32") (result f32) (f32.const 77.7)) + (func (export "value-f64") (result f64) (f64.const 77.77)) + (func (export "value-i32-f64") (result i32 f64) (i32.const 77) (f64.const 7)) + (func (export "value-i32-i32-i32") (result i32 i32 i32) + (i32.const 1) (i32.const 2) (i32.const 3) + ) + (func (export "value-block-void") (block (call $dummy) (call $dummy))) + (func (export "value-block-i32") (result i32) + (block (result i32) (call $dummy) (i32.const 77)) + ) + (func (export "value-block-i32-i64") (result i32 i64) + (block (result i32 i64) (call $dummy) (i32.const 1) (i64.const 2)) + ) + + (func (export "return-empty") (return)) + (func (export "return-i32") (result i32) (return (i32.const 78))) + (func (export "return-i64") (result i64) (return (i64.const 7878))) + (func (export "return-f32") (result f32) (return (f32.const 78.7))) + (func (export "return-f64") (result f64) (return (f64.const 78.78))) + (func (export "return-i32-f64") (result i32 f64) + (return (i32.const 78) (f64.const 78.78)) + ) + (func (export "return-i32-i32-i32") (result i32 i32 i32) + (return (i32.const 1) (i32.const 2) (i32.const 3)) + ) + (func (export "return-block-i32") (result i32) + (return (block (result i32) (call $dummy) (i32.const 77))) + ) + (func (export "return-block-i32-i64") (result i32 i64) + (return (block (result i32 i64) (call $dummy) (i32.const 1) (i64.const 2))) + ) + + (func (export "break-empty") (br 0)) + (func (export "break-i32") (result i32) (br 0 (i32.const 79))) + (func (export "break-i64") (result i64) (br 0 (i64.const 7979))) + (func (export "break-f32") (result f32) (br 0 (f32.const 79.9))) + (func (export "break-f64") (result f64) (br 0 (f64.const 79.79))) + (func (export "break-i32-f64") (result i32 f64) + (br 0 (i32.const 79) (f64.const 79.79)) + ) + (func (export "break-i32-i32-i32") (result i32 i32 i32) + (br 0 (i32.const 1) (i32.const 2) (i32.const 3)) + ) + (func (export "break-block-i32") (result i32) + (br 0 (block (result i32) (call $dummy) (i32.const 77))) + ) + (func (export "break-block-i32-i64") (result i32 i64) + (br 0 (block (result i32 i64) (call $dummy) (i32.const 1) (i64.const 2))) + ) + + (func (export "break-br_if-empty") (param i32) + (br_if 0 (local.get 0)) + ) + (func (export "break-br_if-num") (param i32) (result i32) + (drop (br_if 0 (i32.const 50) (local.get 0))) (i32.const 51) + ) + (func (export "break-br_if-num-num") (param i32) (result i32 i64) + (drop (drop (br_if 0 (i32.const 50) (i64.const 51) (local.get 0)))) + (i32.const 51) (i64.const 52) + ) + + (func (export "break-br_table-empty") (param i32) + (br_table 0 0 0 (local.get 0)) + ) + (func (export "break-br_table-num") (param i32) (result i32) + (br_table 0 0 (i32.const 50) (local.get 0)) (i32.const 51) + ) + (func (export "break-br_table-num-num") (param i32) (result i32 i64) + (br_table 0 0 (i32.const 50) (i64.const 51) (local.get 0)) + (i32.const 51) (i64.const 52) + ) + (func (export "break-br_table-nested-empty") (param i32) + (block (br_table 0 1 0 (local.get 0))) + ) + (func (export "break-br_table-nested-num") (param i32) (result i32) + (i32.add + (block (result i32) + (br_table 0 1 0 (i32.const 50) (local.get 0)) (i32.const 51) + ) + (i32.const 2) + ) + ) + (func (export "break-br_table-nested-num-num") (param i32) (result i32 i32) + (i32.add + (block (result i32 i32) + (br_table 0 1 0 (i32.const 50) (i32.const 51) (local.get 0)) + (i32.const 51) (i32.const -3) + ) + ) + (i32.const 52) + ) + + ;; Large signatures + + (func (export "large-sig") + (param i32 i64 f32 f32 i32 f64 f32 i32 i32 i32 f32 f64 f64 f64 i32 i32 f32) + (result f64 f32 i32 i32 i32 i64 f32 i32 i32 f32 f64 f64 i32 f32 i32 f64) + (local.get 5) + (local.get 2) + (local.get 0) + (local.get 8) + (local.get 7) + (local.get 1) + (local.get 3) + (local.get 9) + (local.get 4) + (local.get 6) + (local.get 13) + (local.get 11) + (local.get 15) + (local.get 16) + (local.get 14) + (local.get 12) + ) + + ;; Default initialization of locals + + (func (export "init-local-i32") (result i32) (local i32) (local.get 0)) + (func (export "init-local-i64") (result i64) (local i64) (local.get 0)) + (func (export "init-local-f32") (result f32) (local f32) (local.get 0)) + (func (export "init-local-f64") (result f64) (local f64) (local.get 0)) +) + +(assert_return (invoke "type-use-1")) +(assert_return (invoke "type-use-2") (i32.const 0)) +(assert_return (invoke "type-use-3" (i32.const 1))) +(assert_return + (invoke "type-use-4" (i32.const 1) (f64.const 1) (i32.const 1)) + (i32.const 0) +) +(assert_return (invoke "type-use-5") (i32.const 0)) +(assert_return (invoke "type-use-6" (i32.const 1))) +(assert_return + (invoke "type-use-7" (i32.const 1) (f64.const 1) (i32.const 1)) + (i32.const 0) +) + +(assert_return (invoke "local-first-i32") (i32.const 0)) +(assert_return (invoke "local-first-i64") (i64.const 0)) +(assert_return (invoke "local-first-f32") (f32.const 0)) +(assert_return (invoke "local-first-f64") (f64.const 0)) +(assert_return (invoke "local-second-i32") (i32.const 0)) +(assert_return (invoke "local-second-i64") (i64.const 0)) +(assert_return (invoke "local-second-f32") (f32.const 0)) +(assert_return (invoke "local-second-f64") (f64.const 0)) +(assert_return (invoke "local-mixed") (f64.const 0)) + +(assert_return + (invoke "param-first-i32" (i32.const 2) (i32.const 3)) (i32.const 2) +) +(assert_return + (invoke "param-first-i64" (i64.const 2) (i64.const 3)) (i64.const 2) +) +(assert_return + (invoke "param-first-f32" (f32.const 2) (f32.const 3)) (f32.const 2) +) +(assert_return + (invoke "param-first-f64" (f64.const 2) (f64.const 3)) (f64.const 2) +) +(assert_return + (invoke "param-second-i32" (i32.const 2) (i32.const 3)) (i32.const 3) +) +(assert_return + (invoke "param-second-i64" (i64.const 2) (i64.const 3)) (i64.const 3) +) +(assert_return + (invoke "param-second-f32" (f32.const 2) (f32.const 3)) (f32.const 3) +) +(assert_return + (invoke "param-second-f64" (f64.const 2) (f64.const 3)) (f64.const 3) +) + +(assert_return + (invoke "param-mixed" + (f32.const 1) (i32.const 2) (i64.const 3) + (i32.const 4) (f64.const 5.5) (i32.const 6) + ) + (f64.const 5.5) +) + +(assert_return (invoke "empty")) +(assert_return (invoke "value-void")) +(assert_return (invoke "value-i32") (i32.const 77)) +(assert_return (invoke "value-i64") (i64.const 7777)) +(assert_return (invoke "value-f32") (f32.const 77.7)) +(assert_return (invoke "value-f64") (f64.const 77.77)) +(assert_return (invoke "value-i32-f64") (i32.const 77) (f64.const 7)) +(assert_return (invoke "value-i32-i32-i32") + (i32.const 1) (i32.const 2) (i32.const 3) +) +(assert_return (invoke "value-block-void")) +(assert_return (invoke "value-block-i32") (i32.const 77)) +(assert_return (invoke "value-block-i32-i64") (i32.const 1) (i64.const 2)) + +(assert_return (invoke "return-empty")) +(assert_return (invoke "return-i32") (i32.const 78)) +(assert_return (invoke "return-i64") (i64.const 7878)) +(assert_return (invoke "return-f32") (f32.const 78.7)) +(assert_return (invoke "return-f64") (f64.const 78.78)) +(assert_return (invoke "return-i32-f64") (i32.const 78) (f64.const 78.78)) +(assert_return (invoke "return-i32-i32-i32") + (i32.const 1) (i32.const 2) (i32.const 3) +) +(assert_return (invoke "return-block-i32") (i32.const 77)) +(assert_return (invoke "return-block-i32-i64") (i32.const 1) (i64.const 2)) + +(assert_return (invoke "break-empty")) +(assert_return (invoke "break-i32") (i32.const 79)) +(assert_return (invoke "break-i64") (i64.const 7979)) +(assert_return (invoke "break-f32") (f32.const 79.9)) +(assert_return (invoke "break-f64") (f64.const 79.79)) +(assert_return (invoke "break-i32-f64") (i32.const 79) (f64.const 79.79)) +(assert_return (invoke "break-i32-i32-i32") + (i32.const 1) (i32.const 2) (i32.const 3) +) +(assert_return (invoke "break-block-i32") (i32.const 77)) +(assert_return (invoke "break-block-i32-i64") (i32.const 1) (i64.const 2)) + +(assert_return (invoke "break-br_if-empty" (i32.const 0))) +(assert_return (invoke "break-br_if-empty" (i32.const 2))) +(assert_return (invoke "break-br_if-num" (i32.const 0)) (i32.const 51)) +(assert_return (invoke "break-br_if-num" (i32.const 1)) (i32.const 50)) +(assert_return (invoke "break-br_if-num-num" (i32.const 0)) + (i32.const 51) (i64.const 52) +) +(assert_return (invoke "break-br_if-num-num" (i32.const 1)) + (i32.const 50) (i64.const 51) +) + +(assert_return (invoke "break-br_table-empty" (i32.const 0))) +(assert_return (invoke "break-br_table-empty" (i32.const 1))) +(assert_return (invoke "break-br_table-empty" (i32.const 5))) +(assert_return (invoke "break-br_table-empty" (i32.const -1))) +(assert_return (invoke "break-br_table-num" (i32.const 0)) (i32.const 50)) +(assert_return (invoke "break-br_table-num" (i32.const 1)) (i32.const 50)) +(assert_return (invoke "break-br_table-num" (i32.const 10)) (i32.const 50)) +(assert_return (invoke "break-br_table-num" (i32.const -100)) (i32.const 50)) +(assert_return (invoke "break-br_table-num-num" (i32.const 0)) + (i32.const 50) (i64.const 51) +) +(assert_return (invoke "break-br_table-num-num" (i32.const 1)) + (i32.const 50) (i64.const 51) +) +(assert_return (invoke "break-br_table-num-num" (i32.const 10)) + (i32.const 50) (i64.const 51) +) +(assert_return (invoke "break-br_table-num-num" (i32.const -100)) + (i32.const 50) (i64.const 51) +) +(assert_return (invoke "break-br_table-nested-empty" (i32.const 0))) +(assert_return (invoke "break-br_table-nested-empty" (i32.const 1))) +(assert_return (invoke "break-br_table-nested-empty" (i32.const 3))) +(assert_return (invoke "break-br_table-nested-empty" (i32.const -2))) +(assert_return + (invoke "break-br_table-nested-num" (i32.const 0)) (i32.const 52) +) +(assert_return + (invoke "break-br_table-nested-num" (i32.const 1)) (i32.const 50) +) +(assert_return + (invoke "break-br_table-nested-num" (i32.const 2)) (i32.const 52) +) +(assert_return + (invoke "break-br_table-nested-num" (i32.const -3)) (i32.const 52) +) +(assert_return + (invoke "break-br_table-nested-num-num" (i32.const 0)) + (i32.const 101) (i32.const 52) +) +(assert_return + (invoke "break-br_table-nested-num-num" (i32.const 1)) + (i32.const 50) (i32.const 51) +) +(assert_return + (invoke "break-br_table-nested-num-num" (i32.const 2)) + (i32.const 101) (i32.const 52) +) +(assert_return + (invoke "break-br_table-nested-num-num" (i32.const -3)) + (i32.const 101) (i32.const 52) +) + +(assert_return + (invoke "large-sig" + (i32.const 0) (i64.const 1) (f32.const 2) (f32.const 3) + (i32.const 4) (f64.const 5) (f32.const 6) (i32.const 7) + (i32.const 8) (i32.const 9) (f32.const 10) (f64.const 11) + (f64.const 12) (f64.const 13) (i32.const 14) (i32.const 15) + (f32.const 16) + ) + (f64.const 5) (f32.const 2) (i32.const 0) (i32.const 8) + (i32.const 7) (i64.const 1) (f32.const 3) (i32.const 9) + (i32.const 4) (f32.const 6) (f64.const 13) (f64.const 11) + (i32.const 15) (f32.const 16) (i32.const 14) (f64.const 12) +) + +(assert_return (invoke "init-local-i32") (i32.const 0)) +(assert_return (invoke "init-local-i64") (i64.const 0)) +(assert_return (invoke "init-local-f32") (f32.const 0)) +(assert_return (invoke "init-local-f64") (f64.const 0)) + + +;; Expansion of inline function types + +(module + (func $f (result f64) (f64.const 0)) ;; adds implicit type definition + (func $g (param i32)) ;; reuses explicit type definition + (type $t (func (param i32))) + + (func $i32->void (type 0)) ;; (param i32) + (func $void->f64 (type 1) (f64.const 0)) ;; (result f64) + (func $check + (call $i32->void (i32.const 0)) + (drop (call $void->f64)) + ) +) + +(assert_invalid + (module + (func $f (result f64) (f64.const 0)) ;; adds implicit type definition + (func $g (param i32)) ;; reuses explicit type definition + (func $h (result f64) (f64.const 1)) ;; reuses implicit type definition + (type $t (func (param i32))) + + (func (type 2)) ;; does not exist + ) + "unknown type" +) + + +(module + (type $sig (func)) + + (func $empty-sig-1) ;; should be assigned type $sig + (func $complex-sig-1 (param f64 i64 f64 i64 f64 i64 f32 i32)) + (func $empty-sig-2) ;; should be assigned type $sig + (func $complex-sig-2 (param f64 i64 f64 i64 f64 i64 f32 i32)) + (func $complex-sig-3 (param f64 i64 f64 i64 f64 i64 f32 i32)) + (func $complex-sig-4 (param i64 i64 f64 i64 f64 i64 f32 i32)) + (func $complex-sig-5 (param i64 i64 f64 i64 f64 i64 f32 i32)) + + (type $empty-sig-duplicate (func)) + (type $complex-sig-duplicate (func (param i64 i64 f64 i64 f64 i64 f32 i32))) + (table funcref + (elem + $complex-sig-3 $empty-sig-2 $complex-sig-1 $complex-sig-3 $empty-sig-1 + $complex-sig-4 $complex-sig-5 + ) + ) + + (func (export "signature-explicit-reused") + (call_indirect (type $sig) (i32.const 1)) + (call_indirect (type $sig) (i32.const 4)) + ) + + (func (export "signature-implicit-reused") + ;; The implicit index 3 in this test depends on the function and + ;; type definitions, and may need adapting if they change. + (call_indirect (type 3) + (f64.const 0) (i64.const 0) (f64.const 0) (i64.const 0) + (f64.const 0) (i64.const 0) (f32.const 0) (i32.const 0) + (i32.const 0) + ) + (call_indirect (type 3) + (f64.const 0) (i64.const 0) (f64.const 0) (i64.const 0) + (f64.const 0) (i64.const 0) (f32.const 0) (i32.const 0) + (i32.const 2) + ) + (call_indirect (type 3) + (f64.const 0) (i64.const 0) (f64.const 0) (i64.const 0) + (f64.const 0) (i64.const 0) (f32.const 0) (i32.const 0) + (i32.const 3) + ) + ) + + (func (export "signature-explicit-duplicate") + (call_indirect (type $empty-sig-duplicate) (i32.const 1)) + ) + + (func (export "signature-implicit-duplicate") + (call_indirect (type $complex-sig-duplicate) + (i64.const 0) (i64.const 0) (f64.const 0) (i64.const 0) + (f64.const 0) (i64.const 0) (f32.const 0) (i32.const 0) + (i32.const 5) + ) + (call_indirect (type $complex-sig-duplicate) + (i64.const 0) (i64.const 0) (f64.const 0) (i64.const 0) + (f64.const 0) (i64.const 0) (f32.const 0) (i32.const 0) + (i32.const 6) + ) + ) +) + +(assert_return (invoke "signature-explicit-reused")) +(assert_return (invoke "signature-implicit-reused")) +(assert_return (invoke "signature-explicit-duplicate")) +(assert_return (invoke "signature-implicit-duplicate")) + + +;; Malformed type use + +(assert_malformed + (module quote + "(type $sig (func (param i32) (result i32)))" + "(func (type $sig) (result i32) (param i32) (i32.const 0))" + ) + "unexpected token" +) +(assert_malformed + (module quote + "(type $sig (func (param i32) (result i32)))" + "(func (param i32) (type $sig) (result i32) (i32.const 0))" + ) + "unexpected token" +) +(assert_malformed + (module quote + "(type $sig (func (param i32) (result i32)))" + "(func (param i32) (result i32) (type $sig) (i32.const 0))" + ) + "unexpected token" +) +(assert_malformed + (module quote + "(type $sig (func (param i32) (result i32)))" + "(func (result i32) (type $sig) (param i32) (i32.const 0))" + ) + "unexpected token" +) +(assert_malformed + (module quote + "(type $sig (func (param i32) (result i32)))" + "(func (result i32) (param i32) (type $sig) (i32.const 0))" + ) + "unexpected token" +) +(assert_malformed + (module quote + "(func (result i32) (param i32) (i32.const 0))" + ) + "unexpected token" +) + +(assert_malformed + (module quote + "(type $sig (func))" + "(func (type $sig) (result i32) (i32.const 0))" + ) + "inline function type" +) +(assert_malformed + (module quote + "(type $sig (func (param i32) (result i32)))" + "(func (type $sig) (result i32) (i32.const 0))" + ) + "inline function type" +) +(assert_malformed + (module quote + "(type $sig (func (param i32) (result i32)))" + "(func (type $sig) (param i32) (i32.const 0))" + ) + "inline function type" +) +(assert_malformed + (module quote + "(type $sig (func (param i32 i32) (result i32)))" + "(func (type $sig) (param i32) (result i32) (unreachable))" + ) + "inline function type" +) + + +;; Invalid typing of locals + +(assert_invalid + (module (func $type-local-num-vs-num (result i64) (local i32) (local.get 0))) + "type mismatch" +) +(assert_invalid + (module (func $type-local-num-vs-num (local f32) (i32.eqz (local.get 0)))) + "type mismatch" +) +(assert_invalid + (module (func $type-local-num-vs-num (local f64 i64) (f64.neg (local.get 1)))) + "type mismatch" +) + + +;; Invalid typing of 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" +) + + +;; Invalid typing of result + +(assert_invalid + (module (func $type-empty-i32 (result i32))) + "type mismatch" +) +(assert_invalid + (module (func $type-empty-i64 (result i64))) + "type mismatch" +) +(assert_invalid + (module (func $type-empty-f32 (result f32))) + "type mismatch" +) +(assert_invalid + (module (func $type-empty-f64 (result f64))) + "type mismatch" +) +(assert_invalid + (module (func $type-empty-f64-i32 (result f64 i32))) + "type mismatch" +) + +(assert_invalid + (module (func $type-value-void-vs-num (result i32) + (nop) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-value-void-vs-nums (result i32 i32) + (nop) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-value-num-vs-void + (i32.const 0) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-value-nums-vs-void + (i32.const 0) (i64.const 0) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-value-num-vs-num (result i32) + (f32.const 0) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-value-num-vs-nums (result f32 f32) + (f32.const 0) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-value-nums-vs-num (result f32) + (f32.const 0) (f32.const 0) + )) + "type mismatch" +) + +(assert_invalid + (module (func $type-return-last-empty-vs-num (result i32) + (return) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-return-last-empty-vs-nums (result i32 i32) + (return) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-return-last-void-vs-num (result i32) + (return (nop)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-return-last-void-vs-nums (result i32 i64) + (return (nop)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-return-last-num-vs-num (result i32) + (return (i64.const 0)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-return-last-num-vs-nums (result i64 i64) + (return (i64.const 0)) + )) + "type mismatch" +) + +(assert_invalid + (module (func $type-return-empty-vs-num (result i32) + (return) (i32.const 1) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-return-empty-vs-nums (result i32 i32) + (return) (i32.const 1) (i32.const 2) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-return-partial-vs-nums (result i32 i32) + (i32.const 1) (return) (i32.const 2) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-return-void-vs-num (result i32) + (return (nop)) (i32.const 1) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-return-void-vs-nums (result i32 i32) + (return (nop)) (i32.const 1) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-return-num-vs-num (result i32) + (return (i64.const 1)) (i32.const 1) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-return-num-vs-nums (result i32 i32) + (return (i64.const 1)) (i32.const 1) (i32.const 2) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-return-first-num-vs-num (result i32) + (return (i64.const 1)) (return (i32.const 1)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-return-first-num-vs-nums (result i32 i32) + (return (i32.const 1)) (return (i32.const 1) (i32.const 2)) + )) + "type mismatch" +) + +(assert_invalid + (module (func $type-break-last-void-vs-num (result i32) + (br 0) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-last-void-vs-nums (result i32 i32) + (br 0) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-last-num-vs-num (result i32) + (br 0 (f32.const 0)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-last-num-vs-nums (result i32 i32) + (br 0 (i32.const 0)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-void-vs-num (result i32) + (br 0) (i32.const 1) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-void-vs-nums (result i32 i32) + (br 0) (i32.const 1) (i32.const 2) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-num-vs-num (result i32) + (br 0 (i64.const 1)) (i32.const 1) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-num-vs-nums (result i32 i32) + (br 0 (i32.const 1)) (i32.const 1) (i32.const 2) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-first-num-vs-num (result i32) + (br 0 (i64.const 1)) (br 0 (i32.const 1)) + )) + "type mismatch" +) + +(assert_invalid + (module (func $type-break-nested-empty-vs-num (result i32) + (block (br 1)) (br 0 (i32.const 1)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-nested-empty-vs-nums (result i32 i32) + (block (br 1)) (br 0 (i32.const 1) (i32.const 2)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-nested-void-vs-num (result i32) + (block (br 1 (nop))) (br 0 (i32.const 1)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-nested-void-vs-nums (result i32 i32) + (block (br 1 (nop))) (br 0 (i32.const 1) (i32.const 2)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-nested-num-vs-num (result i32) + (block (br 1 (i64.const 1))) (br 0 (i32.const 1)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-break-nested-num-vs-nums (result i32 i32) + (block (result i32) (br 1 (i32.const 1))) (br 0 (i32.const 1) (i32.const 2)) + )) + "type mismatch" +) + + +;; Syntax errors + +(assert_malformed + (module quote "(func (nop) (local i32))") + "unexpected token" +) +(assert_malformed + (module quote "(func (nop) (param i32))") + "unexpected token" +) +(assert_malformed + (module quote "(func (nop) (result i32))") + "unexpected token" +) +(assert_malformed + (module quote "(func (local i32) (param i32))") + "unexpected token" +) +(assert_malformed + (module quote "(func (local i32) (result i32) (local.get 0))") + "unexpected token" +) +(assert_malformed + (module quote "(func (result i32) (param i32) (local.get 0))") + "unexpected token" +) diff --git a/runtime/near-vm/tests/wast/spec/proposals/multi-value/if.wast b/runtime/near-vm/tests/wast/spec/proposals/multi-value/if.wast new file mode 100644 index 00000000000..1cbb617a7fa --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/proposals/multi-value/if.wast @@ -0,0 +1,1550 @@ +;; Test `if` operator + +(module + ;; Auxiliary definition + (memory 1) + + (func $dummy) + + (func (export "empty") (param i32) + (if (local.get 0) (then)) + (if (local.get 0) (then) (else)) + (if $l (local.get 0) (then)) + (if $l (local.get 0) (then) (else)) + ) + + (func (export "singular") (param i32) (result i32) + (if (local.get 0) (then (nop))) + (if (local.get 0) (then (nop)) (else (nop))) + (if (result i32) (local.get 0) (then (i32.const 7)) (else (i32.const 8))) + ) + + (func (export "multi") (param i32) (result i32 i32) + (if (local.get 0) (then (call $dummy) (call $dummy) (call $dummy))) + (if (local.get 0) (then) (else (call $dummy) (call $dummy) (call $dummy))) + (if (result i32) (local.get 0) + (then (call $dummy) (call $dummy) (i32.const 8) (call $dummy)) + (else (call $dummy) (call $dummy) (i32.const 9) (call $dummy)) + ) + (if (result i32 i64 i32) (local.get 0) + (then + (call $dummy) (call $dummy) (i32.const 1) (call $dummy) + (call $dummy) (call $dummy) (i64.const 2) (call $dummy) + (call $dummy) (call $dummy) (i32.const 3) (call $dummy) + ) + (else + (call $dummy) (call $dummy) (i32.const -1) (call $dummy) + (call $dummy) (call $dummy) (i64.const -2) (call $dummy) + (call $dummy) (call $dummy) (i32.const -3) (call $dummy) + ) + ) + (drop) (drop) + ) + + (func (export "nested") (param i32 i32) (result i32) + (if (result i32) (local.get 0) + (then + (if (local.get 1) (then (call $dummy) (block) (nop))) + (if (local.get 1) (then) (else (call $dummy) (block) (nop))) + (if (result i32) (local.get 1) + (then (call $dummy) (i32.const 9)) + (else (call $dummy) (i32.const 10)) + ) + ) + (else + (if (local.get 1) (then (call $dummy) (block) (nop))) + (if (local.get 1) (then) (else (call $dummy) (block) (nop))) + (if (result i32) (local.get 1) + (then (call $dummy) (i32.const 10)) + (else (call $dummy) (i32.const 11)) + ) + ) + ) + ) + + (func (export "as-select-first") (param i32) (result i32) + (select + (if (result i32) (local.get 0) + (then (call $dummy) (i32.const 1)) + (else (call $dummy) (i32.const 0)) + ) + (i32.const 2) (i32.const 3) + ) + ) + (func (export "as-select-mid") (param i32) (result i32) + (select + (i32.const 2) + (if (result i32) (local.get 0) + (then (call $dummy) (i32.const 1)) + (else (call $dummy) (i32.const 0)) + ) + (i32.const 3) + ) + ) + (func (export "as-select-last") (param i32) (result i32) + (select + (i32.const 2) (i32.const 3) + (if (result i32) (local.get 0) + (then (call $dummy) (i32.const 1)) + (else (call $dummy) (i32.const 0)) + ) + ) + ) + + (func (export "as-loop-first") (param i32) (result i32) + (loop (result i32) + (if (result i32) (local.get 0) + (then (call $dummy) (i32.const 1)) + (else (call $dummy) (i32.const 0)) + ) + (call $dummy) (call $dummy) + ) + ) + (func (export "as-loop-mid") (param i32) (result i32) + (loop (result i32) + (call $dummy) + (if (result i32) (local.get 0) + (then (call $dummy) (i32.const 1)) + (else (call $dummy) (i32.const 0)) + ) + (call $dummy) + ) + ) + (func (export "as-loop-last") (param i32) (result i32) + (loop (result i32) + (call $dummy) (call $dummy) + (if (result i32) (local.get 0) + (then (call $dummy) (i32.const 1)) + (else (call $dummy) (i32.const 0)) + ) + ) + ) + + (func (export "as-if-condition") (param i32) (result i32) + (if (result i32) + (if (result i32) (local.get 0) + (then (i32.const 1)) (else (i32.const 0)) + ) + (then (call $dummy) (i32.const 2)) + (else (call $dummy) (i32.const 3)) + ) + ) + + (func (export "as-br_if-first") (param i32) (result i32) + (block (result i32) + (br_if 0 + (if (result i32) (local.get 0) + (then (call $dummy) (i32.const 1)) + (else (call $dummy) (i32.const 0)) + ) + (i32.const 2) + ) + (return (i32.const 3)) + ) + ) + (func (export "as-br_if-last") (param i32) (result i32) + (block (result i32) + (br_if 0 + (i32.const 2) + (if (result i32) (local.get 0) + (then (call $dummy) (i32.const 1)) + (else (call $dummy) (i32.const 0)) + ) + ) + (return (i32.const 3)) + ) + ) + + (func (export "as-br_table-first") (param i32) (result i32) + (block (result i32) + (if (result i32) (local.get 0) + (then (call $dummy) (i32.const 1)) + (else (call $dummy) (i32.const 0)) + ) + (i32.const 2) + (br_table 0 0) + ) + ) + (func (export "as-br_table-last") (param i32) (result i32) + (block (result i32) + (i32.const 2) + (if (result i32) (local.get 0) + (then (call $dummy) (i32.const 1)) + (else (call $dummy) (i32.const 0)) + ) + (br_table 0 0) + ) + ) + + (func $func (param i32 i32) (result i32) (local.get 0)) + (type $check (func (param i32 i32) (result i32))) + (table funcref (elem $func)) + (func (export "as-call_indirect-first") (param i32) (result i32) + (block (result i32) + (call_indirect (type $check) + (if (result i32) (local.get 0) + (then (call $dummy) (i32.const 1)) + (else (call $dummy) (i32.const 0)) + ) + (i32.const 2) (i32.const 0) + ) + ) + ) + (func (export "as-call_indirect-mid") (param i32) (result i32) + (block (result i32) + (call_indirect (type $check) + (i32.const 2) + (if (result i32) (local.get 0) + (then (call $dummy) (i32.const 1)) + (else (call $dummy) (i32.const 0)) + ) + (i32.const 0) + ) + ) + ) + (func (export "as-call_indirect-last") (param i32) (result i32) + (block (result i32) + (call_indirect (type $check) + (i32.const 2) (i32.const 0) + (if (result i32) (local.get 0) + (then (call $dummy) (i32.const 1)) + (else (call $dummy) (i32.const 0)) + ) + ) + ) + ) + + (func (export "as-store-first") (param i32) + (if (result i32) (local.get 0) + (then (call $dummy) (i32.const 1)) + (else (call $dummy) (i32.const 0)) + ) + (i32.const 2) + (i32.store) + ) + (func (export "as-store-last") (param i32) + (i32.const 2) + (if (result i32) (local.get 0) + (then (call $dummy) (i32.const 1)) + (else (call $dummy) (i32.const 0)) + ) + (i32.store) + ) + + (func (export "as-memory.grow-value") (param i32) (result i32) + (memory.grow + (if (result i32) (local.get 0) + (then (i32.const 1)) + (else (i32.const 0)) + ) + ) + ) + + (func $f (param i32) (result i32) (local.get 0)) + + (func (export "as-call-value") (param i32) (result i32) + (call $f + (if (result i32) (local.get 0) + (then (i32.const 1)) + (else (i32.const 0)) + ) + ) + ) + (func (export "as-return-value") (param i32) (result i32) + (if (result i32) (local.get 0) + (then (i32.const 1)) + (else (i32.const 0))) + (return) + ) + (func (export "as-drop-operand") (param i32) + (drop + (if (result i32) (local.get 0) + (then (i32.const 1)) + (else (i32.const 0)) + ) + ) + ) + (func (export "as-br-value") (param i32) (result i32) + (block (result i32) + (br 0 + (if (result i32) (local.get 0) + (then (i32.const 1)) + (else (i32.const 0)) + ) + ) + ) + ) + (func (export "as-local.set-value") (param i32) (result i32) + (local i32) + (local.set 0 + (if (result i32) (local.get 0) + (then (i32.const 1)) + (else (i32.const 0)) + ) + ) + (local.get 0) + ) + (func (export "as-local.tee-value") (param i32) (result i32) + (local.tee 0 + (if (result i32) (local.get 0) + (then (i32.const 1)) + (else (i32.const 0)) + ) + ) + ) + (global $a (mut i32) (i32.const 10)) + (func (export "as-global.set-value") (param i32) (result i32) + (global.set $a + (if (result i32) (local.get 0) + (then (i32.const 1)) + (else (i32.const 0)) + ) + ) (global.get $a) + ) + (func (export "as-load-operand") (param i32) (result i32) + (i32.load + (if (result i32) (local.get 0) + (then (i32.const 11)) + (else (i32.const 10)) + ) + ) + ) + + (func (export "as-unary-operand") (param i32) (result i32) + (i32.ctz + (if (result i32) (local.get 0) + (then (call $dummy) (i32.const 13)) + (else (call $dummy) (i32.const -13)) + ) + ) + ) + (func (export "as-binary-operand") (param i32 i32) (result i32) + (i32.mul + (if (result i32) (local.get 0) + (then (call $dummy) (i32.const 3)) + (else (call $dummy) (i32.const -3)) + ) + (if (result i32) (local.get 1) + (then (call $dummy) (i32.const 4)) + (else (call $dummy) (i32.const -5)) + ) + ) + ) + (func (export "as-test-operand") (param i32) (result i32) + (i32.eqz + (if (result i32) (local.get 0) + (then (call $dummy) (i32.const 13)) + (else (call $dummy) (i32.const 0)) + ) + ) + ) + (func (export "as-compare-operand") (param i32 i32) (result i32) + (f32.gt + (if (result f32) (local.get 0) + (then (call $dummy) (f32.const 3)) + (else (call $dummy) (f32.const -3)) + ) + (if (result f32) (local.get 1) + (then (call $dummy) (f32.const 4)) + (else (call $dummy) (f32.const -4)) + ) + ) + ) + (func (export "as-binary-operands") (param i32) (result i32) + (i32.mul + (if (result i32 i32) (local.get 0) + (then (call $dummy) (i32.const 3) (call $dummy) (i32.const 4)) + (else (call $dummy) (i32.const 3) (call $dummy) (i32.const -4)) + ) + ) + ) + (func (export "as-compare-operands") (param i32) (result i32) + (f32.gt + (if (result f32 f32) (local.get 0) + (then (call $dummy) (f32.const 3) (call $dummy) (f32.const 3)) + (else (call $dummy) (f32.const -2) (call $dummy) (f32.const -3)) + ) + ) + ) + (func (export "as-mixed-operands") (param i32) (result i32) + (if (result i32 i32) (local.get 0) + (then (call $dummy) (i32.const 3) (call $dummy) (i32.const 4)) + (else (call $dummy) (i32.const -3) (call $dummy) (i32.const -4)) + ) + (i32.const 5) + (i32.add) + (i32.mul) + ) + + (func (export "break-bare") (result i32) + (if (i32.const 1) (then (br 0) (unreachable))) + (if (i32.const 1) (then (br 0) (unreachable)) (else (unreachable))) + (if (i32.const 0) (then (unreachable)) (else (br 0) (unreachable))) + (if (i32.const 1) (then (br_if 0 (i32.const 1)) (unreachable))) + (if (i32.const 1) (then (br_if 0 (i32.const 1)) (unreachable)) (else (unreachable))) + (if (i32.const 0) (then (unreachable)) (else (br_if 0 (i32.const 1)) (unreachable))) + (if (i32.const 1) (then (br_table 0 (i32.const 0)) (unreachable))) + (if (i32.const 1) (then (br_table 0 (i32.const 0)) (unreachable)) (else (unreachable))) + (if (i32.const 0) (then (unreachable)) (else (br_table 0 (i32.const 0)) (unreachable))) + (i32.const 19) + ) + + (func (export "break-value") (param i32) (result i32) + (if (result i32) (local.get 0) + (then (br 0 (i32.const 18)) (i32.const 19)) + (else (br 0 (i32.const 21)) (i32.const 20)) + ) + ) + (func (export "break-multi-value") (param i32) (result i32 i32 i64) + (if (result i32 i32 i64) (local.get 0) + (then + (br 0 (i32.const 18) (i32.const -18) (i64.const 18)) + (i32.const 19) (i32.const -19) (i64.const 19) + ) + (else + (br 0 (i32.const -18) (i32.const 18) (i64.const -18)) + (i32.const -19) (i32.const 19) (i64.const -19) + ) + ) + ) + + (func (export "param") (param i32) (result i32) + (i32.const 1) + (if (param i32) (result i32) (local.get 0) + (then (i32.const 2) (i32.add)) + (else (i32.const -2) (i32.add)) + ) + ) + (func (export "params") (param i32) (result i32) + (i32.const 1) + (i32.const 2) + (if (param i32 i32) (result i32) (local.get 0) + (then (i32.add)) + (else (i32.sub)) + ) + ) + (func (export "params-id") (param i32) (result i32) + (i32.const 1) + (i32.const 2) + (if (param i32 i32) (result i32 i32) (local.get 0) (then)) + (i32.add) + ) + (func (export "param-break") (param i32) (result i32) + (i32.const 1) + (if (param i32) (result i32) (local.get 0) + (then (i32.const 2) (i32.add) (br 0)) + (else (i32.const -2) (i32.add) (br 0)) + ) + ) + (func (export "params-break") (param i32) (result i32) + (i32.const 1) + (i32.const 2) + (if (param i32 i32) (result i32) (local.get 0) + (then (i32.add) (br 0)) + (else (i32.sub) (br 0)) + ) + ) + (func (export "params-id-break") (param i32) (result i32) + (i32.const 1) + (i32.const 2) + (if (param i32 i32) (result i32 i32) (local.get 0) (then (br 0))) + (i32.add) + ) + + (func (export "effects") (param i32) (result i32) + (local i32) + (if + (block (result i32) (local.set 1 (i32.const 1)) (local.get 0)) + (then + (local.set 1 (i32.mul (local.get 1) (i32.const 3))) + (local.set 1 (i32.sub (local.get 1) (i32.const 5))) + (local.set 1 (i32.mul (local.get 1) (i32.const 7))) + (br 0) + (local.set 1 (i32.mul (local.get 1) (i32.const 100))) + ) + (else + (local.set 1 (i32.mul (local.get 1) (i32.const 5))) + (local.set 1 (i32.sub (local.get 1) (i32.const 7))) + (local.set 1 (i32.mul (local.get 1) (i32.const 3))) + (br 0) + (local.set 1 (i32.mul (local.get 1) (i32.const 1000))) + ) + ) + (local.get 1) + ) + + ;; Examples + + (func $add64_u_with_carry (export "add64_u_with_carry") + (param $i i64) (param $j i64) (param $c i32) (result i64 i32) + (local $k i64) + (local.set $k + (i64.add + (i64.add (local.get $i) (local.get $j)) + (i64.extend_i32_u (local.get $c)) + ) + ) + (return (local.get $k) (i64.lt_u (local.get $k) (local.get $i))) + ) + + (func $add64_u_saturated (export "add64_u_saturated") + (param i64 i64) (result i64) + (call $add64_u_with_carry (local.get 0) (local.get 1) (i32.const 0)) + (if (param i64) (result i64) + (then (drop) (i64.const -1)) + ) + ) + + ;; Block signature syntax + + (type $block-sig-1 (func)) + (type $block-sig-2 (func (result i32))) + (type $block-sig-3 (func (param $x i32))) + (type $block-sig-4 (func (param i32 f64 i32) (result i32 f64 i32))) + + (func (export "type-use") + (if (type $block-sig-1) (i32.const 1) (then)) + (if (type $block-sig-2) (i32.const 1) + (then (i32.const 0)) (else (i32.const 2)) + ) + (if (type $block-sig-3) (i32.const 1) (then (drop)) (else (drop))) + (i32.const 0) (f64.const 0) (i32.const 0) + (if (type $block-sig-4) (i32.const 1) (then)) + (drop) (drop) (drop) + (if (type $block-sig-2) (result i32) (i32.const 1) + (then (i32.const 0)) (else (i32.const 2)) + ) + (if (type $block-sig-3) (param i32) (i32.const 1) + (then (drop)) (else (drop)) + ) + (i32.const 0) (f64.const 0) (i32.const 0) + (if (type $block-sig-4) + (param i32) (param f64 i32) (result i32 f64) (result i32) + (i32.const 1) (then) + ) + (drop) (drop) (drop) + ) +) + +(assert_return (invoke "empty" (i32.const 0))) +(assert_return (invoke "empty" (i32.const 1))) +(assert_return (invoke "empty" (i32.const 100))) +(assert_return (invoke "empty" (i32.const -2))) + +(assert_return (invoke "singular" (i32.const 0)) (i32.const 8)) +(assert_return (invoke "singular" (i32.const 1)) (i32.const 7)) +(assert_return (invoke "singular" (i32.const 10)) (i32.const 7)) +(assert_return (invoke "singular" (i32.const -10)) (i32.const 7)) + +(assert_return (invoke "multi" (i32.const 0)) (i32.const 9) (i32.const -1)) +(assert_return (invoke "multi" (i32.const 1)) (i32.const 8) (i32.const 1)) +(assert_return (invoke "multi" (i32.const 13)) (i32.const 8) (i32.const 1)) +(assert_return (invoke "multi" (i32.const -5)) (i32.const 8) (i32.const 1)) + +(assert_return (invoke "nested" (i32.const 0) (i32.const 0)) (i32.const 11)) +(assert_return (invoke "nested" (i32.const 1) (i32.const 0)) (i32.const 10)) +(assert_return (invoke "nested" (i32.const 0) (i32.const 1)) (i32.const 10)) +(assert_return (invoke "nested" (i32.const 3) (i32.const 2)) (i32.const 9)) +(assert_return (invoke "nested" (i32.const 0) (i32.const -100)) (i32.const 10)) +(assert_return (invoke "nested" (i32.const 10) (i32.const 10)) (i32.const 9)) +(assert_return (invoke "nested" (i32.const 0) (i32.const -1)) (i32.const 10)) +(assert_return (invoke "nested" (i32.const -111) (i32.const -2)) (i32.const 9)) + +(assert_return (invoke "as-select-first" (i32.const 0)) (i32.const 0)) +(assert_return (invoke "as-select-first" (i32.const 1)) (i32.const 1)) +(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 3)) +(assert_return (invoke "as-select-last" (i32.const 1)) (i32.const 2)) + +(assert_return (invoke "as-loop-first" (i32.const 0)) (i32.const 0)) +(assert_return (invoke "as-loop-first" (i32.const 1)) (i32.const 1)) +(assert_return (invoke "as-loop-mid" (i32.const 0)) (i32.const 0)) +(assert_return (invoke "as-loop-mid" (i32.const 1)) (i32.const 1)) +(assert_return (invoke "as-loop-last" (i32.const 0)) (i32.const 0)) +(assert_return (invoke "as-loop-last" (i32.const 1)) (i32.const 1)) + +(assert_return (invoke "as-if-condition" (i32.const 0)) (i32.const 3)) +(assert_return (invoke "as-if-condition" (i32.const 1)) (i32.const 2)) + +(assert_return (invoke "as-br_if-first" (i32.const 0)) (i32.const 0)) +(assert_return (invoke "as-br_if-first" (i32.const 1)) (i32.const 1)) +(assert_return (invoke "as-br_if-last" (i32.const 0)) (i32.const 3)) +(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 0)) +(assert_return (invoke "as-br_table-first" (i32.const 1)) (i32.const 1)) +(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 0)) +(assert_return (invoke "as-call_indirect-first" (i32.const 1)) (i32.const 1)) +(assert_return (invoke "as-call_indirect-mid" (i32.const 0)) (i32.const 2)) +(assert_return (invoke "as-call_indirect-mid" (i32.const 1)) (i32.const 2)) +(assert_return (invoke "as-call_indirect-last" (i32.const 0)) (i32.const 2)) +(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 1)) + +(assert_return (invoke "as-call-value" (i32.const 0)) (i32.const 0)) +(assert_return (invoke "as-call-value" (i32.const 1)) (i32.const 1)) + +(assert_return (invoke "as-return-value" (i32.const 0)) (i32.const 0)) +(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 0)) +(assert_return (invoke "as-br-value" (i32.const 1)) (i32.const 1)) + +(assert_return (invoke "as-local.set-value" (i32.const 0)) (i32.const 0)) +(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 0)) +(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 0)) +(assert_return (invoke "as-global.set-value" (i32.const 1)) (i32.const 1)) + +(assert_return (invoke "as-load-operand" (i32.const 0)) (i32.const 0)) +(assert_return (invoke "as-load-operand" (i32.const 1)) (i32.const 0)) + +(assert_return (invoke "as-unary-operand" (i32.const 0)) (i32.const 0)) +(assert_return (invoke "as-unary-operand" (i32.const 1)) (i32.const 0)) +(assert_return (invoke "as-unary-operand" (i32.const -1)) (i32.const 0)) + +(assert_return (invoke "as-binary-operand" (i32.const 0) (i32.const 0)) (i32.const 15)) +(assert_return (invoke "as-binary-operand" (i32.const 0) (i32.const 1)) (i32.const -12)) +(assert_return (invoke "as-binary-operand" (i32.const 1) (i32.const 0)) (i32.const -15)) +(assert_return (invoke "as-binary-operand" (i32.const 1) (i32.const 1)) (i32.const 12)) + +(assert_return (invoke "as-test-operand" (i32.const 0)) (i32.const 1)) +(assert_return (invoke "as-test-operand" (i32.const 1)) (i32.const 0)) + +(assert_return (invoke "as-compare-operand" (i32.const 0) (i32.const 0)) (i32.const 1)) +(assert_return (invoke "as-compare-operand" (i32.const 0) (i32.const 1)) (i32.const 0)) +(assert_return (invoke "as-compare-operand" (i32.const 1) (i32.const 0)) (i32.const 1)) +(assert_return (invoke "as-compare-operand" (i32.const 1) (i32.const 1)) (i32.const 0)) + +(assert_return (invoke "as-binary-operands" (i32.const 0)) (i32.const -12)) +(assert_return (invoke "as-binary-operands" (i32.const 1)) (i32.const 12)) + +(assert_return (invoke "as-compare-operands" (i32.const 0)) (i32.const 1)) +(assert_return (invoke "as-compare-operands" (i32.const 1)) (i32.const 0)) + +(assert_return (invoke "as-mixed-operands" (i32.const 0)) (i32.const -3)) +(assert_return (invoke "as-mixed-operands" (i32.const 1)) (i32.const 27)) + +(assert_return (invoke "break-bare") (i32.const 19)) +(assert_return (invoke "break-value" (i32.const 1)) (i32.const 18)) +(assert_return (invoke "break-value" (i32.const 0)) (i32.const 21)) +(assert_return (invoke "break-multi-value" (i32.const 0)) + (i32.const -18) (i32.const 18) (i64.const -18) +) +(assert_return (invoke "break-multi-value" (i32.const 1)) + (i32.const 18) (i32.const -18) (i64.const 18) +) + +(assert_return (invoke "param" (i32.const 0)) (i32.const -1)) +(assert_return (invoke "param" (i32.const 1)) (i32.const 3)) +(assert_return (invoke "params" (i32.const 0)) (i32.const -1)) +(assert_return (invoke "params" (i32.const 1)) (i32.const 3)) +(assert_return (invoke "params-id" (i32.const 0)) (i32.const 3)) +(assert_return (invoke "params-id" (i32.const 1)) (i32.const 3)) +(assert_return (invoke "param-break" (i32.const 0)) (i32.const -1)) +(assert_return (invoke "param-break" (i32.const 1)) (i32.const 3)) +(assert_return (invoke "params-break" (i32.const 0)) (i32.const -1)) +(assert_return (invoke "params-break" (i32.const 1)) (i32.const 3)) +(assert_return (invoke "params-id-break" (i32.const 0)) (i32.const 3)) +(assert_return (invoke "params-id-break" (i32.const 1)) (i32.const 3)) + +(assert_return (invoke "effects" (i32.const 1)) (i32.const -14)) +(assert_return (invoke "effects" (i32.const 0)) (i32.const -6)) + +(assert_return + (invoke "add64_u_with_carry" (i64.const 0) (i64.const 0) (i32.const 0)) + (i64.const 0) (i32.const 0) +) +(assert_return + (invoke "add64_u_with_carry" (i64.const 100) (i64.const 124) (i32.const 0)) + (i64.const 224) (i32.const 0) +) +(assert_return + (invoke "add64_u_with_carry" (i64.const -1) (i64.const 0) (i32.const 0)) + (i64.const -1) (i32.const 0) +) +(assert_return + (invoke "add64_u_with_carry" (i64.const -1) (i64.const 1) (i32.const 0)) + (i64.const 0) (i32.const 1) +) +(assert_return + (invoke "add64_u_with_carry" (i64.const -1) (i64.const -1) (i32.const 0)) + (i64.const -2) (i32.const 1) +) +(assert_return + (invoke "add64_u_with_carry" (i64.const -1) (i64.const 0) (i32.const 1)) + (i64.const 0) (i32.const 1) +) +(assert_return + (invoke "add64_u_with_carry" (i64.const -1) (i64.const 1) (i32.const 1)) + (i64.const 1) (i32.const 1) +) +(assert_return + (invoke "add64_u_with_carry" (i64.const 0x8000000000000000) (i64.const 0x8000000000000000) (i32.const 0)) + (i64.const 0) (i32.const 1) +) + +(assert_return + (invoke "add64_u_saturated" (i64.const 0) (i64.const 0)) (i64.const 0) +) +(assert_return + (invoke "add64_u_saturated" (i64.const 1230) (i64.const 23)) (i64.const 1253) +) +(assert_return + (invoke "add64_u_saturated" (i64.const -1) (i64.const 0)) (i64.const -1) +) +(assert_return + (invoke "add64_u_saturated" (i64.const -1) (i64.const 1)) (i64.const -1) +) +(assert_return + (invoke "add64_u_saturated" (i64.const -1) (i64.const -1)) (i64.const -1) +) +(assert_return + (invoke "add64_u_saturated" (i64.const 0x8000000000000000) (i64.const 0x8000000000000000)) (i64.const -1) +) + +(assert_return (invoke "type-use")) + +(assert_malformed + (module quote + "(type $sig (func (param i32) (result i32)))" + "(func (i32.const 0)" + " (if (type $sig) (result i32) (param i32) (i32.const 1) (then))" + ")" + ) + "unexpected token" +) +(assert_malformed + (module quote + "(type $sig (func (param i32) (result i32)))" + "(func (i32.const 0)" + " (if (param i32) (type $sig) (result i32) (i32.const 1) (then))" + ")" + ) + "unexpected token" +) +(assert_malformed + (module quote + "(type $sig (func (param i32) (result i32)))" + "(func (i32.const 0)" + " (if (param i32) (result i32) (type $sig) (i32.const 1) (then))" + ")" + ) + "unexpected token" +) +(assert_malformed + (module quote + "(type $sig (func (param i32) (result i32)))" + "(func (i32.const 0)" + " (if (result i32) (type $sig) (param i32) (i32.const 1) (then))" + ")" + ) + "unexpected token" +) +(assert_malformed + (module quote + "(type $sig (func (param i32) (result i32)))" + "(func (i32.const 0)" + " (if (result i32) (param i32) (type $sig) (i32.const 1) (then))" + ")" + ) + "unexpected token" +) +(assert_malformed + (module quote + "(func (i32.const 0) (if (result i32) (param i32) (i32.const 1) (then)))" + ) + "unexpected token" +) + +(assert_malformed + (module quote + "(func (i32.const 0) (i32.const 1)" + " (if (param $x i32) (then (drop)) (else (drop)))" + ")" + ) + "unexpected token" +) +(assert_malformed + (module quote + "(type $sig (func))" + "(func (i32.const 1)" + " (if (type $sig) (result i32) (then (i32.const 0)) (else (i32.const 2)))" + " (unreachable)" + ")" + ) + "inline function type" +) +(assert_malformed + (module quote + "(type $sig (func (param i32) (result i32)))" + "(func (i32.const 1)" + " (if (type $sig) (result i32) (then (i32.const 0)) (else (i32.const 2)))" + " (unreachable)" + ")" + ) + "inline function type" +) +(assert_malformed + (module quote + "(type $sig (func (param i32) (result i32)))" + "(func (i32.const 0) (i32.const 1)" + " (if (type $sig) (param i32) (then (drop)) (else (drop)))" + " (unreachable)" + ")" + ) + "inline function type" +) +(assert_malformed + (module quote + "(type $sig (func (param i32 i32) (result i32)))" + "(func (i32.const 0) (i32.const 1)" + " (if (type $sig) (param i32) (result i32) (then)) (unreachable)" + ")" + ) + "inline function type" +) + +(assert_invalid + (module + (type $sig (func)) + (func (i32.const 1) (if (type $sig) (i32.const 0) (then))) + ) + "type mismatch" +) + +(assert_invalid + (module (func $type-empty-i32 (result i32) (if (i32.const 0) (then)))) + "type mismatch" +) +(assert_invalid + (module (func $type-empty-i64 (result i64) (if (i32.const 0) (then)))) + "type mismatch" +) +(assert_invalid + (module (func $type-empty-f32 (result f32) (if (i32.const 0) (then)))) + "type mismatch" +) +(assert_invalid + (module (func $type-empty-f64 (result f64) (if (i32.const 0) (then)))) + "type mismatch" +) + +(assert_invalid + (module (func $type-empty-i32 (result i32) (if (i32.const 0) (then) (else)))) + "type mismatch" +) +(assert_invalid + (module (func $type-empty-i64 (result i64) (if (i32.const 0) (then) (else)))) + "type mismatch" +) +(assert_invalid + (module (func $type-empty-f32 (result f32) (if (i32.const 0) (then) (else)))) + "type mismatch" +) +(assert_invalid + (module (func $type-empty-f64 (result f64) (if (i32.const 0) (then) (else)))) + "type mismatch" +) + +(assert_invalid + (module (func $type-then-value-num-vs-void + (if (i32.const 1) (then (i32.const 1))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-then-value-num-vs-void-else + (if (i32.const 1) (then (i32.const 1)) (else)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-else-value-num-vs-void + (if (i32.const 1) (then) (else (i32.const 1))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-both-value-num-vs-void + (if (i32.const 1) (then (i32.const 1)) (else (i32.const 1))) + )) + "type mismatch" +) + +(assert_invalid + (module (func $type-then-value-nums-vs-void + (if (i32.const 1) (then (i32.const 1) (i32.const 2))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-then-value-nums-vs-void-else + (if (i32.const 1) (then (i32.const 1) (i32.const 2)) (else)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-else-value-nums-vs-void + (if (i32.const 1) (then) (else (i32.const 1) (i32.const 2))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-both-value-nums-vs-void + (if (i32.const 1) (then (i32.const 1) (i32.const 2)) (else (i32.const 2) (i32.const 1))) + )) + "type mismatch" +) + +(assert_invalid + (module (func $type-then-value-empty-vs-num (result i32) + (if (result i32) (i32.const 1) (then) (else (i32.const 0))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-else-value-empty-vs-num (result i32) + (if (result i32) (i32.const 1) (then (i32.const 0)) (else)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-both-value-empty-vs-num (result i32) + (if (result i32) (i32.const 1) (then) (else)) + )) + "type mismatch" +) + +(assert_invalid + (module (func $type-then-value-empty-vs-nums (result i32 i32) + (if (result i32 i32) (i32.const 1) (then) (else (i32.const 0) (i32.const 2))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-else-value-empty-vs-nums (result i32 i32) + (if (result i32 i32) (i32.const 1) (then (i32.const 0) (i32.const 1)) (else)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-both-value-empty-vs-nums (result i32 i32) + (if (result i32 i32) (i32.const 1) (then) (else)) + )) + "type mismatch" +) + +(assert_invalid + (module (func $type-no-else-vs-num (result i32) + (if (result i32) (i32.const 1) (then (i32.const 1))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-no-else-vs-nums (result i32 i32) + (if (result i32 i32) (i32.const 1) (then (i32.const 1) (i32.const 1))) + )) + "type mismatch" +) + +(assert_invalid + (module (func $type-then-value-void-vs-num (result i32) + (if (result i32) (i32.const 1) (then (nop)) (else (i32.const 0))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-else-value-void-vs-num (result i32) + (if (result i32) (i32.const 1) (then (i32.const 0)) (else (nop))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-both-value-void-vs-num (result i32) + (if (result i32) (i32.const 1) (then (nop)) (else (nop))) + )) + "type mismatch" +) + +(assert_invalid + (module (func $type-then-value-void-vs-nums (result i32 i32) + (if (result i32 i32) (i32.const 1) (then (nop)) (else (i32.const 0) (i32.const 0))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-else-value-void-vs-nums (result i32 i32) + (if (result i32 i32) (i32.const 1) (then (i32.const 0) (i32.const 0)) (else (nop))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-both-value-void-vs-nums (result i32 i32) + (if (result i32 i32) (i32.const 1) (then (nop)) (else (nop))) + )) + "type mismatch" +) + +(assert_invalid + (module (func $type-then-value-num-vs-num (result i32) + (if (result i32) (i32.const 1) (then (i64.const 1)) (else (i32.const 1))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-else-value-num-vs-num (result i32) + (if (result i32) (i32.const 1) (then (i32.const 1)) (else (i64.const 1))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-both-value-num-vs-num (result i32) + (if (result i32) (i32.const 1) (then (i64.const 1)) (else (i64.const 1))) + )) + "type mismatch" +) + +(assert_invalid + (module (func $type-then-value-num-vs-nums (result i32 i32) + (if (result i32 i32) (i32.const 1) (then (i32.const 1)) (else (i32.const 1) (i32.const 1))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-else-value-num-vs-nums (result i32 i32) + (if (result i32 i32) (i32.const 1) (then (i32.const 1) (i32.const 1)) (else (i32.const 1))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-both-value-num-vs-nums (result i32 i32) + (if (result i32 i32) (i32.const 1) (then (i32.const 1)) (else (i32.const 1))) + )) + "type mismatch" +) + +(assert_invalid + (module (func $type-then-value-partial-vs-nums (result i32 i32) + (i32.const 0) + (if (result i32 i32) (i32.const 1) (then (i32.const 1)) (else (i32.const 1) (i32.const 1))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-else-value-partial-vs-nums (result i32 i32) + (i32.const 0) + (if (result i32 i32) (i32.const 1) (then (i32.const 1) (i32.const 1)) (else (i32.const 1))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-both-value-partial-vs-nums (result i32 i32) + (i32.const 0) + (if (result i32 i32) (i32.const 1) (then (i32.const 1)) (else (i32.const 1))) + )) + "type mismatch" +) + +(assert_invalid + (module (func $type-then-value-nums-vs-num (result i32) + (if (result i32) (i32.const 1) (then (i32.const 1) (i32.const 1)) (else (i32.const 1))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-else-value-nums-vs-num (result i32) + (if (result i32) (i32.const 1) (then (i32.const 1)) (else (i32.const 1) (i32.const 1))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-both-value-nums-vs-num (result i32) + (if (result i32) (i32.const 1) (then (i32.const 1) (i32.const 1)) (else (i32.const 1) (i32.const 1))) + )) + "type mismatch" +) + +(assert_invalid + (module (func $type-both-different-value-num-vs-num (result i32) + (if (result i32) (i32.const 1) (then (i64.const 1)) (else (f64.const 1))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-both-different-value-nums-vs-nums (result i32 i32) + (if (result i32 i32) (i32.const 1) (then (i32.const 1) (i32.const 1) (i32.const 1)) (else (i32.const 1))) + )) + "type mismatch" +) + +(assert_invalid + (module (func $type-then-value-unreached-select (result i32) + (if (result i64) + (i32.const 0) + (then (select (unreachable) (unreachable) (unreachable))) + (else (i64.const 0)) + ) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-else-value-unreached-select (result i32) + (if (result i64) + (i32.const 1) + (then (i64.const 0)) + (else (select (unreachable) (unreachable) (unreachable))) + ) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-else-value-unreached-select (result i32) + (if (result i64) + (i32.const 1) + (then (select (unreachable) (unreachable) (unreachable))) + (else (select (unreachable) (unreachable) (unreachable))) + ) + )) + "type mismatch" +) + +(assert_invalid + (module (func $type-then-break-last-void-vs-num (result i32) + (if (result i32) (i32.const 1) (then (br 0)) (else (i32.const 1))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-else-break-last-void-vs-num (result i32) + (if (result i32) (i32.const 1) (then (i32.const 1)) (else (br 0))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-then-break-last-void-vs-nums (result i32 i32) + (if (result i32 i32) (i32.const 1) (then (br 0)) (else (i32.const 1) (i32.const 1))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-else-break-last-void-vs-nums (result i32 i32) + (if (result i32 i32) (i32.const 1) (then (i32.const 1) (i32.const 1)) (else (br 0))) + )) + "type mismatch" +) + +(assert_invalid + (module (func $type-then-break-empty-vs-num (result i32) + (if (result i32) (i32.const 1) + (then (br 0) (i32.const 1)) + (else (i32.const 1)) + ) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-else-break-empty-vs-num (result i32) + (if (result i32) (i32.const 1) + (then (i32.const 1)) + (else (br 0) (i32.const 1)) + ) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-then-break-empty-vs-nums (result i32 i32) + (if (result i32 i32) (i32.const 1) + (then (br 0) (i32.const 1) (i32.const 1)) + (else (i32.const 1) (i32.const 1)) + ) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-else-break-empty-vs-nums (result i32 i32) + (if (result i32 i32) (i32.const 1) + (then (i32.const 1) (i32.const 1)) + (else (br 0) (i32.const 1) (i32.const 1)) + ) + )) + "type mismatch" +) + +(assert_invalid + (module (func $type-then-break-void-vs-num (result i32) + (if (result i32) (i32.const 1) + (then (br 0 (nop)) (i32.const 1)) + (else (i32.const 1)) + ) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-else-break-void-vs-num (result i32) + (if (result i32) (i32.const 1) + (then (i32.const 1)) + (else (br 0 (nop)) (i32.const 1)) + ) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-then-break-void-vs-nums (result i32 i32) + (if (result i32 i32) (i32.const 1) + (then (br 0 (nop)) (i32.const 1) (i32.const 1)) + (else (i32.const 1) (i32.const 1)) + ) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-else-break-void-vs-nums (result i32 i32) + (if (result i32 i32) (i32.const 1) + (then (i32.const 1) (i32.const 1)) + (else (br 0 (nop)) (i32.const 1) (i32.const 1)) + ) + )) + "type mismatch" +) + +(assert_invalid + (module (func $type-then-break-num-vs-num (result i32) + (if (result i32) (i32.const 1) + (then (br 0 (i64.const 1)) (i32.const 1)) + (else (i32.const 1)) + ) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-else-break-num-vs-num (result i32) + (if (result i32) (i32.const 1) + (then (i32.const 1)) + (else (br 0 (i64.const 1)) (i32.const 1)) + ) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-then-break-num-vs-nums (result i32 i32) + (if (result i32 i32) (i32.const 1) + (then (br 0 (i64.const 1)) (i32.const 1) (i32.const 1)) + (else (i32.const 1) (i32.const 1)) + ) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-else-break-num-vs-nums (result i32 i32) + (if (result i32 i32) (i32.const 1) + (then (i32.const 1) (i32.const 1)) + (else (br 0 (i64.const 1)) (i32.const 1) (i32.const 1)) + ) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-then-break-partial-vs-nums (result i32 i32) + (i32.const 1) + (if (result i32 i32) (i32.const 1) + (then (br 0 (i64.const 1)) (i32.const 1)) + (else (i32.const 1)) + ) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-else-break-partial-vs-nums (result i32 i32) + (i32.const 1) + (if (result i32 i32) (i32.const 1) + (then (i32.const 1)) + (else (br 0 (i64.const 1)) (i32.const 1)) + ) + )) + "type mismatch" +) + +(assert_invalid + (module + (func $type-condition-empty + (if (then)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-condition-empty-in-block + (i32.const 0) + (block (if (then))) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-condition-empty-in-loop + (i32.const 0) + (loop (if (then))) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-condition-empty-in-then + (i32.const 0) (i32.const 0) + (if (then (if (then)))) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-condition-empty-in-else + (i32.const 0) (i32.const 0) + (if (result i32) (then (i32.const 0)) (else (if (then)) (i32.const 0))) + (drop) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-condition-empty-in-br + (i32.const 0) + (block (br 0 (if(then))) (drop)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-condition-empty-in-br_if + (i32.const 0) + (block (br_if 0 (if(then)) (i32.const 1)) (drop)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-condition-empty-in-br_table + (i32.const 0) + (block (br_table 0 (if(then))) (drop)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-condition-empty-in-return + (return (if(then))) (drop) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-condition-empty-in-select + (select (if(then)) (i32.const 1) (i32.const 2)) (drop) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-condition-empty-in-call + (call 1 (if(then))) (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-condition-empty-in-call_indirect + (block (result i32) + (call_indirect (type $sig) + (if(then)) (i32.const 0) + ) + (drop) + ) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-condition-empty-in-local.set + (local i32) + (local.set 0 (if(then))) (local.get 0) (drop) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-condition-empty-in-local.tee + (local i32) + (local.tee 0 (if(then))) (drop) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (global $x (mut i32) (i32.const 0)) + (func $type-condition-empty-in-global.set + (global.set $x (if(then))) (global.get $x) (drop) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (memory 0) + (func $type-condition-empty-in-memory.grow + (memory.grow (if(then))) (drop) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (memory 0) + (func $type-condition-empty-in-load + (i32.load (if(then))) (drop) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (memory 1) + (func $type-condition-empty-in-store + (i32.store (if(then)) (i32.const 1)) + ) + ) + "type mismatch" +) + +(assert_invalid + (module (func $type-param-void-vs-num + (if (param i32) (i32.const 1) (then (drop))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-param-void-vs-nums + (if (param i32 f64) (i32.const 1) (then (drop) (drop))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-param-num-vs-num + (f32.const 0) (if (param i32) (i32.const 1) (then (drop))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-param-num-vs-nums + (f32.const 0) (if (param f32 i32) (i32.const 1) (then (drop) (drop))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-param-nested-void-vs-num + (block (if (param i32) (i32.const 1) (then (drop)))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-param-void-vs-nums + (block (if (param i32 f64) (i32.const 1) (then (drop) (drop)))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-param-num-vs-num + (block (f32.const 0) (if (param i32) (i32.const 1) (then (drop)))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-param-num-vs-nums + (block (f32.const 0) (if (param f32 i32) (i32.const 1) (then (drop) (drop)))) + )) + "type mismatch" +) + +(assert_malformed + (module quote "(func (param i32) (result i32) if (param $x i32) end)") + "unexpected token" +) +(assert_malformed + (module quote "(func (param i32) (result i32) (if (param $x i32) (then)))") + "unexpected token" +) + +(assert_malformed + (module quote "(func i32.const 0 if end $l)") + "mismatching label" +) +(assert_malformed + (module quote "(func i32.const 0 if $a end $l)") + "mismatching label" +) +(assert_malformed + (module quote "(func i32.const 0 if else $l end)") + "mismatching label" +) +(assert_malformed + (module quote "(func i32.const 0 if $a else $l end)") + "mismatching label" +) +(assert_malformed + (module quote "(func i32.const 0 if else end $l)") + "mismatching label" +) +(assert_malformed + (module quote "(func i32.const 0 if else $l end $l)") + "mismatching label" +) +(assert_malformed + (module quote "(func i32.const 0 if else $l1 end $l2)") + "mismatching label" +) +(assert_malformed + (module quote "(func i32.const 0 if $a else end $l)") + "mismatching label" +) +(assert_malformed + (module quote "(func i32.const 0 if $a else $a end $l)") + "mismatching label" +) +(assert_malformed + (module quote "(func i32.const 0 if $a else $l end $l)") + "mismatching label" +) \ No newline at end of file diff --git a/runtime/near-vm/tests/wast/spec/proposals/multi-value/loop.wast b/runtime/near-vm/tests/wast/spec/proposals/multi-value/loop.wast new file mode 100644 index 00000000000..4557869b39c --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/proposals/multi-value/loop.wast @@ -0,0 +1,785 @@ +;; Test `loop` opcode + +(module + (memory 1) + + (func $dummy) + + (func (export "empty") + (loop) + (loop $l) + ) + + (func (export "singular") (result i32) + (loop (nop)) + (loop (result i32) (i32.const 7)) + ) + + (func (export "multi") (result i32) + (loop (call $dummy) (call $dummy) (call $dummy) (call $dummy)) + (loop (result i32) (call $dummy) (call $dummy) (i32.const 8) (call $dummy)) + (drop) + (loop (result i32 i64 i32) + (call $dummy) (call $dummy) (call $dummy) (i32.const 8) (call $dummy) + (call $dummy) (call $dummy) (call $dummy) (i64.const 7) (call $dummy) + (call $dummy) (call $dummy) (call $dummy) (i32.const 9) (call $dummy) + ) + (drop) (drop) + ) + + (func (export "nested") (result i32) + (loop (result i32) + (loop (call $dummy) (block) (nop)) + (loop (result i32) (call $dummy) (i32.const 9)) + ) + ) + + (func (export "deep") (result i32) + (loop (result i32) (block (result i32) + (loop (result i32) (block (result i32) + (loop (result i32) (block (result i32) + (loop (result i32) (block (result i32) + (loop (result i32) (block (result i32) + (loop (result i32) (block (result i32) + (loop (result i32) (block (result i32) + (loop (result i32) (block (result i32) + (loop (result i32) (block (result i32) + (loop (result i32) (block (result i32) + (loop (result i32) (block (result i32) + (loop (result i32) (block (result i32) + (loop (result i32) (block (result i32) + (loop (result i32) (block (result i32) + (loop (result i32) (block (result i32) + (loop (result i32) (block (result i32) + (loop (result i32) (block (result i32) + (loop (result i32) (block (result i32) + (loop (result i32) (block (result i32) + (loop (result i32) (block (result i32) + (call $dummy) (i32.const 150) + )) + )) + )) + )) + )) + )) + )) + )) + )) + )) + )) + )) + )) + )) + )) + )) + )) + )) + )) + )) + ) + + (func (export "as-select-first") (result i32) + (select (loop (result i32) (i32.const 1)) (i32.const 2) (i32.const 3)) + ) + (func (export "as-select-mid") (result i32) + (select (i32.const 2) (loop (result i32) (i32.const 1)) (i32.const 3)) + ) + (func (export "as-select-last") (result i32) + (select (i32.const 2) (i32.const 3) (loop (result i32) (i32.const 1))) + ) + + (func (export "as-if-condition") + (loop (result i32) (i32.const 1)) (if (then (call $dummy))) + ) + (func (export "as-if-then") (result i32) + (if (result i32) (i32.const 1) (then (loop (result i32) (i32.const 1))) (else (i32.const 2))) + ) + (func (export "as-if-else") (result i32) + (if (result i32) (i32.const 1) (then (i32.const 2)) (else (loop (result i32) (i32.const 1)))) + ) + + (func (export "as-br_if-first") (result i32) + (block (result i32) (br_if 0 (loop (result i32) (i32.const 1)) (i32.const 2))) + ) + (func (export "as-br_if-last") (result i32) + (block (result i32) (br_if 0 (i32.const 2) (loop (result i32) (i32.const 1)))) + ) + + (func (export "as-br_table-first") (result i32) + (block (result i32) (loop (result i32) (i32.const 1)) (i32.const 2) (br_table 0 0)) + ) + (func (export "as-br_table-last") (result i32) + (block (result i32) (i32.const 2) (loop (result i32) (i32.const 1)) (br_table 0 0)) + ) + + (func $func (param i32 i32) (result i32) (local.get 0)) + (type $check (func (param i32 i32) (result i32))) + (table funcref (elem $func)) + (func (export "as-call_indirect-first") (result i32) + (block (result i32) + (call_indirect (type $check) + (loop (result i32) (i32.const 1)) (i32.const 2) (i32.const 0) + ) + ) + ) + (func (export "as-call_indirect-mid") (result i32) + (block (result i32) + (call_indirect (type $check) + (i32.const 2) (loop (result i32) (i32.const 1)) (i32.const 0) + ) + ) + ) + (func (export "as-call_indirect-last") (result i32) + (block (result i32) + (call_indirect (type $check) + (i32.const 1) (i32.const 2) (loop (result i32) (i32.const 0)) + ) + ) + ) + + (func (export "as-store-first") + (loop (result i32) (i32.const 1)) (i32.const 1) (i32.store) + ) + (func (export "as-store-last") + (i32.const 10) (loop (result i32) (i32.const 1)) (i32.store) + ) + + (func (export "as-memory.grow-value") (result i32) + (memory.grow (loop (result i32) (i32.const 1))) + ) + + (func $f (param i32) (result i32) (local.get 0)) + + (func (export "as-call-value") (result i32) + (call $f (loop (result i32) (i32.const 1))) + ) + (func (export "as-return-value") (result i32) + (loop (result i32) (i32.const 1)) (return) + ) + (func (export "as-drop-operand") + (drop (loop (result i32) (i32.const 1))) + ) + (func (export "as-br-value") (result i32) + (block (result i32) (br 0 (loop (result i32) (i32.const 1)))) + ) + (func (export "as-local.set-value") (result i32) + (local i32) (local.set 0 (loop (result i32) (i32.const 1))) (local.get 0) + ) + (func (export "as-local.tee-value") (result i32) + (local i32) (local.tee 0 (loop (result i32) (i32.const 1))) + ) + (global $a (mut i32) (i32.const 0)) + (func (export "as-global.set-value") (result i32) + (global.set $a (loop (result i32) (i32.const 1))) + (global.get $a) + ) + (func (export "as-load-operand") (result i32) + (i32.load (loop (result i32) (i32.const 1))) + ) + + (func (export "as-unary-operand") (result i32) + (i32.ctz (loop (result i32) (call $dummy) (i32.const 13))) + ) + (func (export "as-binary-operand") (result i32) + (i32.mul + (loop (result i32) (call $dummy) (i32.const 3)) + (loop (result i32) (call $dummy) (i32.const 4)) + ) + ) + (func (export "as-test-operand") (result i32) + (i32.eqz (loop (result i32) (call $dummy) (i32.const 13))) + ) + (func (export "as-compare-operand") (result i32) + (f32.gt + (loop (result f32) (call $dummy) (f32.const 3)) + (loop (result f32) (call $dummy) (f32.const 3)) + ) + ) + (func (export "as-binary-operands") (result i32) + (i32.mul + (loop (result i32 i32) + (call $dummy) (i32.const 3) (call $dummy) (i32.const 4) + ) + ) + ) + (func (export "as-compare-operands") (result i32) + (f32.gt + (loop (result f32 f32) + (call $dummy) (f32.const 3) (call $dummy) (f32.const 3) + ) + ) + ) + (func (export "as-mixed-operands") (result i32) + (loop (result i32 i32) + (call $dummy) (i32.const 3) (call $dummy) (i32.const 4) + ) + (i32.const 5) + (i32.add) + (i32.mul) + ) + + (func (export "break-bare") (result i32) + (block (loop (br 1) (br 0) (unreachable))) + (block (loop (br_if 1 (i32.const 1)) (unreachable))) + (block (loop (br_table 1 (i32.const 0)) (unreachable))) + (block (loop (br_table 1 1 1 (i32.const 1)) (unreachable))) + (i32.const 19) + ) + (func (export "break-value") (result i32) + (block (result i32) + (i32.const 0) + (loop (param i32) + (block (br 2 (i32.const 18))) + (br 0 (i32.const 20)) + ) + (i32.const 19) + ) + ) + (func (export "break-multi-value") (result i32 i32 i64) + (block (result i32 i32 i64) + (i32.const 0) (i32.const 0) (i64.const 0) + (loop (param i32 i32 i64) + (block (br 2 (i32.const 18) (i32.const -18) (i64.const 18))) + (br 0 (i32.const 20) (i32.const -20) (i64.const 20)) + ) + (i32.const 19) (i32.const -19) (i64.const 19) + ) + ) + (func (export "break-repeated") (result i32) + (block (result i32) + (loop (result i32) + (br 1 (i32.const 18)) + (br 1 (i32.const 19)) + (drop (br_if 1 (i32.const 20) (i32.const 0))) + (drop (br_if 1 (i32.const 20) (i32.const 1))) + (br 1 (i32.const 21)) + (br_table 1 (i32.const 22) (i32.const 0)) + (br_table 1 1 1 (i32.const 23) (i32.const 1)) + (i32.const 21) + ) + ) + ) + (func (export "break-inner") (result i32) + (local i32) + (local.set 0 (i32.const 0)) + (local.set 0 (i32.add (local.get 0) (block (result i32) (loop (result i32) (block (result i32) (br 2 (i32.const 0x1))))))) + (local.set 0 (i32.add (local.get 0) (block (result i32) (loop (result i32) (loop (result i32) (br 2 (i32.const 0x2))))))) + (local.set 0 (i32.add (local.get 0) (block (result i32) (loop (result i32) (block (result i32) (loop (result i32) (br 1 (i32.const 0x4)))))))) + (local.set 0 (i32.add (local.get 0) (block (result i32) (loop (result i32) (i32.ctz (br 1 (i32.const 0x8))))))) + (local.set 0 (i32.add (local.get 0) (block (result i32) (loop (result i32) (i32.ctz (loop (result i32) (br 2 (i32.const 0x10)))))))) + (local.get 0) + ) + (func (export "cont-inner") (result i32) + (local i32) + (local.set 0 (i32.const 0)) + (local.set 0 (i32.add (local.get 0) (loop (result i32) (loop (result i32) (br 1))))) + (local.set 0 (i32.add (local.get 0) (loop (result i32) (i32.ctz (br 0))))) + (local.set 0 (i32.add (local.get 0) (loop (result i32) (i32.ctz (loop (result i32) (br 1)))))) + (local.get 0) + ) + + (func (export "param") (result i32) + (i32.const 1) + (loop (param i32) (result i32) + (i32.const 2) + (i32.add) + ) + ) + (func (export "params") (result i32) + (i32.const 1) + (i32.const 2) + (loop (param i32 i32) (result i32) + (i32.add) + ) + ) + (func (export "params-id") (result i32) + (i32.const 1) + (i32.const 2) + (loop (param i32 i32) (result i32 i32)) + (i32.add) + ) + (func (export "param-break") (result i32) + (local $x i32) + (i32.const 1) + (loop (param i32) (result i32) + (i32.const 4) + (i32.add) + (local.tee $x) + (local.get $x) + (i32.const 10) + (i32.lt_u) + (br_if 0) + ) + ) + (func (export "params-break") (result i32) + (local $x i32) + (i32.const 1) + (i32.const 2) + (loop (param i32 i32) (result i32) + (i32.add) + (local.tee $x) + (i32.const 3) + (local.get $x) + (i32.const 10) + (i32.lt_u) + (br_if 0) + (drop) + ) + ) + (func (export "params-id-break") (result i32) + (local $x i32) + (local.set $x (i32.const 0)) + (i32.const 1) + (i32.const 2) + (loop (param i32 i32) (result i32 i32) + (local.set $x (i32.add (local.get $x) (i32.const 1))) + (br_if 0 (i32.lt_u (local.get $x) (i32.const 10))) + ) + (i32.add) + ) + + (func $fx (export "effects") (result i32) + (local i32) + (block + (loop + (local.set 0 (i32.const 1)) + (local.set 0 (i32.mul (local.get 0) (i32.const 3))) + (local.set 0 (i32.sub (local.get 0) (i32.const 5))) + (local.set 0 (i32.mul (local.get 0) (i32.const 7))) + (br 1) + (local.set 0 (i32.mul (local.get 0) (i32.const 100))) + ) + ) + (i32.eq (local.get 0) (i32.const -14)) + ) + + (func (export "while") (param i64) (result i64) + (local i64) + (local.set 1 (i64.const 1)) + (block + (loop + (br_if 1 (i64.eqz (local.get 0))) + (local.set 1 (i64.mul (local.get 0) (local.get 1))) + (local.set 0 (i64.sub (local.get 0) (i64.const 1))) + (br 0) + ) + ) + (local.get 1) + ) + + (func (export "for") (param i64) (result i64) + (local i64 i64) + (local.set 1 (i64.const 1)) + (local.set 2 (i64.const 2)) + (block + (loop + (br_if 1 (i64.gt_u (local.get 2) (local.get 0))) + (local.set 1 (i64.mul (local.get 1) (local.get 2))) + (local.set 2 (i64.add (local.get 2) (i64.const 1))) + (br 0) + ) + ) + (local.get 1) + ) + + (func (export "nesting") (param f32 f32) (result f32) + (local f32 f32) + (block + (loop + (br_if 1 (f32.eq (local.get 0) (f32.const 0))) + (local.set 2 (local.get 1)) + (block + (loop + (br_if 1 (f32.eq (local.get 2) (f32.const 0))) + (br_if 3 (f32.lt (local.get 2) (f32.const 0))) + (local.set 3 (f32.add (local.get 3) (local.get 2))) + (local.set 2 (f32.sub (local.get 2) (f32.const 2))) + (br 0) + ) + ) + (local.set 3 (f32.div (local.get 3) (local.get 0))) + (local.set 0 (f32.sub (local.get 0) (f32.const 1))) + (br 0) + ) + ) + (local.get 3) + ) + + (type $block-sig-1 (func)) + (type $block-sig-2 (func (result i32))) + (type $block-sig-3 (func (param $x i32))) + (type $block-sig-4 (func (param i32 f64 i32) (result i32 f64 i32))) + + (func (export "type-use") + (loop (type $block-sig-1)) + (loop (type $block-sig-2) (i32.const 0)) + (loop (type $block-sig-3) (drop)) + (i32.const 0) (f64.const 0) (i32.const 0) + (loop (type $block-sig-4)) + (drop) (drop) (drop) + (loop (type $block-sig-2) (result i32) (i32.const 0)) + (loop (type $block-sig-3) (param i32) (drop)) + (i32.const 0) (f64.const 0) (i32.const 0) + (loop (type $block-sig-4) + (param i32) (param f64 i32) (result i32 f64) (result i32) + ) + (drop) (drop) (drop) + ) +) + +(assert_return (invoke "empty")) +(assert_return (invoke "singular") (i32.const 7)) +(assert_return (invoke "multi") (i32.const 8)) +(assert_return (invoke "nested") (i32.const 9)) +(assert_return (invoke "deep") (i32.const 150)) + +(assert_return (invoke "as-select-first") (i32.const 1)) +(assert_return (invoke "as-select-mid") (i32.const 2)) +(assert_return (invoke "as-select-last") (i32.const 2)) + +(assert_return (invoke "as-if-condition")) +(assert_return (invoke "as-if-then") (i32.const 1)) +(assert_return (invoke "as-if-else") (i32.const 2)) + +(assert_return (invoke "as-br_if-first") (i32.const 1)) +(assert_return (invoke "as-br_if-last") (i32.const 2)) + +(assert_return (invoke "as-br_table-first") (i32.const 1)) +(assert_return (invoke "as-br_table-last") (i32.const 2)) + +(assert_return (invoke "as-call_indirect-first") (i32.const 1)) +(assert_return (invoke "as-call_indirect-mid") (i32.const 2)) +(assert_return (invoke "as-call_indirect-last") (i32.const 1)) + +(assert_return (invoke "as-store-first")) +(assert_return (invoke "as-store-last")) + +(assert_return (invoke "as-memory.grow-value") (i32.const 1)) +(assert_return (invoke "as-call-value") (i32.const 1)) +(assert_return (invoke "as-return-value") (i32.const 1)) +(assert_return (invoke "as-drop-operand")) +(assert_return (invoke "as-br-value") (i32.const 1)) +(assert_return (invoke "as-local.set-value") (i32.const 1)) +(assert_return (invoke "as-local.tee-value") (i32.const 1)) +(assert_return (invoke "as-global.set-value") (i32.const 1)) +(assert_return (invoke "as-load-operand") (i32.const 1)) + +(assert_return (invoke "as-unary-operand") (i32.const 0)) +(assert_return (invoke "as-binary-operand") (i32.const 12)) +(assert_return (invoke "as-test-operand") (i32.const 0)) +(assert_return (invoke "as-compare-operand") (i32.const 0)) +(assert_return (invoke "as-binary-operands") (i32.const 12)) +(assert_return (invoke "as-compare-operands") (i32.const 0)) +(assert_return (invoke "as-mixed-operands") (i32.const 27)) + +(assert_return (invoke "break-bare") (i32.const 19)) +(assert_return (invoke "break-value") (i32.const 18)) +(assert_return (invoke "break-multi-value") + (i32.const 18) (i32.const -18) (i64.const 18) +) +(assert_return (invoke "break-repeated") (i32.const 18)) +(assert_return (invoke "break-inner") (i32.const 0x1f)) + +(assert_return (invoke "param") (i32.const 3)) +(assert_return (invoke "params") (i32.const 3)) +(assert_return (invoke "params-id") (i32.const 3)) +(assert_return (invoke "param-break") (i32.const 13)) +(assert_return (invoke "params-break") (i32.const 12)) +(assert_return (invoke "params-id-break") (i32.const 3)) + +(assert_return (invoke "effects") (i32.const 1)) + +(assert_return (invoke "while" (i64.const 0)) (i64.const 1)) +(assert_return (invoke "while" (i64.const 1)) (i64.const 1)) +(assert_return (invoke "while" (i64.const 2)) (i64.const 2)) +(assert_return (invoke "while" (i64.const 3)) (i64.const 6)) +(assert_return (invoke "while" (i64.const 5)) (i64.const 120)) +(assert_return (invoke "while" (i64.const 20)) (i64.const 2432902008176640000)) + +(assert_return (invoke "for" (i64.const 0)) (i64.const 1)) +(assert_return (invoke "for" (i64.const 1)) (i64.const 1)) +(assert_return (invoke "for" (i64.const 2)) (i64.const 2)) +(assert_return (invoke "for" (i64.const 3)) (i64.const 6)) +(assert_return (invoke "for" (i64.const 5)) (i64.const 120)) +(assert_return (invoke "for" (i64.const 20)) (i64.const 2432902008176640000)) + +(assert_return (invoke "nesting" (f32.const 0) (f32.const 7)) (f32.const 0)) +(assert_return (invoke "nesting" (f32.const 7) (f32.const 0)) (f32.const 0)) +(assert_return (invoke "nesting" (f32.const 1) (f32.const 1)) (f32.const 1)) +(assert_return (invoke "nesting" (f32.const 1) (f32.const 2)) (f32.const 2)) +(assert_return (invoke "nesting" (f32.const 1) (f32.const 3)) (f32.const 4)) +(assert_return (invoke "nesting" (f32.const 1) (f32.const 4)) (f32.const 6)) +(assert_return (invoke "nesting" (f32.const 1) (f32.const 100)) (f32.const 2550)) +(assert_return (invoke "nesting" (f32.const 1) (f32.const 101)) (f32.const 2601)) +(assert_return (invoke "nesting" (f32.const 2) (f32.const 1)) (f32.const 1)) +(assert_return (invoke "nesting" (f32.const 3) (f32.const 1)) (f32.const 1)) +(assert_return (invoke "nesting" (f32.const 10) (f32.const 1)) (f32.const 1)) +(assert_return (invoke "nesting" (f32.const 2) (f32.const 2)) (f32.const 3)) +(assert_return (invoke "nesting" (f32.const 2) (f32.const 3)) (f32.const 4)) +(assert_return (invoke "nesting" (f32.const 7) (f32.const 4)) (f32.const 10.3095235825)) +(assert_return (invoke "nesting" (f32.const 7) (f32.const 100)) (f32.const 4381.54785156)) +(assert_return (invoke "nesting" (f32.const 7) (f32.const 101)) (f32.const 2601)) + +(assert_return (invoke "type-use")) + +(assert_malformed + (module quote + "(type $sig (func (param i32) (result i32)))" + "(func (i32.const 0) (loop (type $sig) (result i32) (param i32)))" + ) + "unexpected token" +) +(assert_malformed + (module quote + "(type $sig (func (param i32) (result i32)))" + "(func (i32.const 0) (loop (param i32) (type $sig) (result i32)))" + ) + "unexpected token" +) +(assert_malformed + (module quote + "(type $sig (func (param i32) (result i32)))" + "(func (i32.const 0) (loop (param i32) (result i32) (type $sig)))" + ) + "unexpected token" +) +(assert_malformed + (module quote + "(type $sig (func (param i32) (result i32)))" + "(func (i32.const 0) (loop (result i32) (type $sig) (param i32)))" + ) + "unexpected token" +) +(assert_malformed + (module quote + "(type $sig (func (param i32) (result i32)))" + "(func (i32.const 0) (loop (result i32) (param i32) (type $sig)))" + ) + "unexpected token" +) +(assert_malformed + (module quote + "(func (i32.const 0) (loop (result i32) (param i32)))" + ) + "unexpected token" +) + +(assert_malformed + (module quote "(func (i32.const 0) (loop (param $x i32) (drop)))") + "unexpected token" +) +(assert_malformed + (module quote + "(type $sig (func))" + "(func (loop (type $sig) (result i32) (i32.const 0)) (unreachable))" + ) + "inline function type" +) +(assert_malformed + (module quote + "(type $sig (func (param i32) (result i32)))" + "(func (loop (type $sig) (result i32) (i32.const 0)) (unreachable))" + ) + "inline function type" +) +(assert_malformed + (module quote + "(type $sig (func (param i32) (result i32)))" + "(func (i32.const 0) (loop (type $sig) (param i32) (drop)) (unreachable))" + ) + "inline function type" +) +(assert_malformed + (module quote + "(type $sig (func (param i32 i32) (result i32)))" + "(func (i32.const 0) (loop (type $sig) (param i32) (result i32)) (unreachable))" + ) + "inline function type" +) + +(assert_invalid + (module + (type $sig (func)) + (func (loop (type $sig) (i32.const 0))) + ) + "type mismatch" +) + +(assert_invalid + (module (func $type-empty-i32 (result i32) (loop))) + "type mismatch" +) +(assert_invalid + (module (func $type-empty-i64 (result i64) (loop))) + "type mismatch" +) +(assert_invalid + (module (func $type-empty-f32 (result f32) (loop))) + "type mismatch" +) +(assert_invalid + (module (func $type-empty-f64 (result f64) (loop))) + "type mismatch" +) + +(assert_invalid + (module (func $type-value-num-vs-void + (loop (i32.const 1)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-value-nums-vs-void + (loop (i32.const 1) (i32.const 2)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-value-empty-vs-num (result i32) + (loop (result i32)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-value-empty-vs-nums (result i32 i32) + (loop (result i32 i32)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-value-void-vs-num (result i32) + (loop (result i32) (nop)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-value-void-vs-nums (result i32 i32) + (loop (result i32 i32) (nop)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-value-num-vs-num (result i32) + (loop (result i32) (f32.const 0)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-value-num-vs-nums (result i32 i32) + (loop (result i32 i32) (i32.const 0)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-value-partial-vs-nums (result i32 i32) + (i32.const 1) (loop (result i32 i32) (i32.const 2)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-value-nums-vs-num (result i32) + (loop (result i32) (i32.const 1) (i32.const 2)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-value-unreached-select (result i32) + (loop (result i64) (select (unreachable) (unreachable) (unreachable))) + )) + "type mismatch" +) + +(assert_invalid + (module + (func $type-value-empty-in-block + (i32.const 0) + (block (loop (result i32)) (drop)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-value-empty-in-loop + (i32.const 0) + (loop (loop (result i32)) (drop)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-value-empty-in-then + (i32.const 0) (i32.const 0) + (if (then (loop (result i32)) (drop))) + ) + ) + "type mismatch" +) + +(assert_invalid + (module (func $type-param-void-vs-num + (loop (param i32) (drop)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-param-void-vs-nums + (loop (param i32 f64) (drop) (drop)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-param-num-vs-num + (f32.const 0) (loop (param i32) (drop)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-param-num-vs-nums + (f32.const 0) (loop (param f32 i32) (drop) (drop)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-param-nested-void-vs-num + (block (loop (param i32) (drop))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-param-void-vs-nums + (block (loop (param i32 f64) (drop) (drop))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-param-num-vs-num + (block (f32.const 0) (loop (param i32) (drop))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-param-num-vs-nums + (block (f32.const 0) (loop (param f32 i32) (drop) (drop))) + )) + "type mismatch" +) + +(assert_malformed + (module quote "(func (param i32) (result i32) loop (param $x i32) end)") + "unexpected token" +) +(assert_malformed + (module quote "(func (param i32) (result i32) (loop (param $x i32)))") + "unexpected token" +) + +(assert_malformed + (module quote "(func loop end $l)") + "mismatching label" +) +(assert_malformed + (module quote "(func loop $a end $l)") + "mismatching label" +) diff --git a/runtime/near-vm/tests/wast/spec/proposals/multi-value/type.wast b/runtime/near-vm/tests/wast/spec/proposals/multi-value/type.wast new file mode 100644 index 00000000000..b94063e6a04 --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/proposals/multi-value/type.wast @@ -0,0 +1,50 @@ +;; Test type definitions + +(module + (type (func)) + (type $t (func)) + + (type (func (param i32))) + (type (func (param $x i32))) + (type (func (result i32))) + (type (func (param i32) (result i32))) + (type (func (param $x i32) (result i32))) + + (type (func (param f32 f64))) + (type (func (result i64 f32))) + (type (func (param i32 i64) (result f32 f64))) + + (type (func (param f32) (param f64))) + (type (func (param $x f32) (param f64))) + (type (func (param f32) (param $y f64))) + (type (func (param $x f32) (param $y f64))) + (type (func (result i64) (result f32))) + (type (func (param i32) (param i64) (result f32) (result f64))) + (type (func (param $x i32) (param $y i64) (result f32) (result f64))) + + (type (func (param f32 f64) (param $x i32) (param f64 i32 i32))) + (type (func (result i64 i64 f32) (result f32 i32))) + (type + (func (param i32 i32) (param i64 i32) (result f32 f64) (result f64 i32)) + ) + + (type (func (param) (param $x f32) (param) (param) (param f64 i32) (param))) + (type + (func (result) (result) (result i64 i64) (result) (result f32) (result)) + ) + (type + (func + (param i32 i32) (param i64 i32) (param) (param $x i32) (param) + (result) (result f32 f64) (result f64 i32) (result) + ) + ) +) + +(assert_malformed + (module quote "(type (func (result i32) (param i32)))") + "result before parameter" +) +(assert_malformed + (module quote "(type (func (result $x i32)))") + "unexpected token" +) diff --git a/runtime/near-vm/tests/wast/spec/proposals/mutable-global/globals.wast b/runtime/near-vm/tests/wast/spec/proposals/mutable-global/globals.wast new file mode 100644 index 00000000000..175af367919 --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/proposals/mutable-global/globals.wast @@ -0,0 +1,164 @@ +;; Test globals + +(module + (global $a i32 (i32.const -2)) + (global (;1;) f32 (f32.const -3)) + (global (;2;) f64 (f64.const -4)) + (global $b i64 (i64.const -5)) + + (global $x (mut i32) (i32.const -12)) + (global (;5;) (mut f32) (f32.const -13)) + (global (;6;) (mut f64) (f64.const -14)) + (global $y (mut i64) (i64.const -15)) + + (func (export "get-a") (result i32) (get_global $a)) + (func (export "get-b") (result i64) (get_global $b)) + (func (export "get-x") (result i32) (get_global $x)) + (func (export "get-y") (result i64) (get_global $y)) + (func (export "set-x") (param i32) (set_global $x (get_local 0))) + (func (export "set-y") (param i64) (set_global $y (get_local 0))) + + (func (export "get-1") (result f32) (get_global 1)) + (func (export "get-2") (result f64) (get_global 2)) + (func (export "get-5") (result f32) (get_global 5)) + (func (export "get-6") (result f64) (get_global 6)) + (func (export "set-5") (param f32) (set_global 5 (get_local 0))) + (func (export "set-6") (param f64) (set_global 6 (get_local 0))) +) + +(assert_return (invoke "get-a") (i32.const -2)) +(assert_return (invoke "get-b") (i64.const -5)) +(assert_return (invoke "get-x") (i32.const -12)) +(assert_return (invoke "get-y") (i64.const -15)) + +(assert_return (invoke "get-1") (f32.const -3)) +(assert_return (invoke "get-2") (f64.const -4)) +(assert_return (invoke "get-5") (f32.const -13)) +(assert_return (invoke "get-6") (f64.const -14)) + +(assert_return (invoke "set-x" (i32.const 6))) +(assert_return (invoke "set-y" (i64.const 7))) +(assert_return (invoke "set-5" (f32.const 8))) +(assert_return (invoke "set-6" (f64.const 9))) + +(assert_return (invoke "get-x") (i32.const 6)) +(assert_return (invoke "get-y") (i64.const 7)) +(assert_return (invoke "get-5") (f32.const 8)) +(assert_return (invoke "get-6") (f64.const 9)) + +(assert_invalid + (module (global f32 (f32.const 0)) (func (set_global 0 (i32.const 1)))) + "global is immutable" +) + +;; mutable globals can be exported +(module (global (mut f32) (f32.const 0)) (export "a" (global 0))) +(module (global (export "a") (mut f32) (f32.const 0))) + +(assert_invalid + (module (global f32 (f32.neg (f32.const 0)))) + "constant expression required" +) + +(assert_invalid + (module (global f32 (get_local 0))) + "constant expression required" +) + +(assert_invalid + (module (global f32 (f32.neg (f32.const 1)))) + "constant expression required" +) + +(assert_invalid + (module (global i32 (i32.const 0) (nop))) + "constant expression required" +) + +(assert_invalid + (module (global i32 (nop))) + "constant expression required" +) + +(assert_invalid + (module (global i32 (f32.const 0))) + "type mismatch" +) + +(assert_invalid + (module (global i32 (i32.const 0) (i32.const 0))) + "type mismatch" +) + +(assert_invalid + (module (global i32 (;empty instruction sequence;))) + "type mismatch" +) + +(assert_invalid + (module (global i32 (get_global 0))) + "unknown global" +) + +(assert_invalid + (module (global i32 (get_global 1)) (global i32 (i32.const 0))) + "unknown global" +) + +(module + (import "spectest" "global_i32" (global i32)) +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\94\80\80\80\00" ;; import section + "\01" ;; length 1 + "\08\73\70\65\63\74\65\73\74" ;; "spectest" + "\0a\67\6c\6f\62\61\6c\5f\69\33\32" ;; "global_i32" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\02" ;; invalid mutability + ) + "invalid mutability" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\94\80\80\80\00" ;; import section + "\01" ;; length 1 + "\08\73\70\65\63\74\65\73\74" ;; "spectest" + "\0a\67\6c\6f\62\61\6c\5f\69\33\32" ;; "global_i32" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\ff" ;; invalid mutability + ) + "invalid mutability" +) + +(module + (global i32 (i32.const 0)) +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\06\86\80\80\80\00" ;; global section + "\01" ;; length 1 + "\7f" ;; i32 + "\02" ;; invalid mutability + "\41\00" ;; i32.const 0 + "\0b" ;; end + ) + "invalid mutability" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\06\86\80\80\80\00" ;; global section + "\01" ;; length 1 + "\7f" ;; i32 + "\ff" ;; invalid mutability + "\41\00" ;; i32.const 0 + "\0b" ;; end + ) + "invalid mutability" +) diff --git a/runtime/near-vm/tests/wast/spec/proposals/mutable-global/linking.wast b/runtime/near-vm/tests/wast/spec/proposals/mutable-global/linking.wast new file mode 100644 index 00000000000..e2fc8b8f250 --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/proposals/mutable-global/linking.wast @@ -0,0 +1,354 @@ +;; Functions + +(module $Mf + (func (export "call") (result i32) (call $g)) + (func $g (result i32) (i32.const 2)) +) +(register "Mf" $Mf) + +(module $Nf + (func $f (import "Mf" "call") (result i32)) + (export "Mf.call" (func $f)) + (func (export "call Mf.call") (result i32) (call $f)) + (func (export "call") (result i32) (call $g)) + (func $g (result i32) (i32.const 3)) +) + +(assert_return (invoke $Mf "call") (i32.const 2)) +(assert_return (invoke $Nf "Mf.call") (i32.const 2)) +(assert_return (invoke $Nf "call") (i32.const 3)) +(assert_return (invoke $Nf "call Mf.call") (i32.const 2)) + +(module + (import "spectest" "print_i32" (func $f (param i32))) + (export "print" (func $f)) +) +(register "reexport_f") +(assert_unlinkable + (module (import "reexport_f" "print" (func (param i64)))) + "incompatible import type" +) +(assert_unlinkable + (module (import "reexport_f" "print" (func (param i32) (result i32)))) + "incompatible import type" +) + + +;; Globals + +(module $Mg + (global $glob (export "glob") i32 (i32.const 42)) + (func (export "get") (result i32) (get_global $glob)) + + ;; export mutable globals + (global $mut_glob (export "mut_glob") (mut i32) (i32.const 142)) + (func (export "get_mut") (result i32) (get_global $mut_glob)) + (func (export "set_mut") (param i32) (set_global $mut_glob (get_local 0))) +) +(register "Mg" $Mg) + +(module $Ng + (global $x (import "Mg" "glob") i32) + (global $mut_glob (import "Mg" "mut_glob") (mut i32)) + (func $f (import "Mg" "get") (result i32)) + (func $get_mut (import "Mg" "get_mut") (result i32)) + (func $set_mut (import "Mg" "set_mut") (param i32)) + + (export "Mg.glob" (global $x)) + (export "Mg.get" (func $f)) + (global $glob (export "glob") i32 (i32.const 43)) + (func (export "get") (result i32) (get_global $glob)) + + (export "Mg.mut_glob" (global $mut_glob)) + (export "Mg.get_mut" (func $get_mut)) + (export "Mg.set_mut" (func $set_mut)) +) + +(assert_return (get $Mg "glob") (i32.const 42)) +(assert_return (get $Ng "Mg.glob") (i32.const 42)) +(assert_return (get $Ng "glob") (i32.const 43)) +(assert_return (invoke $Mg "get") (i32.const 42)) +(assert_return (invoke $Ng "Mg.get") (i32.const 42)) +(assert_return (invoke $Ng "get") (i32.const 43)) + +(assert_return (get $Mg "mut_glob") (i32.const 142)) +(assert_return (get $Ng "Mg.mut_glob") (i32.const 142)) +(assert_return (invoke $Mg "get_mut") (i32.const 142)) +(assert_return (invoke $Ng "Mg.get_mut") (i32.const 142)) + +(assert_return (invoke $Mg "set_mut" (i32.const 241))) +(assert_return (get $Mg "mut_glob") (i32.const 241)) +(assert_return (get $Ng "Mg.mut_glob") (i32.const 241)) +(assert_return (invoke $Mg "get_mut") (i32.const 241)) +(assert_return (invoke $Ng "Mg.get_mut") (i32.const 241)) + + +(assert_unlinkable + (module (import "Mg" "mut_glob" (global i32))) + "incompatible import type" +) +(assert_unlinkable + (module (import "Mg" "glob" (global (mut i32)))) + "incompatible import type" +) + +;; Tables + +(module $Mt + (type (func (result i32))) + (type (func)) + + (table (export "tab") 10 anyfunc) + (elem (i32.const 2) $g $g $g $g) + (func $g (result i32) (i32.const 4)) + (func (export "h") (result i32) (i32.const -4)) + + (func (export "call") (param i32) (result i32) + (call_indirect (type 0) (get_local 0)) + ) +) +(register "Mt" $Mt) + +(module $Nt + (type (func)) + (type (func (result i32))) + + (func $f (import "Mt" "call") (param i32) (result i32)) + (func $h (import "Mt" "h") (result i32)) + + (table anyfunc (elem $g $g $g $h $f)) + (func $g (result i32) (i32.const 5)) + + (export "Mt.call" (func $f)) + (func (export "call Mt.call") (param i32) (result i32) + (call $f (get_local 0)) + ) + (func (export "call") (param i32) (result i32) + (call_indirect (type 1) (get_local 0)) + ) +) + +(assert_return (invoke $Mt "call" (i32.const 2)) (i32.const 4)) +(assert_return (invoke $Nt "Mt.call" (i32.const 2)) (i32.const 4)) +(assert_return (invoke $Nt "call" (i32.const 2)) (i32.const 5)) +(assert_return (invoke $Nt "call Mt.call" (i32.const 2)) (i32.const 4)) + +(assert_trap (invoke $Mt "call" (i32.const 1)) "uninitialized") +(assert_trap (invoke $Nt "Mt.call" (i32.const 1)) "uninitialized") +(assert_return (invoke $Nt "call" (i32.const 1)) (i32.const 5)) +(assert_trap (invoke $Nt "call Mt.call" (i32.const 1)) "uninitialized") + +(assert_trap (invoke $Mt "call" (i32.const 0)) "uninitialized") +(assert_trap (invoke $Nt "Mt.call" (i32.const 0)) "uninitialized") +(assert_return (invoke $Nt "call" (i32.const 0)) (i32.const 5)) +(assert_trap (invoke $Nt "call Mt.call" (i32.const 0)) "uninitialized") + +(assert_trap (invoke $Mt "call" (i32.const 20)) "undefined") +(assert_trap (invoke $Nt "Mt.call" (i32.const 20)) "undefined") +(assert_trap (invoke $Nt "call" (i32.const 7)) "undefined") +(assert_trap (invoke $Nt "call Mt.call" (i32.const 20)) "undefined") + +(assert_return (invoke $Nt "call" (i32.const 3)) (i32.const -4)) +(assert_trap (invoke $Nt "call" (i32.const 4)) "indirect call") + +(module $Ot + (type (func (result i32))) + + (func $h (import "Mt" "h") (result i32)) + (table (import "Mt" "tab") 5 anyfunc) + (elem (i32.const 1) $i $h) + (func $i (result i32) (i32.const 6)) + + (func (export "call") (param i32) (result i32) + (call_indirect (type 0) (get_local 0)) + ) +) + +(assert_return (invoke $Mt "call" (i32.const 3)) (i32.const 4)) +(assert_return (invoke $Nt "Mt.call" (i32.const 3)) (i32.const 4)) +(assert_return (invoke $Nt "call Mt.call" (i32.const 3)) (i32.const 4)) +(assert_return (invoke $Ot "call" (i32.const 3)) (i32.const 4)) + +(assert_return (invoke $Mt "call" (i32.const 2)) (i32.const -4)) +(assert_return (invoke $Nt "Mt.call" (i32.const 2)) (i32.const -4)) +(assert_return (invoke $Nt "call" (i32.const 2)) (i32.const 5)) +(assert_return (invoke $Nt "call Mt.call" (i32.const 2)) (i32.const -4)) +(assert_return (invoke $Ot "call" (i32.const 2)) (i32.const -4)) + +(assert_return (invoke $Mt "call" (i32.const 1)) (i32.const 6)) +(assert_return (invoke $Nt "Mt.call" (i32.const 1)) (i32.const 6)) +(assert_return (invoke $Nt "call" (i32.const 1)) (i32.const 5)) +(assert_return (invoke $Nt "call Mt.call" (i32.const 1)) (i32.const 6)) +(assert_return (invoke $Ot "call" (i32.const 1)) (i32.const 6)) + +(assert_trap (invoke $Mt "call" (i32.const 0)) "uninitialized") +(assert_trap (invoke $Nt "Mt.call" (i32.const 0)) "uninitialized") +(assert_return (invoke $Nt "call" (i32.const 0)) (i32.const 5)) +(assert_trap (invoke $Nt "call Mt.call" (i32.const 0)) "uninitialized") +(assert_trap (invoke $Ot "call" (i32.const 0)) "uninitialized") + +(assert_trap (invoke $Ot "call" (i32.const 20)) "undefined") + +(module + (table (import "Mt" "tab") 0 anyfunc) + (elem (i32.const 9) $f) + (func $f) +) + +(module $G1 (global (export "g") i32 (i32.const 5))) +(register "G1" $G1) +(module $G2 + (global (import "G1" "g") i32) + (global (export "g") i32 (get_global 0)) +) +(assert_return (get $G2 "g") (i32.const 5)) + +(assert_unlinkable + (module + (table (import "Mt" "tab") 0 anyfunc) + (elem (i32.const 10) $f) + (func $f) + ) + "elements segment does not fit" +) + +(assert_unlinkable + (module + (table (import "Mt" "tab") 10 anyfunc) + (memory (import "Mt" "mem") 1) ;; does not exist + (func $f (result i32) (i32.const 0)) + (elem (i32.const 7) $f) + (elem (i32.const 9) $f) + ) + "unknown import" +) +(assert_trap (invoke $Mt "call" (i32.const 7)) "uninitialized") + +(assert_unlinkable + (module + (table (import "Mt" "tab") 10 anyfunc) + (func $f (result i32) (i32.const 0)) + (elem (i32.const 7) $f) + (elem (i32.const 12) $f) ;; out of bounds + ) + "elements segment does not fit" +) +(assert_trap (invoke $Mt "call" (i32.const 7)) "uninitialized") + +(assert_unlinkable + (module + (table (import "Mt" "tab") 10 anyfunc) + (func $f (result i32) (i32.const 0)) + (elem (i32.const 7) $f) + (memory 1) + (data (i32.const 0x10000) "d") ;; out of bounds + ) + "data segment does not fit" +) +(assert_trap (invoke $Mt "call" (i32.const 7)) "uninitialized") + + +;; Memories + +(module $Mm + (memory (export "mem") 1 5) + (data (i32.const 10) "\00\01\02\03\04\05\06\07\08\09") + + (func (export "load") (param $a i32) (result i32) + (i32.load8_u (get_local 0)) + ) +) +(register "Mm" $Mm) + +(module $Nm + (func $loadM (import "Mm" "load") (param i32) (result i32)) + + (memory 1) + (data (i32.const 10) "\f0\f1\f2\f3\f4\f5") + + (export "Mm.load" (func $loadM)) + (func (export "load") (param $a i32) (result i32) + (i32.load8_u (get_local 0)) + ) +) + +(assert_return (invoke $Mm "load" (i32.const 12)) (i32.const 2)) +(assert_return (invoke $Nm "Mm.load" (i32.const 12)) (i32.const 2)) +(assert_return (invoke $Nm "load" (i32.const 12)) (i32.const 0xf2)) + +(module $Om + (memory (import "Mm" "mem") 1) + (data (i32.const 5) "\a0\a1\a2\a3\a4\a5\a6\a7") + + (func (export "load") (param $a i32) (result i32) + (i32.load8_u (get_local 0)) + ) +) + +(assert_return (invoke $Mm "load" (i32.const 12)) (i32.const 0xa7)) +(assert_return (invoke $Nm "Mm.load" (i32.const 12)) (i32.const 0xa7)) +(assert_return (invoke $Nm "load" (i32.const 12)) (i32.const 0xf2)) +(assert_return (invoke $Om "load" (i32.const 12)) (i32.const 0xa7)) + +(module + (memory (import "Mm" "mem") 0) + (data (i32.const 0xffff) "a") +) + +(assert_unlinkable + (module + (memory (import "Mm" "mem") 0) + (data (i32.const 0x10000) "a") + ) + "data segment does not fit" +) + +(module $Pm + (memory (import "Mm" "mem") 1 8) + + (func (export "grow") (param $a i32) (result i32) + (memory.grow (get_local 0)) + ) +) + +(assert_return (invoke $Pm "grow" (i32.const 0)) (i32.const 1)) +(assert_return (invoke $Pm "grow" (i32.const 2)) (i32.const 1)) +(assert_return (invoke $Pm "grow" (i32.const 0)) (i32.const 3)) +(assert_return (invoke $Pm "grow" (i32.const 1)) (i32.const 3)) +(assert_return (invoke $Pm "grow" (i32.const 1)) (i32.const 4)) +(assert_return (invoke $Pm "grow" (i32.const 0)) (i32.const 5)) +(assert_return (invoke $Pm "grow" (i32.const 1)) (i32.const -1)) +(assert_return (invoke $Pm "grow" (i32.const 0)) (i32.const 5)) + +(assert_unlinkable + (module + (func $host (import "spectest" "print")) + (memory (import "Mm" "mem") 1) + (table (import "Mm" "tab") 0 anyfunc) ;; does not exist + (data (i32.const 0) "abc") + ) + "unknown import" +) +(assert_return (invoke $Mm "load" (i32.const 0)) (i32.const 0)) + +(assert_unlinkable + (module + (memory (import "Mm" "mem") 1) + (data (i32.const 0) "abc") + (data (i32.const 0x50000) "d") ;; out of bounds + ) + "data segment does not fit" +) +(assert_return (invoke $Mm "load" (i32.const 0)) (i32.const 0)) + +(assert_unlinkable + (module + (memory (import "Mm" "mem") 1) + (data (i32.const 0) "abc") + (table 0 anyfunc) + (func) + (elem (i32.const 0) 0) ;; out of bounds + ) + "elements segment does not fit" +) +(assert_return (invoke $Mm "load" (i32.const 0)) (i32.const 0)) diff --git a/runtime/near-vm/tests/wast/spec/proposals/nontrapping-float-to-int-conversions/conversions.wast b/runtime/near-vm/tests/wast/spec/proposals/nontrapping-float-to-int-conversions/conversions.wast new file mode 100644 index 00000000000..99355a08578 --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/proposals/nontrapping-float-to-int-conversions/conversions.wast @@ -0,0 +1,698 @@ +(module + (func (export "i64.extend_i32_s") (param $x i32) (result i64) (i64.extend_i32_s (local.get $x))) + (func (export "i64.extend_i32_u") (param $x i32) (result i64) (i64.extend_i32_u (local.get $x))) + (func (export "i32.wrap_i64") (param $x i64) (result i32) (i32.wrap_i64 (local.get $x))) + (func (export "i32.trunc_f32_s") (param $x f32) (result i32) (i32.trunc_f32_s (local.get $x))) + (func (export "i32.trunc_f32_u") (param $x f32) (result i32) (i32.trunc_f32_u (local.get $x))) + (func (export "i32.trunc_f64_s") (param $x f64) (result i32) (i32.trunc_f64_s (local.get $x))) + (func (export "i32.trunc_f64_u") (param $x f64) (result i32) (i32.trunc_f64_u (local.get $x))) + (func (export "i64.trunc_f32_s") (param $x f32) (result i64) (i64.trunc_f32_s (local.get $x))) + (func (export "i64.trunc_f32_u") (param $x f32) (result i64) (i64.trunc_f32_u (local.get $x))) + (func (export "i64.trunc_f64_s") (param $x f64) (result i64) (i64.trunc_f64_s (local.get $x))) + (func (export "i64.trunc_f64_u") (param $x f64) (result i64) (i64.trunc_f64_u (local.get $x))) + (func (export "i32.trunc_sat_f32_s") (param $x f32) (result i32) (i32.trunc_sat_f32_s (local.get $x))) + (func (export "i32.trunc_sat_f32_u") (param $x f32) (result i32) (i32.trunc_sat_f32_u (local.get $x))) + (func (export "i32.trunc_sat_f64_s") (param $x f64) (result i32) (i32.trunc_sat_f64_s (local.get $x))) + (func (export "i32.trunc_sat_f64_u") (param $x f64) (result i32) (i32.trunc_sat_f64_u (local.get $x))) + (func (export "i64.trunc_sat_f32_s") (param $x f32) (result i64) (i64.trunc_sat_f32_s (local.get $x))) + (func (export "i64.trunc_sat_f32_u") (param $x f32) (result i64) (i64.trunc_sat_f32_u (local.get $x))) + (func (export "i64.trunc_sat_f64_s") (param $x f64) (result i64) (i64.trunc_sat_f64_s (local.get $x))) + (func (export "i64.trunc_sat_f64_u") (param $x f64) (result i64) (i64.trunc_sat_f64_u (local.get $x))) + (func (export "f32.convert_i32_s") (param $x i32) (result f32) (f32.convert_i32_s (local.get $x))) + (func (export "f32.convert_i64_s") (param $x i64) (result f32) (f32.convert_i64_s (local.get $x))) + (func (export "f64.convert_i32_s") (param $x i32) (result f64) (f64.convert_i32_s (local.get $x))) + (func (export "f64.convert_i64_s") (param $x i64) (result f64) (f64.convert_i64_s (local.get $x))) + (func (export "f32.convert_i32_u") (param $x i32) (result f32) (f32.convert_i32_u (local.get $x))) + (func (export "f32.convert_i64_u") (param $x i64) (result f32) (f32.convert_i64_u (local.get $x))) + (func (export "f64.convert_i32_u") (param $x i32) (result f64) (f64.convert_i32_u (local.get $x))) + (func (export "f64.convert_i64_u") (param $x i64) (result f64) (f64.convert_i64_u (local.get $x))) + (func (export "f64.promote_f32") (param $x f32) (result f64) (f64.promote_f32 (local.get $x))) + (func (export "f32.demote_f64") (param $x f64) (result f32) (f32.demote_f64 (local.get $x))) + (func (export "f32.reinterpret_i32") (param $x i32) (result f32) (f32.reinterpret_i32 (local.get $x))) + (func (export "f64.reinterpret_i64") (param $x i64) (result f64) (f64.reinterpret_i64 (local.get $x))) + (func (export "i32.reinterpret_f32") (param $x f32) (result i32) (i32.reinterpret_f32 (local.get $x))) + (func (export "i64.reinterpret_f64") (param $x f64) (result i64) (i64.reinterpret_f64 (local.get $x))) +) + +(assert_return (invoke "i64.extend_i32_s" (i32.const 0)) (i64.const 0)) +(assert_return (invoke "i64.extend_i32_s" (i32.const 10000)) (i64.const 10000)) +(assert_return (invoke "i64.extend_i32_s" (i32.const -10000)) (i64.const -10000)) +(assert_return (invoke "i64.extend_i32_s" (i32.const -1)) (i64.const -1)) +(assert_return (invoke "i64.extend_i32_s" (i32.const 0x7fffffff)) (i64.const 0x000000007fffffff)) +(assert_return (invoke "i64.extend_i32_s" (i32.const 0x80000000)) (i64.const 0xffffffff80000000)) + +(assert_return (invoke "i64.extend_i32_u" (i32.const 0)) (i64.const 0)) +(assert_return (invoke "i64.extend_i32_u" (i32.const 10000)) (i64.const 10000)) +(assert_return (invoke "i64.extend_i32_u" (i32.const -10000)) (i64.const 0x00000000ffffd8f0)) +(assert_return (invoke "i64.extend_i32_u" (i32.const -1)) (i64.const 0xffffffff)) +(assert_return (invoke "i64.extend_i32_u" (i32.const 0x7fffffff)) (i64.const 0x000000007fffffff)) +(assert_return (invoke "i64.extend_i32_u" (i32.const 0x80000000)) (i64.const 0x0000000080000000)) + +(assert_return (invoke "i32.wrap_i64" (i64.const -1)) (i32.const -1)) +(assert_return (invoke "i32.wrap_i64" (i64.const -100000)) (i32.const -100000)) +(assert_return (invoke "i32.wrap_i64" (i64.const 0x80000000)) (i32.const 0x80000000)) +(assert_return (invoke "i32.wrap_i64" (i64.const 0xffffffff7fffffff)) (i32.const 0x7fffffff)) +(assert_return (invoke "i32.wrap_i64" (i64.const 0xffffffff00000000)) (i32.const 0x00000000)) +(assert_return (invoke "i32.wrap_i64" (i64.const 0xfffffffeffffffff)) (i32.const 0xffffffff)) +(assert_return (invoke "i32.wrap_i64" (i64.const 0xffffffff00000001)) (i32.const 0x00000001)) +(assert_return (invoke "i32.wrap_i64" (i64.const 0)) (i32.const 0)) +(assert_return (invoke "i32.wrap_i64" (i64.const 1311768467463790320)) (i32.const 0x9abcdef0)) +(assert_return (invoke "i32.wrap_i64" (i64.const 0x00000000ffffffff)) (i32.const 0xffffffff)) +(assert_return (invoke "i32.wrap_i64" (i64.const 0x0000000100000000)) (i32.const 0x00000000)) +(assert_return (invoke "i32.wrap_i64" (i64.const 0x0000000100000001)) (i32.const 0x00000001)) + +(assert_return (invoke "i32.trunc_f32_s" (f32.const 0.0)) (i32.const 0)) +(assert_return (invoke "i32.trunc_f32_s" (f32.const -0.0)) (i32.const 0)) +(assert_return (invoke "i32.trunc_f32_s" (f32.const 0x1p-149)) (i32.const 0)) +(assert_return (invoke "i32.trunc_f32_s" (f32.const -0x1p-149)) (i32.const 0)) +(assert_return (invoke "i32.trunc_f32_s" (f32.const 1.0)) (i32.const 1)) +(assert_return (invoke "i32.trunc_f32_s" (f32.const 0x1.19999ap+0)) (i32.const 1)) +(assert_return (invoke "i32.trunc_f32_s" (f32.const 1.5)) (i32.const 1)) +(assert_return (invoke "i32.trunc_f32_s" (f32.const -1.0)) (i32.const -1)) +(assert_return (invoke "i32.trunc_f32_s" (f32.const -0x1.19999ap+0)) (i32.const -1)) +(assert_return (invoke "i32.trunc_f32_s" (f32.const -1.5)) (i32.const -1)) +(assert_return (invoke "i32.trunc_f32_s" (f32.const -1.9)) (i32.const -1)) +(assert_return (invoke "i32.trunc_f32_s" (f32.const -2.0)) (i32.const -2)) +(assert_return (invoke "i32.trunc_f32_s" (f32.const 2147483520.0)) (i32.const 2147483520)) +(assert_return (invoke "i32.trunc_f32_s" (f32.const -2147483648.0)) (i32.const -2147483648)) +(assert_trap (invoke "i32.trunc_f32_s" (f32.const 2147483648.0)) "integer overflow") +(assert_trap (invoke "i32.trunc_f32_s" (f32.const -2147483904.0)) "integer overflow") +(assert_trap (invoke "i32.trunc_f32_s" (f32.const inf)) "integer overflow") +(assert_trap (invoke "i32.trunc_f32_s" (f32.const -inf)) "integer overflow") +(assert_trap (invoke "i32.trunc_f32_s" (f32.const nan)) "invalid conversion to integer") +(assert_trap (invoke "i32.trunc_f32_s" (f32.const nan:0x200000)) "invalid conversion to integer") +(assert_trap (invoke "i32.trunc_f32_s" (f32.const -nan)) "invalid conversion to integer") +(assert_trap (invoke "i32.trunc_f32_s" (f32.const -nan:0x200000)) "invalid conversion to integer") + +(assert_return (invoke "i32.trunc_f32_u" (f32.const 0.0)) (i32.const 0)) +(assert_return (invoke "i32.trunc_f32_u" (f32.const -0.0)) (i32.const 0)) +(assert_return (invoke "i32.trunc_f32_u" (f32.const 0x1p-149)) (i32.const 0)) +(assert_return (invoke "i32.trunc_f32_u" (f32.const -0x1p-149)) (i32.const 0)) +(assert_return (invoke "i32.trunc_f32_u" (f32.const 1.0)) (i32.const 1)) +(assert_return (invoke "i32.trunc_f32_u" (f32.const 0x1.19999ap+0)) (i32.const 1)) +(assert_return (invoke "i32.trunc_f32_u" (f32.const 1.5)) (i32.const 1)) +(assert_return (invoke "i32.trunc_f32_u" (f32.const 1.9)) (i32.const 1)) +(assert_return (invoke "i32.trunc_f32_u" (f32.const 2.0)) (i32.const 2)) +(assert_return (invoke "i32.trunc_f32_u" (f32.const 2147483648)) (i32.const -2147483648)) ;; 0x1.00000p+31 -> 8000 0000 +(assert_return (invoke "i32.trunc_f32_u" (f32.const 4294967040.0)) (i32.const -256)) +(assert_return (invoke "i32.trunc_f32_u" (f32.const -0x1.ccccccp-1)) (i32.const 0)) +(assert_return (invoke "i32.trunc_f32_u" (f32.const -0x1.fffffep-1)) (i32.const 0)) +(assert_trap (invoke "i32.trunc_f32_u" (f32.const 4294967296.0)) "integer overflow") +(assert_trap (invoke "i32.trunc_f32_u" (f32.const -1.0)) "integer overflow") +(assert_trap (invoke "i32.trunc_f32_u" (f32.const inf)) "integer overflow") +(assert_trap (invoke "i32.trunc_f32_u" (f32.const -inf)) "integer overflow") +(assert_trap (invoke "i32.trunc_f32_u" (f32.const nan)) "invalid conversion to integer") +(assert_trap (invoke "i32.trunc_f32_u" (f32.const nan:0x200000)) "invalid conversion to integer") +(assert_trap (invoke "i32.trunc_f32_u" (f32.const -nan)) "invalid conversion to integer") +(assert_trap (invoke "i32.trunc_f32_u" (f32.const -nan:0x200000)) "invalid conversion to integer") + +(assert_return (invoke "i32.trunc_f64_s" (f64.const 0.0)) (i32.const 0)) +(assert_return (invoke "i32.trunc_f64_s" (f64.const -0.0)) (i32.const 0)) +(assert_return (invoke "i32.trunc_f64_s" (f64.const 0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "i32.trunc_f64_s" (f64.const -0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "i32.trunc_f64_s" (f64.const 1.0)) (i32.const 1)) +(assert_return (invoke "i32.trunc_f64_s" (f64.const 0x1.199999999999ap+0)) (i32.const 1)) +(assert_return (invoke "i32.trunc_f64_s" (f64.const 1.5)) (i32.const 1)) +(assert_return (invoke "i32.trunc_f64_s" (f64.const -1.0)) (i32.const -1)) +(assert_return (invoke "i32.trunc_f64_s" (f64.const -0x1.199999999999ap+0)) (i32.const -1)) +(assert_return (invoke "i32.trunc_f64_s" (f64.const -1.5)) (i32.const -1)) +(assert_return (invoke "i32.trunc_f64_s" (f64.const -1.9)) (i32.const -1)) +(assert_return (invoke "i32.trunc_f64_s" (f64.const -2.0)) (i32.const -2)) +(assert_return (invoke "i32.trunc_f64_s" (f64.const 2147483647.0)) (i32.const 2147483647)) +(assert_return (invoke "i32.trunc_f64_s" (f64.const -2147483648.0)) (i32.const -2147483648)) +(assert_trap (invoke "i32.trunc_f64_s" (f64.const 2147483648.0)) "integer overflow") +(assert_trap (invoke "i32.trunc_f64_s" (f64.const -2147483649.0)) "integer overflow") +(assert_trap (invoke "i32.trunc_f64_s" (f64.const inf)) "integer overflow") +(assert_trap (invoke "i32.trunc_f64_s" (f64.const -inf)) "integer overflow") +(assert_trap (invoke "i32.trunc_f64_s" (f64.const nan)) "invalid conversion to integer") +(assert_trap (invoke "i32.trunc_f64_s" (f64.const nan:0x4000000000000)) "invalid conversion to integer") +(assert_trap (invoke "i32.trunc_f64_s" (f64.const -nan)) "invalid conversion to integer") +(assert_trap (invoke "i32.trunc_f64_s" (f64.const -nan:0x4000000000000)) "invalid conversion to integer") + +(assert_return (invoke "i32.trunc_f64_u" (f64.const 0.0)) (i32.const 0)) +(assert_return (invoke "i32.trunc_f64_u" (f64.const -0.0)) (i32.const 0)) +(assert_return (invoke "i32.trunc_f64_u" (f64.const 0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "i32.trunc_f64_u" (f64.const -0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "i32.trunc_f64_u" (f64.const 1.0)) (i32.const 1)) +(assert_return (invoke "i32.trunc_f64_u" (f64.const 0x1.199999999999ap+0)) (i32.const 1)) +(assert_return (invoke "i32.trunc_f64_u" (f64.const 1.5)) (i32.const 1)) +(assert_return (invoke "i32.trunc_f64_u" (f64.const 1.9)) (i32.const 1)) +(assert_return (invoke "i32.trunc_f64_u" (f64.const 2.0)) (i32.const 2)) +(assert_return (invoke "i32.trunc_f64_u" (f64.const 2147483648)) (i32.const -2147483648)) ;; 0x1.00000p+31 -> 8000 0000 +(assert_return (invoke "i32.trunc_f64_u" (f64.const 4294967295.0)) (i32.const -1)) +(assert_return (invoke "i32.trunc_f64_u" (f64.const -0x1.ccccccccccccdp-1)) (i32.const 0)) +(assert_return (invoke "i32.trunc_f64_u" (f64.const -0x1.fffffffffffffp-1)) (i32.const 0)) +(assert_return (invoke "i32.trunc_f64_u" (f64.const 1e8)) (i32.const 100000000)) +(assert_trap (invoke "i32.trunc_f64_u" (f64.const 4294967296.0)) "integer overflow") +(assert_trap (invoke "i32.trunc_f64_u" (f64.const -1.0)) "integer overflow") +(assert_trap (invoke "i32.trunc_f64_u" (f64.const 1e16)) "integer overflow") +(assert_trap (invoke "i32.trunc_f64_u" (f64.const 1e30)) "integer overflow") +(assert_trap (invoke "i32.trunc_f64_u" (f64.const 9223372036854775808)) "integer overflow") +(assert_trap (invoke "i32.trunc_f64_u" (f64.const inf)) "integer overflow") +(assert_trap (invoke "i32.trunc_f64_u" (f64.const -inf)) "integer overflow") +(assert_trap (invoke "i32.trunc_f64_u" (f64.const nan)) "invalid conversion to integer") +(assert_trap (invoke "i32.trunc_f64_u" (f64.const nan:0x4000000000000)) "invalid conversion to integer") +(assert_trap (invoke "i32.trunc_f64_u" (f64.const -nan)) "invalid conversion to integer") +(assert_trap (invoke "i32.trunc_f64_u" (f64.const -nan:0x4000000000000)) "invalid conversion to integer") + +(assert_return (invoke "i64.trunc_f32_s" (f32.const 0.0)) (i64.const 0)) +(assert_return (invoke "i64.trunc_f32_s" (f32.const -0.0)) (i64.const 0)) +(assert_return (invoke "i64.trunc_f32_s" (f32.const 0x1p-149)) (i64.const 0)) +(assert_return (invoke "i64.trunc_f32_s" (f32.const -0x1p-149)) (i64.const 0)) +(assert_return (invoke "i64.trunc_f32_s" (f32.const 1.0)) (i64.const 1)) +(assert_return (invoke "i64.trunc_f32_s" (f32.const 0x1.19999ap+0)) (i64.const 1)) +(assert_return (invoke "i64.trunc_f32_s" (f32.const 1.5)) (i64.const 1)) +(assert_return (invoke "i64.trunc_f32_s" (f32.const -1.0)) (i64.const -1)) +(assert_return (invoke "i64.trunc_f32_s" (f32.const -0x1.19999ap+0)) (i64.const -1)) +(assert_return (invoke "i64.trunc_f32_s" (f32.const -1.5)) (i64.const -1)) +(assert_return (invoke "i64.trunc_f32_s" (f32.const -1.9)) (i64.const -1)) +(assert_return (invoke "i64.trunc_f32_s" (f32.const -2.0)) (i64.const -2)) +(assert_return (invoke "i64.trunc_f32_s" (f32.const 4294967296)) (i64.const 4294967296)) ;; 0x1.00000p+32 -> 1 0000 0000 +(assert_return (invoke "i64.trunc_f32_s" (f32.const -4294967296)) (i64.const -4294967296)) ;; -0x1.00000p+32 -> ffff ffff 0000 0000 +(assert_return (invoke "i64.trunc_f32_s" (f32.const 9223371487098961920.0)) (i64.const 9223371487098961920)) +(assert_return (invoke "i64.trunc_f32_s" (f32.const -9223372036854775808.0)) (i64.const -9223372036854775808)) +(assert_trap (invoke "i64.trunc_f32_s" (f32.const 9223372036854775808.0)) "integer overflow") +(assert_trap (invoke "i64.trunc_f32_s" (f32.const -9223373136366403584.0)) "integer overflow") +(assert_trap (invoke "i64.trunc_f32_s" (f32.const inf)) "integer overflow") +(assert_trap (invoke "i64.trunc_f32_s" (f32.const -inf)) "integer overflow") +(assert_trap (invoke "i64.trunc_f32_s" (f32.const nan)) "invalid conversion to integer") +(assert_trap (invoke "i64.trunc_f32_s" (f32.const nan:0x200000)) "invalid conversion to integer") +(assert_trap (invoke "i64.trunc_f32_s" (f32.const -nan)) "invalid conversion to integer") +(assert_trap (invoke "i64.trunc_f32_s" (f32.const -nan:0x200000)) "invalid conversion to integer") + +(assert_return (invoke "i64.trunc_f32_u" (f32.const 0.0)) (i64.const 0)) +(assert_return (invoke "i64.trunc_f32_u" (f32.const -0.0)) (i64.const 0)) +(assert_return (invoke "i64.trunc_f32_u" (f32.const 0x1p-149)) (i64.const 0)) +(assert_return (invoke "i64.trunc_f32_u" (f32.const -0x1p-149)) (i64.const 0)) +(assert_return (invoke "i64.trunc_f32_u" (f32.const 1.0)) (i64.const 1)) +(assert_return (invoke "i64.trunc_f32_u" (f32.const 0x1.19999ap+0)) (i64.const 1)) +(assert_return (invoke "i64.trunc_f32_u" (f32.const 1.5)) (i64.const 1)) +(assert_return (invoke "i64.trunc_f32_u" (f32.const 4294967296)) (i64.const 4294967296)) +(assert_return (invoke "i64.trunc_f32_u" (f32.const 18446742974197923840.0)) (i64.const -1099511627776)) +(assert_return (invoke "i64.trunc_f32_u" (f32.const -0x1.ccccccp-1)) (i64.const 0)) +(assert_return (invoke "i64.trunc_f32_u" (f32.const -0x1.fffffep-1)) (i64.const 0)) +(assert_trap (invoke "i64.trunc_f32_u" (f32.const 18446744073709551616.0)) "integer overflow") +(assert_trap (invoke "i64.trunc_f32_u" (f32.const -1.0)) "integer overflow") +(assert_trap (invoke "i64.trunc_f32_u" (f32.const inf)) "integer overflow") +(assert_trap (invoke "i64.trunc_f32_u" (f32.const -inf)) "integer overflow") +(assert_trap (invoke "i64.trunc_f32_u" (f32.const nan)) "invalid conversion to integer") +(assert_trap (invoke "i64.trunc_f32_u" (f32.const nan:0x200000)) "invalid conversion to integer") +(assert_trap (invoke "i64.trunc_f32_u" (f32.const -nan)) "invalid conversion to integer") +(assert_trap (invoke "i64.trunc_f32_u" (f32.const -nan:0x200000)) "invalid conversion to integer") + +(assert_return (invoke "i64.trunc_f64_s" (f64.const 0.0)) (i64.const 0)) +(assert_return (invoke "i64.trunc_f64_s" (f64.const -0.0)) (i64.const 0)) +(assert_return (invoke "i64.trunc_f64_s" (f64.const 0x0.0000000000001p-1022)) (i64.const 0)) +(assert_return (invoke "i64.trunc_f64_s" (f64.const -0x0.0000000000001p-1022)) (i64.const 0)) +(assert_return (invoke "i64.trunc_f64_s" (f64.const 1.0)) (i64.const 1)) +(assert_return (invoke "i64.trunc_f64_s" (f64.const 0x1.199999999999ap+0)) (i64.const 1)) +(assert_return (invoke "i64.trunc_f64_s" (f64.const 1.5)) (i64.const 1)) +(assert_return (invoke "i64.trunc_f64_s" (f64.const -1.0)) (i64.const -1)) +(assert_return (invoke "i64.trunc_f64_s" (f64.const -0x1.199999999999ap+0)) (i64.const -1)) +(assert_return (invoke "i64.trunc_f64_s" (f64.const -1.5)) (i64.const -1)) +(assert_return (invoke "i64.trunc_f64_s" (f64.const -1.9)) (i64.const -1)) +(assert_return (invoke "i64.trunc_f64_s" (f64.const -2.0)) (i64.const -2)) +(assert_return (invoke "i64.trunc_f64_s" (f64.const 4294967296)) (i64.const 4294967296)) ;; 0x1.00000p+32 -> 1 0000 0000 +(assert_return (invoke "i64.trunc_f64_s" (f64.const -4294967296)) (i64.const -4294967296)) ;; -0x1.00000p+32 -> ffff ffff 0000 0000 +(assert_return (invoke "i64.trunc_f64_s" (f64.const 9223372036854774784.0)) (i64.const 9223372036854774784)) +(assert_return (invoke "i64.trunc_f64_s" (f64.const -9223372036854775808.0)) (i64.const -9223372036854775808)) +(assert_trap (invoke "i64.trunc_f64_s" (f64.const 9223372036854775808.0)) "integer overflow") +(assert_trap (invoke "i64.trunc_f64_s" (f64.const -9223372036854777856.0)) "integer overflow") +(assert_trap (invoke "i64.trunc_f64_s" (f64.const inf)) "integer overflow") +(assert_trap (invoke "i64.trunc_f64_s" (f64.const -inf)) "integer overflow") +(assert_trap (invoke "i64.trunc_f64_s" (f64.const nan)) "invalid conversion to integer") +(assert_trap (invoke "i64.trunc_f64_s" (f64.const nan:0x4000000000000)) "invalid conversion to integer") +(assert_trap (invoke "i64.trunc_f64_s" (f64.const -nan)) "invalid conversion to integer") +(assert_trap (invoke "i64.trunc_f64_s" (f64.const -nan:0x4000000000000)) "invalid conversion to integer") + +(assert_return (invoke "i64.trunc_f64_u" (f64.const 0.0)) (i64.const 0)) +(assert_return (invoke "i64.trunc_f64_u" (f64.const -0.0)) (i64.const 0)) +(assert_return (invoke "i64.trunc_f64_u" (f64.const 0x0.0000000000001p-1022)) (i64.const 0)) +(assert_return (invoke "i64.trunc_f64_u" (f64.const -0x0.0000000000001p-1022)) (i64.const 0)) +(assert_return (invoke "i64.trunc_f64_u" (f64.const 1.0)) (i64.const 1)) +(assert_return (invoke "i64.trunc_f64_u" (f64.const 0x1.199999999999ap+0)) (i64.const 1)) +(assert_return (invoke "i64.trunc_f64_u" (f64.const 1.5)) (i64.const 1)) +(assert_return (invoke "i64.trunc_f64_u" (f64.const 4294967295)) (i64.const 0xffffffff)) +(assert_return (invoke "i64.trunc_f64_u" (f64.const 4294967296)) (i64.const 0x100000000)) +(assert_return (invoke "i64.trunc_f64_u" (f64.const 18446744073709549568.0)) (i64.const -2048)) +(assert_return (invoke "i64.trunc_f64_u" (f64.const -0x1.ccccccccccccdp-1)) (i64.const 0)) +(assert_return (invoke "i64.trunc_f64_u" (f64.const -0x1.fffffffffffffp-1)) (i64.const 0)) +(assert_return (invoke "i64.trunc_f64_u" (f64.const 1e8)) (i64.const 100000000)) +(assert_return (invoke "i64.trunc_f64_u" (f64.const 1e16)) (i64.const 10000000000000000)) +(assert_return (invoke "i64.trunc_f64_u" (f64.const 9223372036854775808)) (i64.const -9223372036854775808)) +(assert_trap (invoke "i64.trunc_f64_u" (f64.const 18446744073709551616.0)) "integer overflow") +(assert_trap (invoke "i64.trunc_f64_u" (f64.const -1.0)) "integer overflow") +(assert_trap (invoke "i64.trunc_f64_u" (f64.const inf)) "integer overflow") +(assert_trap (invoke "i64.trunc_f64_u" (f64.const -inf)) "integer overflow") +(assert_trap (invoke "i64.trunc_f64_u" (f64.const nan)) "invalid conversion to integer") +(assert_trap (invoke "i64.trunc_f64_u" (f64.const nan:0x4000000000000)) "invalid conversion to integer") +(assert_trap (invoke "i64.trunc_f64_u" (f64.const -nan)) "invalid conversion to integer") +(assert_trap (invoke "i64.trunc_f64_u" (f64.const -nan:0x4000000000000)) "invalid conversion to integer") + +(assert_return (invoke "f32.convert_i32_s" (i32.const 1)) (f32.const 1.0)) +(assert_return (invoke "f32.convert_i32_s" (i32.const -1)) (f32.const -1.0)) +(assert_return (invoke "f32.convert_i32_s" (i32.const 0)) (f32.const 0.0)) +(assert_return (invoke "f32.convert_i32_s" (i32.const 2147483647)) (f32.const 2147483648)) +(assert_return (invoke "f32.convert_i32_s" (i32.const -2147483648)) (f32.const -2147483648)) +(assert_return (invoke "f32.convert_i32_s" (i32.const 1234567890)) (f32.const 0x1.26580cp+30)) + +;; Saturating conversions: test all the same values as the non-saturating conversions. + +(assert_return (invoke "i32.trunc_sat_f32_s" (f32.const 0.0)) (i32.const 0)) +(assert_return (invoke "i32.trunc_sat_f32_s" (f32.const -0.0)) (i32.const 0)) +(assert_return (invoke "i32.trunc_sat_f32_s" (f32.const 0x1p-149)) (i32.const 0)) +(assert_return (invoke "i32.trunc_sat_f32_s" (f32.const -0x1p-149)) (i32.const 0)) +(assert_return (invoke "i32.trunc_sat_f32_s" (f32.const 1.0)) (i32.const 1)) +(assert_return (invoke "i32.trunc_sat_f32_s" (f32.const 0x1.19999ap+0)) (i32.const 1)) +(assert_return (invoke "i32.trunc_sat_f32_s" (f32.const 1.5)) (i32.const 1)) +(assert_return (invoke "i32.trunc_sat_f32_s" (f32.const -1.0)) (i32.const -1)) +(assert_return (invoke "i32.trunc_sat_f32_s" (f32.const -0x1.19999ap+0)) (i32.const -1)) +(assert_return (invoke "i32.trunc_sat_f32_s" (f32.const -1.5)) (i32.const -1)) +(assert_return (invoke "i32.trunc_sat_f32_s" (f32.const -1.9)) (i32.const -1)) +(assert_return (invoke "i32.trunc_sat_f32_s" (f32.const -2.0)) (i32.const -2)) +(assert_return (invoke "i32.trunc_sat_f32_s" (f32.const 2147483520.0)) (i32.const 2147483520)) +(assert_return (invoke "i32.trunc_sat_f32_s" (f32.const -2147483648.0)) (i32.const -2147483648)) +(assert_return (invoke "i32.trunc_sat_f32_s" (f32.const 2147483648.0)) (i32.const 0x7fffffff)) +(assert_return (invoke "i32.trunc_sat_f32_s" (f32.const -2147483904.0)) (i32.const 0x80000000)) +(assert_return (invoke "i32.trunc_sat_f32_s" (f32.const inf)) (i32.const 0x7fffffff)) +(assert_return (invoke "i32.trunc_sat_f32_s" (f32.const -inf)) (i32.const 0x80000000)) +(assert_return (invoke "i32.trunc_sat_f32_s" (f32.const nan)) (i32.const 0)) +(assert_return (invoke "i32.trunc_sat_f32_s" (f32.const nan:0x200000)) (i32.const 0)) +(assert_return (invoke "i32.trunc_sat_f32_s" (f32.const -nan)) (i32.const 0)) +(assert_return (invoke "i32.trunc_sat_f32_s" (f32.const -nan:0x200000)) (i32.const 0)) + +(assert_return (invoke "i32.trunc_sat_f32_u" (f32.const 0.0)) (i32.const 0)) +(assert_return (invoke "i32.trunc_sat_f32_u" (f32.const -0.0)) (i32.const 0)) +(assert_return (invoke "i32.trunc_sat_f32_u" (f32.const 0x1p-149)) (i32.const 0)) +(assert_return (invoke "i32.trunc_sat_f32_u" (f32.const -0x1p-149)) (i32.const 0)) +(assert_return (invoke "i32.trunc_sat_f32_u" (f32.const 1.0)) (i32.const 1)) +(assert_return (invoke "i32.trunc_sat_f32_u" (f32.const 0x1.19999ap+0)) (i32.const 1)) +(assert_return (invoke "i32.trunc_sat_f32_u" (f32.const 1.5)) (i32.const 1)) +(assert_return (invoke "i32.trunc_sat_f32_u" (f32.const 1.9)) (i32.const 1)) +(assert_return (invoke "i32.trunc_sat_f32_u" (f32.const 2.0)) (i32.const 2)) +(assert_return (invoke "i32.trunc_sat_f32_u" (f32.const 2147483648)) (i32.const -2147483648)) ;; 0x1.00000p+31 -> 8000 0000 +(assert_return (invoke "i32.trunc_sat_f32_u" (f32.const 4294967040.0)) (i32.const -256)) +(assert_return (invoke "i32.trunc_sat_f32_u" (f32.const -0x1.ccccccp-1)) (i32.const 0)) +(assert_return (invoke "i32.trunc_sat_f32_u" (f32.const -0x1.fffffep-1)) (i32.const 0)) +(assert_return (invoke "i32.trunc_sat_f32_u" (f32.const 4294967296.0)) (i32.const 0xffffffff)) +(assert_return (invoke "i32.trunc_sat_f32_u" (f32.const -1.0)) (i32.const 0x00000000)) +(assert_return (invoke "i32.trunc_sat_f32_u" (f32.const inf)) (i32.const 0xffffffff)) +(assert_return (invoke "i32.trunc_sat_f32_u" (f32.const -inf)) (i32.const 0x00000000)) +(assert_return (invoke "i32.trunc_sat_f32_u" (f32.const nan)) (i32.const 0)) +(assert_return (invoke "i32.trunc_sat_f32_u" (f32.const nan:0x200000)) (i32.const 0)) +(assert_return (invoke "i32.trunc_sat_f32_u" (f32.const -nan)) (i32.const 0)) +(assert_return (invoke "i32.trunc_sat_f32_u" (f32.const -nan:0x200000)) (i32.const 0)) + +(assert_return (invoke "i32.trunc_sat_f64_s" (f64.const 0.0)) (i32.const 0)) +(assert_return (invoke "i32.trunc_sat_f64_s" (f64.const -0.0)) (i32.const 0)) +(assert_return (invoke "i32.trunc_sat_f64_s" (f64.const 0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "i32.trunc_sat_f64_s" (f64.const -0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "i32.trunc_sat_f64_s" (f64.const 1.0)) (i32.const 1)) +(assert_return (invoke "i32.trunc_sat_f64_s" (f64.const 0x1.199999999999ap+0)) (i32.const 1)) +(assert_return (invoke "i32.trunc_sat_f64_s" (f64.const 1.5)) (i32.const 1)) +(assert_return (invoke "i32.trunc_sat_f64_s" (f64.const -1.0)) (i32.const -1)) +(assert_return (invoke "i32.trunc_sat_f64_s" (f64.const -0x1.199999999999ap+0)) (i32.const -1)) +(assert_return (invoke "i32.trunc_sat_f64_s" (f64.const -1.5)) (i32.const -1)) +(assert_return (invoke "i32.trunc_sat_f64_s" (f64.const -1.9)) (i32.const -1)) +(assert_return (invoke "i32.trunc_sat_f64_s" (f64.const -2.0)) (i32.const -2)) +(assert_return (invoke "i32.trunc_sat_f64_s" (f64.const 2147483647.0)) (i32.const 2147483647)) +(assert_return (invoke "i32.trunc_sat_f64_s" (f64.const -2147483648.0)) (i32.const -2147483648)) +(assert_return (invoke "i32.trunc_sat_f64_s" (f64.const 2147483648.0)) (i32.const 0x7fffffff)) +(assert_return (invoke "i32.trunc_sat_f64_s" (f64.const -2147483649.0)) (i32.const 0x80000000)) +(assert_return (invoke "i32.trunc_sat_f64_s" (f64.const inf)) (i32.const 0x7fffffff)) +(assert_return (invoke "i32.trunc_sat_f64_s" (f64.const -inf)) (i32.const 0x80000000)) +(assert_return (invoke "i32.trunc_sat_f64_s" (f64.const nan)) (i32.const 0)) +(assert_return (invoke "i32.trunc_sat_f64_s" (f64.const nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "i32.trunc_sat_f64_s" (f64.const -nan)) (i32.const 0)) +(assert_return (invoke "i32.trunc_sat_f64_s" (f64.const -nan:0x4000000000000)) (i32.const 0)) + +(assert_return (invoke "i32.trunc_sat_f64_u" (f64.const 0.0)) (i32.const 0)) +(assert_return (invoke "i32.trunc_sat_f64_u" (f64.const -0.0)) (i32.const 0)) +(assert_return (invoke "i32.trunc_sat_f64_u" (f64.const 0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "i32.trunc_sat_f64_u" (f64.const -0x0.0000000000001p-1022)) (i32.const 0)) +(assert_return (invoke "i32.trunc_sat_f64_u" (f64.const 1.0)) (i32.const 1)) +(assert_return (invoke "i32.trunc_sat_f64_u" (f64.const 0x1.199999999999ap+0)) (i32.const 1)) +(assert_return (invoke "i32.trunc_sat_f64_u" (f64.const 1.5)) (i32.const 1)) +(assert_return (invoke "i32.trunc_sat_f64_u" (f64.const 1.9)) (i32.const 1)) +(assert_return (invoke "i32.trunc_sat_f64_u" (f64.const 2.0)) (i32.const 2)) +(assert_return (invoke "i32.trunc_sat_f64_u" (f64.const 2147483648)) (i32.const -2147483648)) ;; 0x1.00000p+31 -> 8000 0000 +(assert_return (invoke "i32.trunc_sat_f64_u" (f64.const 4294967295.0)) (i32.const -1)) +(assert_return (invoke "i32.trunc_sat_f64_u" (f64.const -0x1.ccccccccccccdp-1)) (i32.const 0)) +(assert_return (invoke "i32.trunc_sat_f64_u" (f64.const -0x1.fffffffffffffp-1)) (i32.const 0)) +(assert_return (invoke "i32.trunc_sat_f64_u" (f64.const 1e8)) (i32.const 100000000)) +(assert_return (invoke "i32.trunc_sat_f64_u" (f64.const 4294967296.0)) (i32.const 0xffffffff)) +(assert_return (invoke "i32.trunc_sat_f64_u" (f64.const -1.0)) (i32.const 0x00000000)) +(assert_return (invoke "i32.trunc_sat_f64_u" (f64.const 1e16)) (i32.const 0xffffffff)) +(assert_return (invoke "i32.trunc_sat_f64_u" (f64.const 1e30)) (i32.const 0xffffffff)) +(assert_return (invoke "i32.trunc_sat_f64_u" (f64.const 9223372036854775808)) (i32.const 0xffffffff)) +(assert_return (invoke "i32.trunc_sat_f64_u" (f64.const inf)) (i32.const 0xffffffff)) +(assert_return (invoke "i32.trunc_sat_f64_u" (f64.const -inf)) (i32.const 0x00000000)) +(assert_return (invoke "i32.trunc_sat_f64_u" (f64.const nan)) (i32.const 0)) +(assert_return (invoke "i32.trunc_sat_f64_u" (f64.const nan:0x4000000000000)) (i32.const 0)) +(assert_return (invoke "i32.trunc_sat_f64_u" (f64.const -nan)) (i32.const 0)) +(assert_return (invoke "i32.trunc_sat_f64_u" (f64.const -nan:0x4000000000000)) (i32.const 0)) + +(assert_return (invoke "i64.trunc_sat_f32_s" (f32.const 0.0)) (i64.const 0)) +(assert_return (invoke "i64.trunc_sat_f32_s" (f32.const -0.0)) (i64.const 0)) +(assert_return (invoke "i64.trunc_sat_f32_s" (f32.const 0x1p-149)) (i64.const 0)) +(assert_return (invoke "i64.trunc_sat_f32_s" (f32.const -0x1p-149)) (i64.const 0)) +(assert_return (invoke "i64.trunc_sat_f32_s" (f32.const 1.0)) (i64.const 1)) +(assert_return (invoke "i64.trunc_sat_f32_s" (f32.const 0x1.19999ap+0)) (i64.const 1)) +(assert_return (invoke "i64.trunc_sat_f32_s" (f32.const 1.5)) (i64.const 1)) +(assert_return (invoke "i64.trunc_sat_f32_s" (f32.const -1.0)) (i64.const -1)) +(assert_return (invoke "i64.trunc_sat_f32_s" (f32.const -0x1.19999ap+0)) (i64.const -1)) +(assert_return (invoke "i64.trunc_sat_f32_s" (f32.const -1.5)) (i64.const -1)) +(assert_return (invoke "i64.trunc_sat_f32_s" (f32.const -1.9)) (i64.const -1)) +(assert_return (invoke "i64.trunc_sat_f32_s" (f32.const -2.0)) (i64.const -2)) +(assert_return (invoke "i64.trunc_sat_f32_s" (f32.const 4294967296)) (i64.const 4294967296)) ;; 0x1.00000p+32 -> 1 0000 0000 +(assert_return (invoke "i64.trunc_sat_f32_s" (f32.const -4294967296)) (i64.const -4294967296)) ;; -0x1.00000p+32 -> ffff ffff 0000 0000 +(assert_return (invoke "i64.trunc_sat_f32_s" (f32.const 9223371487098961920.0)) (i64.const 9223371487098961920)) +(assert_return (invoke "i64.trunc_sat_f32_s" (f32.const -9223372036854775808.0)) (i64.const -9223372036854775808)) +(assert_return (invoke "i64.trunc_sat_f32_s" (f32.const 9223372036854775808.0)) (i64.const 0x7fffffffffffffff)) +(assert_return (invoke "i64.trunc_sat_f32_s" (f32.const -9223373136366403584.0)) (i64.const 0x8000000000000000)) +(assert_return (invoke "i64.trunc_sat_f32_s" (f32.const inf)) (i64.const 0x7fffffffffffffff)) +(assert_return (invoke "i64.trunc_sat_f32_s" (f32.const -inf)) (i64.const 0x8000000000000000)) +(assert_return (invoke "i64.trunc_sat_f32_s" (f32.const nan)) (i64.const 0)) +(assert_return (invoke "i64.trunc_sat_f32_s" (f32.const nan:0x200000)) (i64.const 0)) +(assert_return (invoke "i64.trunc_sat_f32_s" (f32.const -nan)) (i64.const 0)) +(assert_return (invoke "i64.trunc_sat_f32_s" (f32.const -nan:0x200000)) (i64.const 0)) + +(assert_return (invoke "i64.trunc_sat_f32_u" (f32.const 0.0)) (i64.const 0)) +(assert_return (invoke "i64.trunc_sat_f32_u" (f32.const -0.0)) (i64.const 0)) +(assert_return (invoke "i64.trunc_sat_f32_u" (f32.const 0x1p-149)) (i64.const 0)) +(assert_return (invoke "i64.trunc_sat_f32_u" (f32.const -0x1p-149)) (i64.const 0)) +(assert_return (invoke "i64.trunc_sat_f32_u" (f32.const 1.0)) (i64.const 1)) +(assert_return (invoke "i64.trunc_sat_f32_u" (f32.const 0x1.19999ap+0)) (i64.const 1)) +(assert_return (invoke "i64.trunc_sat_f32_u" (f32.const 1.5)) (i64.const 1)) +(assert_return (invoke "i64.trunc_sat_f32_u" (f32.const 4294967296)) (i64.const 4294967296)) +(assert_return (invoke "i64.trunc_sat_f32_u" (f32.const 18446742974197923840.0)) (i64.const -1099511627776)) +(assert_return (invoke "i64.trunc_sat_f32_u" (f32.const -0x1.ccccccp-1)) (i64.const 0)) +(assert_return (invoke "i64.trunc_sat_f32_u" (f32.const -0x1.fffffep-1)) (i64.const 0)) +(assert_return (invoke "i64.trunc_sat_f32_u" (f32.const 18446744073709551616.0)) (i64.const 0xffffffffffffffff)) +(assert_return (invoke "i64.trunc_sat_f32_u" (f32.const -1.0)) (i64.const 0x0000000000000000)) +(assert_return (invoke "i64.trunc_sat_f32_u" (f32.const inf)) (i64.const 0xffffffffffffffff)) +(assert_return (invoke "i64.trunc_sat_f32_u" (f32.const -inf)) (i64.const 0x0000000000000000)) +(assert_return (invoke "i64.trunc_sat_f32_u" (f32.const nan)) (i64.const 0)) +(assert_return (invoke "i64.trunc_sat_f32_u" (f32.const nan:0x200000)) (i64.const 0)) +(assert_return (invoke "i64.trunc_sat_f32_u" (f32.const -nan)) (i64.const 0)) +(assert_return (invoke "i64.trunc_sat_f32_u" (f32.const -nan:0x200000)) (i64.const 0)) + +(assert_return (invoke "i64.trunc_sat_f64_s" (f64.const 0.0)) (i64.const 0)) +(assert_return (invoke "i64.trunc_sat_f64_s" (f64.const -0.0)) (i64.const 0)) +(assert_return (invoke "i64.trunc_sat_f64_s" (f64.const 0x0.0000000000001p-1022)) (i64.const 0)) +(assert_return (invoke "i64.trunc_sat_f64_s" (f64.const -0x0.0000000000001p-1022)) (i64.const 0)) +(assert_return (invoke "i64.trunc_sat_f64_s" (f64.const 1.0)) (i64.const 1)) +(assert_return (invoke "i64.trunc_sat_f64_s" (f64.const 0x1.199999999999ap+0)) (i64.const 1)) +(assert_return (invoke "i64.trunc_sat_f64_s" (f64.const 1.5)) (i64.const 1)) +(assert_return (invoke "i64.trunc_sat_f64_s" (f64.const -1.0)) (i64.const -1)) +(assert_return (invoke "i64.trunc_sat_f64_s" (f64.const -0x1.199999999999ap+0)) (i64.const -1)) +(assert_return (invoke "i64.trunc_sat_f64_s" (f64.const -1.5)) (i64.const -1)) +(assert_return (invoke "i64.trunc_sat_f64_s" (f64.const -1.9)) (i64.const -1)) +(assert_return (invoke "i64.trunc_sat_f64_s" (f64.const -2.0)) (i64.const -2)) +(assert_return (invoke "i64.trunc_sat_f64_s" (f64.const 4294967296)) (i64.const 4294967296)) ;; 0x1.00000p+32 -> 1 0000 0000 +(assert_return (invoke "i64.trunc_sat_f64_s" (f64.const -4294967296)) (i64.const -4294967296)) ;; -0x1.00000p+32 -> ffff ffff 0000 0000 +(assert_return (invoke "i64.trunc_sat_f64_s" (f64.const 9223372036854774784.0)) (i64.const 9223372036854774784)) +(assert_return (invoke "i64.trunc_sat_f64_s" (f64.const -9223372036854775808.0)) (i64.const -9223372036854775808)) +(assert_return (invoke "i64.trunc_sat_f64_s" (f64.const 9223372036854775808.0)) (i64.const 0x7fffffffffffffff)) +(assert_return (invoke "i64.trunc_sat_f64_s" (f64.const -9223372036854777856.0)) (i64.const 0x8000000000000000)) +(assert_return (invoke "i64.trunc_sat_f64_s" (f64.const inf)) (i64.const 0x7fffffffffffffff)) +(assert_return (invoke "i64.trunc_sat_f64_s" (f64.const -inf)) (i64.const 0x8000000000000000)) +(assert_return (invoke "i64.trunc_sat_f64_s" (f64.const nan)) (i64.const 0)) +(assert_return (invoke "i64.trunc_sat_f64_s" (f64.const nan:0x4000000000000)) (i64.const 0)) +(assert_return (invoke "i64.trunc_sat_f64_s" (f64.const -nan)) (i64.const 0)) +(assert_return (invoke "i64.trunc_sat_f64_s" (f64.const -nan:0x4000000000000)) (i64.const 0)) + +(assert_return (invoke "i64.trunc_sat_f64_u" (f64.const 0.0)) (i64.const 0)) +(assert_return (invoke "i64.trunc_sat_f64_u" (f64.const -0.0)) (i64.const 0)) +(assert_return (invoke "i64.trunc_sat_f64_u" (f64.const 0x0.0000000000001p-1022)) (i64.const 0)) +(assert_return (invoke "i64.trunc_sat_f64_u" (f64.const -0x0.0000000000001p-1022)) (i64.const 0)) +(assert_return (invoke "i64.trunc_sat_f64_u" (f64.const 1.0)) (i64.const 1)) +(assert_return (invoke "i64.trunc_sat_f64_u" (f64.const 0x1.199999999999ap+0)) (i64.const 1)) +(assert_return (invoke "i64.trunc_sat_f64_u" (f64.const 1.5)) (i64.const 1)) +(assert_return (invoke "i64.trunc_sat_f64_u" (f64.const 4294967295)) (i64.const 0xffffffff)) +(assert_return (invoke "i64.trunc_sat_f64_u" (f64.const 4294967296)) (i64.const 0x100000000)) +(assert_return (invoke "i64.trunc_sat_f64_u" (f64.const 18446744073709549568.0)) (i64.const -2048)) +(assert_return (invoke "i64.trunc_sat_f64_u" (f64.const -0x1.ccccccccccccdp-1)) (i64.const 0)) +(assert_return (invoke "i64.trunc_sat_f64_u" (f64.const -0x1.fffffffffffffp-1)) (i64.const 0)) +(assert_return (invoke "i64.trunc_sat_f64_u" (f64.const 1e8)) (i64.const 100000000)) +(assert_return (invoke "i64.trunc_sat_f64_u" (f64.const 1e16)) (i64.const 10000000000000000)) +(assert_return (invoke "i64.trunc_sat_f64_u" (f64.const 9223372036854775808)) (i64.const -9223372036854775808)) +(assert_return (invoke "i64.trunc_sat_f64_u" (f64.const 18446744073709551616.0)) (i64.const 0xffffffffffffffff)) +(assert_return (invoke "i64.trunc_sat_f64_u" (f64.const -1.0)) (i64.const 0x0000000000000000)) +(assert_return (invoke "i64.trunc_sat_f64_u" (f64.const inf)) (i64.const 0xffffffffffffffff)) +(assert_return (invoke "i64.trunc_sat_f64_u" (f64.const -inf)) (i64.const 0x0000000000000000)) +(assert_return (invoke "i64.trunc_sat_f64_u" (f64.const nan)) (i64.const 0)) +(assert_return (invoke "i64.trunc_sat_f64_u" (f64.const nan:0x4000000000000)) (i64.const 0)) +(assert_return (invoke "i64.trunc_sat_f64_u" (f64.const -nan)) (i64.const 0)) +(assert_return (invoke "i64.trunc_sat_f64_u" (f64.const -nan:0x4000000000000)) (i64.const 0)) + +;; Test rounding directions. +(assert_return (invoke "f32.convert_i32_s" (i32.const 16777217)) (f32.const 16777216.0)) +(assert_return (invoke "f32.convert_i32_s" (i32.const -16777217)) (f32.const -16777216.0)) +(assert_return (invoke "f32.convert_i32_s" (i32.const 16777219)) (f32.const 16777220.0)) +(assert_return (invoke "f32.convert_i32_s" (i32.const -16777219)) (f32.const -16777220.0)) + +(assert_return (invoke "f32.convert_i64_s" (i64.const 1)) (f32.const 1.0)) +(assert_return (invoke "f32.convert_i64_s" (i64.const -1)) (f32.const -1.0)) +(assert_return (invoke "f32.convert_i64_s" (i64.const 0)) (f32.const 0.0)) +(assert_return (invoke "f32.convert_i64_s" (i64.const 9223372036854775807)) (f32.const 9223372036854775807)) +(assert_return (invoke "f32.convert_i64_s" (i64.const -9223372036854775808)) (f32.const -9223372036854775808)) +(assert_return (invoke "f32.convert_i64_s" (i64.const 314159265358979)) (f32.const 0x1.1db9e8p+48)) ;; PI +;; Test rounding directions. +(assert_return (invoke "f32.convert_i64_s" (i64.const 16777217)) (f32.const 16777216.0)) +(assert_return (invoke "f32.convert_i64_s" (i64.const -16777217)) (f32.const -16777216.0)) +(assert_return (invoke "f32.convert_i64_s" (i64.const 16777219)) (f32.const 16777220.0)) +(assert_return (invoke "f32.convert_i64_s" (i64.const -16777219)) (f32.const -16777220.0)) + +(assert_return (invoke "f32.convert_i64_s" (i64.const 0x7fffff4000000001)) (f32.const 0x1.fffffep+62)) +(assert_return (invoke "f32.convert_i64_s" (i64.const 0x8000004000000001)) (f32.const -0x1.fffffep+62)) +(assert_return (invoke "f32.convert_i64_s" (i64.const 0x0020000020000001)) (f32.const 0x1.000002p+53)) +(assert_return (invoke "f32.convert_i64_s" (i64.const 0xffdfffffdfffffff)) (f32.const -0x1.000002p+53)) + +(assert_return (invoke "f64.convert_i32_s" (i32.const 1)) (f64.const 1.0)) +(assert_return (invoke "f64.convert_i32_s" (i32.const -1)) (f64.const -1.0)) +(assert_return (invoke "f64.convert_i32_s" (i32.const 0)) (f64.const 0.0)) +(assert_return (invoke "f64.convert_i32_s" (i32.const 2147483647)) (f64.const 2147483647)) +(assert_return (invoke "f64.convert_i32_s" (i32.const -2147483648)) (f64.const -2147483648)) +(assert_return (invoke "f64.convert_i32_s" (i32.const 987654321)) (f64.const 987654321)) + +(assert_return (invoke "f64.convert_i64_s" (i64.const 1)) (f64.const 1.0)) +(assert_return (invoke "f64.convert_i64_s" (i64.const -1)) (f64.const -1.0)) +(assert_return (invoke "f64.convert_i64_s" (i64.const 0)) (f64.const 0.0)) +(assert_return (invoke "f64.convert_i64_s" (i64.const 9223372036854775807)) (f64.const 9223372036854775807)) +(assert_return (invoke "f64.convert_i64_s" (i64.const -9223372036854775808)) (f64.const -9223372036854775808)) +(assert_return (invoke "f64.convert_i64_s" (i64.const 4669201609102990)) (f64.const 4669201609102990)) ;; Feigenbaum +;; Test rounding directions. +(assert_return (invoke "f64.convert_i64_s" (i64.const 9007199254740993)) (f64.const 9007199254740992)) +(assert_return (invoke "f64.convert_i64_s" (i64.const -9007199254740993)) (f64.const -9007199254740992)) +(assert_return (invoke "f64.convert_i64_s" (i64.const 9007199254740995)) (f64.const 9007199254740996)) +(assert_return (invoke "f64.convert_i64_s" (i64.const -9007199254740995)) (f64.const -9007199254740996)) + +(assert_return (invoke "f32.convert_i32_u" (i32.const 1)) (f32.const 1.0)) +(assert_return (invoke "f32.convert_i32_u" (i32.const 0)) (f32.const 0.0)) +(assert_return (invoke "f32.convert_i32_u" (i32.const 2147483647)) (f32.const 2147483648)) +(assert_return (invoke "f32.convert_i32_u" (i32.const -2147483648)) (f32.const 2147483648)) +(assert_return (invoke "f32.convert_i32_u" (i32.const 0x12345678)) (f32.const 0x1.234568p+28)) +(assert_return (invoke "f32.convert_i32_u" (i32.const 0xffffffff)) (f32.const 4294967296.0)) +(assert_return (invoke "f32.convert_i32_u" (i32.const 0x80000080)) (f32.const 0x1.000000p+31)) +(assert_return (invoke "f32.convert_i32_u" (i32.const 0x80000081)) (f32.const 0x1.000002p+31)) +(assert_return (invoke "f32.convert_i32_u" (i32.const 0x80000082)) (f32.const 0x1.000002p+31)) +(assert_return (invoke "f32.convert_i32_u" (i32.const 0xfffffe80)) (f32.const 0x1.fffffcp+31)) +(assert_return (invoke "f32.convert_i32_u" (i32.const 0xfffffe81)) (f32.const 0x1.fffffep+31)) +(assert_return (invoke "f32.convert_i32_u" (i32.const 0xfffffe82)) (f32.const 0x1.fffffep+31)) +;; Test rounding directions. +(assert_return (invoke "f32.convert_i32_u" (i32.const 16777217)) (f32.const 16777216.0)) +(assert_return (invoke "f32.convert_i32_u" (i32.const 16777219)) (f32.const 16777220.0)) + +(assert_return (invoke "f32.convert_i64_u" (i64.const 1)) (f32.const 1.0)) +(assert_return (invoke "f32.convert_i64_u" (i64.const 0)) (f32.const 0.0)) +(assert_return (invoke "f32.convert_i64_u" (i64.const 9223372036854775807)) (f32.const 9223372036854775807)) +(assert_return (invoke "f32.convert_i64_u" (i64.const -9223372036854775808)) (f32.const 9223372036854775808)) +(assert_return (invoke "f32.convert_i64_u" (i64.const 0xffffffffffffffff)) (f32.const 18446744073709551616.0)) +;; Test rounding directions. +(assert_return (invoke "f32.convert_i64_u" (i64.const 16777217)) (f32.const 16777216.0)) +(assert_return (invoke "f32.convert_i64_u" (i64.const 16777219)) (f32.const 16777220.0)) + +(assert_return (invoke "f32.convert_i64_u" (i64.const 0x0020000020000001)) (f32.const 0x1.000002p+53)) +(assert_return (invoke "f32.convert_i64_u" (i64.const 0x7fffffbfffffffff)) (f32.const 0x1.fffffep+62)) +(assert_return (invoke "f32.convert_i64_u" (i64.const 0x8000008000000001)) (f32.const 0x1.000002p+63)) +(assert_return (invoke "f32.convert_i64_u" (i64.const 0xfffffe8000000001)) (f32.const 0x1.fffffep+63)) + +(assert_return (invoke "f64.convert_i32_u" (i32.const 1)) (f64.const 1.0)) +(assert_return (invoke "f64.convert_i32_u" (i32.const 0)) (f64.const 0.0)) +(assert_return (invoke "f64.convert_i32_u" (i32.const 2147483647)) (f64.const 2147483647)) +(assert_return (invoke "f64.convert_i32_u" (i32.const -2147483648)) (f64.const 2147483648)) +(assert_return (invoke "f64.convert_i32_u" (i32.const 0xffffffff)) (f64.const 4294967295.0)) + +(assert_return (invoke "f64.convert_i64_u" (i64.const 1)) (f64.const 1.0)) +(assert_return (invoke "f64.convert_i64_u" (i64.const 0)) (f64.const 0.0)) +(assert_return (invoke "f64.convert_i64_u" (i64.const 9223372036854775807)) (f64.const 9223372036854775807)) +(assert_return (invoke "f64.convert_i64_u" (i64.const -9223372036854775808)) (f64.const 9223372036854775808)) +(assert_return (invoke "f64.convert_i64_u" (i64.const 0xffffffffffffffff)) (f64.const 18446744073709551616.0)) +(assert_return (invoke "f64.convert_i64_u" (i64.const 0x8000000000000400)) (f64.const 0x1.0000000000000p+63)) +(assert_return (invoke "f64.convert_i64_u" (i64.const 0x8000000000000401)) (f64.const 0x1.0000000000001p+63)) +(assert_return (invoke "f64.convert_i64_u" (i64.const 0x8000000000000402)) (f64.const 0x1.0000000000001p+63)) +(assert_return (invoke "f64.convert_i64_u" (i64.const 0xfffffffffffff400)) (f64.const 0x1.ffffffffffffep+63)) +(assert_return (invoke "f64.convert_i64_u" (i64.const 0xfffffffffffff401)) (f64.const 0x1.fffffffffffffp+63)) +(assert_return (invoke "f64.convert_i64_u" (i64.const 0xfffffffffffff402)) (f64.const 0x1.fffffffffffffp+63)) +;; Test rounding directions. +(assert_return (invoke "f64.convert_i64_u" (i64.const 9007199254740993)) (f64.const 9007199254740992)) +(assert_return (invoke "f64.convert_i64_u" (i64.const 9007199254740995)) (f64.const 9007199254740996)) + +(assert_return (invoke "f64.promote_f32" (f32.const 0.0)) (f64.const 0.0)) +(assert_return (invoke "f64.promote_f32" (f32.const -0.0)) (f64.const -0.0)) +(assert_return (invoke "f64.promote_f32" (f32.const 0x1p-149)) (f64.const 0x1p-149)) +(assert_return (invoke "f64.promote_f32" (f32.const -0x1p-149)) (f64.const -0x1p-149)) +(assert_return (invoke "f64.promote_f32" (f32.const 1.0)) (f64.const 1.0)) +(assert_return (invoke "f64.promote_f32" (f32.const -1.0)) (f64.const -1.0)) +(assert_return (invoke "f64.promote_f32" (f32.const -0x1.fffffep+127)) (f64.const -0x1.fffffep+127)) +(assert_return (invoke "f64.promote_f32" (f32.const 0x1.fffffep+127)) (f64.const 0x1.fffffep+127)) +;; Generated randomly by picking a random int and reinterpret it to float. +(assert_return (invoke "f64.promote_f32" (f32.const 0x1p-119)) (f64.const 0x1p-119)) +;; Generated randomly by picking a random float. +(assert_return (invoke "f64.promote_f32" (f32.const 0x1.8f867ep+125)) (f64.const 6.6382536710104395e+37)) +(assert_return (invoke "f64.promote_f32" (f32.const inf)) (f64.const inf)) +(assert_return (invoke "f64.promote_f32" (f32.const -inf)) (f64.const -inf)) +(assert_return (invoke "f64.promote_f32" (f32.const nan)) (f64.const nan:canonical)) +(assert_return (invoke "f64.promote_f32" (f32.const nan:0x200000)) (f64.const nan:arithmetic)) +(assert_return (invoke "f64.promote_f32" (f32.const -nan)) (f64.const nan:canonical)) +(assert_return (invoke "f64.promote_f32" (f32.const -nan:0x200000)) (f64.const nan:arithmetic)) + +(assert_return (invoke "f32.demote_f64" (f64.const 0.0)) (f32.const 0.0)) +(assert_return (invoke "f32.demote_f64" (f64.const -0.0)) (f32.const -0.0)) +(assert_return (invoke "f32.demote_f64" (f64.const 0x0.0000000000001p-1022)) (f32.const 0.0)) +(assert_return (invoke "f32.demote_f64" (f64.const -0x0.0000000000001p-1022)) (f32.const -0.0)) +(assert_return (invoke "f32.demote_f64" (f64.const 1.0)) (f32.const 1.0)) +(assert_return (invoke "f32.demote_f64" (f64.const -1.0)) (f32.const -1.0)) +(assert_return (invoke "f32.demote_f64" (f64.const 0x1.fffffe0000000p-127)) (f32.const 0x1p-126)) +(assert_return (invoke "f32.demote_f64" (f64.const -0x1.fffffe0000000p-127)) (f32.const -0x1p-126)) +(assert_return (invoke "f32.demote_f64" (f64.const 0x1.fffffdfffffffp-127)) (f32.const 0x1.fffffcp-127)) +(assert_return (invoke "f32.demote_f64" (f64.const -0x1.fffffdfffffffp-127)) (f32.const -0x1.fffffcp-127)) +(assert_return (invoke "f32.demote_f64" (f64.const 0x1p-149)) (f32.const 0x1p-149)) +(assert_return (invoke "f32.demote_f64" (f64.const -0x1p-149)) (f32.const -0x1p-149)) +(assert_return (invoke "f32.demote_f64" (f64.const 0x1.fffffd0000000p+127)) (f32.const 0x1.fffffcp+127)) +(assert_return (invoke "f32.demote_f64" (f64.const -0x1.fffffd0000000p+127)) (f32.const -0x1.fffffcp+127)) +(assert_return (invoke "f32.demote_f64" (f64.const 0x1.fffffd0000001p+127)) (f32.const 0x1.fffffep+127)) +(assert_return (invoke "f32.demote_f64" (f64.const -0x1.fffffd0000001p+127)) (f32.const -0x1.fffffep+127)) +(assert_return (invoke "f32.demote_f64" (f64.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127)) +(assert_return (invoke "f32.demote_f64" (f64.const -0x1.fffffep+127)) (f32.const -0x1.fffffep+127)) +(assert_return (invoke "f32.demote_f64" (f64.const 0x1.fffffefffffffp+127)) (f32.const 0x1.fffffep+127)) +(assert_return (invoke "f32.demote_f64" (f64.const -0x1.fffffefffffffp+127)) (f32.const -0x1.fffffep+127)) +(assert_return (invoke "f32.demote_f64" (f64.const 0x1.ffffffp+127)) (f32.const inf)) +(assert_return (invoke "f32.demote_f64" (f64.const -0x1.ffffffp+127)) (f32.const -inf)) +(assert_return (invoke "f32.demote_f64" (f64.const 0x1p-119)) (f32.const 0x1p-119)) +(assert_return (invoke "f32.demote_f64" (f64.const 0x1.8f867ep+125)) (f32.const 0x1.8f867ep+125)) +(assert_return (invoke "f32.demote_f64" (f64.const inf)) (f32.const inf)) +(assert_return (invoke "f32.demote_f64" (f64.const -inf)) (f32.const -inf)) +(assert_return (invoke "f32.demote_f64" (f64.const 0x1.0000000000001p+0)) (f32.const 1.0)) +(assert_return (invoke "f32.demote_f64" (f64.const 0x1.fffffffffffffp-1)) (f32.const 1.0)) +(assert_return (invoke "f32.demote_f64" (f64.const 0x1.0000010000000p+0)) (f32.const 0x1.000000p+0)) +(assert_return (invoke "f32.demote_f64" (f64.const 0x1.0000010000001p+0)) (f32.const 0x1.000002p+0)) +(assert_return (invoke "f32.demote_f64" (f64.const 0x1.000002fffffffp+0)) (f32.const 0x1.000002p+0)) +(assert_return (invoke "f32.demote_f64" (f64.const 0x1.0000030000000p+0)) (f32.const 0x1.000004p+0)) +(assert_return (invoke "f32.demote_f64" (f64.const 0x1.0000050000000p+0)) (f32.const 0x1.000004p+0)) +(assert_return (invoke "f32.demote_f64" (f64.const 0x1.0000010000000p+24)) (f32.const 0x1.0p+24)) +(assert_return (invoke "f32.demote_f64" (f64.const 0x1.0000010000001p+24)) (f32.const 0x1.000002p+24)) +(assert_return (invoke "f32.demote_f64" (f64.const 0x1.000002fffffffp+24)) (f32.const 0x1.000002p+24)) +(assert_return (invoke "f32.demote_f64" (f64.const 0x1.0000030000000p+24)) (f32.const 0x1.000004p+24)) +(assert_return (invoke "f32.demote_f64" (f64.const 0x1.4eae4f7024c7p+108)) (f32.const 0x1.4eae5p+108)) +(assert_return (invoke "f32.demote_f64" (f64.const 0x1.a12e71e358685p-113)) (f32.const 0x1.a12e72p-113)) +(assert_return (invoke "f32.demote_f64" (f64.const 0x1.cb98354d521ffp-127)) (f32.const 0x1.cb9834p-127)) +(assert_return (invoke "f32.demote_f64" (f64.const -0x1.6972b30cfb562p+1)) (f32.const -0x1.6972b4p+1)) +(assert_return (invoke "f32.demote_f64" (f64.const -0x1.bedbe4819d4c4p+112)) (f32.const -0x1.bedbe4p+112)) +(assert_return (invoke "f32.demote_f64" (f64.const nan)) (f32.const nan:canonical)) +(assert_return (invoke "f32.demote_f64" (f64.const nan:0x4000000000000)) (f32.const nan:arithmetic)) +(assert_return (invoke "f32.demote_f64" (f64.const -nan)) (f32.const nan:canonical)) +(assert_return (invoke "f32.demote_f64" (f64.const -nan:0x4000000000000)) (f32.const nan:arithmetic)) +(assert_return (invoke "f32.demote_f64" (f64.const 0x1p-1022)) (f32.const 0.0)) +(assert_return (invoke "f32.demote_f64" (f64.const -0x1p-1022)) (f32.const -0.0)) +(assert_return (invoke "f32.demote_f64" (f64.const 0x1.0p-150)) (f32.const 0.0)) +(assert_return (invoke "f32.demote_f64" (f64.const -0x1.0p-150)) (f32.const -0.0)) +(assert_return (invoke "f32.demote_f64" (f64.const 0x1.0000000000001p-150)) (f32.const 0x1p-149)) +(assert_return (invoke "f32.demote_f64" (f64.const -0x1.0000000000001p-150)) (f32.const -0x1p-149)) + +(assert_return (invoke "f32.reinterpret_i32" (i32.const 0)) (f32.const 0.0)) +(assert_return (invoke "f32.reinterpret_i32" (i32.const 0x80000000)) (f32.const -0.0)) +(assert_return (invoke "f32.reinterpret_i32" (i32.const 1)) (f32.const 0x1p-149)) +(assert_return (invoke "f32.reinterpret_i32" (i32.const -1)) (f32.const -nan:0x7fffff)) +(assert_return (invoke "f32.reinterpret_i32" (i32.const 123456789)) (f32.const 0x1.b79a2ap-113)) +(assert_return (invoke "f32.reinterpret_i32" (i32.const -2147483647)) (f32.const -0x1p-149)) +(assert_return (invoke "f32.reinterpret_i32" (i32.const 0x7f800000)) (f32.const inf)) +(assert_return (invoke "f32.reinterpret_i32" (i32.const 0xff800000)) (f32.const -inf)) +(assert_return (invoke "f32.reinterpret_i32" (i32.const 0x7fc00000)) (f32.const nan)) +(assert_return (invoke "f32.reinterpret_i32" (i32.const 0xffc00000)) (f32.const -nan)) +(assert_return (invoke "f32.reinterpret_i32" (i32.const 0x7fa00000)) (f32.const nan:0x200000)) +(assert_return (invoke "f32.reinterpret_i32" (i32.const 0xffa00000)) (f32.const -nan:0x200000)) + +(assert_return (invoke "f64.reinterpret_i64" (i64.const 0)) (f64.const 0.0)) +(assert_return (invoke "f64.reinterpret_i64" (i64.const 1)) (f64.const 0x0.0000000000001p-1022)) +(assert_return (invoke "f64.reinterpret_i64" (i64.const -1)) (f64.const -nan:0xfffffffffffff)) +(assert_return (invoke "f64.reinterpret_i64" (i64.const 0x8000000000000000)) (f64.const -0.0)) +(assert_return (invoke "f64.reinterpret_i64" (i64.const 1234567890)) (f64.const 0x0.00000499602d2p-1022)) +(assert_return (invoke "f64.reinterpret_i64" (i64.const -9223372036854775807)) (f64.const -0x0.0000000000001p-1022)) +(assert_return (invoke "f64.reinterpret_i64" (i64.const 0x7ff0000000000000)) (f64.const inf)) +(assert_return (invoke "f64.reinterpret_i64" (i64.const 0xfff0000000000000)) (f64.const -inf)) +(assert_return (invoke "f64.reinterpret_i64" (i64.const 0x7ff8000000000000)) (f64.const nan)) +(assert_return (invoke "f64.reinterpret_i64" (i64.const 0xfff8000000000000)) (f64.const -nan)) +(assert_return (invoke "f64.reinterpret_i64" (i64.const 0x7ff4000000000000)) (f64.const nan:0x4000000000000)) +(assert_return (invoke "f64.reinterpret_i64" (i64.const 0xfff4000000000000)) (f64.const -nan:0x4000000000000)) + +(assert_return (invoke "i32.reinterpret_f32" (f32.const 0.0)) (i32.const 0)) +(assert_return (invoke "i32.reinterpret_f32" (f32.const -0.0)) (i32.const 0x80000000)) +(assert_return (invoke "i32.reinterpret_f32" (f32.const 0x1p-149)) (i32.const 1)) +(assert_return (invoke "i32.reinterpret_f32" (f32.const -nan:0x7fffff)) (i32.const -1)) +(assert_return (invoke "i32.reinterpret_f32" (f32.const -0x1p-149)) (i32.const 0x80000001)) +(assert_return (invoke "i32.reinterpret_f32" (f32.const 1.0)) (i32.const 1065353216)) +(assert_return (invoke "i32.reinterpret_f32" (f32.const 3.1415926)) (i32.const 1078530010)) +(assert_return (invoke "i32.reinterpret_f32" (f32.const 0x1.fffffep+127)) (i32.const 2139095039)) +(assert_return (invoke "i32.reinterpret_f32" (f32.const -0x1.fffffep+127)) (i32.const -8388609)) +(assert_return (invoke "i32.reinterpret_f32" (f32.const inf)) (i32.const 0x7f800000)) +(assert_return (invoke "i32.reinterpret_f32" (f32.const -inf)) (i32.const 0xff800000)) +(assert_return (invoke "i32.reinterpret_f32" (f32.const nan)) (i32.const 0x7fc00000)) +(assert_return (invoke "i32.reinterpret_f32" (f32.const -nan)) (i32.const 0xffc00000)) +(assert_return (invoke "i32.reinterpret_f32" (f32.const nan:0x200000)) (i32.const 0x7fa00000)) +(assert_return (invoke "i32.reinterpret_f32" (f32.const -nan:0x200000)) (i32.const 0xffa00000)) + +(assert_return (invoke "i64.reinterpret_f64" (f64.const 0.0)) (i64.const 0)) +(assert_return (invoke "i64.reinterpret_f64" (f64.const -0.0)) (i64.const 0x8000000000000000)) +(assert_return (invoke "i64.reinterpret_f64" (f64.const 0x0.0000000000001p-1022)) (i64.const 1)) +(assert_return (invoke "i64.reinterpret_f64" (f64.const -nan:0xfffffffffffff)) (i64.const -1)) +(assert_return (invoke "i64.reinterpret_f64" (f64.const -0x0.0000000000001p-1022)) (i64.const 0x8000000000000001)) +(assert_return (invoke "i64.reinterpret_f64" (f64.const 1.0)) (i64.const 4607182418800017408)) +(assert_return (invoke "i64.reinterpret_f64" (f64.const 3.14159265358979)) (i64.const 4614256656552045841)) +(assert_return (invoke "i64.reinterpret_f64" (f64.const 0x1.fffffffffffffp+1023)) (i64.const 9218868437227405311)) +(assert_return (invoke "i64.reinterpret_f64" (f64.const -0x1.fffffffffffffp+1023)) (i64.const -4503599627370497)) +(assert_return (invoke "i64.reinterpret_f64" (f64.const inf)) (i64.const 0x7ff0000000000000)) +(assert_return (invoke "i64.reinterpret_f64" (f64.const -inf)) (i64.const 0xfff0000000000000)) +(assert_return (invoke "i64.reinterpret_f64" (f64.const nan)) (i64.const 0x7ff8000000000000)) +(assert_return (invoke "i64.reinterpret_f64" (f64.const -nan)) (i64.const 0xfff8000000000000)) +(assert_return (invoke "i64.reinterpret_f64" (f64.const nan:0x4000000000000)) (i64.const 0x7ff4000000000000)) +(assert_return (invoke "i64.reinterpret_f64" (f64.const -nan:0x4000000000000)) (i64.const 0xfff4000000000000)) + +;; Type check + +(assert_invalid (module (func (result i32) (i32.wrap_i64 (f32.const 0)))) "type mismatch") +(assert_invalid (module (func (result i32) (i32.trunc_f32_s (i64.const 0)))) "type mismatch") +(assert_invalid (module (func (result i32) (i32.trunc_f32_u (i64.const 0)))) "type mismatch") +(assert_invalid (module (func (result i32) (i32.trunc_f64_s (i64.const 0)))) "type mismatch") +(assert_invalid (module (func (result i32) (i32.trunc_f64_u (i64.const 0)))) "type mismatch") +(assert_invalid (module (func (result i32) (i32.reinterpret_f32 (i64.const 0)))) "type mismatch") +(assert_invalid (module (func (result i64) (i64.extend_i32_s (f32.const 0)))) "type mismatch") +(assert_invalid (module (func (result i64) (i64.extend_i32_u (f32.const 0)))) "type mismatch") +(assert_invalid (module (func (result i64) (i64.trunc_f32_s (i32.const 0)))) "type mismatch") +(assert_invalid (module (func (result i64) (i64.trunc_f32_u (i32.const 0)))) "type mismatch") +(assert_invalid (module (func (result i64) (i64.trunc_f64_s (i32.const 0)))) "type mismatch") +(assert_invalid (module (func (result i64) (i64.trunc_f64_u (i32.const 0)))) "type mismatch") +(assert_invalid (module (func (result i64) (i64.reinterpret_f64 (i32.const 0)))) "type mismatch") +(assert_invalid (module (func (result f32) (f32.convert_i32_s (i64.const 0)))) "type mismatch") +(assert_invalid (module (func (result f32) (f32.convert_i32_u (i64.const 0)))) "type mismatch") +(assert_invalid (module (func (result f32) (f32.convert_i64_s (i32.const 0)))) "type mismatch") +(assert_invalid (module (func (result f32) (f32.convert_i64_u (i32.const 0)))) "type mismatch") +(assert_invalid (module (func (result f32) (f32.demote_f64 (i32.const 0)))) "type mismatch") +(assert_invalid (module (func (result f32) (f32.reinterpret_i32 (i64.const 0)))) "type mismatch") +(assert_invalid (module (func (result f64) (f64.convert_i32_s (i64.const 0)))) "type mismatch") +(assert_invalid (module (func (result f64) (f64.convert_i32_u (i64.const 0)))) "type mismatch") +(assert_invalid (module (func (result f64) (f64.convert_i64_s (i32.const 0)))) "type mismatch") +(assert_invalid (module (func (result f64) (f64.convert_i64_u (i32.const 0)))) "type mismatch") +(assert_invalid (module (func (result f64) (f64.promote_f32 (i32.const 0)))) "type mismatch") +(assert_invalid (module (func (result f64) (f64.reinterpret_i64 (i32.const 0)))) "type mismatch") diff --git a/runtime/near-vm/tests/wast/spec/proposals/reference-types/binary.wast b/runtime/near-vm/tests/wast/spec/proposals/reference-types/binary.wast new file mode 100644 index 00000000000..002a9f26e9c --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/proposals/reference-types/binary.wast @@ -0,0 +1,1525 @@ +(module binary "\00asm\01\00\00\00") +(module binary "\00asm" "\01\00\00\00") +(module $M1 binary "\00asm\01\00\00\00") +(module $M2 binary "\00asm" "\01\00\00\00") + +(assert_malformed (module binary "") "unexpected end") +(assert_malformed (module binary "\01") "unexpected end") +(assert_malformed (module binary "\00as") "unexpected end") +(assert_malformed (module binary "asm\00") "magic header not detected") +(assert_malformed (module binary "msa\00") "magic header not detected") +(assert_malformed (module binary "msa\00\01\00\00\00") "magic header not detected") +(assert_malformed (module binary "msa\00\00\00\00\01") "magic header not detected") +(assert_malformed (module binary "asm\01\00\00\00\00") "magic header not detected") +(assert_malformed (module binary "wasm\01\00\00\00") "magic header not detected") +(assert_malformed (module binary "\7fasm\01\00\00\00") "magic header not detected") +(assert_malformed (module binary "\80asm\01\00\00\00") "magic header not detected") +(assert_malformed (module binary "\82asm\01\00\00\00") "magic header not detected") +(assert_malformed (module binary "\ffasm\01\00\00\00") "magic header not detected") + +;; 8-byte endian-reversed. +(assert_malformed (module binary "\00\00\00\01msa\00") "magic header not detected") + +;; Middle-endian byte orderings. +(assert_malformed (module binary "a\00ms\00\01\00\00") "magic header not detected") +(assert_malformed (module binary "sm\00a\00\00\01\00") "magic header not detected") + +;; Upper-cased. +(assert_malformed (module binary "\00ASM\01\00\00\00") "magic header not detected") + +;; EBCDIC-encoded magic. +(assert_malformed (module binary "\00\81\a2\94\01\00\00\00") "magic header not detected") + +;; Leading UTF-8 BOM. +(assert_malformed (module binary "\ef\bb\bf\00asm\01\00\00\00") "magic header not detected") + +;; Malformed binary version. +(assert_malformed (module binary "\00asm") "unexpected end") +(assert_malformed (module binary "\00asm\01") "unexpected end") +(assert_malformed (module binary "\00asm\01\00\00") "unexpected end") +(assert_malformed (module binary "\00asm\00\00\00\00") "unknown binary version") +(assert_malformed (module binary "\00asm\0d\00\00\00") "unknown binary version") +(assert_malformed (module binary "\00asm\0e\00\00\00") "unknown binary version") +(assert_malformed (module binary "\00asm\00\01\00\00") "unknown binary version") +(assert_malformed (module binary "\00asm\00\00\01\00") "unknown binary version") +(assert_malformed (module binary "\00asm\00\00\00\01") "unknown binary version") + +;; Unsigned LEB128 can have non-minimal length +(module binary + "\00asm" "\01\00\00\00" + "\05\04\01" ;; Memory section with 1 entry + "\00\82\00" ;; no max, minimum 2 +) +(module binary + "\00asm" "\01\00\00\00" + "\05\07\01" ;; Memory section with 1 entry + "\00\82\80\80\80\00" ;; no max, minimum 2 +) + +;; Signed LEB128 can have non-minimal length +(module binary + "\00asm" "\01\00\00\00" + "\06\07\01" ;; Global section with 1 entry + "\7f\00" ;; i32, immutable + "\41\80\00" ;; i32.const 0 + "\0b" ;; end +) +(module binary + "\00asm" "\01\00\00\00" + "\06\07\01" ;; Global section with 1 entry + "\7f\00" ;; i32, immutable + "\41\ff\7f" ;; i32.const -1 + "\0b" ;; end +) +(module binary + "\00asm" "\01\00\00\00" + "\06\0a\01" ;; Global section with 1 entry + "\7f\00" ;; i32, immutable + "\41\80\80\80\80\00" ;; i32.const 0 + "\0b" ;; end +) +(module binary + "\00asm" "\01\00\00\00" + "\06\0a\01" ;; Global section with 1 entry + "\7f\00" ;; i32, immutable + "\41\ff\ff\ff\ff\7f" ;; i32.const -1 + "\0b" ;; end +) + +(module binary + "\00asm" "\01\00\00\00" + "\06\07\01" ;; Global section with 1 entry + "\7e\00" ;; i64, immutable + "\42\80\00" ;; i64.const 0 with unused bits set + "\0b" ;; end +) +(module binary + "\00asm" "\01\00\00\00" + "\06\07\01" ;; Global section with 1 entry + "\7e\00" ;; i64, immutable + "\42\ff\7f" ;; i64.const -1 with unused bits unset + "\0b" ;; end +) +(module binary + "\00asm" "\01\00\00\00" + "\06\0f\01" ;; Global section with 1 entry + "\7e\00" ;; i64, immutable + "\42\80\80\80\80\80\80\80\80\80\00" ;; i64.const 0 with unused bits set + "\0b" ;; end +) +(module binary + "\00asm" "\01\00\00\00" + "\06\0f\01" ;; Global section with 1 entry + "\7e\00" ;; i64, immutable + "\42\ff\ff\ff\ff\ff\ff\ff\ff\ff\7f" ;; i64.const -1 with unused bits unset + "\0b" ;; end +) + +(module binary + "\00asm" "\01\00\00\00" + "\05\03\01" ;; Memory section with 1 entry + "\00\00" ;; no max, minimum 0 + "\0b\06\01" ;; Data section with 1 entry + "\00" ;; Memory index 0 + "\41\00\0b\00" ;; (i32.const 0) with contents "" +) + +(module binary + "\00asm" "\01\00\00\00" + "\04\04\01" ;; Table section with 1 entry + "\70\00\00" ;; no max, minimum 0, funcref + "\09\06\01" ;; Element section with 1 entry + "\00" ;; Table index 0 + "\41\00\0b\00" ;; (i32.const 0) with no elements +) + +;; Data segment memory index can have non-minimal length +(module binary + "\00asm" "\01\00\00\00" + "\05\03\01" ;; Memory section with 1 entry + "\00\00" ;; no max, minimum 0 + "\0b\07\01" ;; Data section with 1 entry + "\80\00" ;; Memory index 0, encoded with 2 bytes + "\41\00\0b\00" ;; (i32.const 0) with contents "" +) + +;; Element segment table index can have non-minimal length +(module binary + "\00asm" "\01\00\00\00" + "\04\04\01" ;; Table section with 1 entry + "\70\00\00" ;; no max, minimum 0, funcref + "\09\09\01" ;; Element section with 1 entry + "\02\80\00" ;; Table index 0, encoded with 2 bytes + "\41\00\0b\00\00" ;; (i32.const 0) with no elements +) + +;; Unsigned LEB128 must not be overlong +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\05\08\01" ;; Memory section with 1 entry + "\00\82\80\80\80\80\00" ;; no max, minimum 2 with one byte too many + ) + "integer representation too long" +) + +;; Signed LEB128 must not be overlong +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\06\0b\01" ;; Global section with 1 entry + "\7f\00" ;; i32, immutable + "\41\80\80\80\80\80\00" ;; i32.const 0 with one byte too many + "\0b" ;; end + ) + "integer representation too long" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\06\0b\01" ;; Global section with 1 entry + "\7f\00" ;; i32, immutable + "\41\ff\ff\ff\ff\ff\7f" ;; i32.const -1 with one byte too many + "\0b" ;; end + ) + "integer representation too long" +) + +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\06\10\01" ;; Global section with 1 entry + "\7e\00" ;; i64, immutable + "\42\80\80\80\80\80\80\80\80\80\80\00" ;; i64.const 0 with one byte too many + "\0b" ;; end + ) + "integer representation too long" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\06\10\01" ;; Global section with 1 entry + "\7e\00" ;; i64, immutable + "\42\ff\ff\ff\ff\ff\ff\ff\ff\ff\ff\7f" ;; i64.const -1 with one byte too many + "\0b" ;; end + ) + "integer representation too long" +) + +;; Unsigned LEB128s zero-extend +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\05\07\01" ;; Memory section with 1 entry + "\00\82\80\80\80\70" ;; no max, minimum 2 with unused bits set + ) + "integer too large" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\05\07\01" ;; Memory section with 1 entry + "\00\82\80\80\80\40" ;; no max, minimum 2 with some unused bits set + ) + "integer too large" +) + +;; Signed LEB128s sign-extend +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\06\0a\01" ;; Global section with 1 entry + "\7f\00" ;; i32, immutable + "\41\80\80\80\80\70" ;; i32.const 0 with unused bits set + "\0b" ;; end + ) + "integer too large" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\06\0a\01" ;; Global section with 1 entry + "\7f\00" ;; i32, immutable + "\41\ff\ff\ff\ff\0f" ;; i32.const -1 with unused bits unset + "\0b" ;; end + ) + "integer too large" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\06\0a\01" ;; Global section with 1 entry + "\7f\00" ;; i32, immutable + "\41\80\80\80\80\1f" ;; i32.const 0 with some unused bits set + "\0b" ;; end + ) + "integer too large" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\06\0a\01" ;; Global section with 1 entry + "\7f\00" ;; i32, immutable + "\41\ff\ff\ff\ff\4f" ;; i32.const -1 with some unused bits unset + "\0b" ;; end + ) + "integer too large" +) + +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\06\0f\01" ;; Global section with 1 entry + "\7e\00" ;; i64, immutable + "\42\80\80\80\80\80\80\80\80\80\7e" ;; i64.const 0 with unused bits set + "\0b" ;; end + ) + "integer too large" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\06\0f\01" ;; Global section with 1 entry + "\7e\00" ;; i64, immutable + "\42\ff\ff\ff\ff\ff\ff\ff\ff\ff\01" ;; i64.const -1 with unused bits unset + "\0b" ;; end + ) + "integer too large" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\06\0f\01" ;; Global section with 1 entry + "\7e\00" ;; i64, immutable + "\42\80\80\80\80\80\80\80\80\80\02" ;; i64.const 0 with some unused bits set + "\0b" ;; end + ) + "integer too large" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\06\0f\01" ;; Global section with 1 entry + "\7e\00" ;; i64, immutable + "\42\ff\ff\ff\ff\ff\ff\ff\ff\ff\41" ;; i64.const -1 with some unused bits unset + "\0b" ;; end + ) + "integer too large" +) + + +;; Unsigned LEB128 must not be overlong +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\05\08\01" ;; Memory section with 1 entry + "\00\82\80\80\80\80\00" ;; no max, minimum 2 with one byte too many + ) + "integer representation too long" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01\60\00\00" ;; Type section + "\03\02\01\00" ;; Function section + "\05\03\01\00\01" ;; Memory section + "\0a\11\01" ;; Code section + ;; function 0 + "\0f\01\01" ;; local type count + "\7f" ;; i32 + "\41\00" ;; i32.const 0 + "\28" ;; i32.load + "\02" ;; alignment 2 + "\82\80\80\80\80\00" ;; offset 2 with one byte too many + "\1a" ;; drop + "\0b" ;; end + ) + "integer representation too long" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01\60\00\00" ;; Type section + "\03\02\01\00" ;; Function section + "\05\03\01\00\01" ;; Memory section + "\0a\11\01" ;; Code section + ;; function 0 + "\0f\01\01" ;; local type count + "\7f" ;; i32 + "\41\00" ;; i32.const 0 + "\28" ;; i32.load + "\82\80\80\80\80\00" ;; alignment 2 with one byte too many + "\00" ;; offset 0 + "\1a" ;; drop + "\0b" ;; end + ) + "integer representation too long" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01\60\00\00" ;; Type section + "\03\02\01\00" ;; Function section + "\05\03\01\00\01" ;; Memory section + "\0a\12\01" ;; Code section + ;; function 0 + "\10\01\01" ;; local type count + "\7f" ;; i32 + "\41\00" ;; i32.const 0 + "\41\03" ;; i32.const 3 + "\36" ;; i32.store + "\82\80\80\80\80\00" ;; alignment 2 with one byte too many + "\03" ;; offset 3 + "\0b" ;; end + ) + "integer representation too long" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01\60\00\00" ;; Type section + "\03\02\01\00" ;; Function section + "\05\03\01\00\01" ;; Memory section + "\0a\12\01" ;; Code section + ;; function 0 + "\10\01\01" ;; local type count + "\7f" ;; i32 + "\41\00" ;; i32.const 0 + "\41\03" ;; i32.const 3 + "\36" ;; i32.store + "\02" ;; alignment 2 + "\82\80\80\80\80\00" ;; offset 2 with one byte too many + "\0b" ;; end + ) + "integer representation too long" +) + +;; Signed LEB128 must not be overlong +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\06\0b\01" ;; Global section with 1 entry + "\7f\00" ;; i32, immutable + "\41\80\80\80\80\80\00" ;; i32.const 0 with one byte too many + "\0b" ;; end + ) + "integer representation too long" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\06\0b\01" ;; Global section with 1 entry + "\7f\00" ;; i32, immutable + "\41\ff\ff\ff\ff\ff\7f" ;; i32.const -1 with one byte too many + "\0b" ;; end + ) + "integer representation too long" +) + +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\06\10\01" ;; Global section with 1 entry + "\7e\00" ;; i64, immutable + "\42\80\80\80\80\80\80\80\80\80\80\00" ;; i64.const 0 with one byte too many + "\0b" ;; end + ) + "integer representation too long" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\06\10\01" ;; Global section with 1 entry + "\7e\00" ;; i64, immutable + "\42\ff\ff\ff\ff\ff\ff\ff\ff\ff\ff\7f" ;; i64.const -1 with one byte too many + "\0b" ;; end + ) + "integer representation too long" +) + +;; Unsigned LEB128s zero-extend +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\05\07\01" ;; Memory section with 1 entry + "\00\82\80\80\80\70" ;; no max, minimum 2 with unused bits set + ) + "integer too large" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\05\07\01" ;; Memory section with 1 entry + "\00\82\80\80\80\40" ;; no max, minimum 2 with some unused bits set + ) + "integer too large" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01\60\00\00" ;; Type section + "\03\02\01\00" ;; Function section + "\05\03\01\00\01" ;; Memory section + "\0a\10\01" ;; Code section + ;; function 0 + "\0e\01\01" ;; local type count + "\7f" ;; i32 + "\41\00" ;; i32.const 0 + "\28" ;; i32.load + "\02" ;; alignment 2 + "\82\80\80\80\10" ;; offset 2 with unused bits set + "\1a" ;; drop + "\0b" ;; end + ) + "integer too large" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01\60\00\00" ;; Type section + "\03\02\01\00" ;; Function section + "\05\03\01\00\01" ;; Memory section + "\0a\10\01" ;; Code section + ;; function 0 + "\0e\01\01" ;; local type count + "\7f" ;; i32 + "\41\00" ;; i32.const 0 + "\28" ;; i32.load + "\02" ;; alignment 2 + "\82\80\80\80\40" ;; offset 2 with some unused bits set + "\1a" ;; drop + "\0b" ;; end + ) + "integer too large" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01\60\00\00" ;; Type section + "\03\02\01\00" ;; Function section + "\05\03\01\00\01" ;; Memory section + "\0a\10\01" ;; Code section + "\0e\01\01" ;; local type count + "\7f" ;; i32 + "\41\00" ;; i32.const 0 + "\28" ;; i32.load + "\82\80\80\80\10" ;; alignment 2 with unused bits set + "\00" ;; offset 0 + "\1a" ;; drop + "\0b" ;; end + ) + "integer too large" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01\60\00\00" ;; Type section + "\03\02\01\00" ;; Function section + "\05\03\01\00\01" ;; Memory section + "\0a\10\01" ;; Code section + ;; function 0 + "\0e\01\01" ;; local type count + "\7f" ;; i32 + "\41\00" ;; i32.const 0 + "\28" ;; i32.load + "\82\80\80\80\40" ;; alignment 2 with some unused bits set + "\00" ;; offset 0 + "\1a" ;; drop + "\0b" ;; end + ) + "integer too large" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01\60\00\00" ;; Type section + "\03\02\01\00" ;; Function section + "\05\03\01\00\01" ;; Memory section + "\0a\11\01" ;; Code section + ;; function 0 + "\0f\01\01" ;; local type count + "\7f" ;; i32 + "\41\00" ;; i32.const 0 + "\41\03" ;; i32.const 3 + "\36" ;; i32.store + "\82\80\80\80\10" ;; alignment 2 with unused bits set + "\03" ;; offset 3 + "\0b" ;; end + ) + "integer too large" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01\60\00\00" ;; Type section + "\03\02\01\00" ;; Function section + "\05\03\01\00\01" ;; Memory section + "\0a\11\01" ;; Code section + ;; function 0 + "\0f\01\01" ;; local type count + "\7f" ;; i32 + "\41\00" ;; i32.const 0 + "\41\03" ;; i32.const 3 + "\36" ;; i32.store + "\82\80\80\80\40" ;; alignment 2 with some unused bits set + "\03" ;; offset 3 + "\0b" ;; end + ) + "integer too large" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01\60\00\00" ;; Type section + "\03\02\01\00" ;; Function section + "\05\03\01\00\01" ;; Memory section + "\0a\11\01" ;; Code section + ;; function 0 + "\0f\01\01" ;; local type count + "\7f" ;; i32 + "\41\00" ;; i32.const 0 + "\41\03" ;; i32.const 3 + "\36" ;; i32.store + "\03" ;; alignment 2 + "\82\80\80\80\10" ;; offset 2 with unused bits set + "\0b" ;; end + ) + "integer too large" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01\60\00\00" ;; Type section + "\03\02\01\00" ;; Function section + "\05\03\01\00\01" ;; Memory section + "\0a\11\01" ;; Code section + + ;; function 0 + "\0f\01\01" ;; local type count + "\7f" ;; i32 + "\41\00" ;; i32.const 0 + "\41\03" ;; i32.const 3 + "\36" ;; i32.store + "\02" ;; alignment 2 + "\82\80\80\80\40" ;; offset 2 with some unused bits set + "\0b" ;; end + ) + "integer too large" +) + +;; Signed LEB128s sign-extend +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\06\0a\01" ;; Global section with 1 entry + "\7f\00" ;; i32, immutable + "\41\80\80\80\80\70" ;; i32.const 0 with unused bits set + "\0b" ;; end + ) + "integer too large" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\06\0a\01" ;; Global section with 1 entry + "\7f\00" ;; i32, immutable + "\41\ff\ff\ff\ff\0f" ;; i32.const -1 with unused bits unset + "\0b" ;; end + ) + "integer too large" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\06\0a\01" ;; Global section with 1 entry + "\7f\00" ;; i32, immutable + "\41\80\80\80\80\1f" ;; i32.const 0 with some unused bits set + "\0b" ;; end + ) + "integer too large" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\06\0a\01" ;; Global section with 1 entry + "\7f\00" ;; i32, immutable + "\41\ff\ff\ff\ff\4f" ;; i32.const -1 with some unused bits unset + "\0b" ;; end + ) + "integer too large" +) + +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\06\0f\01" ;; Global section with 1 entry + "\7e\00" ;; i64, immutable + "\42\80\80\80\80\80\80\80\80\80\7e" ;; i64.const 0 with unused bits set + "\0b" ;; end + ) + "integer too large" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\06\0f\01" ;; Global section with 1 entry + "\7e\00" ;; i64, immutable + "\42\ff\ff\ff\ff\ff\ff\ff\ff\ff\01" ;; i64.const -1 with unused bits unset + "\0b" ;; end + ) + "integer too large" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\06\0f\01" ;; Global section with 1 entry + "\7e\00" ;; i64, immutable + "\42\80\80\80\80\80\80\80\80\80\02" ;; i64.const 0 with some unused bits set + "\0b" ;; end + ) + "integer too large" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\06\0f\01" ;; Global section with 1 entry + "\7e\00" ;; i64, immutable + "\42\ff\ff\ff\ff\ff\ff\ff\ff\ff\41" ;; i64.const -1 with some unused bits unset + "\0b" ;; end + ) + "integer too large" +) + +;; memory.grow reserved byte equal to zero. +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01\60\00\00" ;; Type section + "\03\02\01\00" ;; Function section + "\05\03\01\00\00" ;; Memory section + "\0a\09\01" ;; Code section + + ;; function 0 + "\07\00" + "\41\00" ;; i32.const 0 + "\40" ;; memory.grow + "\01" ;; memory.grow reserved byte is not equal to zero! + "\1a" ;; drop + "\0b" ;; end + ) + "zero flag expected" +) + +;; memory.grow reserved byte should not be a "long" LEB128 zero. +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01\60\00\00" ;; Type section + "\03\02\01\00" ;; Function section + "\05\03\01\00\00" ;; Memory section + "\0a\0a\01" ;; Code section + + ;; function 0 + "\08\00" + "\41\00" ;; i32.const 0 + "\40" ;; memory.grow + "\80\00" ;; memory.grow reserved byte + "\1a" ;; drop + "\0b" ;; end + ) + "zero flag expected" +) + +;; Same as above for 3, 4, and 5-byte zero encodings. +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01\60\00\00" ;; Type section + "\03\02\01\00" ;; Function section + "\05\03\01\00\00" ;; Memory section + "\0a\0b\01" ;; Code section + + ;; function 0 + "\09\00" + "\41\00" ;; i32.const 0 + "\40" ;; memory.grow + "\80\80\00" ;; memory.grow reserved byte + "\1a" ;; drop + "\0b" ;; end + ) + "zero flag expected" +) + +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01\60\00\00" ;; Type section + "\03\02\01\00" ;; Function section + "\05\03\01\00\00" ;; Memory section + "\0a\0c\01" ;; Code section + + ;; function 0 + "\0a\00" + "\41\00" ;; i32.const 0 + "\40" ;; memory.grow + "\80\80\80\00" ;; memory.grow reserved byte + "\1a" ;; drop + "\0b" ;; end + ) + "zero flag expected" +) + +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01\60\00\00" ;; Type section + "\03\02\01\00" ;; Function section + "\05\03\01\00\00" ;; Memory section + "\0a\0d\01" ;; Code section + + ;; function 0 + "\0b\00" + "\41\00" ;; i32.const 0 + "\40" ;; memory.grow + "\80\80\80\80\00" ;; memory.grow reserved byte + "\1a" ;; drop + "\0b" ;; end + ) + "zero flag expected" +) + +;; memory.size reserved byte equal to zero. +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01\60\00\00" ;; Type section + "\03\02\01\00" ;; Function section + "\05\03\01\00\00" ;; Memory section + "\0a\07\01" ;; Code section + + ;; function 0 + "\05\00" + "\3f" ;; memory.size + "\01" ;; memory.size reserved byte is not equal to zero! + "\1a" ;; drop + "\0b" ;; end + ) + "zero flag expected" +) + +;; memory.size reserved byte should not be a "long" LEB128 zero. +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01\60\00\00" ;; Type section + "\03\02\01\00" ;; Function section + "\05\03\01\00\00" ;; Memory section + "\0a\08\01" ;; Code section + + ;; function 0 + "\06\00" + "\3f" ;; memory.size + "\80\00" ;; memory.size reserved byte + "\1a" ;; drop + "\0b" ;; end + ) + "zero flag expected" +) + +;; Same as above for 3, 4, and 5-byte zero encodings. +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01\60\00\00" ;; Type section + "\03\02\01\00" ;; Function section + "\05\03\01\00\00" ;; Memory section + "\0a\09\01" ;; Code section + + ;; function 0 + "\07\00" + "\3f" ;; memory.size + "\80\80\00" ;; memory.size reserved byte + "\1a" ;; drop + "\0b" ;; end + ) + "zero flag expected" +) + +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01\60\00\00" ;; Type section + "\03\02\01\00" ;; Function section + "\05\03\01\00\00" ;; Memory section + "\0a\0a\01" ;; Code section + + ;; function 0 + "\08\00" + "\3f" ;; memory.size + "\80\80\80\00" ;; memory.size reserved byte + "\1a" ;; drop + "\0b" ;; end + ) + "zero flag expected" +) + +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01\60\00\00" ;; Type section + "\03\02\01\00" ;; Function section + "\05\03\01\00\00" ;; Memory section + "\0a\0b\01" ;; Code section + + ;; function 0 + "\09\00" + "\3f" ;; memory.size + "\80\80\80\80\00" ;; memory.size reserved byte + "\1a" ;; drop + "\0b" ;; end + ) + "zero flag expected" +) + +;; No more than 2^32 locals. +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01\60\00\00" ;; Type section + "\03\02\01\00" ;; Function section + "\0a\0c\01" ;; Code section + + ;; function 0 + "\0a\02" + "\ff\ff\ff\ff\0f\7f" ;; 0xFFFFFFFF i32 + "\02\7e" ;; 0x00000002 i64 + "\0b" ;; end + ) + "too many locals" +) + +;; Local count can be 0. +(module binary + "\00asm" "\01\00\00\00" + "\01\04\01\60\00\00" ;; Type section + "\03\02\01\00" ;; Function section + "\0a\0a\01" ;; Code section + + ;; function 0 + "\08\03" + "\00\7f" ;; 0 i32 + "\00\7e" ;; 0 i64 + "\02\7d" ;; 2 f32 + "\0b" ;; end +) + +;; Function section has non-zero count, but code section is absent. +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01\60\00\00" ;; Type section + "\03\03\02\00\00" ;; Function section with 2 functions + ) + "function and code section have inconsistent lengths" +) + +;; Code section has non-zero count, but function section is absent. +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\0a\04\01\02\00\0b" ;; Code section with 1 empty function + ) + "function and code section have inconsistent lengths" +) + +;; Function section count > code section count +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01\60\00\00" ;; Type section + "\03\03\02\00\00" ;; Function section with 2 functions + "\0a\04\01\02\00\0b" ;; Code section with 1 empty function + ) + "function and code section have inconsistent lengths" +) + +;; Function section count < code section count +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01\60\00\00" ;; Type section + "\03\02\01\00" ;; Function section with 1 function + "\0a\07\02\02\00\0b\02\00\0b" ;; Code section with 2 empty functions + ) + "function and code section have inconsistent lengths" +) + +;; Function section has zero count, and code section is absent. +(module binary + "\00asm" "\01\00\00\00" + "\03\01\00" ;; Function section with 0 functions +) + +;; Code section has zero count, and function section is absent. +(module binary + "\00asm" "\01\00\00\00" + "\0a\01\00" ;; Code section with 0 functions +) + +;; Fewer passive segments than datacount +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\0c\01\03" ;; Datacount section with value "3" + "\0b\05\02" ;; Data section with two entries + "\01\00" ;; Passive data section + "\01\00") ;; Passive data section + "data count and data section have inconsistent lengths") + +;; More passive segments than datacount +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\0c\01\01" ;; Datacount section with value "1" + "\0b\05\02" ;; Data section with two entries + "\01\00" ;; Passive data section + "\01\00") ;; Passive data section + "data count and data section have inconsistent lengths") + +;; memory.init requires a datacount section +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + + "\01\04\01\60\00\00" ;; Type section + "\03\02\01\00" ;; Function section + "\05\03\01\00\00" ;; Memory section + "\0a\0e\01" ;; Code section + + ;; function 0 + "\0c\00" + "\41\00" ;; zero args + "\41\00" + "\41\00" + "\fc\08\00\00" ;; memory.init + "\0b" + + "\0b\03\01\01\00" ;; Data section + ) ;; end + "data count section required") + +;; data.drop requires a datacount section +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + + "\01\04\01\60\00\00" ;; Type section + "\03\02\01\00" ;; Function section + "\05\03\01\00\00" ;; Memory section + "\0a\07\01" ;; Code section + + ;; function 0 + "\05\00" + "\fc\09\00" ;; data.drop + "\0b" + + "\0b\03\01\01\00" ;; Data section + ) ;; end + "data count section required") + +;; passive element segment containing opcode other than ref.func or ref.null +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + + "\01\04\01\60\00\00" ;; Type section + + "\03\02\01\00" ;; Function section + + "\04\04\01" ;; Table section with 1 entry + "\70\00\00" ;; no max, minimum 0, funcref + + "\05\03\01\00\00" ;; Memory section + + "\09\07\01" ;; Element section with one segment + "\05\70" ;; Passive, funcref + "\01" ;; 1 element + "\d3\00\0b" ;; bad opcode, index 0, end + + "\0a\04\01" ;; Code section + + ;; function 0 + "\02\00" + "\0b") ;; end + "illegal opcode") + +;; passive element segment containing type other than funcref +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + + "\01\04\01\60\00\00" ;; Type section + + "\03\02\01\00" ;; Function section + + "\04\04\01" ;; Table section with 1 entry + "\70\00\00" ;; no max, minimum 0, funcref + + "\05\03\01\00\00" ;; Memory section + + "\09\07\01" ;; Element section with one segment + "\05\7f" ;; Passive, i32 + "\01" ;; 1 element + "\d2\00\0b" ;; ref.func, index 0, end + + "\0a\04\01" ;; Code section + + ;; function 0 + "\02\00" + "\0b") ;; end + "invalid reference type") + +;; passive element segment containing opcode ref.func +(module binary + "\00asm" "\01\00\00\00" + + "\01\04\01\60\00\00" ;; Type section + + "\03\02\01\00" ;; Function section + + "\04\04\01" ;; Table section with 1 entry + "\70\00\00" ;; no max, minimum 0, funcref + + "\05\03\01\00\00" ;; Memory section + + "\09\07\01" ;; Element section with one segment + "\05\70" ;; Passive, funcref + "\01" ;; 1 element + "\d2\00\0b" ;; ref.func, index 0, end + + "\0a\04\01" ;; Code section + + ;; function 0 + "\02\00" + "\0b") ;; end + +;; passive element segment containing opcode ref.null +(module binary + "\00asm" "\01\00\00\00" + + "\01\04\01\60\00\00" ;; Type section + + "\03\02\01\00" ;; Function section + + "\04\04\01" ;; Table section with 1 entry + "\70\00\00" ;; no max, minimum 0, funcref + + "\05\03\01\00\00" ;; Memory section + + "\09\06\01" ;; Element section with one segment + "\05\70" ;; Passive, funcref + "\01" ;; 1 element + "\d0\0b" ;; ref.null, end + + "\0a\04\01" ;; Code section + + ;; function 0 + "\02\00" + "\0b") ;; end + + +;; Type count can be zero +(module binary + "\00asm" "\01\00\00\00" + "\01\01\00" ;; type count can be zero +) + +;; 2 type declared, 1 given +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\07\02" ;; type section with inconsistent count (2 declared, 1 given) + "\60\00\00" ;; 1st type + ;; "\60\00\00" ;; 2nd type (missed) + ) + "unexpected end of section or function" +) + +;; 1 type declared, 2 given +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\07\01" ;; type section with inconsistent count (1 declared, 2 given) + "\60\00\00" ;; 1st type + "\60\00\00" ;; 2nd type (redundant) + ) + "section size mismatch" +) + +;; Import count can be zero +(module binary + "\00asm" "\01\00\00\00" + "\01\05\01" ;; type section + "\60\01\7f\00" ;; type 0 + "\02\01\00" ;; import count can be zero +) + +;; 2 import declared, 1 given +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\05\01" ;; type section + "\60\01\7f\00" ;; type 0 + "\02\16\02" ;; import section with inconsistent count (2 declared, 1 given) + ;; 1st import + "\08" ;; string length + "\73\70\65\63\74\65\73\74" ;; spectest + "\09" ;; string length + "\70\72\69\6e\74\5f\69\33\32" ;; print_i32 + "\00\00" ;; import kind, import signature index + ;; 2nd import + ;; (missed) + ) + "unexpected end of section or function" +) + +;; 1 import declared, 2 given +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\09\02" ;; type section + "\60\01\7f\00" ;; type 0 + "\60\01\7d\00" ;; type 1 + "\02\2b\01" ;; import section with inconsistent count (1 declared, 2 given) + ;; 1st import + "\08" ;; string length + "\73\70\65\63\74\65\73\74" ;; spectest + "\09" ;; string length + "\70\72\69\6e\74\5f\69\33\32" ;; print_i32 + "\00\00" ;; import kind, import signature index + ;; 2nd import + ;; (redundant) + "\08" ;; string length + "\73\70\65\63\74\65\73\74" ;; spectest + "\09" ;; string length + "\70\72\69\6e\74\5f\66\33\32" ;; print_f32 + "\00\01" ;; import kind, import signature index + ) + "section size mismatch" +) + +;; Table count can be zero +(module binary + "\00asm" "\01\00\00\00" + "\04\01\00" ;; table count can be zero +) + +;; 1 table declared, 0 given +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\04\01\01" ;; table section with inconsistent count (1 declared, 0 given) + ;; "\70\01\00\00" ;; table entity + ) + "unexpected end of section or function" +) + +;; Memory count can be zero +(module binary + "\00asm" "\01\00\00\00" + "\05\01\00" ;; memory count can be zero +) + +;; 1 memory declared, 0 given +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\05\01\01" ;; memory section with inconsistent count (1 declared, 0 given) + ;; "\00\00" ;; memory 0 (missed) + ) + "unexpected end of section or function" +) + +;; Global count can be zero +(module binary + "\00asm" "\01\00\00\00" + "\06\01\00" ;; global count can be zero +) + +;; 2 global declared, 1 given +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\06\06\02" ;; global section with inconsistent count (2 declared, 1 given) + "\7f\00\41\00\0b" ;; global 0 + ;; "\7f\00\41\00\0b" ;; global 1 (missed) + ) + "unexpected end of section or function" +) + +;; 1 global declared, 2 given +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\06\0b\01" ;; global section with inconsistent count (1 declared, 2 given) + "\7f\00\41\00\0b" ;; global 0 + "\7f\00\41\00\0b" ;; global 1 (redundant) + ) + "section size mismatch" +) + +;; Export count can be 0 +(module binary + "\00asm" "\01\00\00\00" + "\01\04\01" ;; type section + "\60\00\00" ;; type 0 + "\03\03\02\00\00" ;; func section + "\07\01\00" ;; export count can be zero + "\0a\07\02" ;; code section + "\02\00\0b" ;; function body 0 + "\02\00\0b" ;; function body 1 +) + +;; 2 export declared, 1 given +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01" ;; type section + "\60\00\00" ;; type 0 + "\03\03\02\00\00" ;; func section + "\07\06\02" ;; export section with inconsistent count (2 declared, 1 given) + "\02" ;; export 0 + "\66\31" ;; export name + "\00\00" ;; export kind, export func index + ;; "\02" ;; export 1 (missed) + ;; "\66\32" ;; export name + ;; "\00\01" ;; export kind, export func index + "\0a\07\02" ;; code section + "\02\00\0b" ;; function body 0 + "\02\00\0b" ;; function body 1 + ) + "unexpected end of section or function" +) + +;; 1 export declared, 2 given +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01" ;; type section + "\60\00\00" ;; type 0 + "\03\03\02\00\00" ;; func section + "\07\0b\01" ;; export section with inconsistent count (1 declared, 2 given) + "\02" ;; export 0 + "\66\31" ;; export name + "\00\00" ;; export kind, export func index + "\02" ;; export 1 (redundant) + "\66\32" ;; export name + "\00\01" ;; export kind, export func index + "\0a\07\02" ;; code section + "\02\00\0b" ;; function body 0 + "\02\00\0b" ;; function body 1 + ) + "section size mismatch" +) + +;; elem segment count can be zero +(module binary + "\00asm" "\01\00\00\00" + "\01\04\01" ;; type section + "\60\00\00" ;; type 0 + "\03\02\01\00" ;; func section + "\04\04\01" ;; table section + "\70\00\01" ;; table 0 + "\09\01\00" ;; elem segment count can be zero + "\0a\04\01" ;; code section + "\02\00\0b" ;; function body +) + +;; 2 elem segment declared, 1 given +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01" ;; type section + "\60\00\00" ;; type 0 + "\03\02\01\00" ;; func section + "\04\04\01" ;; table section + "\70\00\01" ;; table 0 + "\09\07\02" ;; elem with inconsistent segment count (2 declared, 1 given) + "\00\41\00\0b\01\00" ;; elem 0 + ;; "\00\41\00\0b\01\00" ;; elem 1 (missed) + "\0a\04\01" ;; code section + "\02\00\0b" ;; function body + ) + "invalid elements segment kind" +) + +;; 1 elem segment declared, 2 given +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01" ;; type section + "\60\00\00" ;; type 0 + "\03\02\01\00" ;; func section + "\04\04\01" ;; table section + "\70\00\01" ;; table 0 + "\09\0d\01" ;; elem with inconsistent segment count (1 declared, 2 given) + "\00\41\00\0b\01\00" ;; elem 0 + "\00\41\00\0b\01\00" ;; elem 1 (redundant) + "\0a\04\01" ;; code section + "\02\00\0b" ;; function body + ) + "section size mismatch" +) + +;; data segment count can be zero +(module binary + "\00asm" "\01\00\00\00" + "\05\03\01" ;; memory section + "\00\01" ;; memory 0 + "\0b\01\00" ;; data segment count can be zero +) + +;; 2 data segment declared, 1 given +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\05\03\01" ;; memory section + "\00\01" ;; memory 0 + "\0b\07\02" ;; data with inconsistent segment count (2 declared, 1 given) + "\00\41\00\0b\01\61" ;; data 0 + ;; "\00\41\01\0b\01\62" ;; data 1 (missed) + ) + "unexpected end of section or function" +) + +;; 1 data segment declared, 2 given +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\05\03\01" ;; memory section + "\00\01" ;; memory 0 + "\0b\0d\01" ;; data with inconsistent segment count (1 declared, 2 given) + "\00\41\00\0b\01\61" ;; data 0 + "\00\41\01\0b\01\62" ;; data 1 (redundant) + ) + "section size mismatch" +) + +;; data segment has 7 bytes declared, but 6 bytes given +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\05\03\01" ;; memory section + "\00\01" ;; memory 0 + "\0b\0c\01" ;; data section + "\00\41\03\0b" ;; data segment 0 + "\07" ;; data segment size with inconsistent lengths (7 declared, 6 given) + "\61\62\63\64\65\66" ;; 6 bytes given + ) + "unexpected end of section or function" +) + +;; data segment has 5 bytes declared, but 6 bytes given +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\05\03\01" ;; memory section + "\00\01" ;; memory 0 + "\0b\0c\01" ;; data section + "\00\41\00\0b" ;; data segment 0 + "\05" ;; data segment size with inconsistent lengths (5 declared, 6 given) + "\61\62\63\64\65\66" ;; 6 bytes given + ) + "section size mismatch" +) + +;; br_table target count can be zero +(module binary + "\00asm" "\01\00\00\00" + "\01\04\01" ;; type section + "\60\00\00" ;; type 0 + "\03\02\01\00" ;; func section + "\0a\11\01" ;; code section + "\0f\00" ;; func 0 + "\02\40" ;; block 0 + "\41\01" ;; condition of if 0 + "\04\40" ;; if 0 + "\41\01" ;; index of br_table element + "\0e\00" ;; br_table target count can be zero + "\02" ;; break depth for default + "\0b\0b\0b" ;; end +) + +;; 2 br_table target declared, 1 given +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01" ;; type section + "\60\00\00" ;; type 0 + "\03\02\01\00" ;; func section + "\0a\12\01" ;; code section + "\10\00" ;; func 0 + "\02\40" ;; block 0 + "\41\01" ;; condition of if 0 + "\04\40" ;; if 0 + "\41\01" ;; index of br_table element + "\0e\02" ;; br_table with inconsistent target count (2 declared, 1 given) + "\00" ;; break depth 0 + ;; "\01" ;; break depth 1 (missed) + "\02" ;; break depth for default + "\0b\0b\0b" ;; end + ) + "unexpected end of section or function" +) + +;; 1 br_table target declared, 2 given +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01" ;; type section + "\60\00\00" ;; type 0 + "\03\02\01\00" ;; func section + "\0a\12\01" ;; code section + "\11\00" ;; func 0 + "\02\40" ;; block 0 + "\41\01" ;; condition of if 0 + "\04\40" ;; if 0 + "\41\01" ;; index of br_table element + "\0e\01" ;; br_table with inconsistent target count (1 declared, 2 given) + "\00" ;; break depth 0 + "\01" ;; break depth 1 + "\02" ;; break depth for default + "\0b\0b\0b" ;; end + ) + "invalid reference type" +) + +;; Start section +(module binary + "\00asm" "\01\00\00\00" + "\01\04\01\60\00\00" ;; Type section + "\03\02\01\00" ;; Function section + "\08\01\00" ;; Start section: function 0 + + "\0a\04\01" ;; Code section + ;; function 0 + "\02\00" + "\0b" ;; end +) + +;; Multiple start sections +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\04\01\60\00\00" ;; Type section + "\03\02\01\00" ;; Function section + "\08\01\00" ;; Start section: function 0 + "\08\01\00" ;; Start section: function 0 + + "\0a\04\01" ;; Code section + ;; function 0 + "\02\00" + "\0b" ;; end + ) + "junk after last section" +) diff --git a/runtime/near-vm/tests/wast/spec/proposals/reference-types/br_table.wast b/runtime/near-vm/tests/wast/spec/proposals/reference-types/br_table.wast new file mode 100644 index 00000000000..48e7a874a3c --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/proposals/reference-types/br_table.wast @@ -0,0 +1,1690 @@ +;; Test `br_table` operator + +(module + ;; Auxiliary definition + (func $dummy) + + (func (export "type-i32") + (block (drop (i32.ctz (br_table 0 0 (i32.const 0))))) + ) + (func (export "type-i64") + (block (drop (i64.ctz (br_table 0 0 (i32.const 0))))) + ) + (func (export "type-f32") + (block (drop (f32.neg (br_table 0 0 (i32.const 0))))) + ) + (func (export "type-f64") + (block (drop (f64.neg (br_table 0 0 (i32.const 0))))) + ) + + (func (export "type-i32-value") (result i32) + (block (result i32) (i32.ctz (br_table 0 0 (i32.const 1) (i32.const 0)))) + ) + (func (export "type-i64-value") (result i64) + (block (result i64) (i64.ctz (br_table 0 0 (i64.const 2) (i32.const 0)))) + ) + (func (export "type-f32-value") (result f32) + (block (result f32) (f32.neg (br_table 0 0 (f32.const 3) (i32.const 0)))) + ) + (func (export "type-f64-value") (result f64) + (block (result f64) (f64.neg (br_table 0 0 (f64.const 4) (i32.const 0)))) + ) + + (func (export "empty") (param i32) (result i32) + (block (br_table 0 (local.get 0)) (return (i32.const 21))) + (i32.const 22) + ) + (func (export "empty-value") (param i32) (result i32) + (block (result i32) + (br_table 0 (i32.const 33) (local.get 0)) (i32.const 31) + ) + ) + + (func (export "singleton") (param i32) (result i32) + (block + (block + (br_table 1 0 (local.get 0)) + (return (i32.const 21)) + ) + (return (i32.const 20)) + ) + (i32.const 22) + ) + + (func (export "singleton-value") (param i32) (result i32) + (block (result i32) + (drop + (block (result i32) + (br_table 0 1 (i32.const 33) (local.get 0)) + (return (i32.const 31)) + ) + ) + (i32.const 32) + ) + ) + + (func (export "multiple") (param i32) (result i32) + (block + (block + (block + (block + (block + (br_table 3 2 1 0 4 (local.get 0)) + (return (i32.const 99)) + ) + (return (i32.const 100)) + ) + (return (i32.const 101)) + ) + (return (i32.const 102)) + ) + (return (i32.const 103)) + ) + (i32.const 104) + ) + + (func (export "multiple-value") (param i32) (result i32) + (local i32) + (local.set 1 (block (result i32) + (local.set 1 (block (result i32) + (local.set 1 (block (result i32) + (local.set 1 (block (result i32) + (local.set 1 (block (result i32) + (br_table 3 2 1 0 4 (i32.const 200) (local.get 0)) + (return (i32.add (local.get 1) (i32.const 99))) + )) + (return (i32.add (local.get 1) (i32.const 10))) + )) + (return (i32.add (local.get 1) (i32.const 11))) + )) + (return (i32.add (local.get 1) (i32.const 12))) + )) + (return (i32.add (local.get 1) (i32.const 13))) + )) + (i32.add (local.get 1) (i32.const 14)) + ) + + (func (export "large") (param i32) (result i32) + (block + (block + (br_table + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 + (local.get 0) + ) + (return (i32.const -1)) + ) + (return (i32.const 0)) + ) + (return (i32.const 1)) + ) + + (func (export "as-block-first") + (block (br_table 0 0 0 (i32.const 0)) (call $dummy)) + ) + (func (export "as-block-mid") + (block (call $dummy) (br_table 0 0 0 (i32.const 0)) (call $dummy)) + ) + (func (export "as-block-last") + (block (nop) (call $dummy) (br_table 0 0 0 (i32.const 0))) + ) + (func (export "as-block-value") (result i32) + (block (result i32) + (nop) (call $dummy) (br_table 0 0 0 (i32.const 2) (i32.const 0)) + ) + ) + + (func (export "as-loop-first") (result i32) + (loop (result i32) (br_table 1 1 (i32.const 3) (i32.const 0)) (i32.const 1)) + ) + (func (export "as-loop-mid") (result i32) + (loop (result i32) + (call $dummy) + (br_table 1 1 1 (i32.const 4) (i32.const -1)) + (i32.const 2) + ) + ) + (func (export "as-loop-last") (result i32) + (loop (result i32) + (nop) (call $dummy) (br_table 1 1 1 (i32.const 5) (i32.const 1)) + ) + ) + + (func (export "as-br-value") (result i32) + (block (result i32) (br 0 (br_table 0 (i32.const 9) (i32.const 0)))) + ) + + (func (export "as-br_if-cond") + (block (br_if 0 (br_table 0 0 0 (i32.const 1)))) + ) + (func (export "as-br_if-value") (result i32) + (block (result i32) + (drop (br_if 0 (br_table 0 (i32.const 8) (i32.const 0)) (i32.const 1))) + (i32.const 7) + ) + ) + (func (export "as-br_if-value-cond") (result i32) + (block (result i32) + (drop (br_if 0 (i32.const 6) (br_table 0 0 (i32.const 9) (i32.const 0)))) + (i32.const 7) + ) + ) + + (func (export "as-br_table-index") + (block (br_table 0 0 0 (br_table 0 (i32.const 1)))) + ) + (func (export "as-br_table-value") (result i32) + (block (result i32) + (br_table 0 0 0 (br_table 0 (i32.const 10) (i32.const 0)) (i32.const 1)) + (i32.const 7) + ) + ) + (func (export "as-br_table-value-index") (result i32) + (block (result i32) + (br_table 0 0 (i32.const 6) (br_table 0 (i32.const 11) (i32.const 1))) + (i32.const 7) + ) + ) + + (func (export "as-return-value") (result i64) + (block (result i64) (return (br_table 0 (i64.const 7) (i32.const 0)))) + ) + + (func (export "as-if-cond") (result i32) + (block (result i32) + (if (result i32) + (br_table 0 (i32.const 2) (i32.const 0)) + (then (i32.const 0)) + (else (i32.const 1)) + ) + ) + ) + (func (export "as-if-then") (param i32 i32) (result i32) + (block (result i32) + (if (result i32) + (local.get 0) + (then (br_table 1 (i32.const 3) (i32.const 0))) + (else (local.get 1)) + ) + ) + ) + (func (export "as-if-else") (param i32 i32) (result i32) + (block (result i32) + (if (result i32) + (local.get 0) + (then (local.get 1)) + (else (br_table 1 0 (i32.const 4) (i32.const 0))) + ) + ) + ) + + (func (export "as-select-first") (param i32 i32) (result i32) + (block (result i32) + (select + (br_table 0 (i32.const 5) (i32.const 0)) (local.get 0) (local.get 1) + ) + ) + ) + (func (export "as-select-second") (param i32 i32) (result i32) + (block (result i32) + (select + (local.get 0) (br_table 0 (i32.const 6) (i32.const 1)) (local.get 1) + ) + ) + ) + (func (export "as-select-cond") (result i32) + (block (result i32) + (select + (i32.const 0) (i32.const 1) (br_table 0 (i32.const 7) (i32.const 1)) + ) + ) + ) + + (func $f (param i32 i32 i32) (result i32) (i32.const -1)) + (func (export "as-call-first") (result i32) + (block (result i32) + (call $f + (br_table 0 (i32.const 12) (i32.const 1)) (i32.const 2) (i32.const 3) + ) + ) + ) + (func (export "as-call-mid") (result i32) + (block (result i32) + (call $f + (i32.const 1) (br_table 0 (i32.const 13) (i32.const 1)) (i32.const 3) + ) + ) + ) + (func (export "as-call-last") (result i32) + (block (result i32) + (call $f + (i32.const 1) (i32.const 2) (br_table 0 (i32.const 14) (i32.const 1)) + ) + ) + ) + + (type $sig (func (param i32 i32 i32) (result i32))) + (table funcref (elem $f)) + (func (export "as-call_indirect-first") (result i32) + (block (result i32) + (call_indirect (type $sig) + (br_table 0 (i32.const 20) (i32.const 1)) (i32.const 1) (i32.const 2) + (i32.const 3) + ) + ) + ) + (func (export "as-call_indirect-mid") (result i32) + (block (result i32) + (call_indirect (type $sig) + (i32.const 0) (br_table 0 (i32.const 21) (i32.const 1)) (i32.const 2) + (i32.const 3) + ) + ) + ) + (func (export "as-call_indirect-last") (result i32) + (block (result i32) + (call_indirect (type $sig) + (i32.const 0) (i32.const 1) (br_table 0 (i32.const 22) (i32.const 1)) + (i32.const 3) + ) + ) + ) + (func (export "as-call_indirect-func") (result i32) + (block (result i32) + (call_indirect (type $sig) + (i32.const 0) (i32.const 1) (i32.const 2) + (br_table 0 (i32.const 23) (i32.const 1)) + ) + ) + ) + + (func (export "as-local.set-value") (result i32) + (local f32) + (block (result i32) + (local.set 0 (br_table 0 (i32.const 17) (i32.const 1))) + (i32.const -1) + ) + ) + (func (export "as-local.tee-value") (result i32) + (local i32) + (block (result i32) + (local.set 0 (br_table 0 (i32.const 1) (i32.const 1))) + (i32.const -1) + ) + ) + (global $a (mut i32) (i32.const 10)) + (func (export "as-global.set-value") (result i32) + (block (result i32) + (global.set $a (br_table 0 (i32.const 1) (i32.const 1))) + (i32.const -1) + ) + ) + + (memory 1) + (func (export "as-load-address") (result f32) + (block (result f32) (f32.load (br_table 0 (f32.const 1.7) (i32.const 1)))) + ) + (func (export "as-loadN-address") (result i64) + (block (result i64) (i64.load8_s (br_table 0 (i64.const 30) (i32.const 1)))) + ) + + (func (export "as-store-address") (result i32) + (block (result i32) + (f64.store (br_table 0 (i32.const 30) (i32.const 1)) (f64.const 7)) + (i32.const -1) + ) + ) + (func (export "as-store-value") (result i32) + (block (result i32) + (i64.store (i32.const 2) (br_table 0 (i32.const 31) (i32.const 1))) + (i32.const -1) + ) + ) + + (func (export "as-storeN-address") (result i32) + (block (result i32) + (i32.store8 (br_table 0 (i32.const 32) (i32.const 0)) (i32.const 7)) + (i32.const -1) + ) + ) + (func (export "as-storeN-value") (result i32) + (block (result i32) + (i64.store16 (i32.const 2) (br_table 0 (i32.const 33) (i32.const 0))) + (i32.const -1) + ) + ) + + (func (export "as-unary-operand") (result f32) + (block (result f32) (f32.neg (br_table 0 (f32.const 3.4) (i32.const 0)))) + ) + + (func (export "as-binary-left") (result i32) + (block (result i32) + (i32.add (br_table 0 0 (i32.const 3) (i32.const 0)) (i32.const 10)) + ) + ) + (func (export "as-binary-right") (result i64) + (block (result i64) + (i64.sub (i64.const 10) (br_table 0 (i64.const 45) (i32.const 0))) + ) + ) + + (func (export "as-test-operand") (result i32) + (block (result i32) (i32.eqz (br_table 0 (i32.const 44) (i32.const 0)))) + ) + + (func (export "as-compare-left") (result i32) + (block (result i32) + (f64.le (br_table 0 0 (i32.const 43) (i32.const 0)) (f64.const 10)) + ) + ) + (func (export "as-compare-right") (result i32) + (block (result i32) + (f32.ne (f32.const 10) (br_table 0 (i32.const 42) (i32.const 0))) + ) + ) + + (func (export "as-convert-operand") (result i32) + (block (result i32) + (i32.wrap_i64 (br_table 0 (i32.const 41) (i32.const 0))) + ) + ) + + (func (export "as-memory.grow-size") (result i32) + (block (result i32) (memory.grow (br_table 0 (i32.const 40) (i32.const 0)))) + ) + + (func (export "nested-block-value") (param i32) (result i32) + (block (result i32) + (drop (i32.const -1)) + (i32.add + (i32.const 1) + (block (result i32) + (i32.add + (i32.const 2) + (block (result i32) + (drop (i32.const 4)) + (i32.add + (i32.const 8) + (br_table 0 1 2 (i32.const 16) (local.get 0)) + ) + ) + ) + ) + ) + ) + ) + + (func (export "nested-br-value") (param i32) (result i32) + (block (result i32) + (i32.add + (i32.const 1) + (block (result i32) + (drop (i32.const 2)) + (drop + (block (result i32) + (drop (i32.const 4)) + (br 0 (br_table 2 1 0 (i32.const 8) (local.get 0))) + ) + ) + (i32.const 16) + ) + ) + ) + ) + + (func (export "nested-br_if-value") (param i32) (result i32) + (block (result i32) + (i32.add + (i32.const 1) + (block (result i32) + (drop (i32.const 2)) + (drop + (block (result i32) + (drop (i32.const 4)) + (drop + (br_if 0 + (br_table 0 1 2 (i32.const 8) (local.get 0)) + (i32.const 1) + ) + ) + (i32.const 32) + ) + ) + (i32.const 16) + ) + ) + ) + ) + + (func (export "nested-br_if-value-cond") (param i32) (result i32) + (block (result i32) + (i32.add + (i32.const 1) + (block (result i32) + (drop (i32.const 2)) + (drop + (br_if 0 (i32.const 4) (br_table 0 1 0 (i32.const 8) (local.get 0))) + ) + (i32.const 16) + ) + ) + ) + ) + + (func (export "nested-br_table-value") (param i32) (result i32) + (block (result i32) + (i32.add + (i32.const 1) + (block (result i32) + (drop (i32.const 2)) + (drop + (block (result i32) + (drop (i32.const 4)) + (br_table 0 (br_table 0 1 2 (i32.const 8) (local.get 0)) (i32.const 1)) + (i32.const 32) + ) + ) + (i32.const 16) + ) + ) + ) + ) + + (func (export "nested-br_table-value-index") (param i32) (result i32) + (block (result i32) + (i32.add + (i32.const 1) + (block (result i32) + (drop (i32.const 2)) + (br_table 0 (i32.const 4) (br_table 0 1 0 (i32.const 8) (local.get 0))) + (i32.const 16) + ) + ) + ) + ) + + (func (export "nested-br_table-loop-block") (param i32) (result i32) + (local.set 0 + (loop (result i32) + (block + (br_table 1 0 0 (local.get 0)) + ) + (i32.const 0) + ) + ) + (loop (result i32) + (block + (br_table 0 1 1 (local.get 0)) + ) + (i32.const 3) + ) + ) + + (func (export "meet-anyref") (param i32) (param anyref) (result anyref) + (block $l1 (result anyref) + (block $l2 (result anyref) + (br_table $l1 $l2 $l1 (local.get 1) (local.get 0)) + ) + ) + ) + + (func (export "meet-funcref-1") (param i32) (result anyref) + (block $l1 (result anyref) + (block $l2 (result funcref) + (br_table $l1 $l1 $l2 (table.get 0 (i32.const 0)) (local.get 0)) + ) + ) + ) + (func (export "meet-funcref-2") (param i32) (result anyref) + (block $l1 (result anyref) + (block $l2 (result funcref) + (br_table $l2 $l2 $l1 (table.get 0 (i32.const 0)) (local.get 0)) + ) + ) + ) + (func (export "meet-funcref-3") (param i32) (result anyref) + (block $l1 (result anyref) + (block $l2 (result funcref) + (br_table $l2 $l1 $l2 (table.get 0 (i32.const 0)) (local.get 0)) + ) + ) + ) + (func (export "meet-funcref-4") (param i32) (result anyref) + (block $l1 (result anyref) + (block $l2 (result funcref) + (br_table $l1 $l2 $l1 (table.get 0 (i32.const 0)) (local.get 0)) + ) + ) + ) + + (func (export "meet-nullref") (param i32) (result funcref) + (block $l1 (result funcref) + (block $l2 (result nullref) + (br_table $l1 $l2 $l1 (ref.null) (local.get 0)) + ) + ) + ) + + (func (export "meet-multi-ref") (param i32) (result anyref) + (block $l1 (result anyref) + (block $l2 (result funcref) + (block $l3 (result nullref) + (br_table $l3 $l2 $l1 (ref.null) (local.get 0)) + ) + ) + ) + ) + + (func (export "meet-bottom") + (block (result f64) + (block (result f32) + (unreachable) + (br_table 0 1 1 (i32.const 1)) + ) + (drop) + (f64.const 0) + ) + (drop) + ) +) + +(assert_return (invoke "type-i32")) +(assert_return (invoke "type-i64")) +(assert_return (invoke "type-f32")) +(assert_return (invoke "type-f64")) + +(assert_return (invoke "type-i32-value") (i32.const 1)) +(assert_return (invoke "type-i64-value") (i64.const 2)) +(assert_return (invoke "type-f32-value") (f32.const 3)) +(assert_return (invoke "type-f64-value") (f64.const 4)) + +(assert_return (invoke "empty" (i32.const 0)) (i32.const 22)) +(assert_return (invoke "empty" (i32.const 1)) (i32.const 22)) +(assert_return (invoke "empty" (i32.const 11)) (i32.const 22)) +(assert_return (invoke "empty" (i32.const -1)) (i32.const 22)) +(assert_return (invoke "empty" (i32.const -100)) (i32.const 22)) +(assert_return (invoke "empty" (i32.const 0xffffffff)) (i32.const 22)) + +(assert_return (invoke "empty-value" (i32.const 0)) (i32.const 33)) +(assert_return (invoke "empty-value" (i32.const 1)) (i32.const 33)) +(assert_return (invoke "empty-value" (i32.const 11)) (i32.const 33)) +(assert_return (invoke "empty-value" (i32.const -1)) (i32.const 33)) +(assert_return (invoke "empty-value" (i32.const -100)) (i32.const 33)) +(assert_return (invoke "empty-value" (i32.const 0xffffffff)) (i32.const 33)) + +(assert_return (invoke "singleton" (i32.const 0)) (i32.const 22)) +(assert_return (invoke "singleton" (i32.const 1)) (i32.const 20)) +(assert_return (invoke "singleton" (i32.const 11)) (i32.const 20)) +(assert_return (invoke "singleton" (i32.const -1)) (i32.const 20)) +(assert_return (invoke "singleton" (i32.const -100)) (i32.const 20)) +(assert_return (invoke "singleton" (i32.const 0xffffffff)) (i32.const 20)) + +(assert_return (invoke "singleton-value" (i32.const 0)) (i32.const 32)) +(assert_return (invoke "singleton-value" (i32.const 1)) (i32.const 33)) +(assert_return (invoke "singleton-value" (i32.const 11)) (i32.const 33)) +(assert_return (invoke "singleton-value" (i32.const -1)) (i32.const 33)) +(assert_return (invoke "singleton-value" (i32.const -100)) (i32.const 33)) +(assert_return (invoke "singleton-value" (i32.const 0xffffffff)) (i32.const 33)) + +(assert_return (invoke "multiple" (i32.const 0)) (i32.const 103)) +(assert_return (invoke "multiple" (i32.const 1)) (i32.const 102)) +(assert_return (invoke "multiple" (i32.const 2)) (i32.const 101)) +(assert_return (invoke "multiple" (i32.const 3)) (i32.const 100)) +(assert_return (invoke "multiple" (i32.const 4)) (i32.const 104)) +(assert_return (invoke "multiple" (i32.const 5)) (i32.const 104)) +(assert_return (invoke "multiple" (i32.const 6)) (i32.const 104)) +(assert_return (invoke "multiple" (i32.const 10)) (i32.const 104)) +(assert_return (invoke "multiple" (i32.const -1)) (i32.const 104)) +(assert_return (invoke "multiple" (i32.const 0xffffffff)) (i32.const 104)) + +(assert_return (invoke "multiple-value" (i32.const 0)) (i32.const 213)) +(assert_return (invoke "multiple-value" (i32.const 1)) (i32.const 212)) +(assert_return (invoke "multiple-value" (i32.const 2)) (i32.const 211)) +(assert_return (invoke "multiple-value" (i32.const 3)) (i32.const 210)) +(assert_return (invoke "multiple-value" (i32.const 4)) (i32.const 214)) +(assert_return (invoke "multiple-value" (i32.const 5)) (i32.const 214)) +(assert_return (invoke "multiple-value" (i32.const 6)) (i32.const 214)) +(assert_return (invoke "multiple-value" (i32.const 10)) (i32.const 214)) +(assert_return (invoke "multiple-value" (i32.const -1)) (i32.const 214)) +(assert_return (invoke "multiple-value" (i32.const 0xffffffff)) (i32.const 214)) + +(assert_return (invoke "large" (i32.const 0)) (i32.const 0)) +(assert_return (invoke "large" (i32.const 1)) (i32.const 1)) +(assert_return (invoke "large" (i32.const 100)) (i32.const 0)) +(assert_return (invoke "large" (i32.const 101)) (i32.const 1)) +(assert_return (invoke "large" (i32.const 10000)) (i32.const 0)) +(assert_return (invoke "large" (i32.const 10001)) (i32.const 1)) +(assert_return (invoke "large" (i32.const 1000000)) (i32.const 1)) +(assert_return (invoke "large" (i32.const 1000001)) (i32.const 1)) + +(assert_return (invoke "as-block-first")) +(assert_return (invoke "as-block-mid")) +(assert_return (invoke "as-block-last")) +(assert_return (invoke "as-block-value") (i32.const 2)) + +(assert_return (invoke "as-loop-first") (i32.const 3)) +(assert_return (invoke "as-loop-mid") (i32.const 4)) +(assert_return (invoke "as-loop-last") (i32.const 5)) + +(assert_return (invoke "as-br-value") (i32.const 9)) + +(assert_return (invoke "as-br_if-cond")) +(assert_return (invoke "as-br_if-value") (i32.const 8)) +(assert_return (invoke "as-br_if-value-cond") (i32.const 9)) + +(assert_return (invoke "as-br_table-index")) +(assert_return (invoke "as-br_table-value") (i32.const 10)) +(assert_return (invoke "as-br_table-value-index") (i32.const 11)) + +(assert_return (invoke "as-return-value") (i64.const 7)) + +(assert_return (invoke "as-if-cond") (i32.const 2)) +(assert_return (invoke "as-if-then" (i32.const 1) (i32.const 6)) (i32.const 3)) +(assert_return (invoke "as-if-then" (i32.const 0) (i32.const 6)) (i32.const 6)) +(assert_return (invoke "as-if-else" (i32.const 0) (i32.const 6)) (i32.const 4)) +(assert_return (invoke "as-if-else" (i32.const 1) (i32.const 6)) (i32.const 6)) + +(assert_return (invoke "as-select-first" (i32.const 0) (i32.const 6)) (i32.const 5)) +(assert_return (invoke "as-select-first" (i32.const 1) (i32.const 6)) (i32.const 5)) +(assert_return (invoke "as-select-second" (i32.const 0) (i32.const 6)) (i32.const 6)) +(assert_return (invoke "as-select-second" (i32.const 1) (i32.const 6)) (i32.const 6)) +(assert_return (invoke "as-select-cond") (i32.const 7)) + +(assert_return (invoke "as-call-first") (i32.const 12)) +(assert_return (invoke "as-call-mid") (i32.const 13)) +(assert_return (invoke "as-call-last") (i32.const 14)) + +(assert_return (invoke "as-call_indirect-first") (i32.const 20)) +(assert_return (invoke "as-call_indirect-mid") (i32.const 21)) +(assert_return (invoke "as-call_indirect-last") (i32.const 22)) +(assert_return (invoke "as-call_indirect-func") (i32.const 23)) + +(assert_return (invoke "as-local.set-value") (i32.const 17)) +(assert_return (invoke "as-local.tee-value") (i32.const 1)) +(assert_return (invoke "as-global.set-value") (i32.const 1)) + +(assert_return (invoke "as-load-address") (f32.const 1.7)) +(assert_return (invoke "as-loadN-address") (i64.const 30)) + +(assert_return (invoke "as-store-address") (i32.const 30)) +(assert_return (invoke "as-store-value") (i32.const 31)) +(assert_return (invoke "as-storeN-address") (i32.const 32)) +(assert_return (invoke "as-storeN-value") (i32.const 33)) + +(assert_return (invoke "as-unary-operand") (f32.const 3.4)) + +(assert_return (invoke "as-binary-left") (i32.const 3)) +(assert_return (invoke "as-binary-right") (i64.const 45)) + +(assert_return (invoke "as-test-operand") (i32.const 44)) + +(assert_return (invoke "as-compare-left") (i32.const 43)) +(assert_return (invoke "as-compare-right") (i32.const 42)) + +(assert_return (invoke "as-convert-operand") (i32.const 41)) + +(assert_return (invoke "as-memory.grow-size") (i32.const 40)) + +(assert_return (invoke "nested-block-value" (i32.const 0)) (i32.const 19)) +(assert_return (invoke "nested-block-value" (i32.const 1)) (i32.const 17)) +(assert_return (invoke "nested-block-value" (i32.const 2)) (i32.const 16)) +(assert_return (invoke "nested-block-value" (i32.const 10)) (i32.const 16)) +(assert_return (invoke "nested-block-value" (i32.const -1)) (i32.const 16)) +(assert_return (invoke "nested-block-value" (i32.const 100000)) (i32.const 16)) + +(assert_return (invoke "nested-br-value" (i32.const 0)) (i32.const 8)) +(assert_return (invoke "nested-br-value" (i32.const 1)) (i32.const 9)) +(assert_return (invoke "nested-br-value" (i32.const 2)) (i32.const 17)) +(assert_return (invoke "nested-br-value" (i32.const 11)) (i32.const 17)) +(assert_return (invoke "nested-br-value" (i32.const -4)) (i32.const 17)) +(assert_return (invoke "nested-br-value" (i32.const 10213210)) (i32.const 17)) + +(assert_return (invoke "nested-br_if-value" (i32.const 0)) (i32.const 17)) +(assert_return (invoke "nested-br_if-value" (i32.const 1)) (i32.const 9)) +(assert_return (invoke "nested-br_if-value" (i32.const 2)) (i32.const 8)) +(assert_return (invoke "nested-br_if-value" (i32.const 9)) (i32.const 8)) +(assert_return (invoke "nested-br_if-value" (i32.const -9)) (i32.const 8)) +(assert_return (invoke "nested-br_if-value" (i32.const 999999)) (i32.const 8)) + +(assert_return (invoke "nested-br_if-value-cond" (i32.const 0)) (i32.const 9)) +(assert_return (invoke "nested-br_if-value-cond" (i32.const 1)) (i32.const 8)) +(assert_return (invoke "nested-br_if-value-cond" (i32.const 2)) (i32.const 9)) +(assert_return (invoke "nested-br_if-value-cond" (i32.const 3)) (i32.const 9)) +(assert_return (invoke "nested-br_if-value-cond" (i32.const -1000000)) (i32.const 9)) +(assert_return (invoke "nested-br_if-value-cond" (i32.const 9423975)) (i32.const 9)) + +(assert_return (invoke "nested-br_table-value" (i32.const 0)) (i32.const 17)) +(assert_return (invoke "nested-br_table-value" (i32.const 1)) (i32.const 9)) +(assert_return (invoke "nested-br_table-value" (i32.const 2)) (i32.const 8)) +(assert_return (invoke "nested-br_table-value" (i32.const 9)) (i32.const 8)) +(assert_return (invoke "nested-br_table-value" (i32.const -9)) (i32.const 8)) +(assert_return (invoke "nested-br_table-value" (i32.const 999999)) (i32.const 8)) + +(assert_return (invoke "nested-br_table-value-index" (i32.const 0)) (i32.const 9)) +(assert_return (invoke "nested-br_table-value-index" (i32.const 1)) (i32.const 8)) +(assert_return (invoke "nested-br_table-value-index" (i32.const 2)) (i32.const 9)) +(assert_return (invoke "nested-br_table-value-index" (i32.const 3)) (i32.const 9)) +(assert_return (invoke "nested-br_table-value-index" (i32.const -1000000)) (i32.const 9)) +(assert_return (invoke "nested-br_table-value-index" (i32.const 9423975)) (i32.const 9)) + +(assert_return (invoke "nested-br_table-loop-block" (i32.const 1)) (i32.const 3)) + +(assert_return (invoke "meet-anyref" (i32.const 0) (ref.host 1)) (ref.host 1)) +(assert_return (invoke "meet-anyref" (i32.const 1) (ref.host 1)) (ref.host 1)) +(assert_return (invoke "meet-anyref" (i32.const 2) (ref.host 1)) (ref.host 1)) + +(assert_return (invoke "meet-funcref-1" (i32.const 0)) (ref.func)) +(assert_return (invoke "meet-funcref-1" (i32.const 1)) (ref.func)) +(assert_return (invoke "meet-funcref-1" (i32.const 2)) (ref.func)) +(assert_return (invoke "meet-funcref-2" (i32.const 0)) (ref.func)) +(assert_return (invoke "meet-funcref-2" (i32.const 1)) (ref.func)) +(assert_return (invoke "meet-funcref-2" (i32.const 2)) (ref.func)) +(assert_return (invoke "meet-funcref-3" (i32.const 0)) (ref.func)) +(assert_return (invoke "meet-funcref-3" (i32.const 1)) (ref.func)) +(assert_return (invoke "meet-funcref-3" (i32.const 2)) (ref.func)) +(assert_return (invoke "meet-funcref-4" (i32.const 0)) (ref.func)) +(assert_return (invoke "meet-funcref-4" (i32.const 1)) (ref.func)) +(assert_return (invoke "meet-funcref-4" (i32.const 2)) (ref.func)) + +(assert_invalid + (module (func $type-arg-void-vs-num (result i32) + (block (br_table 0 (i32.const 1)) (i32.const 1)) + )) + "type mismatch" +) + +(assert_invalid + (module (func $type-arg-empty-vs-num (result i32) + (block (br_table 0) (i32.const 1)) + )) + "type mismatch" +) + +(assert_invalid + (module (func $type-arg-void-vs-num (result i32) + (block (result i32) (br_table 0 (nop) (i32.const 1)) (i32.const 1)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-arg-num-vs-num (result i32) + (block (result i32) + (br_table 0 0 0 (i64.const 1) (i32.const 1)) (i32.const 1) + ) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-arg-num-vs-arg-num + (block + (block (result f32) + (br_table 0 1 (f32.const 0) (i32.const 0)) + ) + (drop) + ) + )) + "type mismatch" +) + +(assert_invalid + (module (func $type-index-void-vs-i32 + (block (br_table 0 0 0 (nop))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-index-num-vs-i32 + (block (br_table 0 (i64.const 0))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-arg-index-void-vs-i32 (result i32) + (block (result i32) (br_table 0 0 (i32.const 0) (nop)) (i32.const 1)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-arg-void-vs-num-nested (result i32) + (block (result i32) (i32.const 0) (block (br_table 1 (i32.const 0)))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-arg-index-num-vs-i32 (result i32) + (block (result i32) + (br_table 0 0 (i32.const 0) (i64.const 0)) (i32.const 1) + ) + )) + "type mismatch" +) + +(assert_invalid + (module (func $type-arg-void-vs-num (result i32) + (block (br_table 0 (i32.const 1)) (i32.const 1)) + )) + "type mismatch" +) + +(assert_invalid + (module + (func $type-arg-index-empty-in-then + (block + (i32.const 0) (i32.const 0) + (if (result i32) (then (br_table 0))) + ) + (i32.eqz) (drop) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-arg-value-empty-in-then + (block + (i32.const 0) (i32.const 0) + (if (result i32) (then (br_table 0 (i32.const 1)))) + ) + (i32.eqz) (drop) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-arg-index-empty-in-return + (block (result i32) + (return (br_table 0)) + ) + (i32.eqz) (drop) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-arg-value-empty-in-return + (block (result i32) + (return (br_table 0 (i32.const 1))) + ) + (i32.eqz) (drop) + ) + ) + "type mismatch" +) + +(assert_invalid + (module (func $meet-bottom (param i32) (result anyref) + (block $l1 (result anyref) + (drop + (block $l2 (result i32) + (br_table $l2 $l1 $l2 (ref.null) (local.get 0)) + ) + ) + (ref.null) + ) + )) + "type mismatch" +) + +(assert_invalid + (module (func $unbound-label + (block (br_table 2 1 (i32.const 1))) + )) + "unknown label" +) +(assert_invalid + (module (func $unbound-nested-label + (block (block (br_table 0 5 (i32.const 1)))) + )) + "unknown label" +) +(assert_invalid + (module (func $large-label + (block (br_table 0 0x10000001 0 (i32.const 1))) + )) + "unknown label" +) + +(assert_invalid + (module (func $unbound-label-default + (block (br_table 1 2 (i32.const 1))) + )) + "unknown label" +) +(assert_invalid + (module (func $unbound-nested-label-default + (block (block (br_table 0 5 (i32.const 1)))) + )) + "unknown label" +) +(assert_invalid + (module (func $large-label-default + (block (br_table 0 0 0x10000001 (i32.const 1))) + )) + "unknown label" +) + diff --git a/runtime/near-vm/tests/wast/spec/proposals/reference-types/bulk.wast b/runtime/near-vm/tests/wast/spec/proposals/reference-types/bulk.wast new file mode 100644 index 00000000000..fe71939d3ba --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/proposals/reference-types/bulk.wast @@ -0,0 +1,307 @@ +;; segment syntax +(module + (memory 1) + (data "foo")) + +(module + (table 3 funcref) + (elem funcref (ref.func 0) (ref.null) (ref.func 1)) + (func) + (func)) + +;; memory.fill +(module + (memory 1) + + (func (export "fill") (param i32 i32 i32) + (memory.fill + (local.get 0) + (local.get 1) + (local.get 2))) + + (func (export "load8_u") (param i32) (result i32) + (i32.load8_u (local.get 0))) +) + +;; Basic fill test. +(invoke "fill" (i32.const 1) (i32.const 0xff) (i32.const 3)) +(assert_return (invoke "load8_u" (i32.const 0)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 1)) (i32.const 0xff)) +(assert_return (invoke "load8_u" (i32.const 2)) (i32.const 0xff)) +(assert_return (invoke "load8_u" (i32.const 3)) (i32.const 0xff)) +(assert_return (invoke "load8_u" (i32.const 4)) (i32.const 0)) + +;; Fill value is stored as a byte. +(invoke "fill" (i32.const 0) (i32.const 0xbbaa) (i32.const 2)) +(assert_return (invoke "load8_u" (i32.const 0)) (i32.const 0xaa)) +(assert_return (invoke "load8_u" (i32.const 1)) (i32.const 0xaa)) + +;; Fill all of memory +(invoke "fill" (i32.const 0) (i32.const 0) (i32.const 0x10000)) + +;; Out-of-bounds writes trap, and nothing is written +(assert_trap (invoke "fill" (i32.const 0xff00) (i32.const 1) (i32.const 0x101)) + "out of bounds memory access") +(assert_return (invoke "load8_u" (i32.const 0xff00)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 0xffff)) (i32.const 0)) + +;; Succeed when writing 0 bytes at the end of the region. +(invoke "fill" (i32.const 0x10000) (i32.const 0) (i32.const 0)) + +;; Writing 0 bytes outside the memory traps. +(assert_trap (invoke "fill" (i32.const 0x10001) (i32.const 0) (i32.const 0)) + "out of bounds memory access") + + +;; memory.copy +(module + (memory (data "\aa\bb\cc\dd")) + + (func (export "copy") (param i32 i32 i32) + (memory.copy + (local.get 0) + (local.get 1) + (local.get 2))) + + (func (export "load8_u") (param i32) (result i32) + (i32.load8_u (local.get 0))) +) + +;; Non-overlapping copy. +(invoke "copy" (i32.const 10) (i32.const 0) (i32.const 4)) + +(assert_return (invoke "load8_u" (i32.const 9)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 10)) (i32.const 0xaa)) +(assert_return (invoke "load8_u" (i32.const 11)) (i32.const 0xbb)) +(assert_return (invoke "load8_u" (i32.const 12)) (i32.const 0xcc)) +(assert_return (invoke "load8_u" (i32.const 13)) (i32.const 0xdd)) +(assert_return (invoke "load8_u" (i32.const 14)) (i32.const 0)) + +;; Overlap, source > dest +(invoke "copy" (i32.const 8) (i32.const 10) (i32.const 4)) +(assert_return (invoke "load8_u" (i32.const 8)) (i32.const 0xaa)) +(assert_return (invoke "load8_u" (i32.const 9)) (i32.const 0xbb)) +(assert_return (invoke "load8_u" (i32.const 10)) (i32.const 0xcc)) +(assert_return (invoke "load8_u" (i32.const 11)) (i32.const 0xdd)) +(assert_return (invoke "load8_u" (i32.const 12)) (i32.const 0xcc)) +(assert_return (invoke "load8_u" (i32.const 13)) (i32.const 0xdd)) + +;; Overlap, source < dest +(invoke "copy" (i32.const 10) (i32.const 7) (i32.const 6)) +(assert_return (invoke "load8_u" (i32.const 10)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 11)) (i32.const 0xaa)) +(assert_return (invoke "load8_u" (i32.const 12)) (i32.const 0xbb)) +(assert_return (invoke "load8_u" (i32.const 13)) (i32.const 0xcc)) +(assert_return (invoke "load8_u" (i32.const 14)) (i32.const 0xdd)) +(assert_return (invoke "load8_u" (i32.const 15)) (i32.const 0xcc)) +(assert_return (invoke "load8_u" (i32.const 16)) (i32.const 0)) + +;; Copy ending at memory limit is ok. +(invoke "copy" (i32.const 0xff00) (i32.const 0) (i32.const 0x100)) +(invoke "copy" (i32.const 0xfe00) (i32.const 0xff00) (i32.const 0x100)) + +;; Succeed when copying 0 bytes at the end of the region. +(invoke "copy" (i32.const 0x10000) (i32.const 0) (i32.const 0)) +(invoke "copy" (i32.const 0) (i32.const 0x10000) (i32.const 0)) + +;; Copying 0 bytes outside the memory traps. +(assert_trap (invoke "copy" (i32.const 0x10001) (i32.const 0) (i32.const 0)) + "out of bounds memory access") +(assert_trap (invoke "copy" (i32.const 0) (i32.const 0x10001) (i32.const 0)) + "out of bounds memory access") + + +;; memory.init +(module + (memory 1) + (data "\aa\bb\cc\dd") + + (func (export "init") (param i32 i32 i32) + (memory.init 0 + (local.get 0) + (local.get 1) + (local.get 2))) + + (func (export "load8_u") (param i32) (result i32) + (i32.load8_u (local.get 0))) +) + +(invoke "init" (i32.const 0) (i32.const 1) (i32.const 2)) +(assert_return (invoke "load8_u" (i32.const 0)) (i32.const 0xbb)) +(assert_return (invoke "load8_u" (i32.const 1)) (i32.const 0xcc)) +(assert_return (invoke "load8_u" (i32.const 2)) (i32.const 0)) + +;; Init ending at memory limit and segment limit is ok. +(invoke "init" (i32.const 0xfffc) (i32.const 0) (i32.const 4)) + +;; Out-of-bounds writes trap, and nothing is written. +(assert_trap (invoke "init" (i32.const 0xfffe) (i32.const 0) (i32.const 3)) + "out of bounds memory access") +(assert_return (invoke "load8_u" (i32.const 0xfffe)) (i32.const 0xcc)) +(assert_return (invoke "load8_u" (i32.const 0xffff)) (i32.const 0xdd)) + +;; Succeed when writing 0 bytes at the end of either region. +(invoke "init" (i32.const 0x10000) (i32.const 0) (i32.const 0)) +(invoke "init" (i32.const 0) (i32.const 4) (i32.const 0)) + +;; Writing 0 bytes outside the memory traps. +(assert_trap (invoke "init" (i32.const 0x10001) (i32.const 0) (i32.const 0)) + "out of bounds memory access") +(assert_trap (invoke "init" (i32.const 0) (i32.const 5) (i32.const 0)) + "out of bounds memory access") + +;; data.drop +(module + (memory 1) + (data $p "x") + (data $a (memory 0) (i32.const 0) "x") + + (func (export "drop_passive") (data.drop $p)) + (func (export "init_passive") (param $len i32) + (memory.init $p (i32.const 0) (i32.const 0) (local.get $len))) + + (func (export "drop_active") (data.drop $a)) + (func (export "init_active") (param $len i32) + (memory.init $a (i32.const 0) (i32.const 0) (local.get $len))) +) + +(invoke "init_passive" (i32.const 1)) +(invoke "drop_passive") +(invoke "drop_passive") +(assert_return (invoke "init_passive" (i32.const 0))) +(assert_trap (invoke "init_passive" (i32.const 1)) "out of bounds") +(invoke "init_passive" (i32.const 0)) +(invoke "drop_active") +(assert_return (invoke "init_active" (i32.const 0))) +(assert_trap (invoke "init_active" (i32.const 1)) "out of bounds") +(invoke "init_active" (i32.const 0)) + + +;; table.init +(module + (table 3 funcref) + (elem funcref + (ref.func $zero) (ref.func $one) (ref.func $zero) (ref.func $one)) + + (func $zero (result i32) (i32.const 0)) + (func $one (result i32) (i32.const 1)) + + (func (export "init") (param i32 i32 i32) + (table.init 0 + (local.get 0) + (local.get 1) + (local.get 2))) + + (func (export "call") (param i32) (result i32) + (call_indirect (result i32) + (local.get 0))) +) + +;; Out-of-bounds stores trap, and nothing is written. +(assert_trap (invoke "init" (i32.const 2) (i32.const 0) (i32.const 2)) + "out of bounds table access") +(assert_trap (invoke "call" (i32.const 2)) + "uninitialized element 2") + +(invoke "init" (i32.const 0) (i32.const 1) (i32.const 2)) +(assert_return (invoke "call" (i32.const 0)) (i32.const 1)) +(assert_return (invoke "call" (i32.const 1)) (i32.const 0)) +(assert_trap (invoke "call" (i32.const 2)) "uninitialized element") + +;; Init ending at table limit and segment limit is ok. +(invoke "init" (i32.const 1) (i32.const 2) (i32.const 2)) + +;; Succeed when storing 0 elements at the end of either region. +(invoke "init" (i32.const 3) (i32.const 0) (i32.const 0)) +(invoke "init" (i32.const 0) (i32.const 4) (i32.const 0)) + +;; Writing 0 elements outside the table traps. +(assert_trap (invoke "init" (i32.const 4) (i32.const 0) (i32.const 0)) + "out of bounds table access") +(assert_trap (invoke "init" (i32.const 0) (i32.const 5) (i32.const 0)) + "out of bounds table access") + + +;; elem.drop +(module + (table 1 funcref) + (func $f) + (elem $p funcref (ref.func $f)) + (elem $a (table 0) (i32.const 0) func $f) + + (func (export "drop_passive") (elem.drop $p)) + (func (export "init_passive") (param $len i32) + (table.init $p (i32.const 0) (i32.const 0) (local.get $len)) + ) + + (func (export "drop_active") (elem.drop $a)) + (func (export "init_active") (param $len i32) + (table.init $a (i32.const 0) (i32.const 0) (local.get $len)) + ) +) + +(invoke "init_passive" (i32.const 1)) +(invoke "drop_passive") +(invoke "drop_passive") +(assert_return (invoke "init_passive" (i32.const 0))) +(assert_trap (invoke "init_passive" (i32.const 1)) "out of bounds") +(invoke "init_passive" (i32.const 0)) +(invoke "drop_active") +(assert_return (invoke "init_active" (i32.const 0))) +(assert_trap (invoke "init_active" (i32.const 1)) "out of bounds") +(invoke "init_active" (i32.const 0)) + + +;; table.copy +(module + (table 10 funcref) + (elem (i32.const 0) $zero $one $two) + (func $zero (result i32) (i32.const 0)) + (func $one (result i32) (i32.const 1)) + (func $two (result i32) (i32.const 2)) + + (func (export "copy") (param i32 i32 i32) + (table.copy + (local.get 0) + (local.get 1) + (local.get 2))) + + (func (export "call") (param i32) (result i32) + (call_indirect (result i32) + (local.get 0))) +) + +;; Non-overlapping copy. +(invoke "copy" (i32.const 3) (i32.const 0) (i32.const 3)) +;; Now [$zero, $one, $two, $zero, $one, $two, ...] +(assert_return (invoke "call" (i32.const 3)) (i32.const 0)) +(assert_return (invoke "call" (i32.const 4)) (i32.const 1)) +(assert_return (invoke "call" (i32.const 5)) (i32.const 2)) + +;; Overlap, source > dest +(invoke "copy" (i32.const 0) (i32.const 1) (i32.const 3)) +;; Now [$one, $two, $zero, $zero, $one, $two, ...] +(assert_return (invoke "call" (i32.const 0)) (i32.const 1)) +(assert_return (invoke "call" (i32.const 1)) (i32.const 2)) +(assert_return (invoke "call" (i32.const 2)) (i32.const 0)) + +;; Overlap, source < dest +(invoke "copy" (i32.const 2) (i32.const 0) (i32.const 3)) +;; Now [$one, $two, $one, $two, $zero, $two, ...] +(assert_return (invoke "call" (i32.const 2)) (i32.const 1)) +(assert_return (invoke "call" (i32.const 3)) (i32.const 2)) +(assert_return (invoke "call" (i32.const 4)) (i32.const 0)) + +;; Copy ending at table limit is ok. +(invoke "copy" (i32.const 6) (i32.const 8) (i32.const 2)) +(invoke "copy" (i32.const 8) (i32.const 6) (i32.const 2)) + +;; Succeed when copying 0 elements at the end of the region. +(invoke "copy" (i32.const 10) (i32.const 0) (i32.const 0)) +(invoke "copy" (i32.const 0) (i32.const 10) (i32.const 0)) + +;; Fail on out-of-bounds when copying 0 elements outside of table. +(assert_trap (invoke "copy" (i32.const 11) (i32.const 0) (i32.const 0)) + "out of bounds") +(assert_trap (invoke "copy" (i32.const 0) (i32.const 11) (i32.const 0)) + "out of bounds") diff --git a/runtime/near-vm/tests/wast/spec/proposals/reference-types/custom.wast b/runtime/near-vm/tests/wast/spec/proposals/reference-types/custom.wast new file mode 100644 index 00000000000..0310f76b546 --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/proposals/reference-types/custom.wast @@ -0,0 +1,130 @@ +(module binary + "\00asm" "\01\00\00\00" + "\00\24\10" "a custom section" "this is the payload" + "\00\20\10" "a custom section" "this is payload" + "\00\11\10" "a custom section" "" + "\00\10\00" "" "this is payload" + "\00\01\00" "" "" + "\00\24\10" "\00\00custom sectio\00" "this is the payload" + "\00\24\10" "\ef\bb\bfa custom sect" "this is the payload" + "\00\24\10" "a custom sect\e2\8c\a3" "this is the payload" + "\00\1f\16" "module within a module" "\00asm" "\01\00\00\00" +) + +(module binary + "\00asm" "\01\00\00\00" + "\00\0e\06" "custom" "payload" + "\00\0e\06" "custom" "payload" + "\01\01\00" ;; type section + "\00\0e\06" "custom" "payload" + "\00\0e\06" "custom" "payload" + "\02\01\00" ;; import section + "\00\0e\06" "custom" "payload" + "\00\0e\06" "custom" "payload" + "\03\01\00" ;; function section + "\00\0e\06" "custom" "payload" + "\00\0e\06" "custom" "payload" + "\04\01\00" ;; table section + "\00\0e\06" "custom" "payload" + "\00\0e\06" "custom" "payload" + "\05\01\00" ;; memory section + "\00\0e\06" "custom" "payload" + "\00\0e\06" "custom" "payload" + "\06\01\00" ;; global section + "\00\0e\06" "custom" "payload" + "\00\0e\06" "custom" "payload" + "\07\01\00" ;; export section + "\00\0e\06" "custom" "payload" + "\00\0e\06" "custom" "payload" + "\09\01\00" ;; element section + "\00\0e\06" "custom" "payload" + "\00\0e\06" "custom" "payload" + "\0a\01\00" ;; code section + "\00\0e\06" "custom" "payload" + "\00\0e\06" "custom" "payload" + "\0b\01\00" ;; data section + "\00\0e\06" "custom" "payload" + "\00\0e\06" "custom" "payload" +) + +(module binary + "\00asm" "\01\00\00\00" + "\01\07\01\60\02\7f\7f\01\7f" ;; type section + "\00\1a\06" "custom" "this is the payload" ;; custom section + "\03\02\01\00" ;; function section + "\07\0a\01\06\61\64\64\54\77\6f\00\00" ;; export section + "\0a\09\01\07\00\20\00\20\01\6a\0b" ;; code section + "\00\1b\07" "custom2" "this is the payload" ;; custom section +) + +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00" + ) + "unexpected end" +) + +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\00" + ) + "unexpected end" +) + +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\00\00\05\01\00\07\00\00" + ) + "unexpected end" +) + +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\26\10" "a custom section" "this is the payload" + ) + "unexpected end" +) + +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\25\10" "a custom section" "this is the payload" + "\00\24\10" "a custom section" "this is the payload" + ) + "invalid section id" +) + +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\01\07\01\60\02\7f\7f\01\7f" ;; type section + "\00\25\10" "a custom section" "this is the payload" ;; invalid length! + "\03\02\01\00" ;; function section + "\0a\09\01\07\00\20\00\20\01\6a\0b" ;; code section + "\00\1b\07" "custom2" "this is the payload" ;; custom section + ) + "function and code section have inconsistent lengths" +) + +;; Test concatenated modules. +(assert_malformed + (module binary + "\00asm\01\00\00\00" + "\00asm\01\00\00\00" + ) + "length out of bounds" +) + +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\05\03\01\00\01" ;; memory section + "\0c\01\02" ;; data count section (2 segments) + "\0b\06\01\00\41\00\0b\00" ;; data section (1 segment) + ) + "data count and data section have inconsistent lengths" +) diff --git a/runtime/near-vm/tests/wast/spec/proposals/reference-types/data.wast b/runtime/near-vm/tests/wast/spec/proposals/reference-types/data.wast new file mode 100644 index 00000000000..aabe1021b23 --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/proposals/reference-types/data.wast @@ -0,0 +1,345 @@ +;; Test the data section + +;; Syntax + +(module + (memory $m 1) + (data (i32.const 0)) + (data (i32.const 1) "a" "" "bcd") + (data (offset (i32.const 0))) + (data (offset (i32.const 0)) "" "a" "bc" "") + (data (memory 0) (i32.const 0)) + (data (memory 0x0) (i32.const 1) "a" "" "bcd") + (data (memory 0x000) (offset (i32.const 0))) + (data (memory 0) (offset (i32.const 0)) "" "a" "bc" "") + (data (memory $m) (i32.const 0)) + (data (memory $m) (i32.const 1) "a" "" "bcd") + (data (memory $m) (offset (i32.const 0))) + (data (memory $m) (offset (i32.const 0)) "" "a" "bc" "") + (data $d1 (i32.const 0)) + (data $d2 (i32.const 1) "a" "" "bcd") + (data $d3 (offset (i32.const 0))) + (data $d4 (offset (i32.const 0)) "" "a" "bc" "") + (data $d5 (memory 0) (i32.const 0)) + (data $d6 (memory 0x0) (i32.const 1) "a" "" "bcd") + (data $d7 (memory 0x000) (offset (i32.const 0))) + (data $d8 (memory 0) (offset (i32.const 0)) "" "a" "bc" "") + (data $d9 (memory $m) (i32.const 0)) + (data $d10 (memory $m) (i32.const 1) "a" "" "bcd") + (data $d11 (memory $m) (offset (i32.const 0))) + (data $d12 (memory $m) (offset (i32.const 0)) "" "a" "bc" "") +) + +;; Basic use + +(module + (memory 1) + (data (i32.const 0) "a") +) +(module + (import "spectest" "memory" (memory 1)) + (data (i32.const 0) "a") +) + +(module + (memory 1) + (data (i32.const 0) "a") + (data (i32.const 3) "b") + (data (i32.const 100) "cde") + (data (i32.const 5) "x") + (data (i32.const 3) "c") +) +(module + (import "spectest" "memory" (memory 1)) + (data (i32.const 0) "a") + (data (i32.const 1) "b") + (data (i32.const 2) "cde") + (data (i32.const 3) "f") + (data (i32.const 2) "g") + (data (i32.const 1) "h") +) + +(module + (global (import "spectest" "global_i32") i32) + (memory 1) + (data (global.get 0) "a") +) +(module + (global (import "spectest" "global_i32") i32) + (import "spectest" "memory" (memory 1)) + (data (global.get 0) "a") +) + +(module + (global $g (import "spectest" "global_i32") i32) + (memory 1) + (data (global.get $g) "a") +) +(module + (global $g (import "spectest" "global_i32") i32) + (import "spectest" "memory" (memory 1)) + (data (global.get $g) "a") +) + +;; Use of internal globals in constant expressions is not allowed in MVP. +;; (module (memory 1) (data (global.get 0) "a") (global i32 (i32.const 0))) +;; (module (memory 1) (data (global.get $g) "a") (global $g i32 (i32.const 0))) + +;; Corner cases + +(module + (memory 1) + (data (i32.const 0) "a") + (data (i32.const 0xffff) "b") +) +(module + (import "spectest" "memory" (memory 1)) + (data (i32.const 0) "a") + (data (i32.const 0xffff) "b") +) + +(module + (memory 2) + (data (i32.const 0x1_ffff) "a") +) + +(module + (memory 0) + (data (i32.const 0)) +) +(module + (import "spectest" "memory" (memory 0)) + (data (i32.const 0)) +) + +(module + (memory 0 0) + (data (i32.const 0)) +) + +(module + (memory 1) + (data (i32.const 0x1_0000) "") +) + +(module + (memory 0) + (data (i32.const 0) "" "") +) +(module + (import "spectest" "memory" (memory 0)) + (data (i32.const 0) "" "") +) + +(module + (memory 0 0) + (data (i32.const 0) "" "") +) + +(module + (import "spectest" "memory" (memory 0)) + (data (i32.const 0) "a") +) + +(module + (import "spectest" "memory" (memory 0 3)) + (data (i32.const 0) "a") +) + +(module + (global (import "spectest" "global_i32") i32) + (import "spectest" "memory" (memory 0)) + (data (global.get 0) "a") +) + +(module + (global (import "spectest" "global_i32") i32) + (import "spectest" "memory" (memory 0 3)) + (data (global.get 0) "a") +) + +(module + (import "spectest" "memory" (memory 0)) + (data (i32.const 1) "a") +) + +(module + (import "spectest" "memory" (memory 0 3)) + (data (i32.const 1) "a") +) + +;; Invalid bounds for data + +(assert_trap + (module + (memory 0) + (data (i32.const 0) "a") + ) + "out of bounds" +) + +(assert_trap + (module + (memory 0 0) + (data (i32.const 0) "a") + ) + "out of bounds" +) + +(assert_trap + (module + (memory 0 1) + (data (i32.const 0) "a") + ) + "out of bounds" +) +(assert_trap + (module + (memory 0) + (data (i32.const 1)) + ) + "out of bounds" +) +(assert_trap + (module + (memory 0 1) + (data (i32.const 1)) + ) + "out of bounds" +) + +;; This seems to cause a time-out on Travis. +(;assert_unlinkable + (module + (memory 0x10000) + (data (i32.const 0xffffffff) "ab") + ) + "" ;; either out of memory or out of bounds +;) + +(assert_trap + (module + (global (import "spectest" "global_i32") i32) + (memory 0) + (data (global.get 0) "a") + ) + "out of bounds" +) + +(assert_trap + (module + (memory 1 2) + (data (i32.const 0x1_0000) "a") + ) + "out of bounds" +) +(assert_trap + (module + (import "spectest" "memory" (memory 1)) + (data (i32.const 0x1_0000) "a") + ) + "out of bounds" +) + +(assert_trap + (module + (memory 2) + (data (i32.const 0x2_0000) "a") + ) + "out of bounds" +) + +(assert_trap + (module + (memory 2 3) + (data (i32.const 0x2_0000) "a") + ) + "out of bounds" +) + +(assert_trap + (module + (memory 1) + (data (i32.const -1) "a") + ) + "out of bounds" +) +(assert_trap + (module + (import "spectest" "memory" (memory 1)) + (data (i32.const -1) "a") + ) + "out of bounds" +) + +(assert_trap + (module + (memory 2) + (data (i32.const -100) "a") + ) + "out of bounds" +) +(assert_trap + (module + (import "spectest" "memory" (memory 1)) + (data (i32.const -100) "a") + ) + "out of bounds" +) + +;; Data without memory + +(assert_invalid + (module + (data (i32.const 0) "") + ) + "unknown memory" +) + +;; Invalid offsets + +(assert_invalid + (module + (memory 1) + (data (i64.const 0)) + ) + "type mismatch" +) + +(assert_invalid + (module + (memory 1) + (data (i32.ctz (i32.const 0))) + ) + "constant expression required" +) + +(assert_invalid + (module + (memory 1) + (data (nop)) + ) + "constant expression required" +) + +(assert_invalid + (module + (memory 1) + (data (offset (nop) (i32.const 0))) + ) + "constant expression required" +) + +(assert_invalid + (module + (memory 1) + (data (offset (i32.const 0) (nop))) + ) + "constant expression required" +) + +;; Use of internal globals in constant expressions is not allowed in MVP. +;; (assert_invalid +;; (module (memory 1) (data (global.get $g)) (global $g (mut i32) (i32.const 0))) +;; "constant expression required" +;; ) diff --git a/runtime/near-vm/tests/wast/spec/proposals/reference-types/elem.wast b/runtime/near-vm/tests/wast/spec/proposals/reference-types/elem.wast new file mode 100644 index 00000000000..6661c9a89f4 --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/proposals/reference-types/elem.wast @@ -0,0 +1,468 @@ +;; Test the element section + +;; Syntax +(module + (table $t 10 funcref) + (func $f) + (func $g) + + ;; Passive + (elem funcref) + (elem funcref (ref.func $f) (item ref.func $f) (item (ref.null)) (ref.func $g)) + (elem func) + (elem func $f $f $g $g) + + (elem $p1 funcref) + (elem $p2 funcref (ref.func $f) (ref.func $f) (ref.null) (ref.func $g)) + (elem $p3 func) + (elem $p4 func $f $f $g $g) + + ;; Active + (elem (table $t) (i32.const 0) funcref) + (elem (table $t) (i32.const 0) funcref (ref.func $f) (ref.null)) + (elem (table $t) (i32.const 0) func) + (elem (table $t) (i32.const 0) func $f $g) + (elem (table $t) (offset (i32.const 0)) funcref) + (elem (table $t) (offset (i32.const 0)) func $f $g) + (elem (table 0) (i32.const 0) func) + (elem (table 0x0) (i32.const 0) func $f $f) + (elem (table 0x000) (offset (i32.const 0)) func) + (elem (table 0) (offset (i32.const 0)) func $f $f) + (elem (table $t) (i32.const 0) func) + (elem (table $t) (i32.const 0) func $f $f) + (elem (table $t) (offset (i32.const 0)) func) + (elem (table $t) (offset (i32.const 0)) func $f $f) + (elem (offset (i32.const 0))) + (elem (offset (i32.const 0)) funcref (ref.func $f) (ref.null)) + (elem (offset (i32.const 0)) func $f $f) + (elem (offset (i32.const 0)) $f $f) + (elem (i32.const 0)) + (elem (i32.const 0) funcref (ref.func $f) (ref.null)) + (elem (i32.const 0) func $f $f) + (elem (i32.const 0) $f $f) + + (elem $a1 (table $t) (i32.const 0) funcref) + (elem $a2 (table $t) (i32.const 0) funcref (ref.func $f) (ref.null)) + (elem $a3 (table $t) (i32.const 0) func) + (elem $a4 (table $t) (i32.const 0) func $f $g) + (elem $a9 (table $t) (offset (i32.const 0)) funcref) + (elem $a10 (table $t) (offset (i32.const 0)) func $f $g) + (elem $a11 (table 0) (i32.const 0) func) + (elem $a12 (table 0x0) (i32.const 0) func $f $f) + (elem $a13 (table 0x000) (offset (i32.const 0)) func) + (elem $a14 (table 0) (offset (i32.const 0)) func $f $f) + (elem $a15 (table $t) (i32.const 0) func) + (elem $a16 (table $t) (i32.const 0) func $f $f) + (elem $a17 (table $t) (offset (i32.const 0)) func) + (elem $a18 (table $t) (offset (i32.const 0)) func $f $f) + (elem $a19 (offset (i32.const 0))) + (elem $a20 (offset (i32.const 0)) funcref (ref.func $f) (ref.null)) + (elem $a21 (offset (i32.const 0)) func $f $f) + (elem $a22 (offset (i32.const 0)) $f $f) + (elem $a23 (i32.const 0)) + (elem $a24 (i32.const 0) funcref (ref.func $f) (ref.null)) + (elem $a25 (i32.const 0) func $f $f) + (elem $a26 (i32.const 0) $f $f) + + ;; Declarative + (elem declare funcref) + (elem declare funcref (ref.func $f) (ref.func $f) (ref.null) (ref.func $g)) + (elem declare func) + (elem declare func $f $f $g $g) + + (elem $d1 declare funcref) + (elem $d2 declare funcref (ref.func $f) (ref.func $f) (ref.null) (ref.func $g)) + (elem $d3 declare func) + (elem $d4 declare func $f $f $g $g) +) + +(module + (func $f) + (func $g) + + (table $t funcref (elem (ref.func $f) (ref.null) (ref.func $g))) +) + + +;; Basic use + +(module + (table 10 funcref) + (func $f) + (elem (i32.const 0) $f) +) +(module + (import "spectest" "table" (table 10 funcref)) + (func $f) + (elem (i32.const 0) $f) +) + +(module + (table 10 funcref) + (func $f) + (elem (i32.const 0) $f) + (elem (i32.const 3) $f) + (elem (i32.const 7) $f) + (elem (i32.const 5) $f) + (elem (i32.const 3) $f) +) +(module + (import "spectest" "table" (table 10 funcref)) + (func $f) + (elem (i32.const 9) $f) + (elem (i32.const 3) $f) + (elem (i32.const 7) $f) + (elem (i32.const 3) $f) + (elem (i32.const 5) $f) +) + +(module + (global (import "spectest" "global_i32") i32) + (table 1000 funcref) + (func $f) + (elem (global.get 0) $f) +) + +(module + (global $g (import "spectest" "global_i32") i32) + (table 1000 funcref) + (func $f) + (elem (global.get $g) $f) +) + +(module + (type $out-i32 (func (result i32))) + (table 10 funcref) + (elem (i32.const 7) $const-i32-a) + (elem (i32.const 9) $const-i32-b) + (func $const-i32-a (type $out-i32) (i32.const 65)) + (func $const-i32-b (type $out-i32) (i32.const 66)) + (func (export "call-7") (type $out-i32) + (call_indirect (type $out-i32) (i32.const 7)) + ) + (func (export "call-9") (type $out-i32) + (call_indirect (type $out-i32) (i32.const 9)) + ) +) +(assert_return (invoke "call-7") (i32.const 65)) +(assert_return (invoke "call-9") (i32.const 66)) + +;; Corner cases + +(module + (table 10 funcref) + (func $f) + (elem (i32.const 9) $f) +) +(module + (import "spectest" "table" (table 10 funcref)) + (func $f) + (elem (i32.const 9) $f) +) + +(module + (table 0 funcref) + (elem (i32.const 0)) +) +(module + (import "spectest" "table" (table 0 funcref)) + (elem (i32.const 0)) +) + +(module + (table 0 0 funcref) + (elem (i32.const 0)) +) + +(module + (table 20 funcref) + (elem (i32.const 20)) +) + +(module + (import "spectest" "table" (table 0 funcref)) + (func $f) + (elem (i32.const 0) $f) +) + +(module + (import "spectest" "table" (table 0 100 funcref)) + (func $f) + (elem (i32.const 0) $f) +) + +(module + (import "spectest" "table" (table 0 funcref)) + (func $f) + (elem (i32.const 1) $f) +) + +(module + (import "spectest" "table" (table 0 30 funcref)) + (func $f) + (elem (i32.const 1) $f) +) + +;; Invalid bounds for elements + +(assert_trap + (module + (table 0 funcref) + (func $f) + (elem (i32.const 0) $f) + ) + "out of bounds" +) + +(assert_trap + (module + (table 0 0 funcref) + (func $f) + (elem (i32.const 0) $f) + ) + "out of bounds" +) + +(assert_trap + (module + (table 0 1 funcref) + (func $f) + (elem (i32.const 0) $f) + ) + "out of bounds" +) + +(assert_trap + (module + (table 0 funcref) + (elem (i32.const 1)) + ) + "out of bounds" +) +(assert_trap + (module + (table 10 funcref) + (func $f) + (elem (i32.const 10) $f) + ) + "out of bounds" +) +(assert_trap + (module + (import "spectest" "table" (table 10 funcref)) + (func $f) + (elem (i32.const 10) $f) + ) + "out of bounds" +) + +(assert_trap + (module + (table 10 20 funcref) + (func $f) + (elem (i32.const 10) $f) + ) + "out of bounds" +) +(assert_trap + (module + (import "spectest" "table" (table 10 funcref)) + (func $f) + (elem (i32.const 10) $f) + ) + "out of bounds" +) + +(assert_trap + (module + (table 10 funcref) + (func $f) + (elem (i32.const -1) $f) + ) + "out of bounds" +) +(assert_trap + (module + (import "spectest" "table" (table 10 funcref)) + (func $f) + (elem (i32.const -1) $f) + ) + "out of bounds" +) + +(assert_trap + (module + (table 10 funcref) + (func $f) + (elem (i32.const -10) $f) + ) + "out of bounds" +) +(assert_trap + (module + (import "spectest" "table" (table 10 funcref)) + (func $f) + (elem (i32.const -10) $f) + ) + "out of bounds" +) + +;; Implicitly dropped elements + +(module + (table 10 funcref) + (elem $e (i32.const 0) func $f) + (func $f) + (func (export "init") + (table.init $e (i32.const 0) (i32.const 0) (i32.const 1)) + ) +) +(assert_trap (invoke "init") "out of bounds") + +(module + (table 10 funcref) + (elem $e declare func $f) + (func $f) + (func (export "init") + (table.init $e (i32.const 0) (i32.const 0) (i32.const 1)) + ) +) +(assert_trap (invoke "init") "out of bounds") + +;; Element without table + +(assert_invalid + (module + (func $f) + (elem (i32.const 0) $f) + ) + "unknown table" +) + +;; Invalid offsets + +(assert_invalid + (module + (table 1 funcref) + (elem (i64.const 0)) + ) + "type mismatch" +) + +(assert_invalid + (module + (table 1 funcref) + (elem (i32.ctz (i32.const 0))) + ) + "constant expression required" +) + +(assert_invalid + (module + (table 1 funcref) + (elem (nop)) + ) + "constant expression required" +) + +(assert_invalid + (module + (table 1 funcref) + (elem (offset (nop) (i32.const 0))) + ) + "constant expression required" +) + +(assert_invalid + (module + (table 1 funcref) + (elem (offset (i32.const 0) (nop))) + ) + "constant expression required" +) + +;; Use of internal globals in constant expressions is not allowed in MVP. +;; (assert_invalid +;; (module (memory 1) (data (global.get $g)) (global $g (mut i32) (i32.const 0))) +;; "constant expression required" +;; ) + +;; Two elements target the same slot + +(module + (type $out-i32 (func (result i32))) + (table 10 funcref) + (elem (i32.const 9) $const-i32-a) + (elem (i32.const 9) $const-i32-b) + (func $const-i32-a (type $out-i32) (i32.const 65)) + (func $const-i32-b (type $out-i32) (i32.const 66)) + (func (export "call-overwritten") (type $out-i32) + (call_indirect (type $out-i32) (i32.const 9)) + ) +) +(assert_return (invoke "call-overwritten") (i32.const 66)) + +(module + (type $out-i32 (func (result i32))) + (import "spectest" "table" (table 10 funcref)) + (elem (i32.const 9) $const-i32-a) + (elem (i32.const 9) $const-i32-b) + (func $const-i32-a (type $out-i32) (i32.const 65)) + (func $const-i32-b (type $out-i32) (i32.const 66)) + (func (export "call-overwritten-element") (type $out-i32) + (call_indirect (type $out-i32) (i32.const 9)) + ) +) +(assert_return (invoke "call-overwritten-element") (i32.const 66)) + +;; Element sections across multiple modules change the same table + +(module $module1 + (type $out-i32 (func (result i32))) + (table (export "shared-table") 10 funcref) + (elem (i32.const 8) $const-i32-a) + (elem (i32.const 9) $const-i32-b) + (func $const-i32-a (type $out-i32) (i32.const 65)) + (func $const-i32-b (type $out-i32) (i32.const 66)) + (func (export "call-7") (type $out-i32) + (call_indirect (type $out-i32) (i32.const 7)) + ) + (func (export "call-8") (type $out-i32) + (call_indirect (type $out-i32) (i32.const 8)) + ) + (func (export "call-9") (type $out-i32) + (call_indirect (type $out-i32) (i32.const 9)) + ) +) + +(register "module1" $module1) + +(assert_trap (invoke $module1 "call-7") "uninitialized element") +(assert_return (invoke $module1 "call-8") (i32.const 65)) +(assert_return (invoke $module1 "call-9") (i32.const 66)) + +(module $module2 + (type $out-i32 (func (result i32))) + (import "module1" "shared-table" (table 10 funcref)) + (elem (i32.const 7) $const-i32-c) + (elem (i32.const 8) $const-i32-d) + (func $const-i32-c (type $out-i32) (i32.const 67)) + (func $const-i32-d (type $out-i32) (i32.const 68)) +) + +(assert_return (invoke $module1 "call-7") (i32.const 67)) +(assert_return (invoke $module1 "call-8") (i32.const 68)) +(assert_return (invoke $module1 "call-9") (i32.const 66)) + +(module $module3 + (type $out-i32 (func (result i32))) + (import "module1" "shared-table" (table 10 funcref)) + (elem (i32.const 8) $const-i32-e) + (elem (i32.const 9) $const-i32-f) + (func $const-i32-e (type $out-i32) (i32.const 69)) + (func $const-i32-f (type $out-i32) (i32.const 70)) +) + +(assert_return (invoke $module1 "call-7") (i32.const 67)) +(assert_return (invoke $module1 "call-8") (i32.const 69)) +(assert_return (invoke $module1 "call-9") (i32.const 70)) diff --git a/runtime/near-vm/tests/wast/spec/proposals/reference-types/exports.wast b/runtime/near-vm/tests/wast/spec/proposals/reference-types/exports.wast new file mode 100644 index 00000000000..a099172ac28 --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/proposals/reference-types/exports.wast @@ -0,0 +1,196 @@ +;; Functions + +(module (func) (export "a" (func 0))) +(module (func) (export "a" (func 0)) (export "b" (func 0))) +(module (func) (func) (export "a" (func 0)) (export "b" (func 1))) + +(module (func (export "a"))) +(module (func (export "a") (export "b") (export "c"))) +(module (func (export "a") (export "b") (param i32))) +(module (func) (export "a" (func 0))) +(module (func $a (export "a"))) +(module (func $a) (export "a" (func $a))) +(module (export "a" (func 0)) (func)) +(module (export "a" (func $a)) (func $a)) + +(module $Func + (export "e" (func $f)) + (func $f (param $n i32) (result i32) + (return (i32.add (local.get $n) (i32.const 1))) + ) +) +(assert_return (invoke "e" (i32.const 42)) (i32.const 43)) +(assert_return (invoke $Func "e" (i32.const 42)) (i32.const 43)) +(module) +(module $Other1) +(assert_return (invoke $Func "e" (i32.const 42)) (i32.const 43)) + +(assert_invalid + (module (func) (export "a" (func 1))) + "unknown function" +) +(assert_invalid + (module (func) (export "a" (func 0)) (export "a" (func 0))) + "duplicate export name" +) +(assert_invalid + (module (func) (func) (export "a" (func 0)) (export "a" (func 1))) + "duplicate export name" +) +(assert_invalid + (module (func) (global i32 (i32.const 0)) (export "a" (func 0)) (export "a" (global 0))) + "duplicate export name" +) +(assert_invalid + (module (func) (table 0 funcref) (export "a" (func 0)) (export "a" (table 0))) + "duplicate export name" +) +(assert_invalid + (module (func) (memory 0) (export "a" (func 0)) (export "a" (memory 0))) + "duplicate export name" +) + + +;; Globals + +(module (global i32 (i32.const 0)) (export "a" (global 0))) +(module (global i32 (i32.const 0)) (export "a" (global 0)) (export "b" (global 0))) +(module (global i32 (i32.const 0)) (global i32 (i32.const 0)) (export "a" (global 0)) (export "b" (global 1))) + +(module (global (export "a") i32 (i32.const 0))) +(module (global i32 (i32.const 0)) (export "a" (global 0))) +(module (global $a (export "a") i32 (i32.const 0))) +(module (global $a i32 (i32.const 0)) (export "a" (global $a))) +(module (export "a" (global 0)) (global i32 (i32.const 0))) +(module (export "a" (global $a)) (global $a i32 (i32.const 0))) + +(module $Global + (export "e" (global $g)) + (global $g i32 (i32.const 42)) +) +(assert_return (get "e") (i32.const 42)) +(assert_return (get $Global "e") (i32.const 42)) +(module) +(module $Other2) +(assert_return (get $Global "e") (i32.const 42)) + +(assert_invalid + (module (global i32 (i32.const 0)) (export "a" (global 1))) + "unknown global" +) +(assert_invalid + (module (global i32 (i32.const 0)) (export "a" (global 0)) (export "a" (global 0))) + "duplicate export name" +) +(assert_invalid + (module (global i32 (i32.const 0)) (global i32 (i32.const 0)) (export "a" (global 0)) (export "a" (global 1))) + "duplicate export name" +) +(assert_invalid + (module (global i32 (i32.const 0)) (func) (export "a" (global 0)) (export "a" (func 0))) + "duplicate export name" +) +(assert_invalid + (module (global i32 (i32.const 0)) (table 0 funcref) (export "a" (global 0)) (export "a" (table 0))) + "duplicate export name" +) +(assert_invalid + (module (global i32 (i32.const 0)) (memory 0) (export "a" (global 0)) (export "a" (memory 0))) + "duplicate export name" +) + + +;; Tables + +(module (table 0 funcref) (export "a" (table 0))) +(module (table 0 funcref) (export "a" (table 0)) (export "b" (table 0))) +(module (table 0 funcref) (table 0 funcref) (export "a" (table 0)) (export "b" (table 1))) + +(module (table (export "a") 0 funcref)) +(module (table (export "a") 0 1 funcref)) +(module (table 0 funcref) (export "a" (table 0))) +(module (table 0 1 funcref) (export "a" (table 0))) +(module (table $a (export "a") 0 funcref)) +(module (table $a (export "a") 0 1 funcref)) +(module (table $a 0 funcref) (export "a" (table $a))) +(module (table $a 0 1 funcref) (export "a" (table $a))) +(module (export "a" (table 0)) (table 0 funcref)) +(module (export "a" (table 0)) (table 0 1 funcref)) +(module (export "a" (table $a)) (table $a 0 funcref)) +(module (export "a" (table $a)) (table $a 0 1 funcref)) + +(; TODO: access table ;) + +(assert_invalid + (module (table 0 funcref) (export "a" (table 1))) + "unknown table" +) +(assert_invalid + (module (table 0 funcref) (export "a" (table 0)) (export "a" (table 0))) + "duplicate export name" +) +(assert_invalid + (module (table 0 funcref) (table 0 funcref) (export "a" (table 0)) (export "a" (table 1))) + "duplicate export name" +) +(assert_invalid + (module (table 0 funcref) (func) (export "a" (table 0)) (export "a" (func 0))) + "duplicate export name" +) +(assert_invalid + (module (table 0 funcref) (global i32 (i32.const 0)) (export "a" (table 0)) (export "a" (global 0))) + "duplicate export name" +) +(assert_invalid + (module (table 0 funcref) (memory 0) (export "a" (table 0)) (export "a" (memory 0))) + "duplicate export name" +) + + +;; Memories + +(module (memory 0) (export "a" (memory 0))) +(module (memory 0) (export "a" (memory 0)) (export "b" (memory 0))) +;; No multiple memories yet. +;; (module (memory 0) (memory 0) (export "a" (memory 0)) (export "b" (memory 1))) + +(module (memory (export "a") 0)) +(module (memory (export "a") 0 1)) +(module (memory 0) (export "a" (memory 0))) +(module (memory 0 1) (export "a" (memory 0))) +(module (memory $a (export "a") 0)) +(module (memory $a (export "a") 0 1)) +(module (memory $a 0) (export "a" (memory $a))) +(module (memory $a 0 1) (export "a" (memory $a))) +(module (export "a" (memory 0)) (memory 0)) +(module (export "a" (memory 0)) (memory 0 1)) +(module (export "a" (memory $a)) (memory $a 0)) +(module (export "a" (memory $a)) (memory $a 0 1)) + +(; TODO: access memory ;) + +(assert_invalid + (module (memory 0) (export "a" (memory 1))) + "unknown memory" +) +(assert_invalid + (module (memory 0) (export "a" (memory 0)) (export "a" (memory 0))) + "duplicate export name" +) +;; No multiple memories yet. +;; (assert_invalid +;; (module (memory 0) (memory 0) (export "a" (memory 0)) (export "a" (memory 1))) +;; "duplicate export name" +;; ) +(assert_invalid + (module (memory 0) (func) (export "a" (memory 0)) (export "a" (func 0))) + "duplicate export name" +) +(assert_invalid + (module (memory 0) (global i32 (i32.const 0)) (export "a" (memory 0)) (export "a" (global 0))) + "duplicate export name" +) +(assert_invalid + (module (memory 0) (table 0 funcref) (export "a" (memory 0)) (export "a" (table 0))) + "duplicate export name" +) diff --git a/runtime/near-vm/tests/wast/spec/proposals/reference-types/globals.wast b/runtime/near-vm/tests/wast/spec/proposals/reference-types/globals.wast new file mode 100644 index 00000000000..63aabb934fa --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/proposals/reference-types/globals.wast @@ -0,0 +1,492 @@ +;; Test globals + +(module + (global $a i32 (i32.const -2)) + (global (;1;) f32 (f32.const -3)) + (global (;2;) f64 (f64.const -4)) + (global $b i64 (i64.const -5)) + + (global $x (mut i32) (i32.const -12)) + (global (;5;) (mut f32) (f32.const -13)) + (global (;6;) (mut f64) (f64.const -14)) + (global $y (mut i64) (i64.const -15)) + + (global $r anyref (ref.null)) + (global funcref (ref.null)) + + (func (export "get-a") (result i32) (global.get $a)) + (func (export "get-b") (result i64) (global.get $b)) + (func (export "get-r") (result anyref) (global.get $r)) + (func (export "get-x") (result i32) (global.get $x)) + (func (export "get-y") (result i64) (global.get $y)) + (func (export "set-x") (param i32) (global.set $x (local.get 0))) + (func (export "set-y") (param i64) (global.set $y (local.get 0))) + + (func (export "get-1") (result f32) (global.get 1)) + (func (export "get-2") (result f64) (global.get 2)) + (func (export "get-5") (result f32) (global.get 5)) + (func (export "get-6") (result f64) (global.get 6)) + (func (export "set-5") (param f32) (global.set 5 (local.get 0))) + (func (export "set-6") (param f64) (global.set 6 (local.get 0))) + + ;; As the argument of control constructs and instructions + + (memory 1) + + (func $dummy) + + (func (export "as-select-first") (result i32) + (select (global.get $x) (i32.const 2) (i32.const 3)) + ) + (func (export "as-select-mid") (result i32) + (select (i32.const 2) (global.get $x) (i32.const 3)) + ) + (func (export "as-select-last") (result i32) + (select (i32.const 2) (i32.const 3) (global.get $x)) + ) + + (func (export "as-loop-first") (result i32) + (loop (result i32) + (global.get $x) (call $dummy) (call $dummy) + ) + ) + (func (export "as-loop-mid") (result i32) + (loop (result i32) + (call $dummy) (global.get $x) (call $dummy) + ) + ) + (func (export "as-loop-last") (result i32) + (loop (result i32) + (call $dummy) (call $dummy) (global.get $x) + ) + ) + + (func (export "as-if-condition") (result i32) + (if (result i32) (global.get $x) + (then (call $dummy) (i32.const 2)) + (else (call $dummy) (i32.const 3)) + ) + ) + (func (export "as-if-then") (result i32) + (if (result i32) (i32.const 1) + (then (global.get $x)) (else (i32.const 2)) + ) + ) + (func (export "as-if-else") (result i32) + (if (result i32) (i32.const 0) + (then (i32.const 2)) (else (global.get $x)) + ) + ) + + (func (export "as-br_if-first") (result i32) + (block (result i32) + (br_if 0 (global.get $x) (i32.const 2)) + (return (i32.const 3)) + ) + ) + (func (export "as-br_if-last") (result i32) + (block (result i32) + (br_if 0 (i32.const 2) (global.get $x)) + (return (i32.const 3)) + ) + ) + + (func (export "as-br_table-first") (result i32) + (block (result i32) + (global.get $x) (i32.const 2) (br_table 0 0) + ) + ) + (func (export "as-br_table-last") (result i32) + (block (result i32) + (i32.const 2) (global.get $x) (br_table 0 0) + ) + ) + + (func $func (param i32 i32) (result i32) (local.get 0)) + (type $check (func (param i32 i32) (result i32))) + (table funcref (elem $func)) + (func (export "as-call_indirect-first") (result i32) + (block (result i32) + (call_indirect (type $check) + (global.get $x) (i32.const 2) (i32.const 0) + ) + ) + ) + (func (export "as-call_indirect-mid") (result i32) + (block (result i32) + (call_indirect (type $check) + (i32.const 2) (global.get $x) (i32.const 0) + ) + ) + ) + (func (export "as-call_indirect-last") (result i32) + (block (result i32) + (call_indirect (type $check) + (i32.const 2) (i32.const 0) (global.get $x) + ) + ) + ) + + (func (export "as-store-first") + (global.get $x) (i32.const 1) (i32.store) + ) + (func (export "as-store-last") + (i32.const 0) (global.get $x) (i32.store) + ) + (func (export "as-load-operand") (result i32) + (i32.load (global.get $x)) + ) + (func (export "as-memory.grow-value") (result i32) + (memory.grow (global.get $x)) + ) + + (func $f (param i32) (result i32) (local.get 0)) + (func (export "as-call-value") (result i32) + (call $f (global.get $x)) + ) + + (func (export "as-return-value") (result i32) + (global.get $x) (return) + ) + (func (export "as-drop-operand") + (drop (global.get $x)) + ) + (func (export "as-br-value") (result i32) + (block (result i32) (br 0 (global.get $x))) + ) + + (func (export "as-local.set-value") (param i32) (result i32) + (local.set 0 (global.get $x)) + (local.get 0) + ) + (func (export "as-local.tee-value") (param i32) (result i32) + (local.tee 0 (global.get $x)) + ) + (func (export "as-global.set-value") (result i32) + (global.set $x (global.get $x)) + (global.get $x) + ) + + (func (export "as-unary-operand") (result i32) + (i32.eqz (global.get $x)) + ) + (func (export "as-binary-operand") (result i32) + (i32.mul + (global.get $x) (global.get $x) + ) + ) + (func (export "as-compare-operand") (result i32) + (i32.gt_u + (global.get 0) (i32.const 1) + ) + ) +) + +(assert_return (invoke "get-a") (i32.const -2)) +(assert_return (invoke "get-b") (i64.const -5)) +(assert_return (invoke "get-r") (ref.null)) +(assert_return (invoke "get-x") (i32.const -12)) +(assert_return (invoke "get-y") (i64.const -15)) + +(assert_return (invoke "get-1") (f32.const -3)) +(assert_return (invoke "get-2") (f64.const -4)) +(assert_return (invoke "get-5") (f32.const -13)) +(assert_return (invoke "get-6") (f64.const -14)) + +(assert_return (invoke "set-x" (i32.const 6))) +(assert_return (invoke "set-y" (i64.const 7))) +(assert_return (invoke "set-5" (f32.const 8))) +(assert_return (invoke "set-6" (f64.const 9))) + +(assert_return (invoke "get-x") (i32.const 6)) +(assert_return (invoke "get-y") (i64.const 7)) +(assert_return (invoke "get-5") (f32.const 8)) +(assert_return (invoke "get-6") (f64.const 9)) + +(assert_return (invoke "as-select-first") (i32.const 6)) +(assert_return (invoke "as-select-mid") (i32.const 2)) +(assert_return (invoke "as-select-last") (i32.const 2)) + +(assert_return (invoke "as-loop-first") (i32.const 6)) +(assert_return (invoke "as-loop-mid") (i32.const 6)) +(assert_return (invoke "as-loop-last") (i32.const 6)) + +(assert_return (invoke "as-if-condition") (i32.const 2)) +(assert_return (invoke "as-if-then") (i32.const 6)) +(assert_return (invoke "as-if-else") (i32.const 6)) + +(assert_return (invoke "as-br_if-first") (i32.const 6)) +(assert_return (invoke "as-br_if-last") (i32.const 2)) + +(assert_return (invoke "as-br_table-first") (i32.const 6)) +(assert_return (invoke "as-br_table-last") (i32.const 2)) + +(assert_return (invoke "as-call_indirect-first") (i32.const 6)) +(assert_return (invoke "as-call_indirect-mid") (i32.const 2)) +(assert_trap (invoke "as-call_indirect-last") "undefined element") + +(assert_return (invoke "as-store-first")) +(assert_return (invoke "as-store-last")) +(assert_return (invoke "as-load-operand") (i32.const 1)) +(assert_return (invoke "as-memory.grow-value") (i32.const 1)) + +(assert_return (invoke "as-call-value") (i32.const 6)) + +(assert_return (invoke "as-return-value") (i32.const 6)) +(assert_return (invoke "as-drop-operand")) +(assert_return (invoke "as-br-value") (i32.const 6)) + +(assert_return (invoke "as-local.set-value" (i32.const 1)) (i32.const 6)) +(assert_return (invoke "as-local.tee-value" (i32.const 1)) (i32.const 6)) +(assert_return (invoke "as-global.set-value") (i32.const 6)) + +(assert_return (invoke "as-unary-operand") (i32.const 0)) +(assert_return (invoke "as-binary-operand") (i32.const 36)) +(assert_return (invoke "as-compare-operand") (i32.const 1)) + +(assert_invalid + (module (global f32 (f32.const 0)) (func (global.set 0 (f32.const 1)))) + "global is immutable" +) + +;; mutable globals can be exported +(module (global (mut f32) (f32.const 0)) (export "a" (global 0))) +(module (global (export "a") (mut f32) (f32.const 0))) + +(assert_invalid + (module (global f32 (f32.neg (f32.const 0)))) + "constant expression required" +) + +(assert_invalid + (module (global f32 (local.get 0))) + "constant expression required" +) + +(assert_invalid + (module (global f32 (f32.neg (f32.const 1)))) + "constant expression required" +) + +(assert_invalid + (module (global i32 (i32.const 0) (nop))) + "constant expression required" +) + +(assert_invalid + (module (global i32 (nop))) + "constant expression required" +) + +(assert_invalid + (module (global i32 (f32.const 0))) + "type mismatch" +) + +(assert_invalid + (module (global i32 (i32.const 0) (i32.const 0))) + "type mismatch" +) + +(assert_invalid + (module (global i32 (;empty instruction sequence;))) + "type mismatch" +) + +(assert_invalid + (module (global (import "" "") anyref) (global funcref (global.get 0))) + "type mismatch" +) + +(assert_invalid + (module (global i32 (global.get 0))) + "unknown global" +) + +(assert_invalid + (module (global i32 (global.get 1)) (global i32 (i32.const 0))) + "unknown global" +) + +(module + (import "spectest" "global_i32" (global i32)) +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\98\80\80\80\00" ;; import section + "\01" ;; length 1 + "\08\73\70\65\63\74\65\73\74" ;; "spectest" + "\0a\67\6c\6f\62\61\6c\5f\69\33\32" ;; "global_i32" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\02" ;; invalid mutability + ) + "invalid mutability" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\98\80\80\80\00" ;; import section + "\01" ;; length 1 + "\08\73\70\65\63\74\65\73\74" ;; "spectest" + "\0a\67\6c\6f\62\61\6c\5f\69\33\32" ;; "global_i32" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\ff" ;; invalid mutability + ) + "invalid mutability" +) + +(module + (global i32 (i32.const 0)) +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\06\86\80\80\80\00" ;; global section + "\01" ;; length 1 + "\7f" ;; i32 + "\02" ;; invalid mutability + "\41\00" ;; i32.const 0 + "\0b" ;; end + ) + "invalid mutability" +) +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\06\86\80\80\80\00" ;; global section + "\01" ;; length 1 + "\7f" ;; i32 + "\ff" ;; invalid mutability + "\41\00" ;; i32.const 0 + "\0b" ;; end + ) + "invalid mutability" +) + + +(assert_invalid + (module + (global $x (mut i32) (i32.const 0)) + (func $type-global.set-value-empty + (global.set $x) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (global $x (mut i32) (i32.const 0)) + (func $type-global.set-value-empty-in-block + (i32.const 0) + (block (global.set $x)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (global $x (mut i32) (i32.const 0)) + (func $type-global.set-value-empty-in-loop + (i32.const 0) + (loop (global.set $x)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (global $x (mut i32) (i32.const 0)) + (func $type-global.set-value-empty-in-then + (i32.const 0) (i32.const 0) + (if (then (global.set $x))) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (global $x (mut i32) (i32.const 0)) + (func $type-global.set-value-empty-in-else + (i32.const 0) (i32.const 0) + (if (result i32) (then (i32.const 0)) (else (global.set $x))) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (global $x (mut i32) (i32.const 0)) + (func $type-global.set-value-empty-in-br + (i32.const 0) + (block (br 0 (global.set $x))) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (global $x (mut i32) (i32.const 0)) + (func $type-global.set-value-empty-in-br_if + (i32.const 0) + (block (br_if 0 (global.set $x))) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (global $x (mut i32) (i32.const 0)) + (func $type-global.set-value-empty-in-br_table + (i32.const 0) + (block (br_table 0 (global.set $x))) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (global $x (mut i32) (i32.const 0)) + (func $type-global.set-value-empty-in-return + (return (global.set $x)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (global $x (mut i32) (i32.const 0)) + (func $type-global.set-value-empty-in-select + (select (global.set $x) (i32.const 1) (i32.const 2)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (global $x (mut i32) (i32.const 0)) + (func $type-global.set-value-empty-in-call + (call 1 (global.set $x)) + ) + (func (param i32) (result i32) (local.get 0)) + ) + "type mismatch" +) +(assert_invalid + (module + (global $x (mut i32) (i32.const 0)) + (func $f (param i32) (result i32) (local.get 0)) + (type $sig (func (param i32) (result i32))) + (table funcref (elem $f)) + (func $type-global.set-value-empty-in-call_indirect + (block (result i32) + (call_indirect (type $sig) + (global.set $x) (i32.const 0) + ) + ) + ) + ) + "type mismatch" +) diff --git a/runtime/near-vm/tests/wast/spec/proposals/reference-types/imports.wast b/runtime/near-vm/tests/wast/spec/proposals/reference-types/imports.wast new file mode 100644 index 00000000000..c3a011d73c8 --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/proposals/reference-types/imports.wast @@ -0,0 +1,605 @@ +;; Auxiliary module to import from + +(module + (func (export "func")) + (func (export "func-i32") (param i32)) + (func (export "func-f32") (param f32)) + (func (export "func->i32") (result i32) (i32.const 22)) + (func (export "func->f32") (result f32) (f32.const 11)) + (func (export "func-i32->i32") (param i32) (result i32) (local.get 0)) + (func (export "func-i64->i64") (param i64) (result i64) (local.get 0)) + (global (export "global-i32") i32 (i32.const 55)) + (global (export "global-f32") f32 (f32.const 44)) + (table (export "table-10-inf") 10 funcref) + (table (export "table-10-20") 10 20 funcref) + (memory (export "memory-2-inf") 2) + ;; Multiple memories are not yet supported + ;; (memory (export "memory-2-4") 2 4) +) + +(register "test") + + +;; Functions + +(module + (type $func_i32 (func (param i32))) + (type $func_i64 (func (param i64))) + (type $func_f32 (func (param f32))) + (type $func_f64 (func (param f64))) + + (import "spectest" "print_i32" (func (param i32))) + ;; JavaScript can't handle i64 yet. + ;; (func (import "spectest" "print_i64") (param i64)) + (import "spectest" "print_i32" (func $print_i32 (param i32))) + ;; JavaScript can't handle i64 yet. + ;; (import "spectest" "print_i64" (func $print_i64 (param i64))) + (import "spectest" "print_f32" (func $print_f32 (param f32))) + (import "spectest" "print_f64" (func $print_f64 (param f64))) + (import "spectest" "print_i32_f32" (func $print_i32_f32 (param i32 f32))) + (import "spectest" "print_f64_f64" (func $print_f64_f64 (param f64 f64))) + (func $print_i32-2 (import "spectest" "print_i32") (param i32)) + (func $print_f64-2 (import "spectest" "print_f64") (param f64)) + (import "test" "func-i64->i64" (func $i64->i64 (param i64) (result i64))) + + (func (export "p1") (import "spectest" "print_i32") (param i32)) + (func $p (export "p2") (import "spectest" "print_i32") (param i32)) + (func (export "p3") (export "p4") (import "spectest" "print_i32") (param i32)) + (func (export "p5") (import "spectest" "print_i32") (type 0)) + (func (export "p6") (import "spectest" "print_i32") (type 0) (param i32) (result)) + + (import "spectest" "print_i32" (func (type $forward))) + (func (import "spectest" "print_i32") (type $forward)) + (type $forward (func (param i32))) + + (table funcref (elem $print_i32 $print_f64)) + + (func (export "print32") (param $i i32) + (local $x f32) + (local.set $x (f32.convert_i32_s (local.get $i))) + (call 0 (local.get $i)) + (call $print_i32_f32 + (i32.add (local.get $i) (i32.const 1)) + (f32.const 42) + ) + (call $print_i32 (local.get $i)) + (call $print_i32-2 (local.get $i)) + (call $print_f32 (local.get $x)) + (call_indirect (type $func_i32) (local.get $i) (i32.const 0)) + ) + + (func (export "print64") (param $i i64) + (local $x f64) + (local.set $x (f64.convert_i64_s (call $i64->i64 (local.get $i)))) + ;; JavaScript can't handle i64 yet. + ;; (call 1 (local.get $i)) + (call $print_f64_f64 + (f64.add (local.get $x) (f64.const 1)) + (f64.const 53) + ) + ;; JavaScript can't handle i64 yet. + ;; (call $print_i64 (local.get $i)) + (call $print_f64 (local.get $x)) + (call $print_f64-2 (local.get $x)) + (call_indirect (type $func_f64) (local.get $x) (i32.const 1)) + ) +) + +(assert_return (invoke "print32" (i32.const 13))) +(assert_return (invoke "print64" (i64.const 24))) + +(assert_invalid + (module + (type (func (result i32))) + (import "test" "func" (func (type 1))) + ) + "unknown type" +) + +(module (import "test" "func" (func))) +(module (import "test" "func-i32" (func (param i32)))) +(module (import "test" "func-f32" (func (param f32)))) +(module (import "test" "func->i32" (func (result i32)))) +(module (import "test" "func->f32" (func (result f32)))) +(module (import "test" "func-i32->i32" (func (param i32) (result i32)))) +(module (import "test" "func-i64->i64" (func (param i64) (result i64)))) + +(assert_unlinkable + (module (import "test" "unknown" (func))) + "unknown import" +) +(assert_unlinkable + (module (import "spectest" "unknown" (func))) + "unknown import" +) + +(assert_unlinkable + (module (import "test" "func" (func (param i32)))) + "incompatible import type" +) +(assert_unlinkable + (module (import "test" "func" (func (result i32)))) + "incompatible import type" +) +(assert_unlinkable + (module (import "test" "func" (func (param i32) (result i32)))) + "incompatible import type" +) +(assert_unlinkable + (module (import "test" "func-i32" (func))) + "incompatible import type" +) +(assert_unlinkable + (module (import "test" "func-i32" (func (result i32)))) + "incompatible import type" +) +(assert_unlinkable + (module (import "test" "func-i32" (func (param f32)))) + "incompatible import type" +) +(assert_unlinkable + (module (import "test" "func-i32" (func (param i64)))) + "incompatible import type" +) +(assert_unlinkable + (module (import "test" "func-i32" (func (param i32) (result i32)))) + "incompatible import type" +) +(assert_unlinkable + (module (import "test" "func->i32" (func))) + "incompatible import type" +) +(assert_unlinkable + (module (import "test" "func->i32" (func (param i32)))) + "incompatible import type" +) +(assert_unlinkable + (module (import "test" "func->i32" (func (result f32)))) + "incompatible import type" +) +(assert_unlinkable + (module (import "test" "func->i32" (func (result i64)))) + "incompatible import type" +) +(assert_unlinkable + (module (import "test" "func->i32" (func (param i32) (result i32)))) + "incompatible import type" +) +(assert_unlinkable + (module (import "test" "func-i32->i32" (func))) + "incompatible import type" +) +(assert_unlinkable + (module (import "test" "func-i32->i32" (func (param i32)))) + "incompatible import type" +) +(assert_unlinkable + (module (import "test" "func-i32->i32" (func (result i32)))) + "incompatible import type" +) + +(assert_unlinkable + (module (import "test" "global-i32" (func (result i32)))) + "incompatible import type" +) +(assert_unlinkable + (module (import "test" "table-10-inf" (func))) + "incompatible import type" +) +(assert_unlinkable + (module (import "test" "memory-2-inf" (func))) + "incompatible import type" +) +(assert_unlinkable + (module (import "spectest" "global_i32" (func))) + "incompatible import type" +) +(assert_unlinkable + (module (import "spectest" "table" (func))) + "incompatible import type" +) +(assert_unlinkable + (module (import "spectest" "memory" (func))) + "incompatible import type" +) + + +;; Globals + +(module + (import "spectest" "global_i32" (global i32)) + (global (import "spectest" "global_i32") i32) + + (import "spectest" "global_i32" (global $x i32)) + (global $y (import "spectest" "global_i32") i32) + + ;; JavaScript can't handle i64 yet. + ;; (import "spectest" "global_i64" (global i64)) + (import "spectest" "global_f32" (global f32)) + (import "spectest" "global_f64" (global f64)) + + (func (export "get-0") (result i32) (global.get 0)) + (func (export "get-1") (result i32) (global.get 1)) + (func (export "get-x") (result i32) (global.get $x)) + (func (export "get-y") (result i32) (global.get $y)) +) + +(assert_return (invoke "get-0") (i32.const 666)) +(assert_return (invoke "get-1") (i32.const 666)) +(assert_return (invoke "get-x") (i32.const 666)) +(assert_return (invoke "get-y") (i32.const 666)) + +(module (import "test" "global-i32" (global i32))) +(module (import "test" "global-f32" (global f32))) + +(assert_unlinkable + (module (import "test" "unknown" (global i32))) + "unknown import" +) +(assert_unlinkable + (module (import "spectest" "unknown" (global i32))) + "unknown import" +) + +(assert_unlinkable + (module (import "test" "func" (global i32))) + "incompatible import type" +) +(assert_unlinkable + (module (import "test" "table-10-inf" (global i32))) + "incompatible import type" +) +(assert_unlinkable + (module (import "test" "memory-2-inf" (global i32))) + "incompatible import type" +) +(assert_unlinkable + (module (import "spectest" "print_i32" (global i32))) + "incompatible import type" +) +(assert_unlinkable + (module (import "spectest" "table" (global i32))) + "incompatible import type" +) +(assert_unlinkable + (module (import "spectest" "memory" (global i32))) + "incompatible import type" +) + + +;; Tables + +(module + (type (func (result i32))) + (import "spectest" "table" (table $tab 10 20 funcref)) + (elem (table $tab) (i32.const 1) func $f $g) + + (func (export "call") (param i32) (result i32) + (call_indirect $tab (type 0) (local.get 0)) + ) + (func $f (result i32) (i32.const 11)) + (func $g (result i32) (i32.const 22)) +) + +(assert_trap (invoke "call" (i32.const 0)) "uninitialized element") +(assert_return (invoke "call" (i32.const 1)) (i32.const 11)) +(assert_return (invoke "call" (i32.const 2)) (i32.const 22)) +(assert_trap (invoke "call" (i32.const 3)) "uninitialized element") +(assert_trap (invoke "call" (i32.const 100)) "undefined element") + + +(module + (type (func (result i32))) + (table $tab (import "spectest" "table") 10 20 funcref) + (elem (table $tab) (i32.const 1) func $f $g) + + (func (export "call") (param i32) (result i32) + (call_indirect $tab (type 0) (local.get 0)) + ) + (func $f (result i32) (i32.const 11)) + (func $g (result i32) (i32.const 22)) +) + +(assert_trap (invoke "call" (i32.const 0)) "uninitialized element") +(assert_return (invoke "call" (i32.const 1)) (i32.const 11)) +(assert_return (invoke "call" (i32.const 2)) (i32.const 22)) +(assert_trap (invoke "call" (i32.const 3)) "uninitialized element") +(assert_trap (invoke "call" (i32.const 100)) "undefined element") + + +(module + (import "spectest" "table" (table 0 funcref)) + (import "spectest" "table" (table 0 funcref)) + (table 10 funcref) + (table 10 funcref) +) + +(module (import "test" "table-10-inf" (table 10 funcref))) +(module (import "test" "table-10-inf" (table 5 funcref))) +(module (import "test" "table-10-inf" (table 0 funcref))) +(module (import "test" "table-10-20" (table 10 funcref))) +(module (import "test" "table-10-20" (table 5 funcref))) +(module (import "test" "table-10-20" (table 0 funcref))) +(module (import "test" "table-10-20" (table 10 20 funcref))) +(module (import "test" "table-10-20" (table 5 20 funcref))) +(module (import "test" "table-10-20" (table 0 20 funcref))) +(module (import "test" "table-10-20" (table 10 25 funcref))) +(module (import "test" "table-10-20" (table 5 25 funcref))) +(module (import "test" "table-10-20" (table 0 25 funcref))) +(module (import "spectest" "table" (table 10 funcref))) +(module (import "spectest" "table" (table 5 funcref))) +(module (import "spectest" "table" (table 0 funcref))) +(module (import "spectest" "table" (table 10 20 funcref))) +(module (import "spectest" "table" (table 5 20 funcref))) +(module (import "spectest" "table" (table 0 20 funcref))) +(module (import "spectest" "table" (table 10 25 funcref))) +(module (import "spectest" "table" (table 5 25 funcref))) + +(assert_unlinkable + (module (import "test" "unknown" (table 10 funcref))) + "unknown import" +) +(assert_unlinkable + (module (import "spectest" "unknown" (table 10 funcref))) + "unknown import" +) + +(assert_unlinkable + (module (import "test" "table-10-inf" (table 12 funcref))) + "incompatible import type" +) +(assert_unlinkable + (module (import "test" "table-10-inf" (table 10 20 funcref))) + "incompatible import type" +) +(assert_unlinkable + (module (import "test" "table-10-20" (table 12 20 funcref))) + "incompatible import type" +) +(assert_unlinkable + (module (import "test" "table-10-20" (table 10 18 funcref))) + "incompatible import type" +) +(assert_unlinkable + (module (import "spectest" "table" (table 12 funcref))) + "incompatible import type" +) +(assert_unlinkable + (module (import "spectest" "table" (table 10 15 funcref))) + "incompatible import type" +) + +(assert_unlinkable + (module (import "test" "func" (table 10 funcref))) + "incompatible import type" +) +(assert_unlinkable + (module (import "test" "global-i32" (table 10 funcref))) + "incompatible import type" +) +(assert_unlinkable + (module (import "test" "memory-2-inf" (table 10 funcref))) + "incompatible import type" +) +(assert_unlinkable + (module (import "spectest" "print_i32" (table 10 funcref))) + "incompatible import type" +) + + + +;; Memories + +(module + (import "spectest" "memory" (memory 1 2)) + (data (memory 0) (i32.const 10) "\10") + + (func (export "load") (param i32) (result i32) (i32.load (local.get 0))) +) + +(assert_return (invoke "load" (i32.const 0)) (i32.const 0)) +(assert_return (invoke "load" (i32.const 10)) (i32.const 16)) +(assert_return (invoke "load" (i32.const 8)) (i32.const 0x100000)) +(assert_trap (invoke "load" (i32.const 1000000)) "out of bounds memory access") + +(module + (memory (import "spectest" "memory") 1 2) + (data (memory 0) (i32.const 10) "\10") + + (func (export "load") (param i32) (result i32) (i32.load (local.get 0))) +) +(assert_return (invoke "load" (i32.const 0)) (i32.const 0)) +(assert_return (invoke "load" (i32.const 10)) (i32.const 16)) +(assert_return (invoke "load" (i32.const 8)) (i32.const 0x100000)) +(assert_trap (invoke "load" (i32.const 1000000)) "out of bounds memory access") + +(assert_invalid + (module (import "" "" (memory 1)) (import "" "" (memory 1))) + "multiple memories" +) +(assert_invalid + (module (import "" "" (memory 1)) (memory 0)) + "multiple memories" +) +(assert_invalid + (module (memory 0) (memory 0)) + "multiple memories" +) + +(module (import "test" "memory-2-inf" (memory 2))) +(module (import "test" "memory-2-inf" (memory 1))) +(module (import "test" "memory-2-inf" (memory 0))) +(module (import "spectest" "memory" (memory 1))) +(module (import "spectest" "memory" (memory 0))) +(module (import "spectest" "memory" (memory 1 2))) +(module (import "spectest" "memory" (memory 0 2))) +(module (import "spectest" "memory" (memory 1 3))) +(module (import "spectest" "memory" (memory 0 3))) + +(assert_unlinkable + (module (import "test" "unknown" (memory 1))) + "unknown import" +) +(assert_unlinkable + (module (import "spectest" "unknown" (memory 1))) + "unknown import" +) + +(assert_unlinkable + (module (import "test" "memory-2-inf" (memory 3))) + "incompatible import type" +) +(assert_unlinkable + (module (import "test" "memory-2-inf" (memory 2 3))) + "incompatible import type" +) +(assert_unlinkable + (module (import "spectest" "memory" (memory 2))) + "incompatible import type" +) +(assert_unlinkable + (module (import "spectest" "memory" (memory 1 1))) + "incompatible import type" +) + +(assert_unlinkable + (module (import "test" "func-i32" (memory 1))) + "incompatible import type" +) +(assert_unlinkable + (module (import "test" "global-i32" (memory 1))) + "incompatible import type" +) +(assert_unlinkable + (module (import "test" "table-10-inf" (memory 1))) + "incompatible import type" +) +(assert_unlinkable + (module (import "spectest" "print_i32" (memory 1))) + "incompatible import type" +) +(assert_unlinkable + (module (import "spectest" "global_i32" (memory 1))) + "incompatible import type" +) +(assert_unlinkable + (module (import "spectest" "table" (memory 1))) + "incompatible import type" +) + +(assert_unlinkable + (module (import "spectest" "memory" (memory 2))) + "incompatible import type" +) +(assert_unlinkable + (module (import "spectest" "memory" (memory 1 1))) + "incompatible import type" +) + +(module + (import "spectest" "memory" (memory 0 3)) ;; actual has max size 2 + (func (export "grow") (param i32) (result i32) (memory.grow (local.get 0))) +) +(assert_return (invoke "grow" (i32.const 0)) (i32.const 1)) +(assert_return (invoke "grow" (i32.const 1)) (i32.const 1)) +(assert_return (invoke "grow" (i32.const 0)) (i32.const 2)) +(assert_return (invoke "grow" (i32.const 1)) (i32.const -1)) +(assert_return (invoke "grow" (i32.const 0)) (i32.const 2)) + + +;; Syntax errors + +(assert_malformed + (module quote "(func) (import \"\" \"\" (func))") + "import after function" +) +(assert_malformed + (module quote "(func) (import \"\" \"\" (global i64))") + "import after function" +) +(assert_malformed + (module quote "(func) (import \"\" \"\" (table 0 funcref))") + "import after function" +) +(assert_malformed + (module quote "(func) (import \"\" \"\" (memory 0))") + "import after function" +) + +(assert_malformed + (module quote "(global i64 (i64.const 0)) (import \"\" \"\" (func))") + "import after global" +) +(assert_malformed + (module quote "(global i64 (i64.const 0)) (import \"\" \"\" (global f32))") + "import after global" +) +(assert_malformed + (module quote "(global i64 (i64.const 0)) (import \"\" \"\" (table 0 funcref))") + "import after global" +) +(assert_malformed + (module quote "(global i64 (i64.const 0)) (import \"\" \"\" (memory 0))") + "import after global" +) + +(assert_malformed + (module quote "(table 0 funcref) (import \"\" \"\" (func))") + "import after table" +) +(assert_malformed + (module quote "(table 0 funcref) (import \"\" \"\" (global i32))") + "import after table" +) +(assert_malformed + (module quote "(table 0 funcref) (import \"\" \"\" (table 0 funcref))") + "import after table" +) +(assert_malformed + (module quote "(table 0 funcref) (import \"\" \"\" (memory 0))") + "import after table" +) + +(assert_malformed + (module quote "(memory 0) (import \"\" \"\" (func))") + "import after memory" +) +(assert_malformed + (module quote "(memory 0) (import \"\" \"\" (global i32))") + "import after memory" +) +(assert_malformed + (module quote "(memory 0) (import \"\" \"\" (table 1 3 funcref))") + "import after memory" +) +(assert_malformed + (module quote "(memory 0) (import \"\" \"\" (memory 1 2))") + "import after memory" +) + +;; This module is required to validate, regardless of whether it can be +;; linked. Overloading is not possible in wasm itself, but it is possible +;; in modules from which wasm can import. +(module) +(register "not wasm") +(assert_unlinkable + (module + (import "not wasm" "overloaded" (func)) + (import "not wasm" "overloaded" (func (param i32))) + (import "not wasm" "overloaded" (func (param i32 i32))) + (import "not wasm" "overloaded" (func (param i64))) + (import "not wasm" "overloaded" (func (param f32))) + (import "not wasm" "overloaded" (func (param f64))) + (import "not wasm" "overloaded" (func (result i32))) + (import "not wasm" "overloaded" (func (result i64))) + (import "not wasm" "overloaded" (func (result f32))) + (import "not wasm" "overloaded" (func (result f64))) + (import "not wasm" "overloaded" (global i32)) + (import "not wasm" "overloaded" (global i64)) + (import "not wasm" "overloaded" (global f32)) + (import "not wasm" "overloaded" (global f64)) + (import "not wasm" "overloaded" (table 0 funcref)) + (import "not wasm" "overloaded" (memory 0)) + ) + "unknown import" +) diff --git a/runtime/near-vm/tests/wast/spec/proposals/reference-types/linking.wast b/runtime/near-vm/tests/wast/spec/proposals/reference-types/linking.wast new file mode 100644 index 00000000000..49d55723db0 --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/proposals/reference-types/linking.wast @@ -0,0 +1,495 @@ +;; Functions + +(module $Mf + (func (export "call") (result i32) (call $g)) + (func $g (result i32) (i32.const 2)) +) +(register "Mf" $Mf) + +(module $Nf + (func $f (import "Mf" "call") (result i32)) + (export "Mf.call" (func $f)) + (func (export "call Mf.call") (result i32) (call $f)) + (func (export "call") (result i32) (call $g)) + (func $g (result i32) (i32.const 3)) +) + +(assert_return (invoke $Mf "call") (i32.const 2)) +(assert_return (invoke $Nf "Mf.call") (i32.const 2)) +(assert_return (invoke $Nf "call") (i32.const 3)) +(assert_return (invoke $Nf "call Mf.call") (i32.const 2)) + +(module + (import "spectest" "print_i32" (func $f (param i32))) + (export "print" (func $f)) +) +(register "reexport_f") +(assert_unlinkable + (module (import "reexport_f" "print" (func (param i64)))) + "incompatible import type" +) +(assert_unlinkable + (module (import "reexport_f" "print" (func (param i32) (result i32)))) + "incompatible import type" +) + + +;; Globals + +(module $Mg + (global $glob (export "glob") i32 (i32.const 42)) + (func (export "get") (result i32) (global.get $glob)) + + ;; export mutable globals + (global $mut_glob (export "mut_glob") (mut i32) (i32.const 142)) + (func (export "get_mut") (result i32) (global.get $mut_glob)) + (func (export "set_mut") (param i32) (global.set $mut_glob (local.get 0))) +) +(register "Mg" $Mg) + +(module $Ng + (global $x (import "Mg" "glob") i32) + (global $mut_glob (import "Mg" "mut_glob") (mut i32)) + (func $f (import "Mg" "get") (result i32)) + (func $get_mut (import "Mg" "get_mut") (result i32)) + (func $set_mut (import "Mg" "set_mut") (param i32)) + + (export "Mg.glob" (global $x)) + (export "Mg.get" (func $f)) + (global $glob (export "glob") i32 (i32.const 43)) + (func (export "get") (result i32) (global.get $glob)) + + (export "Mg.mut_glob" (global $mut_glob)) + (export "Mg.get_mut" (func $get_mut)) + (export "Mg.set_mut" (func $set_mut)) +) + +(assert_return (get $Mg "glob") (i32.const 42)) +(assert_return (get $Ng "Mg.glob") (i32.const 42)) +(assert_return (get $Ng "glob") (i32.const 43)) +(assert_return (invoke $Mg "get") (i32.const 42)) +(assert_return (invoke $Ng "Mg.get") (i32.const 42)) +(assert_return (invoke $Ng "get") (i32.const 43)) + +(assert_return (get $Mg "mut_glob") (i32.const 142)) +(assert_return (get $Ng "Mg.mut_glob") (i32.const 142)) +(assert_return (invoke $Mg "get_mut") (i32.const 142)) +(assert_return (invoke $Ng "Mg.get_mut") (i32.const 142)) + +(assert_return (invoke $Mg "set_mut" (i32.const 241))) +(assert_return (get $Mg "mut_glob") (i32.const 241)) +(assert_return (get $Ng "Mg.mut_glob") (i32.const 241)) +(assert_return (invoke $Mg "get_mut") (i32.const 241)) +(assert_return (invoke $Ng "Mg.get_mut") (i32.const 241)) + + +(assert_unlinkable + (module (import "Mg" "mut_glob" (global i32))) + "incompatible import type" +) +(assert_unlinkable + (module (import "Mg" "glob" (global (mut i32)))) + "incompatible import type" +) + + +(module $Mref_ex + (global (export "g-const-null") nullref (ref.null)) + (global (export "g-var-null") (mut nullref) (ref.null)) + (global (export "g-const-func") funcref (ref.null)) + (global (export "g-var-func") (mut funcref) (ref.null)) + (global (export "g-const-any") anyref (ref.null)) + (global (export "g-var-any") (mut anyref) (ref.null)) +) +(register "Mref_ex" $Mref_ex) + +(module $Mref_im + (global (import "Mref_ex" "g-const-null") nullref) + (global (import "Mref_ex" "g-const-null") funcref) + (global (import "Mref_ex" "g-const-null") anyref) + (global (import "Mref_ex" "g-const-func") funcref) + (global (import "Mref_ex" "g-const-func") anyref) + (global (import "Mref_ex" "g-const-any") anyref) + + (global (import "Mref_ex" "g-var-null") (mut nullref)) + (global (import "Mref_ex" "g-var-func") (mut funcref)) + (global (import "Mref_ex" "g-var-any") (mut anyref)) +) + +(assert_unlinkable + (module (global (import "Mref_ex" "g-const-func") nullref)) + "incompatible import type" +) +(assert_unlinkable + (module (global (import "Mref_ex" "g-const-any") nullref)) + "incompatible import type" +) +(assert_unlinkable + (module (global (import "Mref_ex" "g-const-any") funcref)) + "incompatible import type" +) + + +(assert_unlinkable + (module (global (import "Mref_ex" "g-var-null") (mut funcref))) + "incompatible import type" +) +(assert_unlinkable + (module (global (import "Mref_ex" "g-var-null") (mut anyref))) + "incompatible import type" +) +(assert_unlinkable + (module (global (import "Mref_ex" "g-var-func") (mut nullref))) + "incompatible import type" +) +(assert_unlinkable + (module (global (import "Mref_ex" "g-var-func") (mut anyref))) + "incompatible import type" +) +(assert_unlinkable + (module (global (import "Mref_ex" "g-var-any") (mut nullref))) + "incompatible import type" +) +(assert_unlinkable + (module (global (import "Mref_ex" "g-var-any") (mut funcref))) + "incompatible import type" +) + + +;; Tables + +(module $Mt + (type (func (result i32))) + (type (func)) + + (table (export "tab") 10 funcref) + (elem (i32.const 2) $g $g $g $g) + (func $g (result i32) (i32.const 4)) + (func (export "h") (result i32) (i32.const -4)) + + (func (export "call") (param i32) (result i32) + (call_indirect (type 0) (local.get 0)) + ) +) +(register "Mt" $Mt) + +(module $Nt + (type (func)) + (type (func (result i32))) + + (func $f (import "Mt" "call") (param i32) (result i32)) + (func $h (import "Mt" "h") (result i32)) + + (table funcref (elem $g $g $g $h $f)) + (func $g (result i32) (i32.const 5)) + + (export "Mt.call" (func $f)) + (func (export "call Mt.call") (param i32) (result i32) + (call $f (local.get 0)) + ) + (func (export "call") (param i32) (result i32) + (call_indirect (type 1) (local.get 0)) + ) +) + +(assert_return (invoke $Mt "call" (i32.const 2)) (i32.const 4)) +(assert_return (invoke $Nt "Mt.call" (i32.const 2)) (i32.const 4)) +(assert_return (invoke $Nt "call" (i32.const 2)) (i32.const 5)) +(assert_return (invoke $Nt "call Mt.call" (i32.const 2)) (i32.const 4)) + +(assert_trap (invoke $Mt "call" (i32.const 1)) "uninitialized") +(assert_trap (invoke $Nt "Mt.call" (i32.const 1)) "uninitialized") +(assert_return (invoke $Nt "call" (i32.const 1)) (i32.const 5)) +(assert_trap (invoke $Nt "call Mt.call" (i32.const 1)) "uninitialized") + +(assert_trap (invoke $Mt "call" (i32.const 0)) "uninitialized") +(assert_trap (invoke $Nt "Mt.call" (i32.const 0)) "uninitialized") +(assert_return (invoke $Nt "call" (i32.const 0)) (i32.const 5)) +(assert_trap (invoke $Nt "call Mt.call" (i32.const 0)) "uninitialized") + +(assert_trap (invoke $Mt "call" (i32.const 20)) "undefined") +(assert_trap (invoke $Nt "Mt.call" (i32.const 20)) "undefined") +(assert_trap (invoke $Nt "call" (i32.const 7)) "undefined") +(assert_trap (invoke $Nt "call Mt.call" (i32.const 20)) "undefined") + +(assert_return (invoke $Nt "call" (i32.const 3)) (i32.const -4)) +(assert_trap (invoke $Nt "call" (i32.const 4)) "indirect call") + +(module $Ot + (type (func (result i32))) + + (func $h (import "Mt" "h") (result i32)) + (table (import "Mt" "tab") 5 funcref) + (elem (i32.const 1) $i $h) + (func $i (result i32) (i32.const 6)) + + (func (export "call") (param i32) (result i32) + (call_indirect (type 0) (local.get 0)) + ) +) + +(assert_return (invoke $Mt "call" (i32.const 3)) (i32.const 4)) +(assert_return (invoke $Nt "Mt.call" (i32.const 3)) (i32.const 4)) +(assert_return (invoke $Nt "call Mt.call" (i32.const 3)) (i32.const 4)) +(assert_return (invoke $Ot "call" (i32.const 3)) (i32.const 4)) + +(assert_return (invoke $Mt "call" (i32.const 2)) (i32.const -4)) +(assert_return (invoke $Nt "Mt.call" (i32.const 2)) (i32.const -4)) +(assert_return (invoke $Nt "call" (i32.const 2)) (i32.const 5)) +(assert_return (invoke $Nt "call Mt.call" (i32.const 2)) (i32.const -4)) +(assert_return (invoke $Ot "call" (i32.const 2)) (i32.const -4)) + +(assert_return (invoke $Mt "call" (i32.const 1)) (i32.const 6)) +(assert_return (invoke $Nt "Mt.call" (i32.const 1)) (i32.const 6)) +(assert_return (invoke $Nt "call" (i32.const 1)) (i32.const 5)) +(assert_return (invoke $Nt "call Mt.call" (i32.const 1)) (i32.const 6)) +(assert_return (invoke $Ot "call" (i32.const 1)) (i32.const 6)) + +(assert_trap (invoke $Mt "call" (i32.const 0)) "uninitialized") +(assert_trap (invoke $Nt "Mt.call" (i32.const 0)) "uninitialized") +(assert_return (invoke $Nt "call" (i32.const 0)) (i32.const 5)) +(assert_trap (invoke $Nt "call Mt.call" (i32.const 0)) "uninitialized") +(assert_trap (invoke $Ot "call" (i32.const 0)) "uninitialized") + +(assert_trap (invoke $Ot "call" (i32.const 20)) "undefined") + +(module + (table (import "Mt" "tab") 0 funcref) + (elem (i32.const 9) $f) + (func $f) +) + +(module $G1 (global (export "g") i32 (i32.const 5))) +(register "G1" $G1) +(module $G2 + (global (import "G1" "g") i32) + (global (export "g") i32 (global.get 0)) +) +(assert_return (get $G2 "g") (i32.const 5)) + +(assert_trap + (module + (table (import "Mt" "tab") 0 funcref) + (elem (i32.const 10) $f) + (func $f) + ) + "out of bounds" +) + +(assert_unlinkable + (module + (table (import "Mt" "tab") 10 funcref) + (memory (import "Mt" "mem") 1) ;; does not exist + (func $f (result i32) (i32.const 0)) + (elem (i32.const 7) $f) + (elem (i32.const 9) $f) + ) + "unknown import" +) +(assert_trap (invoke $Mt "call" (i32.const 7)) "uninitialized") + +;; Unlike in the v1 spec, active element segments stored before an +;; out-of-bounds access persist after the instantiation failure. +(assert_trap + (module + (table (import "Mt" "tab") 10 funcref) + (func $f (result i32) (i32.const 0)) + (elem (i32.const 7) $f) + (elem (i32.const 12) $f) ;; out of bounds + ) + "out of bounds" +) +(assert_return (invoke $Mt "call" (i32.const 7)) (i32.const 0)) + +(assert_trap + (module + (table (import "Mt" "tab") 10 funcref) + (func $f (result i32) (i32.const 0)) + (elem (i32.const 7) $f) + (memory 1) + (data (i32.const 0x10000) "d") ;; out of bounds + ) + "out of bounds" +) +(assert_return (invoke $Mt "call" (i32.const 7)) (i32.const 0)) + + +(module $Mtable_ex + (table $t1 (export "t-null") 1 nullref) + (table $t2 (export "t-func") 1 funcref) + (table $t3 (export "t-any") 1 anyref) +) +(register "Mtable_ex" $Mtable_ex) + +(module + (table (import "Mtable_ex" "t-null") 1 nullref) + (table (import "Mtable_ex" "t-func") 1 funcref) + (table (import "Mtable_ex" "t-any") 1 anyref) +) + +(assert_unlinkable + (module (table (import "Mtable_ex" "t-null") 1 funcref)) + "incompatible import type" +) +(assert_unlinkable + (module (table (import "Mtable_ex" "t-null") 1 anyref)) + "incompatible import type" +) +(assert_unlinkable + (module (table (import "Mtable_ex" "t-func") 1 nullref)) + "incompatible import type" +) +(assert_unlinkable + (module (table (import "Mtable_ex" "t-func") 1 anyref)) + "incompatible import type" +) +(assert_unlinkable + (module (table (import "Mtable_ex" "t-any") 1 nullref)) + "incompatible import type" +) +(assert_unlinkable + (module (table (import "Mtable_ex" "t-any") 1 funcref)) + "incompatible import type" +) + + +;; Memories + +(module $Mm + (memory (export "mem") 1 5) + (data (i32.const 10) "\00\01\02\03\04\05\06\07\08\09") + + (func (export "load") (param $a i32) (result i32) + (i32.load8_u (local.get 0)) + ) +) +(register "Mm" $Mm) + +(module $Nm + (func $loadM (import "Mm" "load") (param i32) (result i32)) + + (memory 1) + (data (i32.const 10) "\f0\f1\f2\f3\f4\f5") + + (export "Mm.load" (func $loadM)) + (func (export "load") (param $a i32) (result i32) + (i32.load8_u (local.get 0)) + ) +) + +(assert_return (invoke $Mm "load" (i32.const 12)) (i32.const 2)) +(assert_return (invoke $Nm "Mm.load" (i32.const 12)) (i32.const 2)) +(assert_return (invoke $Nm "load" (i32.const 12)) (i32.const 0xf2)) + +(module $Om + (memory (import "Mm" "mem") 1) + (data (i32.const 5) "\a0\a1\a2\a3\a4\a5\a6\a7") + + (func (export "load") (param $a i32) (result i32) + (i32.load8_u (local.get 0)) + ) +) + +(assert_return (invoke $Mm "load" (i32.const 12)) (i32.const 0xa7)) +(assert_return (invoke $Nm "Mm.load" (i32.const 12)) (i32.const 0xa7)) +(assert_return (invoke $Nm "load" (i32.const 12)) (i32.const 0xf2)) +(assert_return (invoke $Om "load" (i32.const 12)) (i32.const 0xa7)) + +(module + (memory (import "Mm" "mem") 0) + (data (i32.const 0xffff) "a") +) + +(assert_trap + (module + (memory (import "Mm" "mem") 0) + (data (i32.const 0x10000) "a") + ) + "out of bounds" +) + +(module $Pm + (memory (import "Mm" "mem") 1 8) + + (func (export "grow") (param $a i32) (result i32) + (memory.grow (local.get 0)) + ) +) + +(assert_return (invoke $Pm "grow" (i32.const 0)) (i32.const 1)) +(assert_return (invoke $Pm "grow" (i32.const 2)) (i32.const 1)) +(assert_return (invoke $Pm "grow" (i32.const 0)) (i32.const 3)) +(assert_return (invoke $Pm "grow" (i32.const 1)) (i32.const 3)) +(assert_return (invoke $Pm "grow" (i32.const 1)) (i32.const 4)) +(assert_return (invoke $Pm "grow" (i32.const 0)) (i32.const 5)) +(assert_return (invoke $Pm "grow" (i32.const 1)) (i32.const -1)) +(assert_return (invoke $Pm "grow" (i32.const 0)) (i32.const 5)) + +(assert_unlinkable + (module + (func $host (import "spectest" "print")) + (memory (import "Mm" "mem") 1) + (table (import "Mm" "tab") 0 funcref) ;; does not exist + (data (i32.const 0) "abc") + ) + "unknown import" +) +(assert_return (invoke $Mm "load" (i32.const 0)) (i32.const 0)) + +;; Unlike in v1 spec, active data segments written before an +;; out-of-bounds access persist after the instantiation failure. +(assert_trap + (module + (memory (import "Mm" "mem") 1) + (data (i32.const 0) "abc") + (data (i32.const 0x50000) "d") ;; out of bounds + ) + "out of bounds" +) +(assert_return (invoke $Mm "load" (i32.const 0)) (i32.const 97)) + +(assert_trap + (module + (memory (import "Mm" "mem") 1) + (data (i32.const 0) "abc") + (table 0 funcref) + (func) + (elem (i32.const 0) 0) ;; out of bounds + ) + "out of bounds" +) +(assert_return (invoke $Mm "load" (i32.const 0)) (i32.const 97)) + +;; Store is modified if the start function traps. +(module $Ms + (type $t (func (result i32))) + (memory (export "memory") 1) + (table (export "table") 1 funcref) + (func (export "get memory[0]") (type $t) + (i32.load8_u (i32.const 0)) + ) + (func (export "get table[0]") (type $t) + (call_indirect (type $t) (i32.const 0)) + ) +) +(register "Ms" $Ms) + +(assert_trap + (module + (import "Ms" "memory" (memory 1)) + (import "Ms" "table" (table 1 funcref)) + (data (i32.const 0) "hello") + (elem (i32.const 0) $f) + (func $f (result i32) + (i32.const 0xdead) + ) + (func $main + (unreachable) + ) + (start $main) + ) + "unreachable" +) + +(assert_return (invoke $Ms "get memory[0]") (i32.const 104)) ;; 'h' +(assert_return (invoke $Ms "get table[0]") (i32.const 0xdead)) diff --git a/runtime/near-vm/tests/wast/spec/proposals/reference-types/memory_copy.wast b/runtime/near-vm/tests/wast/spec/proposals/reference-types/memory_copy.wast new file mode 100644 index 00000000000..692e1ad85fb --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/proposals/reference-types/memory_copy.wast @@ -0,0 +1,5577 @@ +;; +;; Generated by ../meta/generate_memory_copy.js +;; + +(module + (memory (export "memory0") 1 1) + (data (i32.const 2) "\03\01\04\01") + (data (i32.const 12) "\07\05\02\03\06") + (func (export "test") + (nop)) + (func (export "load8_u") (param i32) (result i32) + (i32.load8_u (local.get 0)))) + +(invoke "test") + +(assert_return (invoke "load8_u" (i32.const 0)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 1)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 2)) (i32.const 3)) +(assert_return (invoke "load8_u" (i32.const 3)) (i32.const 1)) +(assert_return (invoke "load8_u" (i32.const 4)) (i32.const 4)) +(assert_return (invoke "load8_u" (i32.const 5)) (i32.const 1)) +(assert_return (invoke "load8_u" (i32.const 6)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 7)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 8)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 9)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 10)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 11)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 12)) (i32.const 7)) +(assert_return (invoke "load8_u" (i32.const 13)) (i32.const 5)) +(assert_return (invoke "load8_u" (i32.const 14)) (i32.const 2)) +(assert_return (invoke "load8_u" (i32.const 15)) (i32.const 3)) +(assert_return (invoke "load8_u" (i32.const 16)) (i32.const 6)) +(assert_return (invoke "load8_u" (i32.const 17)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 18)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 19)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 20)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 21)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 22)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 23)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 24)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 25)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 26)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 27)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 28)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 29)) (i32.const 0)) + +(module + (memory (export "memory0") 1 1) + (data (i32.const 2) "\03\01\04\01") + (data (i32.const 12) "\07\05\02\03\06") + (func (export "test") + (memory.copy (i32.const 13) (i32.const 2) (i32.const 3))) + (func (export "load8_u") (param i32) (result i32) + (i32.load8_u (local.get 0)))) + +(invoke "test") + +(assert_return (invoke "load8_u" (i32.const 0)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 1)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 2)) (i32.const 3)) +(assert_return (invoke "load8_u" (i32.const 3)) (i32.const 1)) +(assert_return (invoke "load8_u" (i32.const 4)) (i32.const 4)) +(assert_return (invoke "load8_u" (i32.const 5)) (i32.const 1)) +(assert_return (invoke "load8_u" (i32.const 6)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 7)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 8)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 9)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 10)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 11)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 12)) (i32.const 7)) +(assert_return (invoke "load8_u" (i32.const 13)) (i32.const 3)) +(assert_return (invoke "load8_u" (i32.const 14)) (i32.const 1)) +(assert_return (invoke "load8_u" (i32.const 15)) (i32.const 4)) +(assert_return (invoke "load8_u" (i32.const 16)) (i32.const 6)) +(assert_return (invoke "load8_u" (i32.const 17)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 18)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 19)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 20)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 21)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 22)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 23)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 24)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 25)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 26)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 27)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 28)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 29)) (i32.const 0)) + +(module + (memory (export "memory0") 1 1) + (data (i32.const 2) "\03\01\04\01") + (data (i32.const 12) "\07\05\02\03\06") + (func (export "test") + (memory.copy (i32.const 25) (i32.const 15) (i32.const 2))) + (func (export "load8_u") (param i32) (result i32) + (i32.load8_u (local.get 0)))) + +(invoke "test") + +(assert_return (invoke "load8_u" (i32.const 0)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 1)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 2)) (i32.const 3)) +(assert_return (invoke "load8_u" (i32.const 3)) (i32.const 1)) +(assert_return (invoke "load8_u" (i32.const 4)) (i32.const 4)) +(assert_return (invoke "load8_u" (i32.const 5)) (i32.const 1)) +(assert_return (invoke "load8_u" (i32.const 6)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 7)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 8)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 9)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 10)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 11)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 12)) (i32.const 7)) +(assert_return (invoke "load8_u" (i32.const 13)) (i32.const 5)) +(assert_return (invoke "load8_u" (i32.const 14)) (i32.const 2)) +(assert_return (invoke "load8_u" (i32.const 15)) (i32.const 3)) +(assert_return (invoke "load8_u" (i32.const 16)) (i32.const 6)) +(assert_return (invoke "load8_u" (i32.const 17)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 18)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 19)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 20)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 21)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 22)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 23)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 24)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 25)) (i32.const 3)) +(assert_return (invoke "load8_u" (i32.const 26)) (i32.const 6)) +(assert_return (invoke "load8_u" (i32.const 27)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 28)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 29)) (i32.const 0)) + +(module + (memory (export "memory0") 1 1) + (data (i32.const 2) "\03\01\04\01") + (data (i32.const 12) "\07\05\02\03\06") + (func (export "test") + (memory.copy (i32.const 13) (i32.const 25) (i32.const 3))) + (func (export "load8_u") (param i32) (result i32) + (i32.load8_u (local.get 0)))) + +(invoke "test") + +(assert_return (invoke "load8_u" (i32.const 0)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 1)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 2)) (i32.const 3)) +(assert_return (invoke "load8_u" (i32.const 3)) (i32.const 1)) +(assert_return (invoke "load8_u" (i32.const 4)) (i32.const 4)) +(assert_return (invoke "load8_u" (i32.const 5)) (i32.const 1)) +(assert_return (invoke "load8_u" (i32.const 6)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 7)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 8)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 9)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 10)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 11)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 12)) (i32.const 7)) +(assert_return (invoke "load8_u" (i32.const 13)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 14)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 15)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 16)) (i32.const 6)) +(assert_return (invoke "load8_u" (i32.const 17)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 18)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 19)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 20)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 21)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 22)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 23)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 24)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 25)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 26)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 27)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 28)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 29)) (i32.const 0)) + +(module + (memory (export "memory0") 1 1) + (data (i32.const 2) "\03\01\04\01") + (data (i32.const 12) "\07\05\02\03\06") + (func (export "test") + (memory.copy (i32.const 20) (i32.const 22) (i32.const 4))) + (func (export "load8_u") (param i32) (result i32) + (i32.load8_u (local.get 0)))) + +(invoke "test") + +(assert_return (invoke "load8_u" (i32.const 0)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 1)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 2)) (i32.const 3)) +(assert_return (invoke "load8_u" (i32.const 3)) (i32.const 1)) +(assert_return (invoke "load8_u" (i32.const 4)) (i32.const 4)) +(assert_return (invoke "load8_u" (i32.const 5)) (i32.const 1)) +(assert_return (invoke "load8_u" (i32.const 6)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 7)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 8)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 9)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 10)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 11)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 12)) (i32.const 7)) +(assert_return (invoke "load8_u" (i32.const 13)) (i32.const 5)) +(assert_return (invoke "load8_u" (i32.const 14)) (i32.const 2)) +(assert_return (invoke "load8_u" (i32.const 15)) (i32.const 3)) +(assert_return (invoke "load8_u" (i32.const 16)) (i32.const 6)) +(assert_return (invoke "load8_u" (i32.const 17)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 18)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 19)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 20)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 21)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 22)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 23)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 24)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 25)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 26)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 27)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 28)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 29)) (i32.const 0)) + +(module + (memory (export "memory0") 1 1) + (data (i32.const 2) "\03\01\04\01") + (data (i32.const 12) "\07\05\02\03\06") + (func (export "test") + (memory.copy (i32.const 25) (i32.const 1) (i32.const 3))) + (func (export "load8_u") (param i32) (result i32) + (i32.load8_u (local.get 0)))) + +(invoke "test") + +(assert_return (invoke "load8_u" (i32.const 0)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 1)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 2)) (i32.const 3)) +(assert_return (invoke "load8_u" (i32.const 3)) (i32.const 1)) +(assert_return (invoke "load8_u" (i32.const 4)) (i32.const 4)) +(assert_return (invoke "load8_u" (i32.const 5)) (i32.const 1)) +(assert_return (invoke "load8_u" (i32.const 6)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 7)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 8)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 9)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 10)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 11)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 12)) (i32.const 7)) +(assert_return (invoke "load8_u" (i32.const 13)) (i32.const 5)) +(assert_return (invoke "load8_u" (i32.const 14)) (i32.const 2)) +(assert_return (invoke "load8_u" (i32.const 15)) (i32.const 3)) +(assert_return (invoke "load8_u" (i32.const 16)) (i32.const 6)) +(assert_return (invoke "load8_u" (i32.const 17)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 18)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 19)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 20)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 21)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 22)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 23)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 24)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 25)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 26)) (i32.const 3)) +(assert_return (invoke "load8_u" (i32.const 27)) (i32.const 1)) +(assert_return (invoke "load8_u" (i32.const 28)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 29)) (i32.const 0)) + +(module + (memory (export "memory0") 1 1) + (data (i32.const 2) "\03\01\04\01") + (data (i32.const 12) "\07\05\02\03\06") + (func (export "test") + (memory.copy (i32.const 10) (i32.const 12) (i32.const 7))) + (func (export "load8_u") (param i32) (result i32) + (i32.load8_u (local.get 0)))) + +(invoke "test") + +(assert_return (invoke "load8_u" (i32.const 0)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 1)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 2)) (i32.const 3)) +(assert_return (invoke "load8_u" (i32.const 3)) (i32.const 1)) +(assert_return (invoke "load8_u" (i32.const 4)) (i32.const 4)) +(assert_return (invoke "load8_u" (i32.const 5)) (i32.const 1)) +(assert_return (invoke "load8_u" (i32.const 6)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 7)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 8)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 9)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 10)) (i32.const 7)) +(assert_return (invoke "load8_u" (i32.const 11)) (i32.const 5)) +(assert_return (invoke "load8_u" (i32.const 12)) (i32.const 2)) +(assert_return (invoke "load8_u" (i32.const 13)) (i32.const 3)) +(assert_return (invoke "load8_u" (i32.const 14)) (i32.const 6)) +(assert_return (invoke "load8_u" (i32.const 15)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 16)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 17)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 18)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 19)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 20)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 21)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 22)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 23)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 24)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 25)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 26)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 27)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 28)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 29)) (i32.const 0)) + +(module + (memory (export "memory0") 1 1) + (data (i32.const 2) "\03\01\04\01") + (data (i32.const 12) "\07\05\02\03\06") + (func (export "test") + (memory.copy (i32.const 12) (i32.const 10) (i32.const 7))) + (func (export "load8_u") (param i32) (result i32) + (i32.load8_u (local.get 0)))) + +(invoke "test") + +(assert_return (invoke "load8_u" (i32.const 0)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 1)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 2)) (i32.const 3)) +(assert_return (invoke "load8_u" (i32.const 3)) (i32.const 1)) +(assert_return (invoke "load8_u" (i32.const 4)) (i32.const 4)) +(assert_return (invoke "load8_u" (i32.const 5)) (i32.const 1)) +(assert_return (invoke "load8_u" (i32.const 6)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 7)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 8)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 9)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 10)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 11)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 12)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 13)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 14)) (i32.const 7)) +(assert_return (invoke "load8_u" (i32.const 15)) (i32.const 5)) +(assert_return (invoke "load8_u" (i32.const 16)) (i32.const 2)) +(assert_return (invoke "load8_u" (i32.const 17)) (i32.const 3)) +(assert_return (invoke "load8_u" (i32.const 18)) (i32.const 6)) +(assert_return (invoke "load8_u" (i32.const 19)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 20)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 21)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 22)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 23)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 24)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 25)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 26)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 27)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 28)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 29)) (i32.const 0)) + +(module + (memory (export "mem") 1 1 ) + (data (i32.const 0) "\00\01\02\03\04\05\06\07\08\09\0a\0b\0c\0d\0e\0f\10\11\12\13") + (func (export "run") (param $targetOffs i32) (param $srcOffs i32) (param $len i32) + (memory.copy (local.get $targetOffs) (local.get $srcOffs) (local.get $len))) + (func (export "load8_u") (param i32) (result i32) + (i32.load8_u (local.get 0)))) + +(assert_trap (invoke "run" (i32.const 65516) (i32.const 0) (i32.const 40)) + "out of bounds") + +(assert_return (invoke "load8_u" (i32.const 0)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 1)) (i32.const 1)) +(assert_return (invoke "load8_u" (i32.const 2)) (i32.const 2)) +(assert_return (invoke "load8_u" (i32.const 3)) (i32.const 3)) +(assert_return (invoke "load8_u" (i32.const 4)) (i32.const 4)) +(assert_return (invoke "load8_u" (i32.const 5)) (i32.const 5)) +(assert_return (invoke "load8_u" (i32.const 6)) (i32.const 6)) +(assert_return (invoke "load8_u" (i32.const 7)) (i32.const 7)) +(assert_return (invoke "load8_u" (i32.const 8)) (i32.const 8)) +(assert_return (invoke "load8_u" (i32.const 9)) (i32.const 9)) +(assert_return (invoke "load8_u" (i32.const 10)) (i32.const 10)) +(assert_return (invoke "load8_u" (i32.const 11)) (i32.const 11)) +(assert_return (invoke "load8_u" (i32.const 12)) (i32.const 12)) +(assert_return (invoke "load8_u" (i32.const 13)) (i32.const 13)) +(assert_return (invoke "load8_u" (i32.const 14)) (i32.const 14)) +(assert_return (invoke "load8_u" (i32.const 15)) (i32.const 15)) +(assert_return (invoke "load8_u" (i32.const 16)) (i32.const 16)) +(assert_return (invoke "load8_u" (i32.const 17)) (i32.const 17)) +(assert_return (invoke "load8_u" (i32.const 18)) (i32.const 18)) +(assert_return (invoke "load8_u" (i32.const 19)) (i32.const 19)) +(assert_return (invoke "load8_u" (i32.const 218)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 417)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 616)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 815)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 1014)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 1213)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 1412)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 1611)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 1810)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 2009)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 2208)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 2407)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 2606)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 2805)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 3004)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 3203)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 3402)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 3601)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 3800)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 3999)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 4198)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 4397)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 4596)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 4795)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 4994)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 5193)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 5392)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 5591)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 5790)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 5989)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 6188)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 6387)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 6586)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 6785)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 6984)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 7183)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 7382)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 7581)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 7780)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 7979)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 8178)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 8377)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 8576)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 8775)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 8974)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 9173)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 9372)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 9571)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 9770)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 9969)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 10168)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 10367)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 10566)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 10765)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 10964)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 11163)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 11362)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 11561)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 11760)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 11959)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 12158)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 12357)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 12556)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 12755)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 12954)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 13153)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 13352)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 13551)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 13750)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 13949)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 14148)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 14347)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 14546)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 14745)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 14944)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 15143)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 15342)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 15541)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 15740)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 15939)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 16138)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 16337)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 16536)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 16735)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 16934)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 17133)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 17332)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 17531)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 17730)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 17929)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 18128)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 18327)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 18526)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 18725)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 18924)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 19123)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 19322)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 19521)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 19720)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 19919)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 20118)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 20317)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 20516)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 20715)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 20914)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 21113)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 21312)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 21511)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 21710)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 21909)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 22108)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 22307)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 22506)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 22705)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 22904)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 23103)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 23302)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 23501)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 23700)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 23899)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 24098)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 24297)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 24496)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 24695)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 24894)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 25093)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 25292)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 25491)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 25690)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 25889)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 26088)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 26287)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 26486)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 26685)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 26884)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 27083)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 27282)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 27481)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 27680)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 27879)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 28078)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 28277)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 28476)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 28675)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 28874)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 29073)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 29272)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 29471)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 29670)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 29869)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 30068)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 30267)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 30466)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 30665)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 30864)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 31063)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 31262)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 31461)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 31660)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 31859)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 32058)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 32257)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 32456)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 32655)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 32854)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 33053)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 33252)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 33451)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 33650)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 33849)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 34048)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 34247)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 34446)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 34645)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 34844)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 35043)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 35242)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 35441)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 35640)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 35839)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 36038)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 36237)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 36436)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 36635)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 36834)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 37033)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 37232)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 37431)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 37630)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 37829)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 38028)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 38227)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 38426)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 38625)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 38824)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 39023)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 39222)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 39421)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 39620)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 39819)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 40018)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 40217)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 40416)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 40615)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 40814)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 41013)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 41212)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 41411)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 41610)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 41809)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 42008)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 42207)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 42406)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 42605)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 42804)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 43003)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 43202)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 43401)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 43600)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 43799)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 43998)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 44197)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 44396)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 44595)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 44794)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 44993)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 45192)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 45391)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 45590)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 45789)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 45988)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 46187)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 46386)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 46585)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 46784)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 46983)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 47182)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 47381)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 47580)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 47779)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 47978)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 48177)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 48376)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 48575)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 48774)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 48973)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 49172)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 49371)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 49570)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 49769)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 49968)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 50167)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 50366)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 50565)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 50764)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 50963)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 51162)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 51361)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 51560)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 51759)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 51958)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 52157)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 52356)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 52555)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 52754)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 52953)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 53152)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 53351)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 53550)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 53749)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 53948)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 54147)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 54346)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 54545)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 54744)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 54943)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 55142)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 55341)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 55540)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 55739)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 55938)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 56137)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 56336)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 56535)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 56734)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 56933)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 57132)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 57331)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 57530)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 57729)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 57928)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 58127)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 58326)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 58525)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 58724)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 58923)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 59122)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 59321)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 59520)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 59719)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 59918)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 60117)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 60316)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 60515)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 60714)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 60913)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 61112)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 61311)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 61510)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 61709)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 61908)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 62107)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 62306)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 62505)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 62704)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 62903)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 63102)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 63301)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 63500)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 63699)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 63898)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 64097)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 64296)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 64495)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 64694)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 64893)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 65092)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 65291)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 65490)) (i32.const 0)) + +(module + (memory (export "mem") 1 1 ) + (data (i32.const 0) "\00\01\02\03\04\05\06\07\08\09\0a\0b\0c\0d\0e\0f\10\11\12\13\14") + (func (export "run") (param $targetOffs i32) (param $srcOffs i32) (param $len i32) + (memory.copy (local.get $targetOffs) (local.get $srcOffs) (local.get $len))) + (func (export "load8_u") (param i32) (result i32) + (i32.load8_u (local.get 0)))) + +(assert_trap (invoke "run" (i32.const 65515) (i32.const 0) (i32.const 39)) + "out of bounds") + +(assert_return (invoke "load8_u" (i32.const 0)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 1)) (i32.const 1)) +(assert_return (invoke "load8_u" (i32.const 2)) (i32.const 2)) +(assert_return (invoke "load8_u" (i32.const 3)) (i32.const 3)) +(assert_return (invoke "load8_u" (i32.const 4)) (i32.const 4)) +(assert_return (invoke "load8_u" (i32.const 5)) (i32.const 5)) +(assert_return (invoke "load8_u" (i32.const 6)) (i32.const 6)) +(assert_return (invoke "load8_u" (i32.const 7)) (i32.const 7)) +(assert_return (invoke "load8_u" (i32.const 8)) (i32.const 8)) +(assert_return (invoke "load8_u" (i32.const 9)) (i32.const 9)) +(assert_return (invoke "load8_u" (i32.const 10)) (i32.const 10)) +(assert_return (invoke "load8_u" (i32.const 11)) (i32.const 11)) +(assert_return (invoke "load8_u" (i32.const 12)) (i32.const 12)) +(assert_return (invoke "load8_u" (i32.const 13)) (i32.const 13)) +(assert_return (invoke "load8_u" (i32.const 14)) (i32.const 14)) +(assert_return (invoke "load8_u" (i32.const 15)) (i32.const 15)) +(assert_return (invoke "load8_u" (i32.const 16)) (i32.const 16)) +(assert_return (invoke "load8_u" (i32.const 17)) (i32.const 17)) +(assert_return (invoke "load8_u" (i32.const 18)) (i32.const 18)) +(assert_return (invoke "load8_u" (i32.const 19)) (i32.const 19)) +(assert_return (invoke "load8_u" (i32.const 20)) (i32.const 20)) +(assert_return (invoke "load8_u" (i32.const 219)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 418)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 617)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 816)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 1015)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 1214)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 1413)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 1612)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 1811)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 2010)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 2209)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 2408)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 2607)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 2806)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 3005)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 3204)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 3403)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 3602)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 3801)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 4000)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 4199)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 4398)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 4597)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 4796)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 4995)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 5194)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 5393)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 5592)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 5791)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 5990)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 6189)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 6388)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 6587)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 6786)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 6985)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 7184)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 7383)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 7582)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 7781)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 7980)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 8179)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 8378)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 8577)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 8776)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 8975)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 9174)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 9373)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 9572)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 9771)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 9970)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 10169)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 10368)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 10567)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 10766)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 10965)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 11164)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 11363)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 11562)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 11761)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 11960)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 12159)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 12358)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 12557)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 12756)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 12955)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 13154)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 13353)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 13552)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 13751)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 13950)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 14149)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 14348)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 14547)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 14746)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 14945)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 15144)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 15343)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 15542)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 15741)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 15940)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 16139)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 16338)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 16537)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 16736)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 16935)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 17134)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 17333)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 17532)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 17731)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 17930)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 18129)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 18328)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 18527)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 18726)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 18925)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 19124)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 19323)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 19522)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 19721)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 19920)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 20119)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 20318)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 20517)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 20716)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 20915)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 21114)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 21313)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 21512)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 21711)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 21910)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 22109)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 22308)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 22507)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 22706)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 22905)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 23104)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 23303)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 23502)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 23701)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 23900)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 24099)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 24298)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 24497)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 24696)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 24895)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 25094)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 25293)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 25492)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 25691)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 25890)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 26089)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 26288)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 26487)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 26686)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 26885)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 27084)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 27283)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 27482)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 27681)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 27880)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 28079)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 28278)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 28477)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 28676)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 28875)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 29074)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 29273)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 29472)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 29671)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 29870)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 30069)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 30268)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 30467)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 30666)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 30865)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 31064)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 31263)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 31462)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 31661)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 31860)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 32059)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 32258)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 32457)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 32656)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 32855)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 33054)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 33253)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 33452)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 33651)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 33850)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 34049)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 34248)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 34447)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 34646)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 34845)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 35044)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 35243)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 35442)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 35641)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 35840)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 36039)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 36238)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 36437)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 36636)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 36835)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 37034)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 37233)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 37432)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 37631)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 37830)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 38029)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 38228)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 38427)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 38626)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 38825)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 39024)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 39223)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 39422)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 39621)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 39820)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 40019)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 40218)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 40417)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 40616)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 40815)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 41014)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 41213)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 41412)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 41611)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 41810)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 42009)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 42208)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 42407)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 42606)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 42805)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 43004)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 43203)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 43402)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 43601)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 43800)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 43999)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 44198)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 44397)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 44596)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 44795)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 44994)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 45193)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 45392)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 45591)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 45790)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 45989)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 46188)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 46387)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 46586)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 46785)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 46984)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 47183)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 47382)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 47581)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 47780)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 47979)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 48178)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 48377)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 48576)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 48775)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 48974)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 49173)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 49372)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 49571)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 49770)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 49969)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 50168)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 50367)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 50566)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 50765)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 50964)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 51163)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 51362)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 51561)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 51760)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 51959)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 52158)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 52357)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 52556)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 52755)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 52954)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 53153)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 53352)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 53551)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 53750)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 53949)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 54148)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 54347)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 54546)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 54745)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 54944)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 55143)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 55342)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 55541)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 55740)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 55939)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 56138)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 56337)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 56536)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 56735)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 56934)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 57133)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 57332)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 57531)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 57730)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 57929)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 58128)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 58327)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 58526)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 58725)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 58924)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 59123)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 59322)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 59521)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 59720)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 59919)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 60118)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 60317)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 60516)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 60715)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 60914)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 61113)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 61312)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 61511)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 61710)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 61909)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 62108)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 62307)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 62506)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 62705)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 62904)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 63103)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 63302)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 63501)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 63700)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 63899)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 64098)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 64297)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 64496)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 64695)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 64894)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 65093)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 65292)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 65491)) (i32.const 0)) + +(module + (memory (export "mem") 1 1 ) + (data (i32.const 65516) "\00\01\02\03\04\05\06\07\08\09\0a\0b\0c\0d\0e\0f\10\11\12\13") + (func (export "run") (param $targetOffs i32) (param $srcOffs i32) (param $len i32) + (memory.copy (local.get $targetOffs) (local.get $srcOffs) (local.get $len))) + (func (export "load8_u") (param i32) (result i32) + (i32.load8_u (local.get 0)))) + +(assert_trap (invoke "run" (i32.const 0) (i32.const 65516) (i32.const 40)) + "out of bounds") + +(assert_return (invoke "load8_u" (i32.const 198)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 397)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 596)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 795)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 994)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 1193)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 1392)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 1591)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 1790)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 1989)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 2188)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 2387)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 2586)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 2785)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 2984)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 3183)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 3382)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 3581)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 3780)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 3979)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 4178)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 4377)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 4576)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 4775)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 4974)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 5173)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 5372)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 5571)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 5770)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 5969)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 6168)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 6367)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 6566)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 6765)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 6964)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 7163)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 7362)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 7561)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 7760)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 7959)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 8158)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 8357)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 8556)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 8755)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 8954)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 9153)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 9352)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 9551)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 9750)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 9949)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 10148)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 10347)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 10546)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 10745)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 10944)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 11143)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 11342)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 11541)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 11740)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 11939)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 12138)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 12337)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 12536)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 12735)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 12934)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 13133)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 13332)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 13531)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 13730)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 13929)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 14128)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 14327)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 14526)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 14725)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 14924)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 15123)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 15322)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 15521)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 15720)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 15919)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 16118)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 16317)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 16516)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 16715)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 16914)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 17113)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 17312)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 17511)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 17710)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 17909)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 18108)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 18307)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 18506)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 18705)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 18904)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 19103)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 19302)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 19501)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 19700)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 19899)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 20098)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 20297)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 20496)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 20695)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 20894)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 21093)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 21292)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 21491)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 21690)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 21889)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 22088)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 22287)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 22486)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 22685)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 22884)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 23083)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 23282)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 23481)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 23680)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 23879)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 24078)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 24277)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 24476)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 24675)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 24874)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 25073)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 25272)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 25471)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 25670)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 25869)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 26068)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 26267)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 26466)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 26665)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 26864)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 27063)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 27262)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 27461)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 27660)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 27859)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 28058)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 28257)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 28456)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 28655)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 28854)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 29053)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 29252)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 29451)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 29650)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 29849)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 30048)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 30247)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 30446)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 30645)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 30844)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 31043)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 31242)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 31441)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 31640)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 31839)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 32038)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 32237)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 32436)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 32635)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 32834)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 33033)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 33232)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 33431)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 33630)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 33829)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 34028)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 34227)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 34426)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 34625)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 34824)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 35023)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 35222)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 35421)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 35620)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 35819)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 36018)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 36217)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 36416)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 36615)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 36814)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 37013)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 37212)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 37411)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 37610)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 37809)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 38008)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 38207)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 38406)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 38605)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 38804)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 39003)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 39202)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 39401)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 39600)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 39799)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 39998)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 40197)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 40396)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 40595)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 40794)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 40993)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 41192)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 41391)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 41590)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 41789)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 41988)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 42187)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 42386)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 42585)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 42784)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 42983)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 43182)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 43381)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 43580)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 43779)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 43978)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 44177)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 44376)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 44575)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 44774)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 44973)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 45172)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 45371)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 45570)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 45769)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 45968)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 46167)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 46366)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 46565)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 46764)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 46963)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 47162)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 47361)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 47560)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 47759)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 47958)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 48157)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 48356)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 48555)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 48754)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 48953)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 49152)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 49351)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 49550)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 49749)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 49948)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 50147)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 50346)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 50545)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 50744)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 50943)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 51142)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 51341)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 51540)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 51739)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 51938)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 52137)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 52336)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 52535)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 52734)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 52933)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 53132)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 53331)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 53530)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 53729)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 53928)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 54127)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 54326)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 54525)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 54724)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 54923)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 55122)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 55321)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 55520)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 55719)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 55918)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 56117)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 56316)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 56515)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 56714)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 56913)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 57112)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 57311)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 57510)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 57709)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 57908)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 58107)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 58306)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 58505)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 58704)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 58903)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 59102)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 59301)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 59500)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 59699)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 59898)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 60097)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 60296)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 60495)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 60694)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 60893)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 61092)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 61291)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 61490)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 61689)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 61888)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 62087)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 62286)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 62485)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 62684)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 62883)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 63082)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 63281)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 63480)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 63679)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 63878)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 64077)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 64276)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 64475)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 64674)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 64873)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 65072)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 65271)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 65470)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 65516)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 65517)) (i32.const 1)) +(assert_return (invoke "load8_u" (i32.const 65518)) (i32.const 2)) +(assert_return (invoke "load8_u" (i32.const 65519)) (i32.const 3)) +(assert_return (invoke "load8_u" (i32.const 65520)) (i32.const 4)) +(assert_return (invoke "load8_u" (i32.const 65521)) (i32.const 5)) +(assert_return (invoke "load8_u" (i32.const 65522)) (i32.const 6)) +(assert_return (invoke "load8_u" (i32.const 65523)) (i32.const 7)) +(assert_return (invoke "load8_u" (i32.const 65524)) (i32.const 8)) +(assert_return (invoke "load8_u" (i32.const 65525)) (i32.const 9)) +(assert_return (invoke "load8_u" (i32.const 65526)) (i32.const 10)) +(assert_return (invoke "load8_u" (i32.const 65527)) (i32.const 11)) +(assert_return (invoke "load8_u" (i32.const 65528)) (i32.const 12)) +(assert_return (invoke "load8_u" (i32.const 65529)) (i32.const 13)) +(assert_return (invoke "load8_u" (i32.const 65530)) (i32.const 14)) +(assert_return (invoke "load8_u" (i32.const 65531)) (i32.const 15)) +(assert_return (invoke "load8_u" (i32.const 65532)) (i32.const 16)) +(assert_return (invoke "load8_u" (i32.const 65533)) (i32.const 17)) +(assert_return (invoke "load8_u" (i32.const 65534)) (i32.const 18)) +(assert_return (invoke "load8_u" (i32.const 65535)) (i32.const 19)) + +(module + (memory (export "mem") 1 1 ) + (data (i32.const 65515) "\00\01\02\03\04\05\06\07\08\09\0a\0b\0c\0d\0e\0f\10\11\12\13\14") + (func (export "run") (param $targetOffs i32) (param $srcOffs i32) (param $len i32) + (memory.copy (local.get $targetOffs) (local.get $srcOffs) (local.get $len))) + (func (export "load8_u") (param i32) (result i32) + (i32.load8_u (local.get 0)))) + +(assert_trap (invoke "run" (i32.const 0) (i32.const 65515) (i32.const 39)) + "out of bounds") + +(assert_return (invoke "load8_u" (i32.const 198)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 397)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 596)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 795)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 994)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 1193)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 1392)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 1591)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 1790)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 1989)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 2188)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 2387)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 2586)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 2785)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 2984)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 3183)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 3382)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 3581)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 3780)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 3979)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 4178)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 4377)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 4576)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 4775)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 4974)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 5173)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 5372)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 5571)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 5770)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 5969)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 6168)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 6367)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 6566)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 6765)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 6964)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 7163)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 7362)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 7561)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 7760)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 7959)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 8158)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 8357)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 8556)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 8755)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 8954)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 9153)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 9352)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 9551)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 9750)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 9949)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 10148)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 10347)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 10546)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 10745)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 10944)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 11143)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 11342)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 11541)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 11740)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 11939)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 12138)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 12337)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 12536)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 12735)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 12934)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 13133)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 13332)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 13531)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 13730)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 13929)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 14128)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 14327)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 14526)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 14725)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 14924)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 15123)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 15322)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 15521)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 15720)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 15919)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 16118)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 16317)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 16516)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 16715)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 16914)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 17113)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 17312)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 17511)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 17710)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 17909)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 18108)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 18307)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 18506)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 18705)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 18904)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 19103)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 19302)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 19501)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 19700)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 19899)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 20098)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 20297)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 20496)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 20695)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 20894)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 21093)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 21292)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 21491)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 21690)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 21889)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 22088)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 22287)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 22486)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 22685)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 22884)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 23083)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 23282)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 23481)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 23680)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 23879)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 24078)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 24277)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 24476)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 24675)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 24874)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 25073)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 25272)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 25471)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 25670)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 25869)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 26068)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 26267)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 26466)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 26665)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 26864)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 27063)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 27262)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 27461)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 27660)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 27859)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 28058)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 28257)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 28456)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 28655)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 28854)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 29053)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 29252)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 29451)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 29650)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 29849)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 30048)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 30247)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 30446)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 30645)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 30844)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 31043)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 31242)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 31441)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 31640)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 31839)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 32038)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 32237)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 32436)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 32635)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 32834)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 33033)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 33232)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 33431)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 33630)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 33829)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 34028)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 34227)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 34426)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 34625)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 34824)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 35023)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 35222)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 35421)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 35620)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 35819)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 36018)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 36217)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 36416)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 36615)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 36814)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 37013)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 37212)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 37411)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 37610)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 37809)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 38008)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 38207)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 38406)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 38605)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 38804)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 39003)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 39202)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 39401)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 39600)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 39799)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 39998)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 40197)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 40396)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 40595)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 40794)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 40993)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 41192)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 41391)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 41590)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 41789)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 41988)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 42187)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 42386)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 42585)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 42784)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 42983)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 43182)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 43381)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 43580)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 43779)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 43978)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 44177)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 44376)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 44575)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 44774)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 44973)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 45172)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 45371)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 45570)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 45769)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 45968)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 46167)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 46366)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 46565)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 46764)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 46963)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 47162)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 47361)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 47560)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 47759)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 47958)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 48157)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 48356)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 48555)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 48754)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 48953)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 49152)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 49351)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 49550)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 49749)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 49948)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 50147)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 50346)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 50545)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 50744)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 50943)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 51142)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 51341)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 51540)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 51739)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 51938)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 52137)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 52336)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 52535)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 52734)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 52933)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 53132)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 53331)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 53530)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 53729)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 53928)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 54127)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 54326)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 54525)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 54724)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 54923)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 55122)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 55321)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 55520)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 55719)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 55918)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 56117)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 56316)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 56515)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 56714)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 56913)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 57112)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 57311)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 57510)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 57709)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 57908)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 58107)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 58306)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 58505)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 58704)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 58903)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 59102)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 59301)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 59500)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 59699)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 59898)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 60097)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 60296)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 60495)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 60694)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 60893)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 61092)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 61291)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 61490)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 61689)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 61888)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 62087)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 62286)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 62485)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 62684)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 62883)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 63082)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 63281)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 63480)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 63679)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 63878)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 64077)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 64276)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 64475)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 64674)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 64873)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 65072)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 65271)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 65470)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 65515)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 65516)) (i32.const 1)) +(assert_return (invoke "load8_u" (i32.const 65517)) (i32.const 2)) +(assert_return (invoke "load8_u" (i32.const 65518)) (i32.const 3)) +(assert_return (invoke "load8_u" (i32.const 65519)) (i32.const 4)) +(assert_return (invoke "load8_u" (i32.const 65520)) (i32.const 5)) +(assert_return (invoke "load8_u" (i32.const 65521)) (i32.const 6)) +(assert_return (invoke "load8_u" (i32.const 65522)) (i32.const 7)) +(assert_return (invoke "load8_u" (i32.const 65523)) (i32.const 8)) +(assert_return (invoke "load8_u" (i32.const 65524)) (i32.const 9)) +(assert_return (invoke "load8_u" (i32.const 65525)) (i32.const 10)) +(assert_return (invoke "load8_u" (i32.const 65526)) (i32.const 11)) +(assert_return (invoke "load8_u" (i32.const 65527)) (i32.const 12)) +(assert_return (invoke "load8_u" (i32.const 65528)) (i32.const 13)) +(assert_return (invoke "load8_u" (i32.const 65529)) (i32.const 14)) +(assert_return (invoke "load8_u" (i32.const 65530)) (i32.const 15)) +(assert_return (invoke "load8_u" (i32.const 65531)) (i32.const 16)) +(assert_return (invoke "load8_u" (i32.const 65532)) (i32.const 17)) +(assert_return (invoke "load8_u" (i32.const 65533)) (i32.const 18)) +(assert_return (invoke "load8_u" (i32.const 65534)) (i32.const 19)) +(assert_return (invoke "load8_u" (i32.const 65535)) (i32.const 20)) + +(module + (memory (export "mem") 1 1 ) + (data (i32.const 65486) "\00\01\02\03\04\05\06\07\08\09\0a\0b\0c\0d\0e\0f\10\11\12\13") + (func (export "run") (param $targetOffs i32) (param $srcOffs i32) (param $len i32) + (memory.copy (local.get $targetOffs) (local.get $srcOffs) (local.get $len))) + (func (export "load8_u") (param i32) (result i32) + (i32.load8_u (local.get 0)))) + +(assert_trap (invoke "run" (i32.const 65516) (i32.const 65486) (i32.const 40)) + "out of bounds") + +(assert_return (invoke "load8_u" (i32.const 198)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 397)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 596)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 795)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 994)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 1193)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 1392)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 1591)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 1790)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 1989)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 2188)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 2387)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 2586)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 2785)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 2984)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 3183)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 3382)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 3581)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 3780)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 3979)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 4178)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 4377)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 4576)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 4775)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 4974)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 5173)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 5372)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 5571)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 5770)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 5969)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 6168)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 6367)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 6566)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 6765)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 6964)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 7163)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 7362)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 7561)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 7760)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 7959)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 8158)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 8357)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 8556)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 8755)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 8954)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 9153)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 9352)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 9551)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 9750)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 9949)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 10148)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 10347)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 10546)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 10745)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 10944)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 11143)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 11342)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 11541)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 11740)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 11939)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 12138)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 12337)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 12536)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 12735)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 12934)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 13133)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 13332)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 13531)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 13730)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 13929)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 14128)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 14327)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 14526)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 14725)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 14924)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 15123)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 15322)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 15521)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 15720)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 15919)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 16118)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 16317)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 16516)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 16715)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 16914)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 17113)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 17312)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 17511)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 17710)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 17909)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 18108)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 18307)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 18506)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 18705)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 18904)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 19103)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 19302)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 19501)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 19700)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 19899)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 20098)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 20297)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 20496)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 20695)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 20894)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 21093)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 21292)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 21491)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 21690)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 21889)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 22088)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 22287)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 22486)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 22685)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 22884)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 23083)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 23282)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 23481)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 23680)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 23879)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 24078)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 24277)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 24476)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 24675)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 24874)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 25073)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 25272)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 25471)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 25670)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 25869)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 26068)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 26267)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 26466)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 26665)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 26864)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 27063)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 27262)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 27461)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 27660)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 27859)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 28058)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 28257)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 28456)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 28655)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 28854)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 29053)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 29252)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 29451)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 29650)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 29849)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 30048)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 30247)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 30446)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 30645)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 30844)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 31043)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 31242)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 31441)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 31640)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 31839)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 32038)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 32237)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 32436)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 32635)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 32834)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 33033)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 33232)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 33431)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 33630)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 33829)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 34028)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 34227)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 34426)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 34625)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 34824)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 35023)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 35222)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 35421)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 35620)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 35819)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 36018)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 36217)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 36416)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 36615)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 36814)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 37013)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 37212)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 37411)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 37610)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 37809)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 38008)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 38207)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 38406)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 38605)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 38804)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 39003)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 39202)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 39401)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 39600)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 39799)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 39998)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 40197)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 40396)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 40595)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 40794)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 40993)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 41192)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 41391)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 41590)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 41789)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 41988)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 42187)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 42386)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 42585)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 42784)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 42983)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 43182)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 43381)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 43580)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 43779)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 43978)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 44177)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 44376)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 44575)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 44774)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 44973)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 45172)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 45371)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 45570)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 45769)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 45968)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 46167)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 46366)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 46565)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 46764)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 46963)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 47162)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 47361)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 47560)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 47759)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 47958)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 48157)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 48356)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 48555)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 48754)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 48953)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 49152)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 49351)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 49550)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 49749)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 49948)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 50147)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 50346)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 50545)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 50744)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 50943)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 51142)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 51341)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 51540)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 51739)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 51938)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 52137)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 52336)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 52535)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 52734)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 52933)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 53132)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 53331)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 53530)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 53729)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 53928)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 54127)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 54326)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 54525)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 54724)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 54923)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 55122)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 55321)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 55520)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 55719)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 55918)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 56117)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 56316)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 56515)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 56714)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 56913)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 57112)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 57311)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 57510)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 57709)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 57908)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 58107)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 58306)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 58505)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 58704)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 58903)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 59102)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 59301)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 59500)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 59699)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 59898)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 60097)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 60296)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 60495)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 60694)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 60893)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 61092)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 61291)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 61490)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 61689)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 61888)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 62087)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 62286)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 62485)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 62684)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 62883)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 63082)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 63281)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 63480)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 63679)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 63878)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 64077)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 64276)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 64475)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 64674)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 64873)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 65072)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 65271)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 65470)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 65486)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 65487)) (i32.const 1)) +(assert_return (invoke "load8_u" (i32.const 65488)) (i32.const 2)) +(assert_return (invoke "load8_u" (i32.const 65489)) (i32.const 3)) +(assert_return (invoke "load8_u" (i32.const 65490)) (i32.const 4)) +(assert_return (invoke "load8_u" (i32.const 65491)) (i32.const 5)) +(assert_return (invoke "load8_u" (i32.const 65492)) (i32.const 6)) +(assert_return (invoke "load8_u" (i32.const 65493)) (i32.const 7)) +(assert_return (invoke "load8_u" (i32.const 65494)) (i32.const 8)) +(assert_return (invoke "load8_u" (i32.const 65495)) (i32.const 9)) +(assert_return (invoke "load8_u" (i32.const 65496)) (i32.const 10)) +(assert_return (invoke "load8_u" (i32.const 65497)) (i32.const 11)) +(assert_return (invoke "load8_u" (i32.const 65498)) (i32.const 12)) +(assert_return (invoke "load8_u" (i32.const 65499)) (i32.const 13)) +(assert_return (invoke "load8_u" (i32.const 65500)) (i32.const 14)) +(assert_return (invoke "load8_u" (i32.const 65501)) (i32.const 15)) +(assert_return (invoke "load8_u" (i32.const 65502)) (i32.const 16)) +(assert_return (invoke "load8_u" (i32.const 65503)) (i32.const 17)) +(assert_return (invoke "load8_u" (i32.const 65504)) (i32.const 18)) +(assert_return (invoke "load8_u" (i32.const 65505)) (i32.const 19)) + +(module + (memory (export "mem") 1 1 ) + (data (i32.const 65516) "\00\01\02\03\04\05\06\07\08\09\0a\0b\0c\0d\0e\0f\10\11\12\13") + (func (export "run") (param $targetOffs i32) (param $srcOffs i32) (param $len i32) + (memory.copy (local.get $targetOffs) (local.get $srcOffs) (local.get $len))) + (func (export "load8_u") (param i32) (result i32) + (i32.load8_u (local.get 0)))) + +(assert_trap (invoke "run" (i32.const 65486) (i32.const 65516) (i32.const 40)) + "out of bounds") + +(assert_return (invoke "load8_u" (i32.const 198)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 397)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 596)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 795)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 994)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 1193)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 1392)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 1591)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 1790)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 1989)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 2188)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 2387)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 2586)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 2785)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 2984)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 3183)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 3382)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 3581)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 3780)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 3979)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 4178)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 4377)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 4576)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 4775)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 4974)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 5173)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 5372)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 5571)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 5770)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 5969)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 6168)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 6367)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 6566)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 6765)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 6964)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 7163)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 7362)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 7561)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 7760)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 7959)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 8158)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 8357)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 8556)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 8755)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 8954)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 9153)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 9352)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 9551)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 9750)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 9949)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 10148)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 10347)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 10546)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 10745)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 10944)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 11143)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 11342)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 11541)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 11740)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 11939)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 12138)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 12337)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 12536)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 12735)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 12934)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 13133)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 13332)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 13531)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 13730)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 13929)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 14128)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 14327)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 14526)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 14725)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 14924)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 15123)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 15322)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 15521)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 15720)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 15919)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 16118)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 16317)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 16516)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 16715)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 16914)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 17113)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 17312)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 17511)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 17710)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 17909)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 18108)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 18307)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 18506)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 18705)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 18904)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 19103)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 19302)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 19501)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 19700)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 19899)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 20098)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 20297)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 20496)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 20695)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 20894)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 21093)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 21292)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 21491)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 21690)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 21889)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 22088)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 22287)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 22486)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 22685)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 22884)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 23083)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 23282)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 23481)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 23680)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 23879)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 24078)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 24277)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 24476)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 24675)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 24874)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 25073)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 25272)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 25471)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 25670)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 25869)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 26068)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 26267)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 26466)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 26665)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 26864)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 27063)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 27262)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 27461)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 27660)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 27859)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 28058)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 28257)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 28456)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 28655)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 28854)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 29053)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 29252)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 29451)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 29650)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 29849)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 30048)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 30247)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 30446)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 30645)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 30844)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 31043)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 31242)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 31441)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 31640)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 31839)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 32038)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 32237)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 32436)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 32635)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 32834)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 33033)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 33232)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 33431)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 33630)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 33829)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 34028)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 34227)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 34426)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 34625)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 34824)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 35023)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 35222)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 35421)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 35620)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 35819)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 36018)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 36217)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 36416)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 36615)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 36814)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 37013)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 37212)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 37411)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 37610)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 37809)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 38008)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 38207)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 38406)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 38605)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 38804)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 39003)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 39202)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 39401)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 39600)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 39799)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 39998)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 40197)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 40396)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 40595)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 40794)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 40993)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 41192)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 41391)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 41590)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 41789)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 41988)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 42187)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 42386)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 42585)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 42784)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 42983)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 43182)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 43381)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 43580)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 43779)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 43978)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 44177)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 44376)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 44575)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 44774)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 44973)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 45172)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 45371)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 45570)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 45769)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 45968)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 46167)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 46366)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 46565)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 46764)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 46963)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 47162)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 47361)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 47560)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 47759)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 47958)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 48157)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 48356)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 48555)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 48754)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 48953)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 49152)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 49351)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 49550)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 49749)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 49948)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 50147)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 50346)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 50545)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 50744)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 50943)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 51142)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 51341)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 51540)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 51739)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 51938)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 52137)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 52336)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 52535)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 52734)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 52933)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 53132)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 53331)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 53530)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 53729)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 53928)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 54127)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 54326)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 54525)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 54724)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 54923)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 55122)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 55321)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 55520)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 55719)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 55918)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 56117)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 56316)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 56515)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 56714)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 56913)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 57112)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 57311)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 57510)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 57709)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 57908)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 58107)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 58306)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 58505)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 58704)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 58903)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 59102)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 59301)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 59500)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 59699)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 59898)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 60097)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 60296)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 60495)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 60694)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 60893)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 61092)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 61291)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 61490)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 61689)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 61888)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 62087)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 62286)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 62485)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 62684)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 62883)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 63082)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 63281)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 63480)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 63679)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 63878)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 64077)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 64276)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 64475)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 64674)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 64873)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 65072)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 65271)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 65470)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 65516)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 65517)) (i32.const 1)) +(assert_return (invoke "load8_u" (i32.const 65518)) (i32.const 2)) +(assert_return (invoke "load8_u" (i32.const 65519)) (i32.const 3)) +(assert_return (invoke "load8_u" (i32.const 65520)) (i32.const 4)) +(assert_return (invoke "load8_u" (i32.const 65521)) (i32.const 5)) +(assert_return (invoke "load8_u" (i32.const 65522)) (i32.const 6)) +(assert_return (invoke "load8_u" (i32.const 65523)) (i32.const 7)) +(assert_return (invoke "load8_u" (i32.const 65524)) (i32.const 8)) +(assert_return (invoke "load8_u" (i32.const 65525)) (i32.const 9)) +(assert_return (invoke "load8_u" (i32.const 65526)) (i32.const 10)) +(assert_return (invoke "load8_u" (i32.const 65527)) (i32.const 11)) +(assert_return (invoke "load8_u" (i32.const 65528)) (i32.const 12)) +(assert_return (invoke "load8_u" (i32.const 65529)) (i32.const 13)) +(assert_return (invoke "load8_u" (i32.const 65530)) (i32.const 14)) +(assert_return (invoke "load8_u" (i32.const 65531)) (i32.const 15)) +(assert_return (invoke "load8_u" (i32.const 65532)) (i32.const 16)) +(assert_return (invoke "load8_u" (i32.const 65533)) (i32.const 17)) +(assert_return (invoke "load8_u" (i32.const 65534)) (i32.const 18)) +(assert_return (invoke "load8_u" (i32.const 65535)) (i32.const 19)) + +(module + (memory (export "mem") 1 1 ) + (data (i32.const 65506) "\00\01\02\03\04\05\06\07\08\09\0a\0b\0c\0d\0e\0f\10\11\12\13") + (func (export "run") (param $targetOffs i32) (param $srcOffs i32) (param $len i32) + (memory.copy (local.get $targetOffs) (local.get $srcOffs) (local.get $len))) + (func (export "load8_u") (param i32) (result i32) + (i32.load8_u (local.get 0)))) + +(assert_trap (invoke "run" (i32.const 65516) (i32.const 65506) (i32.const 40)) + "out of bounds") + +(assert_return (invoke "load8_u" (i32.const 198)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 397)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 596)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 795)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 994)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 1193)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 1392)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 1591)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 1790)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 1989)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 2188)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 2387)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 2586)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 2785)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 2984)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 3183)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 3382)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 3581)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 3780)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 3979)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 4178)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 4377)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 4576)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 4775)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 4974)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 5173)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 5372)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 5571)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 5770)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 5969)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 6168)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 6367)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 6566)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 6765)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 6964)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 7163)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 7362)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 7561)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 7760)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 7959)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 8158)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 8357)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 8556)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 8755)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 8954)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 9153)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 9352)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 9551)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 9750)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 9949)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 10148)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 10347)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 10546)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 10745)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 10944)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 11143)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 11342)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 11541)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 11740)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 11939)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 12138)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 12337)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 12536)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 12735)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 12934)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 13133)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 13332)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 13531)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 13730)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 13929)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 14128)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 14327)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 14526)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 14725)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 14924)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 15123)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 15322)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 15521)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 15720)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 15919)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 16118)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 16317)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 16516)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 16715)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 16914)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 17113)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 17312)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 17511)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 17710)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 17909)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 18108)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 18307)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 18506)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 18705)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 18904)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 19103)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 19302)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 19501)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 19700)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 19899)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 20098)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 20297)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 20496)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 20695)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 20894)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 21093)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 21292)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 21491)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 21690)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 21889)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 22088)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 22287)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 22486)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 22685)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 22884)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 23083)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 23282)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 23481)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 23680)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 23879)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 24078)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 24277)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 24476)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 24675)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 24874)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 25073)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 25272)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 25471)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 25670)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 25869)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 26068)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 26267)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 26466)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 26665)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 26864)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 27063)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 27262)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 27461)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 27660)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 27859)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 28058)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 28257)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 28456)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 28655)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 28854)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 29053)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 29252)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 29451)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 29650)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 29849)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 30048)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 30247)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 30446)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 30645)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 30844)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 31043)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 31242)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 31441)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 31640)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 31839)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 32038)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 32237)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 32436)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 32635)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 32834)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 33033)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 33232)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 33431)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 33630)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 33829)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 34028)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 34227)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 34426)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 34625)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 34824)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 35023)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 35222)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 35421)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 35620)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 35819)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 36018)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 36217)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 36416)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 36615)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 36814)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 37013)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 37212)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 37411)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 37610)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 37809)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 38008)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 38207)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 38406)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 38605)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 38804)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 39003)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 39202)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 39401)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 39600)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 39799)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 39998)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 40197)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 40396)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 40595)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 40794)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 40993)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 41192)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 41391)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 41590)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 41789)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 41988)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 42187)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 42386)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 42585)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 42784)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 42983)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 43182)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 43381)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 43580)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 43779)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 43978)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 44177)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 44376)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 44575)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 44774)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 44973)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 45172)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 45371)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 45570)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 45769)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 45968)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 46167)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 46366)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 46565)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 46764)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 46963)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 47162)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 47361)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 47560)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 47759)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 47958)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 48157)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 48356)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 48555)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 48754)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 48953)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 49152)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 49351)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 49550)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 49749)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 49948)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 50147)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 50346)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 50545)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 50744)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 50943)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 51142)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 51341)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 51540)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 51739)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 51938)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 52137)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 52336)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 52535)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 52734)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 52933)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 53132)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 53331)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 53530)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 53729)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 53928)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 54127)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 54326)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 54525)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 54724)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 54923)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 55122)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 55321)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 55520)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 55719)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 55918)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 56117)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 56316)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 56515)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 56714)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 56913)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 57112)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 57311)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 57510)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 57709)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 57908)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 58107)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 58306)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 58505)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 58704)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 58903)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 59102)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 59301)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 59500)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 59699)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 59898)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 60097)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 60296)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 60495)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 60694)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 60893)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 61092)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 61291)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 61490)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 61689)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 61888)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 62087)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 62286)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 62485)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 62684)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 62883)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 63082)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 63281)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 63480)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 63679)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 63878)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 64077)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 64276)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 64475)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 64674)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 64873)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 65072)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 65271)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 65470)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 65506)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 65507)) (i32.const 1)) +(assert_return (invoke "load8_u" (i32.const 65508)) (i32.const 2)) +(assert_return (invoke "load8_u" (i32.const 65509)) (i32.const 3)) +(assert_return (invoke "load8_u" (i32.const 65510)) (i32.const 4)) +(assert_return (invoke "load8_u" (i32.const 65511)) (i32.const 5)) +(assert_return (invoke "load8_u" (i32.const 65512)) (i32.const 6)) +(assert_return (invoke "load8_u" (i32.const 65513)) (i32.const 7)) +(assert_return (invoke "load8_u" (i32.const 65514)) (i32.const 8)) +(assert_return (invoke "load8_u" (i32.const 65515)) (i32.const 9)) +(assert_return (invoke "load8_u" (i32.const 65516)) (i32.const 10)) +(assert_return (invoke "load8_u" (i32.const 65517)) (i32.const 11)) +(assert_return (invoke "load8_u" (i32.const 65518)) (i32.const 12)) +(assert_return (invoke "load8_u" (i32.const 65519)) (i32.const 13)) +(assert_return (invoke "load8_u" (i32.const 65520)) (i32.const 14)) +(assert_return (invoke "load8_u" (i32.const 65521)) (i32.const 15)) +(assert_return (invoke "load8_u" (i32.const 65522)) (i32.const 16)) +(assert_return (invoke "load8_u" (i32.const 65523)) (i32.const 17)) +(assert_return (invoke "load8_u" (i32.const 65524)) (i32.const 18)) +(assert_return (invoke "load8_u" (i32.const 65525)) (i32.const 19)) + +(module + (memory (export "mem") 1 1 ) + (data (i32.const 65516) "\00\01\02\03\04\05\06\07\08\09\0a\0b\0c\0d\0e\0f\10\11\12\13") + (func (export "run") (param $targetOffs i32) (param $srcOffs i32) (param $len i32) + (memory.copy (local.get $targetOffs) (local.get $srcOffs) (local.get $len))) + (func (export "load8_u") (param i32) (result i32) + (i32.load8_u (local.get 0)))) + +(assert_trap (invoke "run" (i32.const 65506) (i32.const 65516) (i32.const 40)) + "out of bounds") + +(assert_return (invoke "load8_u" (i32.const 198)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 397)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 596)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 795)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 994)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 1193)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 1392)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 1591)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 1790)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 1989)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 2188)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 2387)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 2586)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 2785)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 2984)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 3183)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 3382)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 3581)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 3780)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 3979)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 4178)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 4377)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 4576)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 4775)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 4974)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 5173)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 5372)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 5571)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 5770)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 5969)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 6168)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 6367)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 6566)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 6765)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 6964)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 7163)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 7362)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 7561)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 7760)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 7959)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 8158)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 8357)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 8556)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 8755)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 8954)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 9153)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 9352)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 9551)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 9750)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 9949)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 10148)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 10347)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 10546)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 10745)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 10944)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 11143)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 11342)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 11541)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 11740)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 11939)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 12138)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 12337)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 12536)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 12735)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 12934)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 13133)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 13332)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 13531)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 13730)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 13929)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 14128)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 14327)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 14526)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 14725)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 14924)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 15123)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 15322)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 15521)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 15720)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 15919)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 16118)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 16317)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 16516)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 16715)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 16914)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 17113)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 17312)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 17511)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 17710)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 17909)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 18108)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 18307)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 18506)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 18705)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 18904)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 19103)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 19302)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 19501)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 19700)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 19899)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 20098)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 20297)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 20496)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 20695)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 20894)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 21093)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 21292)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 21491)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 21690)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 21889)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 22088)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 22287)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 22486)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 22685)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 22884)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 23083)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 23282)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 23481)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 23680)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 23879)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 24078)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 24277)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 24476)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 24675)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 24874)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 25073)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 25272)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 25471)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 25670)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 25869)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 26068)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 26267)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 26466)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 26665)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 26864)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 27063)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 27262)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 27461)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 27660)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 27859)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 28058)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 28257)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 28456)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 28655)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 28854)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 29053)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 29252)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 29451)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 29650)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 29849)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 30048)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 30247)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 30446)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 30645)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 30844)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 31043)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 31242)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 31441)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 31640)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 31839)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 32038)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 32237)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 32436)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 32635)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 32834)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 33033)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 33232)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 33431)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 33630)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 33829)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 34028)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 34227)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 34426)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 34625)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 34824)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 35023)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 35222)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 35421)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 35620)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 35819)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 36018)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 36217)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 36416)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 36615)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 36814)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 37013)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 37212)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 37411)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 37610)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 37809)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 38008)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 38207)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 38406)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 38605)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 38804)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 39003)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 39202)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 39401)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 39600)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 39799)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 39998)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 40197)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 40396)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 40595)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 40794)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 40993)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 41192)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 41391)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 41590)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 41789)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 41988)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 42187)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 42386)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 42585)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 42784)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 42983)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 43182)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 43381)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 43580)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 43779)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 43978)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 44177)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 44376)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 44575)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 44774)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 44973)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 45172)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 45371)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 45570)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 45769)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 45968)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 46167)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 46366)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 46565)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 46764)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 46963)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 47162)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 47361)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 47560)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 47759)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 47958)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 48157)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 48356)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 48555)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 48754)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 48953)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 49152)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 49351)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 49550)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 49749)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 49948)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 50147)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 50346)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 50545)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 50744)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 50943)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 51142)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 51341)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 51540)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 51739)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 51938)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 52137)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 52336)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 52535)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 52734)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 52933)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 53132)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 53331)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 53530)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 53729)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 53928)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 54127)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 54326)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 54525)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 54724)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 54923)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 55122)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 55321)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 55520)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 55719)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 55918)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 56117)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 56316)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 56515)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 56714)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 56913)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 57112)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 57311)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 57510)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 57709)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 57908)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 58107)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 58306)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 58505)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 58704)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 58903)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 59102)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 59301)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 59500)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 59699)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 59898)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 60097)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 60296)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 60495)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 60694)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 60893)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 61092)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 61291)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 61490)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 61689)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 61888)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 62087)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 62286)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 62485)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 62684)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 62883)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 63082)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 63281)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 63480)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 63679)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 63878)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 64077)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 64276)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 64475)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 64674)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 64873)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 65072)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 65271)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 65470)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 65516)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 65517)) (i32.const 1)) +(assert_return (invoke "load8_u" (i32.const 65518)) (i32.const 2)) +(assert_return (invoke "load8_u" (i32.const 65519)) (i32.const 3)) +(assert_return (invoke "load8_u" (i32.const 65520)) (i32.const 4)) +(assert_return (invoke "load8_u" (i32.const 65521)) (i32.const 5)) +(assert_return (invoke "load8_u" (i32.const 65522)) (i32.const 6)) +(assert_return (invoke "load8_u" (i32.const 65523)) (i32.const 7)) +(assert_return (invoke "load8_u" (i32.const 65524)) (i32.const 8)) +(assert_return (invoke "load8_u" (i32.const 65525)) (i32.const 9)) +(assert_return (invoke "load8_u" (i32.const 65526)) (i32.const 10)) +(assert_return (invoke "load8_u" (i32.const 65527)) (i32.const 11)) +(assert_return (invoke "load8_u" (i32.const 65528)) (i32.const 12)) +(assert_return (invoke "load8_u" (i32.const 65529)) (i32.const 13)) +(assert_return (invoke "load8_u" (i32.const 65530)) (i32.const 14)) +(assert_return (invoke "load8_u" (i32.const 65531)) (i32.const 15)) +(assert_return (invoke "load8_u" (i32.const 65532)) (i32.const 16)) +(assert_return (invoke "load8_u" (i32.const 65533)) (i32.const 17)) +(assert_return (invoke "load8_u" (i32.const 65534)) (i32.const 18)) +(assert_return (invoke "load8_u" (i32.const 65535)) (i32.const 19)) + +(module + (memory (export "mem") 1 1 ) + (data (i32.const 65516) "\00\01\02\03\04\05\06\07\08\09\0a\0b\0c\0d\0e\0f\10\11\12\13") + (func (export "run") (param $targetOffs i32) (param $srcOffs i32) (param $len i32) + (memory.copy (local.get $targetOffs) (local.get $srcOffs) (local.get $len))) + (func (export "load8_u") (param i32) (result i32) + (i32.load8_u (local.get 0)))) + +(assert_trap (invoke "run" (i32.const 65516) (i32.const 65516) (i32.const 40)) + "out of bounds") + +(assert_return (invoke "load8_u" (i32.const 198)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 397)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 596)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 795)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 994)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 1193)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 1392)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 1591)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 1790)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 1989)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 2188)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 2387)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 2586)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 2785)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 2984)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 3183)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 3382)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 3581)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 3780)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 3979)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 4178)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 4377)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 4576)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 4775)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 4974)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 5173)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 5372)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 5571)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 5770)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 5969)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 6168)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 6367)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 6566)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 6765)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 6964)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 7163)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 7362)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 7561)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 7760)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 7959)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 8158)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 8357)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 8556)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 8755)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 8954)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 9153)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 9352)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 9551)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 9750)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 9949)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 10148)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 10347)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 10546)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 10745)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 10944)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 11143)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 11342)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 11541)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 11740)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 11939)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 12138)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 12337)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 12536)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 12735)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 12934)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 13133)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 13332)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 13531)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 13730)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 13929)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 14128)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 14327)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 14526)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 14725)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 14924)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 15123)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 15322)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 15521)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 15720)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 15919)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 16118)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 16317)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 16516)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 16715)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 16914)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 17113)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 17312)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 17511)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 17710)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 17909)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 18108)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 18307)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 18506)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 18705)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 18904)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 19103)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 19302)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 19501)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 19700)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 19899)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 20098)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 20297)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 20496)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 20695)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 20894)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 21093)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 21292)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 21491)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 21690)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 21889)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 22088)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 22287)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 22486)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 22685)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 22884)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 23083)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 23282)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 23481)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 23680)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 23879)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 24078)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 24277)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 24476)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 24675)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 24874)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 25073)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 25272)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 25471)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 25670)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 25869)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 26068)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 26267)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 26466)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 26665)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 26864)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 27063)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 27262)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 27461)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 27660)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 27859)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 28058)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 28257)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 28456)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 28655)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 28854)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 29053)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 29252)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 29451)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 29650)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 29849)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 30048)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 30247)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 30446)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 30645)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 30844)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 31043)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 31242)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 31441)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 31640)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 31839)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 32038)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 32237)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 32436)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 32635)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 32834)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 33033)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 33232)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 33431)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 33630)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 33829)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 34028)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 34227)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 34426)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 34625)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 34824)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 35023)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 35222)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 35421)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 35620)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 35819)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 36018)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 36217)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 36416)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 36615)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 36814)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 37013)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 37212)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 37411)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 37610)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 37809)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 38008)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 38207)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 38406)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 38605)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 38804)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 39003)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 39202)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 39401)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 39600)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 39799)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 39998)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 40197)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 40396)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 40595)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 40794)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 40993)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 41192)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 41391)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 41590)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 41789)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 41988)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 42187)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 42386)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 42585)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 42784)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 42983)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 43182)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 43381)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 43580)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 43779)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 43978)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 44177)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 44376)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 44575)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 44774)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 44973)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 45172)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 45371)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 45570)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 45769)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 45968)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 46167)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 46366)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 46565)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 46764)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 46963)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 47162)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 47361)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 47560)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 47759)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 47958)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 48157)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 48356)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 48555)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 48754)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 48953)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 49152)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 49351)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 49550)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 49749)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 49948)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 50147)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 50346)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 50545)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 50744)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 50943)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 51142)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 51341)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 51540)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 51739)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 51938)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 52137)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 52336)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 52535)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 52734)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 52933)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 53132)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 53331)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 53530)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 53729)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 53928)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 54127)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 54326)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 54525)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 54724)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 54923)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 55122)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 55321)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 55520)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 55719)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 55918)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 56117)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 56316)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 56515)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 56714)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 56913)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 57112)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 57311)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 57510)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 57709)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 57908)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 58107)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 58306)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 58505)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 58704)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 58903)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 59102)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 59301)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 59500)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 59699)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 59898)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 60097)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 60296)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 60495)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 60694)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 60893)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 61092)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 61291)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 61490)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 61689)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 61888)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 62087)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 62286)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 62485)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 62684)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 62883)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 63082)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 63281)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 63480)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 63679)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 63878)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 64077)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 64276)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 64475)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 64674)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 64873)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 65072)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 65271)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 65470)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 65516)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 65517)) (i32.const 1)) +(assert_return (invoke "load8_u" (i32.const 65518)) (i32.const 2)) +(assert_return (invoke "load8_u" (i32.const 65519)) (i32.const 3)) +(assert_return (invoke "load8_u" (i32.const 65520)) (i32.const 4)) +(assert_return (invoke "load8_u" (i32.const 65521)) (i32.const 5)) +(assert_return (invoke "load8_u" (i32.const 65522)) (i32.const 6)) +(assert_return (invoke "load8_u" (i32.const 65523)) (i32.const 7)) +(assert_return (invoke "load8_u" (i32.const 65524)) (i32.const 8)) +(assert_return (invoke "load8_u" (i32.const 65525)) (i32.const 9)) +(assert_return (invoke "load8_u" (i32.const 65526)) (i32.const 10)) +(assert_return (invoke "load8_u" (i32.const 65527)) (i32.const 11)) +(assert_return (invoke "load8_u" (i32.const 65528)) (i32.const 12)) +(assert_return (invoke "load8_u" (i32.const 65529)) (i32.const 13)) +(assert_return (invoke "load8_u" (i32.const 65530)) (i32.const 14)) +(assert_return (invoke "load8_u" (i32.const 65531)) (i32.const 15)) +(assert_return (invoke "load8_u" (i32.const 65532)) (i32.const 16)) +(assert_return (invoke "load8_u" (i32.const 65533)) (i32.const 17)) +(assert_return (invoke "load8_u" (i32.const 65534)) (i32.const 18)) +(assert_return (invoke "load8_u" (i32.const 65535)) (i32.const 19)) + +(module + (memory (export "mem") 1 ) + (data (i32.const 65516) "\00\01\02\03\04\05\06\07\08\09\0a\0b\0c\0d\0e\0f\10\11\12\13") + (func (export "run") (param $targetOffs i32) (param $srcOffs i32) (param $len i32) + (memory.copy (local.get $targetOffs) (local.get $srcOffs) (local.get $len))) + (func (export "load8_u") (param i32) (result i32) + (i32.load8_u (local.get 0)))) + +(assert_trap (invoke "run" (i32.const 0) (i32.const 65516) (i32.const 4294963200)) + "out of bounds") + +(assert_return (invoke "load8_u" (i32.const 198)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 397)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 596)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 795)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 994)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 1193)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 1392)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 1591)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 1790)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 1989)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 2188)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 2387)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 2586)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 2785)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 2984)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 3183)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 3382)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 3581)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 3780)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 3979)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 4178)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 4377)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 4576)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 4775)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 4974)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 5173)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 5372)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 5571)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 5770)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 5969)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 6168)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 6367)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 6566)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 6765)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 6964)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 7163)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 7362)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 7561)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 7760)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 7959)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 8158)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 8357)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 8556)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 8755)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 8954)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 9153)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 9352)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 9551)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 9750)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 9949)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 10148)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 10347)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 10546)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 10745)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 10944)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 11143)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 11342)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 11541)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 11740)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 11939)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 12138)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 12337)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 12536)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 12735)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 12934)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 13133)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 13332)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 13531)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 13730)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 13929)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 14128)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 14327)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 14526)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 14725)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 14924)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 15123)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 15322)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 15521)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 15720)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 15919)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 16118)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 16317)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 16516)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 16715)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 16914)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 17113)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 17312)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 17511)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 17710)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 17909)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 18108)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 18307)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 18506)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 18705)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 18904)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 19103)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 19302)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 19501)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 19700)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 19899)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 20098)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 20297)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 20496)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 20695)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 20894)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 21093)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 21292)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 21491)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 21690)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 21889)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 22088)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 22287)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 22486)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 22685)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 22884)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 23083)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 23282)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 23481)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 23680)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 23879)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 24078)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 24277)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 24476)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 24675)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 24874)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 25073)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 25272)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 25471)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 25670)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 25869)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 26068)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 26267)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 26466)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 26665)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 26864)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 27063)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 27262)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 27461)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 27660)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 27859)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 28058)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 28257)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 28456)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 28655)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 28854)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 29053)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 29252)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 29451)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 29650)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 29849)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 30048)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 30247)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 30446)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 30645)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 30844)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 31043)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 31242)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 31441)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 31640)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 31839)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 32038)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 32237)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 32436)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 32635)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 32834)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 33033)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 33232)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 33431)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 33630)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 33829)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 34028)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 34227)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 34426)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 34625)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 34824)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 35023)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 35222)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 35421)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 35620)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 35819)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 36018)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 36217)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 36416)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 36615)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 36814)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 37013)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 37212)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 37411)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 37610)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 37809)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 38008)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 38207)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 38406)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 38605)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 38804)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 39003)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 39202)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 39401)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 39600)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 39799)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 39998)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 40197)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 40396)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 40595)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 40794)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 40993)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 41192)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 41391)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 41590)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 41789)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 41988)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 42187)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 42386)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 42585)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 42784)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 42983)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 43182)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 43381)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 43580)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 43779)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 43978)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 44177)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 44376)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 44575)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 44774)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 44973)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 45172)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 45371)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 45570)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 45769)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 45968)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 46167)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 46366)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 46565)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 46764)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 46963)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 47162)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 47361)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 47560)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 47759)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 47958)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 48157)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 48356)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 48555)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 48754)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 48953)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 49152)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 49351)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 49550)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 49749)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 49948)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 50147)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 50346)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 50545)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 50744)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 50943)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 51142)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 51341)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 51540)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 51739)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 51938)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 52137)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 52336)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 52535)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 52734)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 52933)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 53132)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 53331)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 53530)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 53729)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 53928)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 54127)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 54326)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 54525)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 54724)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 54923)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 55122)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 55321)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 55520)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 55719)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 55918)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 56117)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 56316)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 56515)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 56714)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 56913)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 57112)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 57311)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 57510)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 57709)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 57908)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 58107)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 58306)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 58505)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 58704)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 58903)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 59102)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 59301)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 59500)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 59699)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 59898)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 60097)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 60296)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 60495)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 60694)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 60893)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 61092)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 61291)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 61490)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 61689)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 61888)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 62087)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 62286)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 62485)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 62684)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 62883)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 63082)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 63281)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 63480)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 63679)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 63878)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 64077)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 64276)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 64475)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 64674)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 64873)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 65072)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 65271)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 65470)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 65516)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 65517)) (i32.const 1)) +(assert_return (invoke "load8_u" (i32.const 65518)) (i32.const 2)) +(assert_return (invoke "load8_u" (i32.const 65519)) (i32.const 3)) +(assert_return (invoke "load8_u" (i32.const 65520)) (i32.const 4)) +(assert_return (invoke "load8_u" (i32.const 65521)) (i32.const 5)) +(assert_return (invoke "load8_u" (i32.const 65522)) (i32.const 6)) +(assert_return (invoke "load8_u" (i32.const 65523)) (i32.const 7)) +(assert_return (invoke "load8_u" (i32.const 65524)) (i32.const 8)) +(assert_return (invoke "load8_u" (i32.const 65525)) (i32.const 9)) +(assert_return (invoke "load8_u" (i32.const 65526)) (i32.const 10)) +(assert_return (invoke "load8_u" (i32.const 65527)) (i32.const 11)) +(assert_return (invoke "load8_u" (i32.const 65528)) (i32.const 12)) +(assert_return (invoke "load8_u" (i32.const 65529)) (i32.const 13)) +(assert_return (invoke "load8_u" (i32.const 65530)) (i32.const 14)) +(assert_return (invoke "load8_u" (i32.const 65531)) (i32.const 15)) +(assert_return (invoke "load8_u" (i32.const 65532)) (i32.const 16)) +(assert_return (invoke "load8_u" (i32.const 65533)) (i32.const 17)) +(assert_return (invoke "load8_u" (i32.const 65534)) (i32.const 18)) +(assert_return (invoke "load8_u" (i32.const 65535)) (i32.const 19)) + +(module + (memory (export "mem") 1 1 ) + (data (i32.const 61440) "\00\01\02\03\04\05\06\07\08\09\0a\0b\0c\0d\0e\0f\10\11\12\13") + (func (export "run") (param $targetOffs i32) (param $srcOffs i32) (param $len i32) + (memory.copy (local.get $targetOffs) (local.get $srcOffs) (local.get $len))) + (func (export "load8_u") (param i32) (result i32) + (i32.load8_u (local.get 0)))) + +(assert_trap (invoke "run" (i32.const 65516) (i32.const 61440) (i32.const 4294967040)) + "out of bounds") + +(assert_return (invoke "load8_u" (i32.const 198)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 397)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 596)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 795)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 994)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 1193)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 1392)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 1591)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 1790)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 1989)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 2188)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 2387)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 2586)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 2785)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 2984)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 3183)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 3382)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 3581)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 3780)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 3979)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 4178)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 4377)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 4576)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 4775)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 4974)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 5173)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 5372)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 5571)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 5770)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 5969)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 6168)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 6367)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 6566)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 6765)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 6964)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 7163)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 7362)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 7561)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 7760)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 7959)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 8158)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 8357)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 8556)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 8755)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 8954)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 9153)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 9352)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 9551)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 9750)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 9949)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 10148)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 10347)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 10546)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 10745)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 10944)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 11143)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 11342)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 11541)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 11740)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 11939)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 12138)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 12337)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 12536)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 12735)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 12934)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 13133)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 13332)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 13531)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 13730)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 13929)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 14128)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 14327)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 14526)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 14725)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 14924)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 15123)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 15322)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 15521)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 15720)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 15919)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 16118)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 16317)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 16516)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 16715)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 16914)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 17113)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 17312)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 17511)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 17710)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 17909)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 18108)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 18307)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 18506)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 18705)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 18904)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 19103)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 19302)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 19501)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 19700)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 19899)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 20098)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 20297)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 20496)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 20695)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 20894)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 21093)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 21292)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 21491)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 21690)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 21889)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 22088)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 22287)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 22486)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 22685)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 22884)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 23083)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 23282)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 23481)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 23680)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 23879)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 24078)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 24277)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 24476)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 24675)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 24874)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 25073)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 25272)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 25471)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 25670)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 25869)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 26068)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 26267)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 26466)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 26665)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 26864)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 27063)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 27262)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 27461)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 27660)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 27859)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 28058)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 28257)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 28456)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 28655)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 28854)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 29053)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 29252)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 29451)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 29650)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 29849)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 30048)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 30247)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 30446)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 30645)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 30844)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 31043)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 31242)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 31441)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 31640)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 31839)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 32038)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 32237)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 32436)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 32635)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 32834)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 33033)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 33232)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 33431)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 33630)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 33829)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 34028)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 34227)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 34426)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 34625)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 34824)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 35023)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 35222)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 35421)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 35620)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 35819)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 36018)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 36217)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 36416)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 36615)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 36814)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 37013)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 37212)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 37411)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 37610)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 37809)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 38008)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 38207)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 38406)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 38605)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 38804)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 39003)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 39202)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 39401)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 39600)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 39799)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 39998)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 40197)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 40396)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 40595)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 40794)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 40993)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 41192)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 41391)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 41590)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 41789)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 41988)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 42187)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 42386)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 42585)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 42784)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 42983)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 43182)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 43381)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 43580)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 43779)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 43978)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 44177)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 44376)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 44575)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 44774)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 44973)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 45172)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 45371)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 45570)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 45769)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 45968)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 46167)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 46366)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 46565)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 46764)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 46963)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 47162)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 47361)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 47560)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 47759)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 47958)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 48157)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 48356)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 48555)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 48754)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 48953)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 49152)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 49351)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 49550)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 49749)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 49948)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 50147)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 50346)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 50545)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 50744)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 50943)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 51142)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 51341)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 51540)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 51739)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 51938)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 52137)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 52336)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 52535)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 52734)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 52933)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 53132)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 53331)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 53530)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 53729)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 53928)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 54127)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 54326)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 54525)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 54724)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 54923)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 55122)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 55321)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 55520)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 55719)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 55918)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 56117)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 56316)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 56515)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 56714)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 56913)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 57112)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 57311)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 57510)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 57709)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 57908)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 58107)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 58306)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 58505)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 58704)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 58903)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 59102)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 59301)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 59500)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 59699)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 59898)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 60097)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 60296)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 60495)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 60694)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 60893)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 61092)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 61291)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 61440)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 61441)) (i32.const 1)) +(assert_return (invoke "load8_u" (i32.const 61442)) (i32.const 2)) +(assert_return (invoke "load8_u" (i32.const 61443)) (i32.const 3)) +(assert_return (invoke "load8_u" (i32.const 61444)) (i32.const 4)) +(assert_return (invoke "load8_u" (i32.const 61445)) (i32.const 5)) +(assert_return (invoke "load8_u" (i32.const 61446)) (i32.const 6)) +(assert_return (invoke "load8_u" (i32.const 61447)) (i32.const 7)) +(assert_return (invoke "load8_u" (i32.const 61448)) (i32.const 8)) +(assert_return (invoke "load8_u" (i32.const 61449)) (i32.const 9)) +(assert_return (invoke "load8_u" (i32.const 61450)) (i32.const 10)) +(assert_return (invoke "load8_u" (i32.const 61451)) (i32.const 11)) +(assert_return (invoke "load8_u" (i32.const 61452)) (i32.const 12)) +(assert_return (invoke "load8_u" (i32.const 61453)) (i32.const 13)) +(assert_return (invoke "load8_u" (i32.const 61454)) (i32.const 14)) +(assert_return (invoke "load8_u" (i32.const 61455)) (i32.const 15)) +(assert_return (invoke "load8_u" (i32.const 61456)) (i32.const 16)) +(assert_return (invoke "load8_u" (i32.const 61457)) (i32.const 17)) +(assert_return (invoke "load8_u" (i32.const 61458)) (i32.const 18)) +(assert_return (invoke "load8_u" (i32.const 61459)) (i32.const 19)) +(assert_return (invoke "load8_u" (i32.const 61510)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 61709)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 61908)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 62107)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 62306)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 62505)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 62704)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 62903)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 63102)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 63301)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 63500)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 63699)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 63898)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 64097)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 64296)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 64495)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 64694)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 64893)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 65092)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 65291)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 65490)) (i32.const 0)) + +(assert_invalid + (module + (func (export "testfn") + (memory.copy (i32.const 10) (i32.const 20) (i32.const 30)))) + "unknown memory 0") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.copy (i32.const 10) (i32.const 20) (f32.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.copy (i32.const 10) (i32.const 20) (i64.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.copy (i32.const 10) (i32.const 20) (f64.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.copy (i32.const 10) (f32.const 20) (i32.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.copy (i32.const 10) (f32.const 20) (f32.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.copy (i32.const 10) (f32.const 20) (i64.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.copy (i32.const 10) (f32.const 20) (f64.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.copy (i32.const 10) (i64.const 20) (i32.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.copy (i32.const 10) (i64.const 20) (f32.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.copy (i32.const 10) (i64.const 20) (i64.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.copy (i32.const 10) (i64.const 20) (f64.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.copy (i32.const 10) (f64.const 20) (i32.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.copy (i32.const 10) (f64.const 20) (f32.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.copy (i32.const 10) (f64.const 20) (i64.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.copy (i32.const 10) (f64.const 20) (f64.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.copy (f32.const 10) (i32.const 20) (i32.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.copy (f32.const 10) (i32.const 20) (f32.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.copy (f32.const 10) (i32.const 20) (i64.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.copy (f32.const 10) (i32.const 20) (f64.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.copy (f32.const 10) (f32.const 20) (i32.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.copy (f32.const 10) (f32.const 20) (f32.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.copy (f32.const 10) (f32.const 20) (i64.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.copy (f32.const 10) (f32.const 20) (f64.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.copy (f32.const 10) (i64.const 20) (i32.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.copy (f32.const 10) (i64.const 20) (f32.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.copy (f32.const 10) (i64.const 20) (i64.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.copy (f32.const 10) (i64.const 20) (f64.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.copy (f32.const 10) (f64.const 20) (i32.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.copy (f32.const 10) (f64.const 20) (f32.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.copy (f32.const 10) (f64.const 20) (i64.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.copy (f32.const 10) (f64.const 20) (f64.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.copy (i64.const 10) (i32.const 20) (i32.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.copy (i64.const 10) (i32.const 20) (f32.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.copy (i64.const 10) (i32.const 20) (i64.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.copy (i64.const 10) (i32.const 20) (f64.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.copy (i64.const 10) (f32.const 20) (i32.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.copy (i64.const 10) (f32.const 20) (f32.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.copy (i64.const 10) (f32.const 20) (i64.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.copy (i64.const 10) (f32.const 20) (f64.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.copy (i64.const 10) (i64.const 20) (i32.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.copy (i64.const 10) (i64.const 20) (f32.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.copy (i64.const 10) (i64.const 20) (i64.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.copy (i64.const 10) (i64.const 20) (f64.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.copy (i64.const 10) (f64.const 20) (i32.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.copy (i64.const 10) (f64.const 20) (f32.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.copy (i64.const 10) (f64.const 20) (i64.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.copy (i64.const 10) (f64.const 20) (f64.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.copy (f64.const 10) (i32.const 20) (i32.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.copy (f64.const 10) (i32.const 20) (f32.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.copy (f64.const 10) (i32.const 20) (i64.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.copy (f64.const 10) (i32.const 20) (f64.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.copy (f64.const 10) (f32.const 20) (i32.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.copy (f64.const 10) (f32.const 20) (f32.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.copy (f64.const 10) (f32.const 20) (i64.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.copy (f64.const 10) (f32.const 20) (f64.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.copy (f64.const 10) (i64.const 20) (i32.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.copy (f64.const 10) (i64.const 20) (f32.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.copy (f64.const 10) (i64.const 20) (i64.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.copy (f64.const 10) (i64.const 20) (f64.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.copy (f64.const 10) (f64.const 20) (i32.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.copy (f64.const 10) (f64.const 20) (f32.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.copy (f64.const 10) (f64.const 20) (i64.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.copy (f64.const 10) (f64.const 20) (f64.const 30)))) + "type mismatch") + + +(module + (memory 1 1) + (func (export "test") + (memory.fill (i32.const 10) (i32.const 0x55) (i32.const 10)) + (memory.copy (i32.const 9) (i32.const 10) (i32.const 5))) + + (func (export "checkRange") (param $from i32) (param $to i32) (param $expected i32) (result i32) + (loop $cont + (if (i32.eq (local.get $from) (local.get $to)) + (then + (return (i32.const -1)))) + (if (i32.eq (i32.load8_u (local.get $from)) (local.get $expected)) + (then + (local.set $from (i32.add (local.get $from) (i32.const 1))) + (br $cont)))) + (return (local.get $from))) +) +(invoke "test") + +(assert_return (invoke "checkRange" (i32.const 0) (i32.const 9) (i32.const 0)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 9) (i32.const 20) (i32.const 85)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 20) (i32.const 65536) (i32.const 0)) + (i32.const -1)) + +(module + (memory 1 1) + (func (export "test") + (memory.fill (i32.const 10) (i32.const 0x55) (i32.const 10)) + (memory.copy (i32.const 16) (i32.const 15) (i32.const 5))) + + (func (export "checkRange") (param $from i32) (param $to i32) (param $expected i32) (result i32) + (loop $cont + (if (i32.eq (local.get $from) (local.get $to)) + (then + (return (i32.const -1)))) + (if (i32.eq (i32.load8_u (local.get $from)) (local.get $expected)) + (then + (local.set $from (i32.add (local.get $from) (i32.const 1))) + (br $cont)))) + (return (local.get $from))) +) +(invoke "test") + +(assert_return (invoke "checkRange" (i32.const 0) (i32.const 10) (i32.const 0)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 10) (i32.const 21) (i32.const 85)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 21) (i32.const 65536) (i32.const 0)) + (i32.const -1)) + +(module + (memory 1 1) + (func (export "test") + (memory.copy (i32.const 0xFF00) (i32.const 0x8000) (i32.const 257)))) +(assert_trap (invoke "test") "out of bounds") + +(module + (memory 1 1) + (func (export "test") + (memory.copy (i32.const 0xFFFFFF00) (i32.const 0x4000) (i32.const 257)))) +(assert_trap (invoke "test") "out of bounds") + +(module + (memory 1 1) + (func (export "test") + (memory.copy (i32.const 0x8000) (i32.const 0xFF00) (i32.const 257)))) +(assert_trap (invoke "test") "out of bounds") + +(module + (memory 1 1) + (func (export "test") + (memory.copy (i32.const 0x4000) (i32.const 0xFFFFFF00) (i32.const 257)))) +(assert_trap (invoke "test") "out of bounds") + +(module + (memory 1 1) + (func (export "test") + (memory.fill (i32.const 0x0000) (i32.const 0x55) (i32.const 0x8000)) + (memory.fill (i32.const 0x8000) (i32.const 0xAA) (i32.const 0x8000)) + (memory.copy (i32.const 0x9000) (i32.const 0x7000) (i32.const 0))) + + (func (export "checkRange") (param $from i32) (param $to i32) (param $expected i32) (result i32) + (loop $cont + (if (i32.eq (local.get $from) (local.get $to)) + (then + (return (i32.const -1)))) + (if (i32.eq (i32.load8_u (local.get $from)) (local.get $expected)) + (then + (local.set $from (i32.add (local.get $from) (i32.const 1))) + (br $cont)))) + (return (local.get $from))) +) +(invoke "test") + +(assert_return (invoke "checkRange" (i32.const 0) (i32.const 32768) (i32.const 85)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 32768) (i32.const 65536) (i32.const 170)) + (i32.const -1)) +(module + (memory 1 1) + (func (export "test") + (memory.copy (i32.const 0x10000) (i32.const 0x7000) (i32.const 0)))) +(invoke "test") + +(module + (memory 1 1) + (func (export "test") + (memory.copy (i32.const 0x20000) (i32.const 0x7000) (i32.const 0)))) +(assert_trap (invoke "test") "out of bounds") + +(module + (memory 1 1) + (func (export "test") + (memory.copy (i32.const 0x9000) (i32.const 0x10000) (i32.const 0)))) +(invoke "test") + +(module + (memory 1 1) + (func (export "test") + (memory.copy (i32.const 0x9000) (i32.const 0x20000) (i32.const 0)))) +(assert_trap (invoke "test") "out of bounds") + +(module + (memory 1 1) + (func (export "test") + (memory.copy (i32.const 0x10000) (i32.const 0x10000) (i32.const 0)))) +(invoke "test") + +(module + (memory 1 1) + (func (export "test") + (memory.copy (i32.const 0x20000) (i32.const 0x20000) (i32.const 0)))) +(assert_trap (invoke "test") "out of bounds") + +(module + (memory 1 1) + (func (export "test") + (memory.fill (i32.const 17767) (i32.const 1) (i32.const 1344)) + (memory.fill (i32.const 39017) (i32.const 2) (i32.const 1055)) + (memory.fill (i32.const 56401) (i32.const 3) (i32.const 988)) + (memory.fill (i32.const 37962) (i32.const 4) (i32.const 322)) + (memory.fill (i32.const 7977) (i32.const 5) (i32.const 1994)) + (memory.fill (i32.const 22714) (i32.const 6) (i32.const 3036)) + (memory.fill (i32.const 16882) (i32.const 7) (i32.const 2372)) + (memory.fill (i32.const 43491) (i32.const 8) (i32.const 835)) + (memory.fill (i32.const 124) (i32.const 9) (i32.const 1393)) + (memory.fill (i32.const 2132) (i32.const 10) (i32.const 2758)) + (memory.fill (i32.const 8987) (i32.const 11) (i32.const 3098)) + (memory.fill (i32.const 52711) (i32.const 12) (i32.const 741)) + (memory.fill (i32.const 3958) (i32.const 13) (i32.const 2823)) + (memory.fill (i32.const 49715) (i32.const 14) (i32.const 1280)) + (memory.fill (i32.const 50377) (i32.const 15) (i32.const 1466)) + (memory.fill (i32.const 20493) (i32.const 16) (i32.const 3158)) + (memory.fill (i32.const 47665) (i32.const 17) (i32.const 544)) + (memory.fill (i32.const 12451) (i32.const 18) (i32.const 2669)) + (memory.fill (i32.const 24869) (i32.const 19) (i32.const 2651)) + (memory.fill (i32.const 45317) (i32.const 20) (i32.const 1570)) + (memory.fill (i32.const 43096) (i32.const 21) (i32.const 1691)) + (memory.fill (i32.const 33886) (i32.const 22) (i32.const 646)) + (memory.fill (i32.const 48555) (i32.const 23) (i32.const 1858)) + (memory.fill (i32.const 53453) (i32.const 24) (i32.const 2657)) + (memory.fill (i32.const 30363) (i32.const 25) (i32.const 981)) + (memory.fill (i32.const 9300) (i32.const 26) (i32.const 1807)) + (memory.fill (i32.const 50190) (i32.const 27) (i32.const 487)) + (memory.fill (i32.const 62753) (i32.const 28) (i32.const 530)) + (memory.fill (i32.const 36316) (i32.const 29) (i32.const 943)) + (memory.fill (i32.const 6768) (i32.const 30) (i32.const 381)) + (memory.fill (i32.const 51262) (i32.const 31) (i32.const 3089)) + (memory.fill (i32.const 49729) (i32.const 32) (i32.const 658)) + (memory.fill (i32.const 44540) (i32.const 33) (i32.const 1702)) + (memory.fill (i32.const 33342) (i32.const 34) (i32.const 1092)) + (memory.fill (i32.const 50814) (i32.const 35) (i32.const 1410)) + (memory.fill (i32.const 47594) (i32.const 36) (i32.const 2204)) + (memory.fill (i32.const 54123) (i32.const 37) (i32.const 2394)) + (memory.fill (i32.const 55183) (i32.const 38) (i32.const 250)) + (memory.fill (i32.const 22620) (i32.const 39) (i32.const 2097)) + (memory.fill (i32.const 17132) (i32.const 40) (i32.const 3264)) + (memory.fill (i32.const 54331) (i32.const 41) (i32.const 3299)) + (memory.fill (i32.const 39474) (i32.const 42) (i32.const 2796)) + (memory.fill (i32.const 36156) (i32.const 43) (i32.const 2070)) + (memory.fill (i32.const 35308) (i32.const 44) (i32.const 2763)) + (memory.fill (i32.const 32731) (i32.const 45) (i32.const 312)) + (memory.fill (i32.const 63746) (i32.const 46) (i32.const 192)) + (memory.fill (i32.const 30974) (i32.const 47) (i32.const 596)) + (memory.fill (i32.const 16635) (i32.const 48) (i32.const 501)) + (memory.fill (i32.const 57002) (i32.const 49) (i32.const 686)) + (memory.fill (i32.const 34299) (i32.const 50) (i32.const 385)) + (memory.fill (i32.const 60881) (i32.const 51) (i32.const 903)) + (memory.fill (i32.const 61445) (i32.const 52) (i32.const 2390)) + (memory.fill (i32.const 46972) (i32.const 53) (i32.const 1441)) + (memory.fill (i32.const 25973) (i32.const 54) (i32.const 3162)) + (memory.fill (i32.const 5566) (i32.const 55) (i32.const 2135)) + (memory.fill (i32.const 35977) (i32.const 56) (i32.const 519)) + (memory.fill (i32.const 44892) (i32.const 57) (i32.const 3280)) + (memory.fill (i32.const 46760) (i32.const 58) (i32.const 1678)) + (memory.fill (i32.const 46607) (i32.const 59) (i32.const 3168)) + (memory.fill (i32.const 22449) (i32.const 60) (i32.const 1441)) + (memory.fill (i32.const 58609) (i32.const 61) (i32.const 663)) + (memory.fill (i32.const 32261) (i32.const 62) (i32.const 1671)) + (memory.fill (i32.const 3063) (i32.const 63) (i32.const 721)) + (memory.fill (i32.const 34025) (i32.const 64) (i32.const 84)) + (memory.fill (i32.const 33338) (i32.const 65) (i32.const 2029)) + (memory.fill (i32.const 36810) (i32.const 66) (i32.const 29)) + (memory.fill (i32.const 19147) (i32.const 67) (i32.const 3034)) + (memory.fill (i32.const 12616) (i32.const 68) (i32.const 1043)) + (memory.fill (i32.const 18276) (i32.const 69) (i32.const 3324)) + (memory.fill (i32.const 4639) (i32.const 70) (i32.const 1091)) + (memory.fill (i32.const 16158) (i32.const 71) (i32.const 1997)) + (memory.fill (i32.const 18204) (i32.const 72) (i32.const 2259)) + (memory.fill (i32.const 50532) (i32.const 73) (i32.const 3189)) + (memory.fill (i32.const 11028) (i32.const 74) (i32.const 1968)) + (memory.fill (i32.const 15962) (i32.const 75) (i32.const 1455)) + (memory.fill (i32.const 45406) (i32.const 76) (i32.const 1177)) + (memory.fill (i32.const 54137) (i32.const 77) (i32.const 1568)) + (memory.fill (i32.const 33083) (i32.const 78) (i32.const 1642)) + (memory.fill (i32.const 61028) (i32.const 79) (i32.const 3284)) + (memory.fill (i32.const 51729) (i32.const 80) (i32.const 223)) + (memory.fill (i32.const 4361) (i32.const 81) (i32.const 2171)) + (memory.fill (i32.const 57514) (i32.const 82) (i32.const 1322)) + (memory.fill (i32.const 55724) (i32.const 83) (i32.const 2648)) + (memory.fill (i32.const 24091) (i32.const 84) (i32.const 1045)) + (memory.fill (i32.const 43183) (i32.const 85) (i32.const 3097)) + (memory.fill (i32.const 32307) (i32.const 86) (i32.const 2796)) + (memory.fill (i32.const 3811) (i32.const 87) (i32.const 2010)) + (memory.fill (i32.const 54856) (i32.const 88) (i32.const 0)) + (memory.fill (i32.const 49941) (i32.const 89) (i32.const 2069)) + (memory.fill (i32.const 20411) (i32.const 90) (i32.const 2896)) + (memory.fill (i32.const 33826) (i32.const 91) (i32.const 192)) + (memory.fill (i32.const 9402) (i32.const 92) (i32.const 2195)) + (memory.fill (i32.const 12413) (i32.const 93) (i32.const 24)) + (memory.fill (i32.const 14091) (i32.const 94) (i32.const 577)) + (memory.fill (i32.const 44058) (i32.const 95) (i32.const 2089)) + (memory.fill (i32.const 36735) (i32.const 96) (i32.const 3436)) + (memory.fill (i32.const 23288) (i32.const 97) (i32.const 2765)) + (memory.fill (i32.const 6392) (i32.const 98) (i32.const 830)) + (memory.fill (i32.const 33307) (i32.const 99) (i32.const 1938)) + (memory.fill (i32.const 21941) (i32.const 100) (i32.const 2750)) + (memory.copy (i32.const 59214) (i32.const 54248) (i32.const 2098)) + (memory.copy (i32.const 63026) (i32.const 39224) (i32.const 230)) + (memory.copy (i32.const 51833) (i32.const 23629) (i32.const 2300)) + (memory.copy (i32.const 6708) (i32.const 23996) (i32.const 639)) + (memory.copy (i32.const 6990) (i32.const 33399) (i32.const 1097)) + (memory.copy (i32.const 19403) (i32.const 10348) (i32.const 3197)) + (memory.copy (i32.const 27308) (i32.const 54406) (i32.const 100)) + (memory.copy (i32.const 27221) (i32.const 43682) (i32.const 1717)) + (memory.copy (i32.const 60528) (i32.const 8629) (i32.const 119)) + (memory.copy (i32.const 5947) (i32.const 2308) (i32.const 658)) + (memory.copy (i32.const 4787) (i32.const 51631) (i32.const 2269)) + (memory.copy (i32.const 12617) (i32.const 19197) (i32.const 833)) + (memory.copy (i32.const 11854) (i32.const 46505) (i32.const 3300)) + (memory.copy (i32.const 11376) (i32.const 45012) (i32.const 2281)) + (memory.copy (i32.const 34186) (i32.const 6697) (i32.const 2572)) + (memory.copy (i32.const 4936) (i32.const 1690) (i32.const 1328)) + (memory.copy (i32.const 63164) (i32.const 7637) (i32.const 1670)) + (memory.copy (i32.const 44568) (i32.const 18344) (i32.const 33)) + (memory.copy (i32.const 43918) (i32.const 22348) (i32.const 1427)) + (memory.copy (i32.const 46637) (i32.const 49819) (i32.const 1434)) + (memory.copy (i32.const 63684) (i32.const 8755) (i32.const 834)) + (memory.copy (i32.const 33485) (i32.const 20131) (i32.const 3317)) + (memory.copy (i32.const 40575) (i32.const 54317) (i32.const 3201)) + (memory.copy (i32.const 25812) (i32.const 59254) (i32.const 2452)) + (memory.copy (i32.const 19678) (i32.const 56882) (i32.const 346)) + (memory.copy (i32.const 15852) (i32.const 35914) (i32.const 2430)) + (memory.copy (i32.const 11824) (i32.const 35574) (i32.const 300)) + (memory.copy (i32.const 59427) (i32.const 13957) (i32.const 3153)) + (memory.copy (i32.const 34299) (i32.const 60594) (i32.const 1281)) + (memory.copy (i32.const 8964) (i32.const 12276) (i32.const 943)) + (memory.copy (i32.const 2827) (i32.const 10425) (i32.const 1887)) + (memory.copy (i32.const 43194) (i32.const 43910) (i32.const 738)) + (memory.copy (i32.const 63038) (i32.const 18949) (i32.const 122)) + (memory.copy (i32.const 24044) (i32.const 44761) (i32.const 1755)) + (memory.copy (i32.const 22608) (i32.const 14755) (i32.const 702)) + (memory.copy (i32.const 11284) (i32.const 26579) (i32.const 1830)) + (memory.copy (i32.const 23092) (i32.const 20471) (i32.const 1064)) + (memory.copy (i32.const 57248) (i32.const 54770) (i32.const 2631)) + (memory.copy (i32.const 25492) (i32.const 1025) (i32.const 3113)) + (memory.copy (i32.const 49588) (i32.const 44220) (i32.const 975)) + (memory.copy (i32.const 28280) (i32.const 41722) (i32.const 2336)) + (memory.copy (i32.const 61289) (i32.const 230) (i32.const 2872)) + (memory.copy (i32.const 22480) (i32.const 52506) (i32.const 2197)) + (memory.copy (i32.const 40553) (i32.const 9578) (i32.const 1958)) + (memory.copy (i32.const 29004) (i32.const 20862) (i32.const 2186)) + (memory.copy (i32.const 53029) (i32.const 43955) (i32.const 1037)) + (memory.copy (i32.const 25476) (i32.const 35667) (i32.const 1650)) + (memory.copy (i32.const 58516) (i32.const 45819) (i32.const 1986)) + (memory.copy (i32.const 38297) (i32.const 5776) (i32.const 1955)) + (memory.copy (i32.const 28503) (i32.const 55364) (i32.const 2368)) + (memory.copy (i32.const 62619) (i32.const 18108) (i32.const 1356)) + (memory.copy (i32.const 50149) (i32.const 13861) (i32.const 382)) + (memory.copy (i32.const 16904) (i32.const 36341) (i32.const 1900)) + (memory.copy (i32.const 48098) (i32.const 11358) (i32.const 2807)) + (memory.copy (i32.const 28512) (i32.const 40362) (i32.const 323)) + (memory.copy (i32.const 35506) (i32.const 27856) (i32.const 1670)) + (memory.copy (i32.const 62970) (i32.const 53332) (i32.const 1341)) + (memory.copy (i32.const 14133) (i32.const 46312) (i32.const 644)) + (memory.copy (i32.const 29030) (i32.const 19074) (i32.const 496)) + (memory.copy (i32.const 44952) (i32.const 47577) (i32.const 2784)) + (memory.copy (i32.const 39559) (i32.const 44661) (i32.const 1350)) + (memory.copy (i32.const 10352) (i32.const 29274) (i32.const 1475)) + (memory.copy (i32.const 46911) (i32.const 46178) (i32.const 1467)) + (memory.copy (i32.const 4905) (i32.const 28740) (i32.const 1895)) + (memory.copy (i32.const 38012) (i32.const 57253) (i32.const 1751)) + (memory.copy (i32.const 26446) (i32.const 27223) (i32.const 1127)) + (memory.copy (i32.const 58835) (i32.const 24657) (i32.const 1063)) + (memory.copy (i32.const 61356) (i32.const 38790) (i32.const 766)) + (memory.copy (i32.const 44160) (i32.const 2284) (i32.const 1520)) + (memory.copy (i32.const 32740) (i32.const 47237) (i32.const 3014)) + (memory.copy (i32.const 11148) (i32.const 21260) (i32.const 1011)) + (memory.copy (i32.const 7665) (i32.const 31612) (i32.const 3034)) + (memory.copy (i32.const 18044) (i32.const 12987) (i32.const 3320)) + (memory.copy (i32.const 57306) (i32.const 55905) (i32.const 308)) + (memory.copy (i32.const 24675) (i32.const 16815) (i32.const 1155)) + (memory.copy (i32.const 19900) (i32.const 10115) (i32.const 722)) + (memory.copy (i32.const 2921) (i32.const 5935) (i32.const 2370)) + (memory.copy (i32.const 32255) (i32.const 50095) (i32.const 2926)) + (memory.copy (i32.const 15126) (i32.const 17299) (i32.const 2607)) + (memory.copy (i32.const 45575) (i32.const 28447) (i32.const 2045)) + (memory.copy (i32.const 55149) (i32.const 36113) (i32.const 2596)) + (memory.copy (i32.const 28461) (i32.const 54157) (i32.const 1168)) + (memory.copy (i32.const 47951) (i32.const 53385) (i32.const 3137)) + (memory.copy (i32.const 30646) (i32.const 45155) (i32.const 2649)) + (memory.copy (i32.const 5057) (i32.const 4295) (i32.const 52)) + (memory.copy (i32.const 6692) (i32.const 24195) (i32.const 441)) + (memory.copy (i32.const 32984) (i32.const 27117) (i32.const 3445)) + (memory.copy (i32.const 32530) (i32.const 59372) (i32.const 2785)) + (memory.copy (i32.const 34361) (i32.const 8962) (i32.const 2406)) + (memory.copy (i32.const 17893) (i32.const 54538) (i32.const 3381)) + (memory.copy (i32.const 22685) (i32.const 44151) (i32.const 136)) + (memory.copy (i32.const 59089) (i32.const 7077) (i32.const 1045)) + (memory.copy (i32.const 42945) (i32.const 55028) (i32.const 2389)) + (memory.copy (i32.const 44693) (i32.const 20138) (i32.const 877)) + (memory.copy (i32.const 36810) (i32.const 25196) (i32.const 3447)) + (memory.copy (i32.const 45742) (i32.const 31888) (i32.const 854)) + (memory.copy (i32.const 24236) (i32.const 31866) (i32.const 1377)) + (memory.copy (i32.const 33778) (i32.const 692) (i32.const 1594)) + (memory.copy (i32.const 60618) (i32.const 18585) (i32.const 2987)) + (memory.copy (i32.const 50370) (i32.const 41271) (i32.const 1406)) + ) + + (func (export "checkRange") (param $from i32) (param $to i32) (param $expected i32) (result i32) + (loop $cont + (if (i32.eq (local.get $from) (local.get $to)) + (then + (return (i32.const -1)))) + (if (i32.eq (i32.load8_u (local.get $from)) (local.get $expected)) + (then + (local.set $from (i32.add (local.get $from) (i32.const 1))) + (br $cont)))) + (return (local.get $from))) +) +(invoke "test") + +(assert_return (invoke "checkRange" (i32.const 0) (i32.const 124) (i32.const 0)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 124) (i32.const 1517) (i32.const 9)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 1517) (i32.const 2132) (i32.const 0)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 2132) (i32.const 2827) (i32.const 10)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 2827) (i32.const 2921) (i32.const 92)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 2921) (i32.const 3538) (i32.const 83)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 3538) (i32.const 3786) (i32.const 77)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 3786) (i32.const 4042) (i32.const 97)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 4042) (i32.const 4651) (i32.const 99)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 4651) (i32.const 5057) (i32.const 0)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 5057) (i32.const 5109) (i32.const 99)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 5109) (i32.const 5291) (i32.const 0)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 5291) (i32.const 5524) (i32.const 72)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 5524) (i32.const 5691) (i32.const 92)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 5691) (i32.const 6552) (i32.const 83)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 6552) (i32.const 7133) (i32.const 77)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 7133) (i32.const 7665) (i32.const 99)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 7665) (i32.const 8314) (i32.const 0)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 8314) (i32.const 8360) (i32.const 62)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 8360) (i32.const 8793) (i32.const 86)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 8793) (i32.const 8979) (i32.const 83)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 8979) (i32.const 9373) (i32.const 79)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 9373) (i32.const 9518) (i32.const 95)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 9518) (i32.const 9934) (i32.const 59)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 9934) (i32.const 10087) (i32.const 77)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 10087) (i32.const 10206) (i32.const 5)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 10206) (i32.const 10230) (i32.const 77)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 10230) (i32.const 10249) (i32.const 41)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 10249) (i32.const 11148) (i32.const 83)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 11148) (i32.const 11356) (i32.const 74)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 11356) (i32.const 11380) (i32.const 93)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 11380) (i32.const 11939) (i32.const 74)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 11939) (i32.const 12159) (i32.const 68)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 12159) (i32.const 12575) (i32.const 83)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 12575) (i32.const 12969) (i32.const 79)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 12969) (i32.const 13114) (i32.const 95)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 13114) (i32.const 14133) (i32.const 59)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 14133) (i32.const 14404) (i32.const 76)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 14404) (i32.const 14428) (i32.const 57)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 14428) (i32.const 14458) (i32.const 59)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 14458) (i32.const 14580) (i32.const 32)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 14580) (i32.const 14777) (i32.const 89)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 14777) (i32.const 15124) (i32.const 59)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 15124) (i32.const 15126) (i32.const 36)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 15126) (i32.const 15192) (i32.const 100)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 15192) (i32.const 15871) (i32.const 96)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 15871) (i32.const 15998) (i32.const 95)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 15998) (i32.const 17017) (i32.const 59)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 17017) (i32.const 17288) (i32.const 76)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 17288) (i32.const 17312) (i32.const 57)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 17312) (i32.const 17342) (i32.const 59)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 17342) (i32.const 17464) (i32.const 32)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 17464) (i32.const 17661) (i32.const 89)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 17661) (i32.const 17727) (i32.const 59)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 17727) (i32.const 17733) (i32.const 5)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 17733) (i32.const 17893) (i32.const 96)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 17893) (i32.const 18553) (i32.const 77)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 18553) (i32.const 18744) (i32.const 42)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 18744) (i32.const 18801) (i32.const 76)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 18801) (i32.const 18825) (i32.const 57)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 18825) (i32.const 18876) (i32.const 59)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 18876) (i32.const 18885) (i32.const 77)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 18885) (i32.const 18904) (i32.const 41)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 18904) (i32.const 19567) (i32.const 83)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 19567) (i32.const 20403) (i32.const 96)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 20403) (i32.const 21274) (i32.const 77)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 21274) (i32.const 21364) (i32.const 100)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 21364) (i32.const 21468) (i32.const 74)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 21468) (i32.const 21492) (i32.const 93)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 21492) (i32.const 22051) (i32.const 74)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 22051) (i32.const 22480) (i32.const 68)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 22480) (i32.const 22685) (i32.const 100)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 22685) (i32.const 22694) (i32.const 68)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 22694) (i32.const 22821) (i32.const 10)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 22821) (i32.const 22869) (i32.const 100)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 22869) (i32.const 24107) (i32.const 97)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 24107) (i32.const 24111) (i32.const 37)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 24111) (i32.const 24236) (i32.const 77)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 24236) (i32.const 24348) (i32.const 72)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 24348) (i32.const 24515) (i32.const 92)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 24515) (i32.const 24900) (i32.const 83)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 24900) (i32.const 25136) (i32.const 95)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 25136) (i32.const 25182) (i32.const 85)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 25182) (i32.const 25426) (i32.const 68)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 25426) (i32.const 25613) (i32.const 89)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 25613) (i32.const 25830) (i32.const 96)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 25830) (i32.const 26446) (i32.const 100)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 26446) (i32.const 26517) (i32.const 10)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 26517) (i32.const 27468) (i32.const 92)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 27468) (i32.const 27503) (i32.const 95)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 27503) (i32.const 27573) (i32.const 77)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 27573) (i32.const 28245) (i32.const 92)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 28245) (i32.const 28280) (i32.const 95)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 28280) (i32.const 29502) (i32.const 77)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 29502) (i32.const 29629) (i32.const 42)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 29629) (i32.const 30387) (i32.const 83)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 30387) (i32.const 30646) (i32.const 77)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 30646) (i32.const 31066) (i32.const 92)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 31066) (i32.const 31131) (i32.const 77)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 31131) (i32.const 31322) (i32.const 42)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 31322) (i32.const 31379) (i32.const 76)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 31379) (i32.const 31403) (i32.const 57)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 31403) (i32.const 31454) (i32.const 59)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 31454) (i32.const 31463) (i32.const 77)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 31463) (i32.const 31482) (i32.const 41)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 31482) (i32.const 31649) (i32.const 83)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 31649) (i32.const 31978) (i32.const 72)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 31978) (i32.const 32145) (i32.const 92)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 32145) (i32.const 32530) (i32.const 83)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 32530) (i32.const 32766) (i32.const 95)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 32766) (i32.const 32812) (i32.const 85)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 32812) (i32.const 33056) (i32.const 68)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 33056) (i32.const 33660) (i32.const 89)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 33660) (i32.const 33752) (i32.const 59)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 33752) (i32.const 33775) (i32.const 36)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 33775) (i32.const 33778) (i32.const 32)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 33778) (i32.const 34603) (i32.const 9)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 34603) (i32.const 35218) (i32.const 0)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 35218) (i32.const 35372) (i32.const 10)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 35372) (i32.const 35486) (i32.const 77)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 35486) (i32.const 35605) (i32.const 5)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 35605) (i32.const 35629) (i32.const 77)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 35629) (i32.const 35648) (i32.const 41)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 35648) (i32.const 36547) (i32.const 83)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 36547) (i32.const 36755) (i32.const 74)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 36755) (i32.const 36767) (i32.const 93)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 36767) (i32.const 36810) (i32.const 83)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 36810) (i32.const 36839) (i32.const 100)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 36839) (i32.const 37444) (i32.const 96)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 37444) (i32.const 38060) (i32.const 100)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 38060) (i32.const 38131) (i32.const 10)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 38131) (i32.const 39082) (i32.const 92)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 39082) (i32.const 39117) (i32.const 95)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 39117) (i32.const 39187) (i32.const 77)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 39187) (i32.const 39859) (i32.const 92)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 39859) (i32.const 39894) (i32.const 95)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 39894) (i32.const 40257) (i32.const 77)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 40257) (i32.const 40344) (i32.const 89)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 40344) (i32.const 40371) (i32.const 59)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 40371) (i32.const 40804) (i32.const 77)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 40804) (i32.const 40909) (i32.const 5)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 40909) (i32.const 42259) (i32.const 92)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 42259) (i32.const 42511) (i32.const 77)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 42511) (i32.const 42945) (i32.const 83)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 42945) (i32.const 43115) (i32.const 77)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 43115) (i32.const 43306) (i32.const 42)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 43306) (i32.const 43363) (i32.const 76)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 43363) (i32.const 43387) (i32.const 57)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 43387) (i32.const 43438) (i32.const 59)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 43438) (i32.const 43447) (i32.const 77)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 43447) (i32.const 43466) (i32.const 41)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 43466) (i32.const 44129) (i32.const 83)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 44129) (i32.const 44958) (i32.const 96)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 44958) (i32.const 45570) (i32.const 77)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 45570) (i32.const 45575) (i32.const 92)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 45575) (i32.const 45640) (i32.const 77)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 45640) (i32.const 45742) (i32.const 42)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 45742) (i32.const 45832) (i32.const 72)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 45832) (i32.const 45999) (i32.const 92)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 45999) (i32.const 46384) (i32.const 83)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 46384) (i32.const 46596) (i32.const 95)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 46596) (i32.const 46654) (i32.const 92)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 46654) (i32.const 47515) (i32.const 83)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 47515) (i32.const 47620) (i32.const 77)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 47620) (i32.const 47817) (i32.const 79)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 47817) (i32.const 47951) (i32.const 95)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 47951) (i32.const 48632) (i32.const 100)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 48632) (i32.const 48699) (i32.const 97)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 48699) (i32.const 48703) (i32.const 37)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 48703) (i32.const 49764) (i32.const 77)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 49764) (i32.const 49955) (i32.const 42)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 49955) (i32.const 50012) (i32.const 76)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 50012) (i32.const 50036) (i32.const 57)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 50036) (i32.const 50087) (i32.const 59)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 50087) (i32.const 50096) (i32.const 77)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 50096) (i32.const 50115) (i32.const 41)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 50115) (i32.const 50370) (i32.const 83)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 50370) (i32.const 51358) (i32.const 92)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 51358) (i32.const 51610) (i32.const 77)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 51610) (i32.const 51776) (i32.const 83)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 51776) (i32.const 51833) (i32.const 89)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 51833) (i32.const 52895) (i32.const 100)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 52895) (i32.const 53029) (i32.const 97)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 53029) (i32.const 53244) (i32.const 68)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 53244) (i32.const 54066) (i32.const 100)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 54066) (i32.const 54133) (i32.const 97)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 54133) (i32.const 54137) (i32.const 37)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 54137) (i32.const 55198) (i32.const 77)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 55198) (i32.const 55389) (i32.const 42)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 55389) (i32.const 55446) (i32.const 76)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 55446) (i32.const 55470) (i32.const 57)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 55470) (i32.const 55521) (i32.const 59)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 55521) (i32.const 55530) (i32.const 77)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 55530) (i32.const 55549) (i32.const 41)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 55549) (i32.const 56212) (i32.const 83)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 56212) (i32.const 57048) (i32.const 96)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 57048) (i32.const 58183) (i32.const 77)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 58183) (i32.const 58202) (i32.const 41)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 58202) (i32.const 58516) (i32.const 83)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 58516) (i32.const 58835) (i32.const 95)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 58835) (i32.const 58855) (i32.const 77)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 58855) (i32.const 59089) (i32.const 95)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 59089) (i32.const 59145) (i32.const 77)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 59145) (i32.const 59677) (i32.const 99)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 59677) (i32.const 60134) (i32.const 0)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 60134) (i32.const 60502) (i32.const 89)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 60502) (i32.const 60594) (i32.const 59)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 60594) (i32.const 60617) (i32.const 36)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 60617) (i32.const 60618) (i32.const 32)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 60618) (i32.const 60777) (i32.const 42)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 60777) (i32.const 60834) (i32.const 76)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 60834) (i32.const 60858) (i32.const 57)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 60858) (i32.const 60909) (i32.const 59)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 60909) (i32.const 60918) (i32.const 77)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 60918) (i32.const 60937) (i32.const 41)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 60937) (i32.const 61600) (i32.const 83)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 61600) (i32.const 62436) (i32.const 96)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 62436) (i32.const 63307) (i32.const 77)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 63307) (i32.const 63397) (i32.const 100)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 63397) (i32.const 63501) (i32.const 74)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 63501) (i32.const 63525) (i32.const 93)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 63525) (i32.const 63605) (i32.const 74)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 63605) (i32.const 63704) (i32.const 100)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 63704) (i32.const 63771) (i32.const 97)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 63771) (i32.const 63775) (i32.const 37)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 63775) (i32.const 64311) (i32.const 77)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 64311) (i32.const 64331) (i32.const 26)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 64331) (i32.const 64518) (i32.const 92)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 64518) (i32.const 64827) (i32.const 11)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 64827) (i32.const 64834) (i32.const 26)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 64834) (i32.const 65536) (i32.const 0)) + (i32.const -1)) diff --git a/runtime/near-vm/tests/wast/spec/proposals/reference-types/memory_fill.wast b/runtime/near-vm/tests/wast/spec/proposals/reference-types/memory_fill.wast new file mode 100644 index 00000000000..caca80b5daa --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/proposals/reference-types/memory_fill.wast @@ -0,0 +1,685 @@ +;; +;; Generated by ../meta/generate_memory_fill.js +;; + +(module + (memory 1 1) + + (func (export "checkRange") (param $from i32) (param $to i32) (param $expected i32) (result i32) + (loop $cont + (if (i32.eq (local.get $from) (local.get $to)) + (then + (return (i32.const -1)))) + (if (i32.eq (i32.load8_u (local.get $from)) (local.get $expected)) + (then + (local.set $from (i32.add (local.get $from) (i32.const 1))) + (br $cont)))) + (return (local.get $from))) + + (func (export "test") + (memory.fill (i32.const 0xFF00) (i32.const 0x55) (i32.const 256)))) +(invoke "test") + +(assert_return (invoke "checkRange" (i32.const 0) (i32.const 65280) (i32.const 0)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 65280) (i32.const 65536) (i32.const 85)) + (i32.const -1)) +(module + (memory 1 1) + + (func (export "checkRange") (param $from i32) (param $to i32) (param $expected i32) (result i32) + (loop $cont + (if (i32.eq (local.get $from) (local.get $to)) + (then + (return (i32.const -1)))) + (if (i32.eq (i32.load8_u (local.get $from)) (local.get $expected)) + (then + (local.set $from (i32.add (local.get $from) (i32.const 1))) + (br $cont)))) + (return (local.get $from))) + + (func (export "test") + (memory.fill (i32.const 0xFF00) (i32.const 0x55) (i32.const 257)))) +(assert_trap (invoke "test") "out of bounds memory access") + +(module + (memory 1 1) + + (func (export "checkRange") (param $from i32) (param $to i32) (param $expected i32) (result i32) + (loop $cont + (if (i32.eq (local.get $from) (local.get $to)) + (then + (return (i32.const -1)))) + (if (i32.eq (i32.load8_u (local.get $from)) (local.get $expected)) + (then + (local.set $from (i32.add (local.get $from) (i32.const 1))) + (br $cont)))) + (return (local.get $from))) + + (func (export "test") + (memory.fill (i32.const 0xFFFFFF00) (i32.const 0x55) (i32.const 257)))) +(assert_trap (invoke "test") "out of bounds memory access") + +(module + (memory 1 1) + + (func (export "checkRange") (param $from i32) (param $to i32) (param $expected i32) (result i32) + (loop $cont + (if (i32.eq (local.get $from) (local.get $to)) + (then + (return (i32.const -1)))) + (if (i32.eq (i32.load8_u (local.get $from)) (local.get $expected)) + (then + (local.set $from (i32.add (local.get $from) (i32.const 1))) + (br $cont)))) + (return (local.get $from))) + + (func (export "test") + (memory.fill (i32.const 0x12) (i32.const 0x55) (i32.const 0)))) +(invoke "test") + +(assert_return (invoke "checkRange" (i32.const 0) (i32.const 65536) (i32.const 0)) + (i32.const -1)) +(module + (memory 1 1) + + (func (export "checkRange") (param $from i32) (param $to i32) (param $expected i32) (result i32) + (loop $cont + (if (i32.eq (local.get $from) (local.get $to)) + (then + (return (i32.const -1)))) + (if (i32.eq (i32.load8_u (local.get $from)) (local.get $expected)) + (then + (local.set $from (i32.add (local.get $from) (i32.const 1))) + (br $cont)))) + (return (local.get $from))) + + (func (export "test") + (memory.fill (i32.const 0x10000) (i32.const 0x55) (i32.const 0)))) +(invoke "test") + +(module + (memory 1 1) + + (func (export "checkRange") (param $from i32) (param $to i32) (param $expected i32) (result i32) + (loop $cont + (if (i32.eq (local.get $from) (local.get $to)) + (then + (return (i32.const -1)))) + (if (i32.eq (i32.load8_u (local.get $from)) (local.get $expected)) + (then + (local.set $from (i32.add (local.get $from) (i32.const 1))) + (br $cont)))) + (return (local.get $from))) + + (func (export "test") + (memory.fill (i32.const 0x20000) (i32.const 0x55) (i32.const 0)))) +(assert_trap (invoke "test") "out of bounds") + +(module + (memory 1 1) + + (func (export "checkRange") (param $from i32) (param $to i32) (param $expected i32) (result i32) + (loop $cont + (if (i32.eq (local.get $from) (local.get $to)) + (then + (return (i32.const -1)))) + (if (i32.eq (i32.load8_u (local.get $from)) (local.get $expected)) + (then + (local.set $from (i32.add (local.get $from) (i32.const 1))) + (br $cont)))) + (return (local.get $from))) + + (func (export "test") + (memory.fill (i32.const 0x1) (i32.const 0xAA) (i32.const 0xFFFE)))) +(invoke "test") + +(assert_return (invoke "checkRange" (i32.const 0) (i32.const 1) (i32.const 0)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 1) (i32.const 65535) (i32.const 170)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 65535) (i32.const 65536) (i32.const 0)) + (i32.const -1)) + +(module + (memory 1 1) + + (func (export "checkRange") (param $from i32) (param $to i32) (param $expected i32) (result i32) + (loop $cont + (if (i32.eq (local.get $from) (local.get $to)) + (then + (return (i32.const -1)))) + (if (i32.eq (i32.load8_u (local.get $from)) (local.get $expected)) + (then + (local.set $from (i32.add (local.get $from) (i32.const 1))) + (br $cont)))) + (return (local.get $from))) + + (func (export "test") + (memory.fill (i32.const 0x12) (i32.const 0x55) (i32.const 10)) + (memory.fill (i32.const 0x15) (i32.const 0xAA) (i32.const 4)))) +(invoke "test") + +(assert_return (invoke "checkRange" (i32.const 0) (i32.const 18) (i32.const 0)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 18) (i32.const 21) (i32.const 85)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 21) (i32.const 25) (i32.const 170)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 25) (i32.const 28) (i32.const 85)) + (i32.const -1)) +(assert_return (invoke "checkRange" (i32.const 28) (i32.const 65536) (i32.const 0)) + (i32.const -1)) +(assert_invalid + (module + (func (export "testfn") + (memory.fill (i32.const 10) (i32.const 20) (i32.const 30)))) + "unknown memory 0") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.fill (i32.const 10) (i32.const 20) (f32.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.fill (i32.const 10) (i32.const 20) (i64.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.fill (i32.const 10) (i32.const 20) (f64.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.fill (i32.const 10) (f32.const 20) (i32.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.fill (i32.const 10) (f32.const 20) (f32.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.fill (i32.const 10) (f32.const 20) (i64.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.fill (i32.const 10) (f32.const 20) (f64.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.fill (i32.const 10) (i64.const 20) (i32.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.fill (i32.const 10) (i64.const 20) (f32.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.fill (i32.const 10) (i64.const 20) (i64.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.fill (i32.const 10) (i64.const 20) (f64.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.fill (i32.const 10) (f64.const 20) (i32.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.fill (i32.const 10) (f64.const 20) (f32.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.fill (i32.const 10) (f64.const 20) (i64.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.fill (i32.const 10) (f64.const 20) (f64.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.fill (f32.const 10) (i32.const 20) (i32.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.fill (f32.const 10) (i32.const 20) (f32.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.fill (f32.const 10) (i32.const 20) (i64.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.fill (f32.const 10) (i32.const 20) (f64.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.fill (f32.const 10) (f32.const 20) (i32.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.fill (f32.const 10) (f32.const 20) (f32.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.fill (f32.const 10) (f32.const 20) (i64.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.fill (f32.const 10) (f32.const 20) (f64.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.fill (f32.const 10) (i64.const 20) (i32.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.fill (f32.const 10) (i64.const 20) (f32.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.fill (f32.const 10) (i64.const 20) (i64.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.fill (f32.const 10) (i64.const 20) (f64.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.fill (f32.const 10) (f64.const 20) (i32.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.fill (f32.const 10) (f64.const 20) (f32.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.fill (f32.const 10) (f64.const 20) (i64.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.fill (f32.const 10) (f64.const 20) (f64.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.fill (i64.const 10) (i32.const 20) (i32.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.fill (i64.const 10) (i32.const 20) (f32.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.fill (i64.const 10) (i32.const 20) (i64.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.fill (i64.const 10) (i32.const 20) (f64.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.fill (i64.const 10) (f32.const 20) (i32.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.fill (i64.const 10) (f32.const 20) (f32.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.fill (i64.const 10) (f32.const 20) (i64.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.fill (i64.const 10) (f32.const 20) (f64.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.fill (i64.const 10) (i64.const 20) (i32.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.fill (i64.const 10) (i64.const 20) (f32.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.fill (i64.const 10) (i64.const 20) (i64.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.fill (i64.const 10) (i64.const 20) (f64.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.fill (i64.const 10) (f64.const 20) (i32.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.fill (i64.const 10) (f64.const 20) (f32.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.fill (i64.const 10) (f64.const 20) (i64.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.fill (i64.const 10) (f64.const 20) (f64.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.fill (f64.const 10) (i32.const 20) (i32.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.fill (f64.const 10) (i32.const 20) (f32.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.fill (f64.const 10) (i32.const 20) (i64.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.fill (f64.const 10) (i32.const 20) (f64.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.fill (f64.const 10) (f32.const 20) (i32.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.fill (f64.const 10) (f32.const 20) (f32.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.fill (f64.const 10) (f32.const 20) (i64.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.fill (f64.const 10) (f32.const 20) (f64.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.fill (f64.const 10) (i64.const 20) (i32.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.fill (f64.const 10) (i64.const 20) (f32.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.fill (f64.const 10) (i64.const 20) (i64.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.fill (f64.const 10) (i64.const 20) (f64.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.fill (f64.const 10) (f64.const 20) (i32.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.fill (f64.const 10) (f64.const 20) (f32.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.fill (f64.const 10) (f64.const 20) (i64.const 30)))) + "type mismatch") + +(assert_invalid + (module + (memory 1 1) + (func (export "testfn") + (memory.fill (f64.const 10) (f64.const 20) (f64.const 30)))) + "type mismatch") + +(module + (memory 1 1 ) + + (func (export "checkRange") (param $from i32) (param $to i32) (param $expected i32) (result i32) + (loop $cont + (if (i32.eq (local.get $from) (local.get $to)) + (then + (return (i32.const -1)))) + (if (i32.eq (i32.load8_u (local.get $from)) (local.get $expected)) + (then + (local.set $from (i32.add (local.get $from) (i32.const 1))) + (br $cont)))) + (return (local.get $from))) + + (func (export "run") (param $offs i32) (param $val i32) (param $len i32) + (memory.fill (local.get $offs) (local.get $val) (local.get $len)))) + +(assert_trap (invoke "run" (i32.const 65280) (i32.const 37) (i32.const 512)) + "out of bounds") + +(assert_return (invoke "checkRange" (i32.const 0) (i32.const 1) (i32.const 0)) + (i32.const -1)) +(module + (memory 1 1 ) + + (func (export "checkRange") (param $from i32) (param $to i32) (param $expected i32) (result i32) + (loop $cont + (if (i32.eq (local.get $from) (local.get $to)) + (then + (return (i32.const -1)))) + (if (i32.eq (i32.load8_u (local.get $from)) (local.get $expected)) + (then + (local.set $from (i32.add (local.get $from) (i32.const 1))) + (br $cont)))) + (return (local.get $from))) + + (func (export "run") (param $offs i32) (param $val i32) (param $len i32) + (memory.fill (local.get $offs) (local.get $val) (local.get $len)))) + +(assert_trap (invoke "run" (i32.const 65279) (i32.const 37) (i32.const 514)) + "out of bounds") + +(assert_return (invoke "checkRange" (i32.const 0) (i32.const 1) (i32.const 0)) + (i32.const -1)) +(module + (memory 1 1 ) + + (func (export "checkRange") (param $from i32) (param $to i32) (param $expected i32) (result i32) + (loop $cont + (if (i32.eq (local.get $from) (local.get $to)) + (then + (return (i32.const -1)))) + (if (i32.eq (i32.load8_u (local.get $from)) (local.get $expected)) + (then + (local.set $from (i32.add (local.get $from) (i32.const 1))) + (br $cont)))) + (return (local.get $from))) + + (func (export "run") (param $offs i32) (param $val i32) (param $len i32) + (memory.fill (local.get $offs) (local.get $val) (local.get $len)))) + +(assert_trap (invoke "run" (i32.const 65279) (i32.const 37) (i32.const 4294967295)) + "out of bounds") + +(assert_return (invoke "checkRange" (i32.const 0) (i32.const 1) (i32.const 0)) + (i32.const -1)) diff --git a/runtime/near-vm/tests/wast/spec/proposals/reference-types/memory_grow.wast b/runtime/near-vm/tests/wast/spec/proposals/reference-types/memory_grow.wast new file mode 100644 index 00000000000..aa56297d25d --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/proposals/reference-types/memory_grow.wast @@ -0,0 +1,379 @@ +(module + (memory 0) + + (func (export "load_at_zero") (result i32) (i32.load (i32.const 0))) + (func (export "store_at_zero") (i32.store (i32.const 0) (i32.const 2))) + + (func (export "load_at_page_size") (result i32) (i32.load (i32.const 0x10000))) + (func (export "store_at_page_size") (i32.store (i32.const 0x10000) (i32.const 3))) + + (func (export "grow") (param $sz i32) (result i32) (memory.grow (local.get $sz))) + (func (export "size") (result i32) (memory.size)) +) + +(assert_return (invoke "size") (i32.const 0)) +(assert_trap (invoke "store_at_zero") "out of bounds memory access") +(assert_trap (invoke "load_at_zero") "out of bounds memory access") +(assert_trap (invoke "store_at_page_size") "out of bounds memory access") +(assert_trap (invoke "load_at_page_size") "out of bounds memory access") +(assert_return (invoke "grow" (i32.const 1)) (i32.const 0)) +(assert_return (invoke "size") (i32.const 1)) +(assert_return (invoke "load_at_zero") (i32.const 0)) +(assert_return (invoke "store_at_zero")) +(assert_return (invoke "load_at_zero") (i32.const 2)) +(assert_trap (invoke "store_at_page_size") "out of bounds memory access") +(assert_trap (invoke "load_at_page_size") "out of bounds memory access") +(assert_return (invoke "grow" (i32.const 4)) (i32.const 1)) +(assert_return (invoke "size") (i32.const 5)) +(assert_return (invoke "load_at_zero") (i32.const 2)) +(assert_return (invoke "store_at_zero")) +(assert_return (invoke "load_at_zero") (i32.const 2)) +(assert_return (invoke "load_at_page_size") (i32.const 0)) +(assert_return (invoke "store_at_page_size")) +(assert_return (invoke "load_at_page_size") (i32.const 3)) + + +(module + (memory 0) + (func (export "grow") (param i32) (result i32) (memory.grow (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)) +(assert_return (invoke "grow" (i32.const 0x10000)) (i32.const -1)) +(assert_return (invoke "grow" (i32.const 64736)) (i32.const -1)) +(assert_return (invoke "grow" (i32.const 1)) (i32.const 803)) + +(module + (memory 0 10) + (func (export "grow") (param i32) (result i32) (memory.grow (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)) + +;; Test that newly allocated memory (program start and memory.grow) is zeroed + +(module + (memory 1) + (func (export "grow") (param i32) (result i32) + (memory.grow (local.get 0)) + ) + (func (export "check-memory-zero") (param i32 i32) (result i32) + (local i32) + (local.set 2 (i32.const 1)) + (block + (loop + (local.set 2 (i32.load8_u (local.get 0))) + (br_if 1 (i32.ne (local.get 2) (i32.const 0))) + (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-memory-zero" (i32.const 0) (i32.const 0xffff)) (i32.const 0)) +(assert_return (invoke "grow" (i32.const 1)) (i32.const 1)) +(assert_return (invoke "check-memory-zero" (i32.const 0x10000) (i32.const 0x1_ffff)) (i32.const 0)) +(assert_return (invoke "grow" (i32.const 1)) (i32.const 2)) +(assert_return (invoke "check-memory-zero" (i32.const 0x20000) (i32.const 0x2_ffff)) (i32.const 0)) +(assert_return (invoke "grow" (i32.const 1)) (i32.const 3)) +(assert_return (invoke "check-memory-zero" (i32.const 0x30000) (i32.const 0x3_ffff)) (i32.const 0)) +(assert_return (invoke "grow" (i32.const 1)) (i32.const 4)) +(assert_return (invoke "check-memory-zero" (i32.const 0x40000) (i32.const 0x4_ffff)) (i32.const 0)) +(assert_return (invoke "grow" (i32.const 1)) (i32.const 5)) +(assert_return (invoke "check-memory-zero" (i32.const 0x50000) (i32.const 0x5_ffff)) (i32.const 0)) + +;; As the argument of control constructs and instructions + +(module + (memory 1) + + (func (export "as-br-value") (result i32) + (block (result i32) (br 0 (memory.grow (i32.const 0)))) + ) + + (func (export "as-br_if-cond") + (block (br_if 0 (memory.grow (i32.const 0)))) + ) + (func (export "as-br_if-value") (result i32) + (block (result i32) + (drop (br_if 0 (memory.grow (i32.const 0)) (i32.const 1))) (i32.const 7) + ) + ) + (func (export "as-br_if-value-cond") (result i32) + (block (result i32) + (drop (br_if 0 (i32.const 6) (memory.grow (i32.const 0)))) (i32.const 7) + ) + ) + + (func (export "as-br_table-index") + (block (br_table 0 0 0 (memory.grow (i32.const 0)))) + ) + (func (export "as-br_table-value") (result i32) + (block (result i32) + (br_table 0 0 0 (memory.grow (i32.const 0)) (i32.const 1)) (i32.const 7) + ) + ) + (func (export "as-br_table-value-index") (result i32) + (block (result i32) + (br_table 0 0 (i32.const 6) (memory.grow (i32.const 0))) (i32.const 7) + ) + ) + + (func (export "as-return-value") (result i32) + (return (memory.grow (i32.const 0))) + ) + + (func (export "as-if-cond") (result i32) + (if (result i32) (memory.grow (i32.const 0)) + (then (i32.const 0)) (else (i32.const 1)) + ) + ) + (func (export "as-if-then") (result i32) + (if (result i32) (i32.const 1) + (then (memory.grow (i32.const 0))) (else (i32.const 0)) + ) + ) + (func (export "as-if-else") (result i32) + (if (result i32) (i32.const 0) + (then (i32.const 0)) (else (memory.grow (i32.const 0))) + ) + ) + + (func (export "as-select-first") (param i32 i32) (result i32) + (select (memory.grow (i32.const 0)) (local.get 0) (local.get 1)) + ) + (func (export "as-select-second") (param i32 i32) (result i32) + (select (local.get 0) (memory.grow (i32.const 0)) (local.get 1)) + ) + (func (export "as-select-cond") (result i32) + (select (i32.const 0) (i32.const 1) (memory.grow (i32.const 0))) + ) + + (func $f (param i32 i32 i32) (result i32) (i32.const -1)) + (func (export "as-call-first") (result i32) + (call $f (memory.grow (i32.const 0)) (i32.const 2) (i32.const 3)) + ) + (func (export "as-call-mid") (result i32) + (call $f (i32.const 1) (memory.grow (i32.const 0)) (i32.const 3)) + ) + (func (export "as-call-last") (result i32) + (call $f (i32.const 1) (i32.const 2) (memory.grow (i32.const 0))) + ) + + (type $sig (func (param i32 i32 i32) (result i32))) + (table funcref (elem $f)) + (func (export "as-call_indirect-first") (result i32) + (call_indirect (type $sig) + (memory.grow (i32.const 0)) (i32.const 2) (i32.const 3) (i32.const 0) + ) + ) + (func (export "as-call_indirect-mid") (result i32) + (call_indirect (type $sig) + (i32.const 1) (memory.grow (i32.const 0)) (i32.const 3) (i32.const 0) + ) + ) + (func (export "as-call_indirect-last") (result i32) + (call_indirect (type $sig) + (i32.const 1) (i32.const 2) (memory.grow (i32.const 0)) (i32.const 0) + ) + ) + (func (export "as-call_indirect-index") (result i32) + (call_indirect (type $sig) + (i32.const 1) (i32.const 2) (i32.const 3) (memory.grow (i32.const 0)) + ) + ) + + (func (export "as-local.set-value") (local i32) + (local.set 0 (memory.grow (i32.const 0))) + ) + (func (export "as-local.tee-value") (result i32) (local i32) + (local.tee 0 (memory.grow (i32.const 0))) + ) + (global $g (mut i32) (i32.const 0)) + (func (export "as-global.set-value") (local i32) + (global.set $g (memory.grow (i32.const 0))) + ) + + (func (export "as-load-address") (result i32) + (i32.load (memory.grow (i32.const 0))) + ) + (func (export "as-loadN-address") (result i32) + (i32.load8_s (memory.grow (i32.const 0))) + ) + + (func (export "as-store-address") + (i32.store (memory.grow (i32.const 0)) (i32.const 7)) + ) + (func (export "as-store-value") + (i32.store (i32.const 2) (memory.grow (i32.const 0))) + ) + + (func (export "as-storeN-address") + (i32.store8 (memory.grow (i32.const 0)) (i32.const 7)) + ) + (func (export "as-storeN-value") + (i32.store16 (i32.const 2) (memory.grow (i32.const 0))) + ) + + (func (export "as-unary-operand") (result i32) + (i32.clz (memory.grow (i32.const 0))) + ) + + (func (export "as-binary-left") (result i32) + (i32.add (memory.grow (i32.const 0)) (i32.const 10)) + ) + (func (export "as-binary-right") (result i32) + (i32.sub (i32.const 10) (memory.grow (i32.const 0))) + ) + + (func (export "as-test-operand") (result i32) + (i32.eqz (memory.grow (i32.const 0))) + ) + + (func (export "as-compare-left") (result i32) + (i32.le_s (memory.grow (i32.const 0)) (i32.const 10)) + ) + (func (export "as-compare-right") (result i32) + (i32.ne (i32.const 10) (memory.grow (i32.const 0))) + ) + + (func (export "as-memory.grow-size") (result i32) + (memory.grow (memory.grow (i32.const 0))) + ) +) + +(assert_return (invoke "as-br-value") (i32.const 1)) + +(assert_return (invoke "as-br_if-cond")) +(assert_return (invoke "as-br_if-value") (i32.const 1)) +(assert_return (invoke "as-br_if-value-cond") (i32.const 6)) + +(assert_return (invoke "as-br_table-index")) +(assert_return (invoke "as-br_table-value") (i32.const 1)) +(assert_return (invoke "as-br_table-value-index") (i32.const 6)) + +(assert_return (invoke "as-return-value") (i32.const 1)) + +(assert_return (invoke "as-if-cond") (i32.const 0)) +(assert_return (invoke "as-if-then") (i32.const 1)) +(assert_return (invoke "as-if-else") (i32.const 1)) + +(assert_return (invoke "as-select-first" (i32.const 0) (i32.const 1)) (i32.const 1)) +(assert_return (invoke "as-select-second" (i32.const 0) (i32.const 0)) (i32.const 1)) +(assert_return (invoke "as-select-cond") (i32.const 0)) + +(assert_return (invoke "as-call-first") (i32.const -1)) +(assert_return (invoke "as-call-mid") (i32.const -1)) +(assert_return (invoke "as-call-last") (i32.const -1)) + +(assert_return (invoke "as-call_indirect-first") (i32.const -1)) +(assert_return (invoke "as-call_indirect-mid") (i32.const -1)) +(assert_return (invoke "as-call_indirect-last") (i32.const -1)) +(assert_trap (invoke "as-call_indirect-index") "undefined element") + +(assert_return (invoke "as-local.set-value")) +(assert_return (invoke "as-local.tee-value") (i32.const 1)) +(assert_return (invoke "as-global.set-value")) + +(assert_return (invoke "as-load-address") (i32.const 0)) +(assert_return (invoke "as-loadN-address") (i32.const 0)) +(assert_return (invoke "as-store-address")) +(assert_return (invoke "as-store-value")) +(assert_return (invoke "as-storeN-address")) +(assert_return (invoke "as-storeN-value")) + +(assert_return (invoke "as-unary-operand") (i32.const 31)) + +(assert_return (invoke "as-binary-left") (i32.const 11)) +(assert_return (invoke "as-binary-right") (i32.const 9)) + +(assert_return (invoke "as-test-operand") (i32.const 0)) + +(assert_return (invoke "as-compare-left") (i32.const 1)) +(assert_return (invoke "as-compare-right") (i32.const 1)) + +(assert_return (invoke "as-memory.grow-size") (i32.const 1)) + + +(assert_invalid + (module + (memory 0) + (func $type-size-empty-vs-i32 (result i32) + (memory.grow) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (memory 0) + (func $type-size-empty-vs-i32-in-block (result i32) + (i32.const 0) + (block (result i32) (memory.grow)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (memory 0) + (func $type-size-empty-vs-i32-in-loop (result i32) + (i32.const 0) + (loop (result i32) (memory.grow)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (memory 0) + (func $type-size-empty-vs-i32-in-then (result i32) + (i32.const 0) (i32.const 0) + (if (result i32) (then (memory.grow))) + ) + ) + "type mismatch" +) + +(assert_invalid + (module + (memory 1) + (func $type-size-f32-vs-i32 (result i32) + (memory.grow (f32.const 0)) + ) + ) + "type mismatch" +) + +(assert_invalid + (module + (memory 1) + (func $type-result-i32-vs-empty + (memory.grow (i32.const 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (memory 1) + (func $type-result-i32-vs-f32 (result f32) + (memory.grow (i32.const 0)) + ) + ) + "type mismatch" +) diff --git a/runtime/near-vm/tests/wast/spec/proposals/reference-types/memory_init.wast b/runtime/near-vm/tests/wast/spec/proposals/reference-types/memory_init.wast new file mode 100644 index 00000000000..c647079d910 --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/proposals/reference-types/memory_init.wast @@ -0,0 +1,951 @@ +;; +;; Generated by ../meta/generate_memory_init.js +;; + +(module + (memory (export "memory0") 1 1) + (data (i32.const 2) "\03\01\04\01") + (data "\02\07\01\08") + (data (i32.const 12) "\07\05\02\03\06") + (data "\05\09\02\07\06") + (func (export "test") + (nop)) + (func (export "load8_u") (param i32) (result i32) + (i32.load8_u (local.get 0)))) + +(invoke "test") + +(assert_return (invoke "load8_u" (i32.const 0)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 1)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 2)) (i32.const 3)) +(assert_return (invoke "load8_u" (i32.const 3)) (i32.const 1)) +(assert_return (invoke "load8_u" (i32.const 4)) (i32.const 4)) +(assert_return (invoke "load8_u" (i32.const 5)) (i32.const 1)) +(assert_return (invoke "load8_u" (i32.const 6)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 7)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 8)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 9)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 10)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 11)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 12)) (i32.const 7)) +(assert_return (invoke "load8_u" (i32.const 13)) (i32.const 5)) +(assert_return (invoke "load8_u" (i32.const 14)) (i32.const 2)) +(assert_return (invoke "load8_u" (i32.const 15)) (i32.const 3)) +(assert_return (invoke "load8_u" (i32.const 16)) (i32.const 6)) +(assert_return (invoke "load8_u" (i32.const 17)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 18)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 19)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 20)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 21)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 22)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 23)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 24)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 25)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 26)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 27)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 28)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 29)) (i32.const 0)) + +(module + (memory (export "memory0") 1 1) + (data (i32.const 2) "\03\01\04\01") + (data "\02\07\01\08") + (data (i32.const 12) "\07\05\02\03\06") + (data "\05\09\02\07\06") + (func (export "test") + (memory.init 1 (i32.const 7) (i32.const 0) (i32.const 4))) + (func (export "load8_u") (param i32) (result i32) + (i32.load8_u (local.get 0)))) + +(invoke "test") + +(assert_return (invoke "load8_u" (i32.const 0)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 1)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 2)) (i32.const 3)) +(assert_return (invoke "load8_u" (i32.const 3)) (i32.const 1)) +(assert_return (invoke "load8_u" (i32.const 4)) (i32.const 4)) +(assert_return (invoke "load8_u" (i32.const 5)) (i32.const 1)) +(assert_return (invoke "load8_u" (i32.const 6)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 7)) (i32.const 2)) +(assert_return (invoke "load8_u" (i32.const 8)) (i32.const 7)) +(assert_return (invoke "load8_u" (i32.const 9)) (i32.const 1)) +(assert_return (invoke "load8_u" (i32.const 10)) (i32.const 8)) +(assert_return (invoke "load8_u" (i32.const 11)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 12)) (i32.const 7)) +(assert_return (invoke "load8_u" (i32.const 13)) (i32.const 5)) +(assert_return (invoke "load8_u" (i32.const 14)) (i32.const 2)) +(assert_return (invoke "load8_u" (i32.const 15)) (i32.const 3)) +(assert_return (invoke "load8_u" (i32.const 16)) (i32.const 6)) +(assert_return (invoke "load8_u" (i32.const 17)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 18)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 19)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 20)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 21)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 22)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 23)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 24)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 25)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 26)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 27)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 28)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 29)) (i32.const 0)) + +(module + (memory (export "memory0") 1 1) + (data (i32.const 2) "\03\01\04\01") + (data "\02\07\01\08") + (data (i32.const 12) "\07\05\02\03\06") + (data "\05\09\02\07\06") + (func (export "test") + (memory.init 3 (i32.const 15) (i32.const 1) (i32.const 3))) + (func (export "load8_u") (param i32) (result i32) + (i32.load8_u (local.get 0)))) + +(invoke "test") + +(assert_return (invoke "load8_u" (i32.const 0)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 1)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 2)) (i32.const 3)) +(assert_return (invoke "load8_u" (i32.const 3)) (i32.const 1)) +(assert_return (invoke "load8_u" (i32.const 4)) (i32.const 4)) +(assert_return (invoke "load8_u" (i32.const 5)) (i32.const 1)) +(assert_return (invoke "load8_u" (i32.const 6)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 7)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 8)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 9)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 10)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 11)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 12)) (i32.const 7)) +(assert_return (invoke "load8_u" (i32.const 13)) (i32.const 5)) +(assert_return (invoke "load8_u" (i32.const 14)) (i32.const 2)) +(assert_return (invoke "load8_u" (i32.const 15)) (i32.const 9)) +(assert_return (invoke "load8_u" (i32.const 16)) (i32.const 2)) +(assert_return (invoke "load8_u" (i32.const 17)) (i32.const 7)) +(assert_return (invoke "load8_u" (i32.const 18)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 19)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 20)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 21)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 22)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 23)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 24)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 25)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 26)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 27)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 28)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 29)) (i32.const 0)) + +(module + (memory (export "memory0") 1 1) + (data (i32.const 2) "\03\01\04\01") + (data "\02\07\01\08") + (data (i32.const 12) "\07\05\02\03\06") + (data "\05\09\02\07\06") + (func (export "test") + (memory.init 1 (i32.const 7) (i32.const 0) (i32.const 4)) + (data.drop 1) + (memory.init 3 (i32.const 15) (i32.const 1) (i32.const 3)) + (data.drop 3) + (memory.copy (i32.const 20) (i32.const 15) (i32.const 5)) + (memory.copy (i32.const 21) (i32.const 29) (i32.const 1)) + (memory.copy (i32.const 24) (i32.const 10) (i32.const 1)) + (memory.copy (i32.const 13) (i32.const 11) (i32.const 4)) + (memory.copy (i32.const 19) (i32.const 20) (i32.const 5))) + (func (export "load8_u") (param i32) (result i32) + (i32.load8_u (local.get 0)))) + +(invoke "test") + +(assert_return (invoke "load8_u" (i32.const 0)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 1)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 2)) (i32.const 3)) +(assert_return (invoke "load8_u" (i32.const 3)) (i32.const 1)) +(assert_return (invoke "load8_u" (i32.const 4)) (i32.const 4)) +(assert_return (invoke "load8_u" (i32.const 5)) (i32.const 1)) +(assert_return (invoke "load8_u" (i32.const 6)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 7)) (i32.const 2)) +(assert_return (invoke "load8_u" (i32.const 8)) (i32.const 7)) +(assert_return (invoke "load8_u" (i32.const 9)) (i32.const 1)) +(assert_return (invoke "load8_u" (i32.const 10)) (i32.const 8)) +(assert_return (invoke "load8_u" (i32.const 11)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 12)) (i32.const 7)) +(assert_return (invoke "load8_u" (i32.const 13)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 14)) (i32.const 7)) +(assert_return (invoke "load8_u" (i32.const 15)) (i32.const 5)) +(assert_return (invoke "load8_u" (i32.const 16)) (i32.const 2)) +(assert_return (invoke "load8_u" (i32.const 17)) (i32.const 7)) +(assert_return (invoke "load8_u" (i32.const 18)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 19)) (i32.const 9)) +(assert_return (invoke "load8_u" (i32.const 20)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 21)) (i32.const 7)) +(assert_return (invoke "load8_u" (i32.const 22)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 23)) (i32.const 8)) +(assert_return (invoke "load8_u" (i32.const 24)) (i32.const 8)) +(assert_return (invoke "load8_u" (i32.const 25)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 26)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 27)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 28)) (i32.const 0)) +(assert_return (invoke "load8_u" (i32.const 29)) (i32.const 0)) +(assert_invalid + (module + (func (export "test") + (data.drop 0))) + "unknown memory 0") + +(assert_invalid + (module + (memory 1) + (data "\37") + (func (export "test") + (data.drop 4))) + "unknown data segment") + +(module + (memory 1) + (data "\37") + (func (export "test") + (data.drop 0) + (data.drop 0))) +(invoke "test") + +(module + (memory 1) + (data "\37") + (func (export "test") + (data.drop 0) + (memory.init 0 (i32.const 1234) (i32.const 1) (i32.const 1)))) +(assert_trap (invoke "test") "out of bounds") + +(module + (memory 1) + (data (i32.const 0) "\37") + (func (export "test") + (memory.init 0 (i32.const 1234) (i32.const 1) (i32.const 1)))) +(assert_trap (invoke "test") "out of bounds") + +(assert_invalid + (module + (func (export "test") + (memory.init 1 (i32.const 1234) (i32.const 1) (i32.const 1)))) + "unknown memory 0") + +(assert_invalid + (module + (memory 1) + (data "\37") + (func (export "test") + (memory.init 1 (i32.const 1234) (i32.const 1) (i32.const 1)))) + "unknown data segment 1") + +(module + (memory 1) + (data "\37") + (func (export "test") + (memory.init 0 (i32.const 1) (i32.const 0) (i32.const 1)) + (memory.init 0 (i32.const 1) (i32.const 0) (i32.const 1)))) +(invoke "test") + +(module + (memory 1) + (data "\37") + (func (export "test") + (memory.init 0 (i32.const 1234) (i32.const 0) (i32.const 5)))) +(assert_trap (invoke "test") "out of bounds") + +(module + (memory 1) + (data "\37") + (func (export "test") + (memory.init 0 (i32.const 1234) (i32.const 2) (i32.const 3)))) +(assert_trap (invoke "test") "out of bounds") + +(module + (memory 1) + (data "\37") + (func (export "test") + (memory.init 0 (i32.const 0xFFFE) (i32.const 1) (i32.const 3)))) +(assert_trap (invoke "test") "out of bounds") + +(module + (memory 1) + (data "\37") + (func (export "test") + (memory.init 0 (i32.const 1234) (i32.const 4) (i32.const 0)))) +(assert_trap (invoke "test") "out of bounds") + +(module + (memory 1) + (data "\37") + (func (export "test") + (memory.init 0 (i32.const 1234) (i32.const 1) (i32.const 0)))) +(invoke "test") + +(module + (memory 1) + (data "\37") + (func (export "test") + (memory.init 0 (i32.const 0x10001) (i32.const 0) (i32.const 0)))) +(assert_trap (invoke "test") "out of bounds") + +(module + (memory 1) + (data "\37") + (func (export "test") + (memory.init 0 (i32.const 0x10000) (i32.const 0) (i32.const 0)))) +(invoke "test") + +(module + (memory 1) + (data "\37") + (func (export "test") + (memory.init 0 (i32.const 0x10000) (i32.const 1) (i32.const 0)))) +(invoke "test") + +(module + (memory 1) + (data "\37") + (func (export "test") + (memory.init 0 (i32.const 0x10001) (i32.const 4) (i32.const 0)))) +(assert_trap (invoke "test") "out of bounds") + +(assert_invalid + (module + (memory 1) + (data "\37") + (func (export "test") + (memory.init 0 (i32.const 1) (i32.const 1) (f32.const 1)))) + "type mismatch") + +(assert_invalid + (module + (memory 1) + (data "\37") + (func (export "test") + (memory.init 0 (i32.const 1) (i32.const 1) (i64.const 1)))) + "type mismatch") + +(assert_invalid + (module + (memory 1) + (data "\37") + (func (export "test") + (memory.init 0 (i32.const 1) (i32.const 1) (f64.const 1)))) + "type mismatch") + +(assert_invalid + (module + (memory 1) + (data "\37") + (func (export "test") + (memory.init 0 (i32.const 1) (f32.const 1) (i32.const 1)))) + "type mismatch") + +(assert_invalid + (module + (memory 1) + (data "\37") + (func (export "test") + (memory.init 0 (i32.const 1) (f32.const 1) (f32.const 1)))) + "type mismatch") + +(assert_invalid + (module + (memory 1) + (data "\37") + (func (export "test") + (memory.init 0 (i32.const 1) (f32.const 1) (i64.const 1)))) + "type mismatch") + +(assert_invalid + (module + (memory 1) + (data "\37") + (func (export "test") + (memory.init 0 (i32.const 1) (f32.const 1) (f64.const 1)))) + "type mismatch") + +(assert_invalid + (module + (memory 1) + (data "\37") + (func (export "test") + (memory.init 0 (i32.const 1) (i64.const 1) (i32.const 1)))) + "type mismatch") + +(assert_invalid + (module + (memory 1) + (data "\37") + (func (export "test") + (memory.init 0 (i32.const 1) (i64.const 1) (f32.const 1)))) + "type mismatch") + +(assert_invalid + (module + (memory 1) + (data "\37") + (func (export "test") + (memory.init 0 (i32.const 1) (i64.const 1) (i64.const 1)))) + "type mismatch") + +(assert_invalid + (module + (memory 1) + (data "\37") + (func (export "test") + (memory.init 0 (i32.const 1) (i64.const 1) (f64.const 1)))) + "type mismatch") + +(assert_invalid + (module + (memory 1) + (data "\37") + (func (export "test") + (memory.init 0 (i32.const 1) (f64.const 1) (i32.const 1)))) + "type mismatch") + +(assert_invalid + (module + (memory 1) + (data "\37") + (func (export "test") + (memory.init 0 (i32.const 1) (f64.const 1) (f32.const 1)))) + "type mismatch") + +(assert_invalid + (module + (memory 1) + (data "\37") + (func (export "test") + (memory.init 0 (i32.const 1) (f64.const 1) (i64.const 1)))) + "type mismatch") + +(assert_invalid + (module + (memory 1) + (data "\37") + (func (export "test") + (memory.init 0 (i32.const 1) (f64.const 1) (f64.const 1)))) + "type mismatch") + +(assert_invalid + (module + (memory 1) + (data "\37") + (func (export "test") + (memory.init 0 (f32.const 1) (i32.const 1) (i32.const 1)))) + "type mismatch") + +(assert_invalid + (module + (memory 1) + (data "\37") + (func (export "test") + (memory.init 0 (f32.const 1) (i32.const 1) (f32.const 1)))) + "type mismatch") + +(assert_invalid + (module + (memory 1) + (data "\37") + (func (export "test") + (memory.init 0 (f32.const 1) (i32.const 1) (i64.const 1)))) + "type mismatch") + +(assert_invalid + (module + (memory 1) + (data "\37") + (func (export "test") + (memory.init 0 (f32.const 1) (i32.const 1) (f64.const 1)))) + "type mismatch") + +(assert_invalid + (module + (memory 1) + (data "\37") + (func (export "test") + (memory.init 0 (f32.const 1) (f32.const 1) (i32.const 1)))) + "type mismatch") + +(assert_invalid + (module + (memory 1) + (data "\37") + (func (export "test") + (memory.init 0 (f32.const 1) (f32.const 1) (f32.const 1)))) + "type mismatch") + +(assert_invalid + (module + (memory 1) + (data "\37") + (func (export "test") + (memory.init 0 (f32.const 1) (f32.const 1) (i64.const 1)))) + "type mismatch") + +(assert_invalid + (module + (memory 1) + (data "\37") + (func (export "test") + (memory.init 0 (f32.const 1) (f32.const 1) (f64.const 1)))) + "type mismatch") + +(assert_invalid + (module + (memory 1) + (data "\37") + (func (export "test") + (memory.init 0 (f32.const 1) (i64.const 1) (i32.const 1)))) + "type mismatch") + +(assert_invalid + (module + (memory 1) + (data "\37") + (func (export "test") + (memory.init 0 (f32.const 1) (i64.const 1) (f32.const 1)))) + "type mismatch") + +(assert_invalid + (module + (memory 1) + (data "\37") + (func (export "test") + (memory.init 0 (f32.const 1) (i64.const 1) (i64.const 1)))) + "type mismatch") + +(assert_invalid + (module + (memory 1) + (data "\37") + (func (export "test") + (memory.init 0 (f32.const 1) (i64.const 1) (f64.const 1)))) + "type mismatch") + +(assert_invalid + (module + (memory 1) + (data "\37") + (func (export "test") + (memory.init 0 (f32.const 1) (f64.const 1) (i32.const 1)))) + "type mismatch") + +(assert_invalid + (module + (memory 1) + (data "\37") + (func (export "test") + (memory.init 0 (f32.const 1) (f64.const 1) (f32.const 1)))) + "type mismatch") + +(assert_invalid + (module + (memory 1) + (data "\37") + (func (export "test") + (memory.init 0 (f32.const 1) (f64.const 1) (i64.const 1)))) + "type mismatch") + +(assert_invalid + (module + (memory 1) + (data "\37") + (func (export "test") + (memory.init 0 (f32.const 1) (f64.const 1) (f64.const 1)))) + "type mismatch") + +(assert_invalid + (module + (memory 1) + (data "\37") + (func (export "test") + (memory.init 0 (i64.const 1) (i32.const 1) (i32.const 1)))) + "type mismatch") + +(assert_invalid + (module + (memory 1) + (data "\37") + (func (export "test") + (memory.init 0 (i64.const 1) (i32.const 1) (f32.const 1)))) + "type mismatch") + +(assert_invalid + (module + (memory 1) + (data "\37") + (func (export "test") + (memory.init 0 (i64.const 1) (i32.const 1) (i64.const 1)))) + "type mismatch") + +(assert_invalid + (module + (memory 1) + (data "\37") + (func (export "test") + (memory.init 0 (i64.const 1) (i32.const 1) (f64.const 1)))) + "type mismatch") + +(assert_invalid + (module + (memory 1) + (data "\37") + (func (export "test") + (memory.init 0 (i64.const 1) (f32.const 1) (i32.const 1)))) + "type mismatch") + +(assert_invalid + (module + (memory 1) + (data "\37") + (func (export "test") + (memory.init 0 (i64.const 1) (f32.const 1) (f32.const 1)))) + "type mismatch") + +(assert_invalid + (module + (memory 1) + (data "\37") + (func (export "test") + (memory.init 0 (i64.const 1) (f32.const 1) (i64.const 1)))) + "type mismatch") + +(assert_invalid + (module + (memory 1) + (data "\37") + (func (export "test") + (memory.init 0 (i64.const 1) (f32.const 1) (f64.const 1)))) + "type mismatch") + +(assert_invalid + (module + (memory 1) + (data "\37") + (func (export "test") + (memory.init 0 (i64.const 1) (i64.const 1) (i32.const 1)))) + "type mismatch") + +(assert_invalid + (module + (memory 1) + (data "\37") + (func (export "test") + (memory.init 0 (i64.const 1) (i64.const 1) (f32.const 1)))) + "type mismatch") + +(assert_invalid + (module + (memory 1) + (data "\37") + (func (export "test") + (memory.init 0 (i64.const 1) (i64.const 1) (i64.const 1)))) + "type mismatch") + +(assert_invalid + (module + (memory 1) + (data "\37") + (func (export "test") + (memory.init 0 (i64.const 1) (i64.const 1) (f64.const 1)))) + "type mismatch") + +(assert_invalid + (module + (memory 1) + (data "\37") + (func (export "test") + (memory.init 0 (i64.const 1) (f64.const 1) (i32.const 1)))) + "type mismatch") + +(assert_invalid + (module + (memory 1) + (data "\37") + (func (export "test") + (memory.init 0 (i64.const 1) (f64.const 1) (f32.const 1)))) + "type mismatch") + +(assert_invalid + (module + (memory 1) + (data "\37") + (func (export "test") + (memory.init 0 (i64.const 1) (f64.const 1) (i64.const 1)))) + "type mismatch") + +(assert_invalid + (module + (memory 1) + (data "\37") + (func (export "test") + (memory.init 0 (i64.const 1) (f64.const 1) (f64.const 1)))) + "type mismatch") + +(assert_invalid + (module + (memory 1) + (data "\37") + (func (export "test") + (memory.init 0 (f64.const 1) (i32.const 1) (i32.const 1)))) + "type mismatch") + +(assert_invalid + (module + (memory 1) + (data "\37") + (func (export "test") + (memory.init 0 (f64.const 1) (i32.const 1) (f32.const 1)))) + "type mismatch") + +(assert_invalid + (module + (memory 1) + (data "\37") + (func (export "test") + (memory.init 0 (f64.const 1) (i32.const 1) (i64.const 1)))) + "type mismatch") + +(assert_invalid + (module + (memory 1) + (data "\37") + (func (export "test") + (memory.init 0 (f64.const 1) (i32.const 1) (f64.const 1)))) + "type mismatch") + +(assert_invalid + (module + (memory 1) + (data "\37") + (func (export "test") + (memory.init 0 (f64.const 1) (f32.const 1) (i32.const 1)))) + "type mismatch") + +(assert_invalid + (module + (memory 1) + (data "\37") + (func (export "test") + (memory.init 0 (f64.const 1) (f32.const 1) (f32.const 1)))) + "type mismatch") + +(assert_invalid + (module + (memory 1) + (data "\37") + (func (export "test") + (memory.init 0 (f64.const 1) (f32.const 1) (i64.const 1)))) + "type mismatch") + +(assert_invalid + (module + (memory 1) + (data "\37") + (func (export "test") + (memory.init 0 (f64.const 1) (f32.const 1) (f64.const 1)))) + "type mismatch") + +(assert_invalid + (module + (memory 1) + (data "\37") + (func (export "test") + (memory.init 0 (f64.const 1) (i64.const 1) (i32.const 1)))) + "type mismatch") + +(assert_invalid + (module + (memory 1) + (data "\37") + (func (export "test") + (memory.init 0 (f64.const 1) (i64.const 1) (f32.const 1)))) + "type mismatch") + +(assert_invalid + (module + (memory 1) + (data "\37") + (func (export "test") + (memory.init 0 (f64.const 1) (i64.const 1) (i64.const 1)))) + "type mismatch") + +(assert_invalid + (module + (memory 1) + (data "\37") + (func (export "test") + (memory.init 0 (f64.const 1) (i64.const 1) (f64.const 1)))) + "type mismatch") + +(assert_invalid + (module + (memory 1) + (data "\37") + (func (export "test") + (memory.init 0 (f64.const 1) (f64.const 1) (i32.const 1)))) + "type mismatch") + +(assert_invalid + (module + (memory 1) + (data "\37") + (func (export "test") + (memory.init 0 (f64.const 1) (f64.const 1) (f32.const 1)))) + "type mismatch") + +(assert_invalid + (module + (memory 1) + (data "\37") + (func (export "test") + (memory.init 0 (f64.const 1) (f64.const 1) (i64.const 1)))) + "type mismatch") + +(assert_invalid + (module + (memory 1) + (data "\37") + (func (export "test") + (memory.init 0 (f64.const 1) (f64.const 1) (f64.const 1)))) + "type mismatch") + +(module + (memory 1 1 ) + (data "\42\42\42\42\42\42\42\42\42\42\42\42\42\42\42\42") + + (func (export "checkRange") (param $from i32) (param $to i32) (param $expected i32) (result i32) + (loop $cont + (if (i32.eq (local.get $from) (local.get $to)) + (then + (return (i32.const -1)))) + (if (i32.eq (i32.load8_u (local.get $from)) (local.get $expected)) + (then + (local.set $from (i32.add (local.get $from) (i32.const 1))) + (br $cont)))) + (return (local.get $from))) + + (func (export "run") (param $offs i32) (param $len i32) + (memory.init 0 (local.get $offs) (i32.const 0) (local.get $len)))) + +(assert_trap (invoke "run" (i32.const 65528) (i32.const 16)) + "out of bounds") + +(assert_return (invoke "checkRange" (i32.const 0) (i32.const 1) (i32.const 0)) + (i32.const -1)) +(module + (memory 1 1 ) + (data "\42\42\42\42\42\42\42\42\42\42\42\42\42\42\42\42") + + (func (export "checkRange") (param $from i32) (param $to i32) (param $expected i32) (result i32) + (loop $cont + (if (i32.eq (local.get $from) (local.get $to)) + (then + (return (i32.const -1)))) + (if (i32.eq (i32.load8_u (local.get $from)) (local.get $expected)) + (then + (local.set $from (i32.add (local.get $from) (i32.const 1))) + (br $cont)))) + (return (local.get $from))) + + (func (export "run") (param $offs i32) (param $len i32) + (memory.init 0 (local.get $offs) (i32.const 0) (local.get $len)))) + +(assert_trap (invoke "run" (i32.const 65527) (i32.const 16)) + "out of bounds") + +(assert_return (invoke "checkRange" (i32.const 0) (i32.const 1) (i32.const 0)) + (i32.const -1)) +(module + (memory 1 1 ) + (data "\42\42\42\42\42\42\42\42\42\42\42\42\42\42\42\42") + + (func (export "checkRange") (param $from i32) (param $to i32) (param $expected i32) (result i32) + (loop $cont + (if (i32.eq (local.get $from) (local.get $to)) + (then + (return (i32.const -1)))) + (if (i32.eq (i32.load8_u (local.get $from)) (local.get $expected)) + (then + (local.set $from (i32.add (local.get $from) (i32.const 1))) + (br $cont)))) + (return (local.get $from))) + + (func (export "run") (param $offs i32) (param $len i32) + (memory.init 0 (local.get $offs) (i32.const 0) (local.get $len)))) + +(assert_trap (invoke "run" (i32.const 65472) (i32.const 30)) + "out of bounds") + +(assert_return (invoke "checkRange" (i32.const 0) (i32.const 1) (i32.const 0)) + (i32.const -1)) +(module + (memory 1 1 ) + (data "\42\42\42\42\42\42\42\42\42\42\42\42\42\42\42\42") + + (func (export "checkRange") (param $from i32) (param $to i32) (param $expected i32) (result i32) + (loop $cont + (if (i32.eq (local.get $from) (local.get $to)) + (then + (return (i32.const -1)))) + (if (i32.eq (i32.load8_u (local.get $from)) (local.get $expected)) + (then + (local.set $from (i32.add (local.get $from) (i32.const 1))) + (br $cont)))) + (return (local.get $from))) + + (func (export "run") (param $offs i32) (param $len i32) + (memory.init 0 (local.get $offs) (i32.const 0) (local.get $len)))) + +(assert_trap (invoke "run" (i32.const 65473) (i32.const 31)) + "out of bounds") + +(assert_return (invoke "checkRange" (i32.const 0) (i32.const 1) (i32.const 0)) + (i32.const -1)) +(module + (memory 1 ) + (data "\42\42\42\42\42\42\42\42\42\42\42\42\42\42\42\42") + + (func (export "checkRange") (param $from i32) (param $to i32) (param $expected i32) (result i32) + (loop $cont + (if (i32.eq (local.get $from) (local.get $to)) + (then + (return (i32.const -1)))) + (if (i32.eq (i32.load8_u (local.get $from)) (local.get $expected)) + (then + (local.set $from (i32.add (local.get $from) (i32.const 1))) + (br $cont)))) + (return (local.get $from))) + + (func (export "run") (param $offs i32) (param $len i32) + (memory.init 0 (local.get $offs) (i32.const 0) (local.get $len)))) + +(assert_trap (invoke "run" (i32.const 65528) (i32.const 4294967040)) + "out of bounds") + +(assert_return (invoke "checkRange" (i32.const 0) (i32.const 1) (i32.const 0)) + (i32.const -1)) +(module + (memory 1 ) + (data "\42\42\42\42\42\42\42\42\42\42\42\42\42\42\42\42") + + (func (export "checkRange") (param $from i32) (param $to i32) (param $expected i32) (result i32) + (loop $cont + (if (i32.eq (local.get $from) (local.get $to)) + (then + (return (i32.const -1)))) + (if (i32.eq (i32.load8_u (local.get $from)) (local.get $expected)) + (then + (local.set $from (i32.add (local.get $from) (i32.const 1))) + (br $cont)))) + (return (local.get $from))) + + (func (export "run") (param $offs i32) (param $len i32) + (memory.init 0 (local.get $offs) (i32.const 0) (local.get $len)))) + +(assert_trap (invoke "run" (i32.const 0) (i32.const 4294967292)) + "out of bounds") + +(assert_return (invoke "checkRange" (i32.const 0) (i32.const 1) (i32.const 0)) + (i32.const -1)) diff --git a/runtime/near-vm/tests/wast/spec/proposals/reference-types/ref_func.wast b/runtime/near-vm/tests/wast/spec/proposals/reference-types/ref_func.wast new file mode 100644 index 00000000000..e9033a3b04d --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/proposals/reference-types/ref_func.wast @@ -0,0 +1,86 @@ +(module + (func (export "f") (param $x i32) (result i32) (local.get $x)) +) +(register "M") + +(module + (func $f (import "M" "f") (param i32) (result i32)) + (func $g (param $x i32) (result i32) + (i32.add (local.get $x) (i32.const 1)) + ) + + (global anyref (ref.func $f)) + (global anyref (ref.func $g)) + (global funcref (ref.func $f)) + (global funcref (ref.func $g)) + (global $v (mut funcref) (ref.func $f)) + + (global funcref (ref.func $gf1)) + (global funcref (ref.func $gf2)) + (func (drop (ref.func $ff1)) (drop (ref.func $ff2))) + (elem declare func $gf1 $ff1) + (elem declare funcref (ref.func $gf2) (ref.func $ff2)) + (func $gf1) + (func $gf2) + (func $ff1) + (func $ff2) + + (func (export "is_null-f") (result i32) + (ref.is_null (ref.func $f)) + ) + (func (export "is_null-g") (result i32) + (ref.is_null (ref.func $g)) + ) + (func (export "is_null-v") (result i32) + (ref.is_null (global.get $v)) + ) + + (func (export "set-f") (global.set $v (ref.func $f))) + (func (export "set-g") (global.set $v (ref.func $g))) + + (table $t 1 funcref) + (elem declare func $f $g) + + (func (export "call-f") (param $x i32) (result i32) + (table.set $t (i32.const 0) (ref.func $f)) + (call_indirect $t (param i32) (result i32) (local.get $x) (i32.const 0)) + ) + (func (export "call-g") (param $x i32) (result i32) + (table.set $t (i32.const 0) (ref.func $g)) + (call_indirect $t (param i32) (result i32) (local.get $x) (i32.const 0)) + ) + (func (export "call-v") (param $x i32) (result i32) + (table.set $t (i32.const 0) (global.get $v)) + (call_indirect $t (param i32) (result i32) (local.get $x) (i32.const 0)) + ) +) + +(assert_return (invoke "is_null-f") (i32.const 0)) +(assert_return (invoke "is_null-g") (i32.const 0)) +(assert_return (invoke "is_null-v") (i32.const 0)) + +(assert_return (invoke "call-f" (i32.const 4)) (i32.const 4)) +(assert_return (invoke "call-g" (i32.const 4)) (i32.const 5)) +(assert_return (invoke "call-v" (i32.const 4)) (i32.const 4)) +(invoke "set-g") +(assert_return (invoke "call-v" (i32.const 4)) (i32.const 5)) +(invoke "set-f") +(assert_return (invoke "call-v" (i32.const 4)) (i32.const 4)) + +(assert_invalid + (module + (func $f (import "M" "f") (param i32) (result i32)) + (func $g (import "M" "g") (param i32) (result i32)) + (global funcref (ref.func 7)) + ) + "unknown function 7" +) + +(assert_invalid + (module (func $f) (global funcref (ref.func $f))) + "undeclared function reference" +) +(assert_invalid + (module (func $f (drop (ref.func $f)))) + "undeclared function reference" +) diff --git a/runtime/near-vm/tests/wast/spec/proposals/reference-types/ref_is_null.wast b/runtime/near-vm/tests/wast/spec/proposals/reference-types/ref_is_null.wast new file mode 100644 index 00000000000..7a42ca7d5d3 --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/proposals/reference-types/ref_is_null.wast @@ -0,0 +1,62 @@ +(module + (func $f1 (export "nullref") (param $x nullref) (result i32) + (ref.is_null (local.get $x)) + ) + (func $f2 (export "anyref") (param $x anyref) (result i32) + (ref.is_null (local.get $x)) + ) + (func $f3 (export "funcref") (param $x funcref) (result i32) + (ref.is_null (local.get $x)) + ) + + (table $t1 2 nullref) + (table $t2 2 anyref) + (table $t3 2 funcref) + (elem (table $t3) (i32.const 1) func $dummy) + (func $dummy) + + (func (export "init") (param $r anyref) + (table.set $t2 (i32.const 1) (local.get $r)) + ) + (func (export "deinit") + (table.set $t1 (i32.const 1) (ref.null)) + (table.set $t2 (i32.const 1) (ref.null)) + (table.set $t3 (i32.const 1) (ref.null)) + ) + + (func (export "nullref-elem") (param $x i32) (result i32) + (call $f1 (table.get $t1 (local.get $x))) + ) + (func (export "anyref-elem") (param $x i32) (result i32) + (call $f2 (table.get $t2 (local.get $x))) + ) + (func (export "funcref-elem") (param $x i32) (result i32) + (call $f3 (table.get $t3 (local.get $x))) + ) +) + +(assert_return (invoke "nullref" (ref.null)) (i32.const 1)) +(assert_return (invoke "anyref" (ref.null)) (i32.const 1)) +(assert_return (invoke "funcref" (ref.null)) (i32.const 1)) + +(assert_return (invoke "anyref" (ref.host 1)) (i32.const 0)) + +(invoke "init" (ref.host 0)) + +(assert_return (invoke "nullref-elem" (i32.const 0)) (i32.const 1)) +(assert_return (invoke "anyref-elem" (i32.const 0)) (i32.const 1)) +(assert_return (invoke "funcref-elem" (i32.const 0)) (i32.const 1)) + +(assert_return (invoke "nullref-elem" (i32.const 1)) (i32.const 1)) +(assert_return (invoke "anyref-elem" (i32.const 1)) (i32.const 0)) +(assert_return (invoke "funcref-elem" (i32.const 1)) (i32.const 0)) + +(invoke "deinit") + +(assert_return (invoke "nullref-elem" (i32.const 0)) (i32.const 1)) +(assert_return (invoke "anyref-elem" (i32.const 0)) (i32.const 1)) +(assert_return (invoke "funcref-elem" (i32.const 0)) (i32.const 1)) + +(assert_return (invoke "nullref-elem" (i32.const 0)) (i32.const 1)) +(assert_return (invoke "anyref-elem" (i32.const 1)) (i32.const 1)) +(assert_return (invoke "funcref-elem" (i32.const 1)) (i32.const 1)) diff --git a/runtime/near-vm/tests/wast/spec/proposals/reference-types/ref_null.wast b/runtime/near-vm/tests/wast/spec/proposals/reference-types/ref_null.wast new file mode 100644 index 00000000000..96cac314adc --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/proposals/reference-types/ref_null.wast @@ -0,0 +1,13 @@ +(module + (func (export "anyref") (result anyref) (ref.null)) + (func (export "funcref") (result funcref) (ref.null)) + (func (export "nullref") (result nullref) (ref.null)) + + (global anyref (ref.null)) + (global funcref (ref.null)) + (global nullref (ref.null)) +) + +(assert_return (invoke "anyref") (ref.null)) +(assert_return (invoke "funcref") (ref.null)) +(assert_return (invoke "nullref") (ref.null)) diff --git a/runtime/near-vm/tests/wast/spec/proposals/reference-types/select.wast b/runtime/near-vm/tests/wast/spec/proposals/reference-types/select.wast new file mode 100644 index 00000000000..267dd573896 --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/proposals/reference-types/select.wast @@ -0,0 +1,529 @@ +(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-nullref") (param nullref nullref i32) (result nullref) + (select (result nullref) (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-anyref") (param anyref anyref i32) (result anyref) + (select (result anyref) (local.get 0) (local.get 1) (local.get 2)) + ) + + (func (export "join-nullref") (param i32) (result anyref) + (select (result nullref) (ref.null) (ref.null) (local.get 0)) + ) + (func (export "join-funcref") (param i32) (result anyref) + (select (result funcref) + (table.get $tab (i32.const 0)) + (ref.null) + (local.get 0) + ) + ) + (func (export "join-anyref") (param i32) (param anyref) (result anyref) + (select (result anyref) + (table.get $tab (i32.const 0)) + (local.get 1) + (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) (f32.const 0) (i32.const 0) (select) + (unreachable) + ) + + + ;; 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-nullref" (ref.null) (ref.null) (i32.const 1)) (ref.null)) +(assert_return (invoke "select-funcref" (ref.null) (ref.null) (i32.const 1)) (ref.null)) +(assert_return (invoke "select-anyref" (ref.host 1) (ref.host 2) (i32.const 1)) (ref.host 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-anyref" (ref.host 1) (ref.host 2) (i32.const 0)) (ref.host 2)) +(assert_return (invoke "select-anyref" (ref.host 2) (ref.host 1) (i32.const 0)) (ref.host 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-nullref" (i32.const 1)) (ref.null)) +(assert_return (invoke "join-nullref" (i32.const 0)) (ref.null)) + +(assert_return (invoke "join-funcref" (i32.const 1)) (ref.func)) +(assert_return (invoke "join-funcref" (i32.const 0)) (ref.null)) + +(assert_return (invoke "join-anyref" (i32.const 1) (ref.host 1)) (ref.func)) +(assert_return (invoke "join-anyref" (i32.const 0) (ref.host 1)) (ref.host 1)) + +(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 (func $type-nullref-implicit + (drop (select (ref.null) (ref.null) (i32.const 1))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-anyref-implicit (param $r anyref) + (drop (select (local.get $r) (local.get $r) (i32.const 1))) + )) + "type mismatch" +) + +(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-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" +) diff --git a/runtime/near-vm/tests/wast/spec/proposals/reference-types/table-sub.wast b/runtime/near-vm/tests/wast/spec/proposals/reference-types/table-sub.wast new file mode 100644 index 00000000000..66f183108b7 --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/proposals/reference-types/table-sub.wast @@ -0,0 +1,31 @@ +(module + (table $t1 10 anyref) + (table $t2 10 funcref) + (elem $el funcref) + (func $f + (table.init $t1 $el (i32.const 0) (i32.const 1) (i32.const 2)) + (table.copy $t1 $t2 (i32.const 0) (i32.const 1) (i32.const 2)) + ) +) + +(assert_invalid + (module + (table $t1 10 funcref) + (table $t2 10 anyref) + (func $f + (table.copy $t1 $t2 (i32.const 0) (i32.const 1) (i32.const 2)) + ) + ) + "type mismatch" +) + +(assert_invalid + (module + (table $t 10 funcref) + (elem $el anyref) + (func $f + (table.init $t $el (i32.const 0) (i32.const 1) (i32.const 2)) + ) + ) + "type mismatch" +) diff --git a/runtime/near-vm/tests/wast/spec/proposals/reference-types/table_copy.wast b/runtime/near-vm/tests/wast/spec/proposals/reference-types/table_copy.wast new file mode 100644 index 00000000000..d0aa77b2050 --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/proposals/reference-types/table_copy.wast @@ -0,0 +1,1595 @@ +;; +;; Generated by ../meta/generate_table_copy.js +;; + +(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 + (import "a" "ef0" (func (result i32))) ;; index 0 + (import "a" "ef1" (func (result i32))) + (import "a" "ef2" (func (result i32))) + (import "a" "ef3" (func (result i32))) + (import "a" "ef4" (func (result i32))) ;; index 4 + (table 30 30 funcref) + (elem (i32.const 2) 3 1 4 1) + (elem funcref + (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8)) + (elem (i32.const 12) 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") + (nop)) + (func (export "check") (param i32) (result i32) + (call_indirect (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 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 + (import "a" "ef0" (func (result i32))) ;; index 0 + (import "a" "ef1" (func (result i32))) + (import "a" "ef2" (func (result i32))) + (import "a" "ef3" (func (result i32))) + (import "a" "ef4" (func (result i32))) ;; index 4 + (table 30 30 funcref) + (elem (i32.const 2) 3 1 4 1) + (elem funcref + (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8)) + (elem (i32.const 12) 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.copy (i32.const 13) (i32.const 2) (i32.const 3))) + (func (export "check") (param i32) (result i32) + (call_indirect (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 3)) +(assert_return (invoke "check" (i32.const 14)) (i32.const 1)) +(assert_return (invoke "check" (i32.const 15)) (i32.const 4)) +(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 + (import "a" "ef0" (func (result i32))) ;; index 0 + (import "a" "ef1" (func (result i32))) + (import "a" "ef2" (func (result i32))) + (import "a" "ef3" (func (result i32))) + (import "a" "ef4" (func (result i32))) ;; index 4 + (table 30 30 funcref) + (elem (i32.const 2) 3 1 4 1) + (elem funcref + (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8)) + (elem (i32.const 12) 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.copy (i32.const 25) (i32.const 15) (i32.const 2))) + (func (export "check") (param i32) (result i32) + (call_indirect (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 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_return (invoke "check" (i32.const 25)) (i32.const 3)) +(assert_return (invoke "check" (i32.const 26)) (i32.const 6)) +(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 + (import "a" "ef0" (func (result i32))) ;; index 0 + (import "a" "ef1" (func (result i32))) + (import "a" "ef2" (func (result i32))) + (import "a" "ef3" (func (result i32))) + (import "a" "ef4" (func (result i32))) ;; index 4 + (table 30 30 funcref) + (elem (i32.const 2) 3 1 4 1) + (elem funcref + (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8)) + (elem (i32.const 12) 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.copy (i32.const 13) (i32.const 25) (i32.const 3))) + (func (export "check") (param i32) (result i32) + (call_indirect (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_trap (invoke "check" (i32.const 13)) "uninitialized element") +(assert_trap (invoke "check" (i32.const 14)) "uninitialized element") +(assert_trap (invoke "check" (i32.const 15)) "uninitialized element") +(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 + (import "a" "ef0" (func (result i32))) ;; index 0 + (import "a" "ef1" (func (result i32))) + (import "a" "ef2" (func (result i32))) + (import "a" "ef3" (func (result i32))) + (import "a" "ef4" (func (result i32))) ;; index 4 + (table 30 30 funcref) + (elem (i32.const 2) 3 1 4 1) + (elem funcref + (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8)) + (elem (i32.const 12) 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.copy (i32.const 20) (i32.const 22) (i32.const 4))) + (func (export "check") (param i32) (result i32) + (call_indirect (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 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 + (import "a" "ef0" (func (result i32))) ;; index 0 + (import "a" "ef1" (func (result i32))) + (import "a" "ef2" (func (result i32))) + (import "a" "ef3" (func (result i32))) + (import "a" "ef4" (func (result i32))) ;; index 4 + (table 30 30 funcref) + (elem (i32.const 2) 3 1 4 1) + (elem funcref + (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8)) + (elem (i32.const 12) 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.copy (i32.const 25) (i32.const 1) (i32.const 3))) + (func (export "check") (param i32) (result i32) + (call_indirect (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 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_return (invoke "check" (i32.const 26)) (i32.const 3)) +(assert_return (invoke "check" (i32.const 27)) (i32.const 1)) +(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 + (import "a" "ef0" (func (result i32))) ;; index 0 + (import "a" "ef1" (func (result i32))) + (import "a" "ef2" (func (result i32))) + (import "a" "ef3" (func (result i32))) + (import "a" "ef4" (func (result i32))) ;; index 4 + (table 30 30 funcref) + (elem (i32.const 2) 3 1 4 1) + (elem funcref + (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8)) + (elem (i32.const 12) 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.copy (i32.const 10) (i32.const 12) (i32.const 7))) + (func (export "check") (param i32) (result i32) + (call_indirect (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_return (invoke "check" (i32.const 10)) (i32.const 7)) +(assert_return (invoke "check" (i32.const 11)) (i32.const 5)) +(assert_return (invoke "check" (i32.const 12)) (i32.const 2)) +(assert_return (invoke "check" (i32.const 13)) (i32.const 3)) +(assert_return (invoke "check" (i32.const 14)) (i32.const 6)) +(assert_trap (invoke "check" (i32.const 15)) "uninitialized element") +(assert_trap (invoke "check" (i32.const 16)) "uninitialized element") +(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 + (import "a" "ef0" (func (result i32))) ;; index 0 + (import "a" "ef1" (func (result i32))) + (import "a" "ef2" (func (result i32))) + (import "a" "ef3" (func (result i32))) + (import "a" "ef4" (func (result i32))) ;; index 4 + (table 30 30 funcref) + (elem (i32.const 2) 3 1 4 1) + (elem funcref + (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8)) + (elem (i32.const 12) 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.copy (i32.const 12) (i32.const 10) (i32.const 7))) + (func (export "check") (param i32) (result i32) + (call_indirect (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_trap (invoke "check" (i32.const 12)) "uninitialized element") +(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 3)) +(assert_return (invoke "check" (i32.const 18)) (i32.const 6)) +(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 + (table 30 30 funcref) + (elem (i32.const 2) 3 1 4 1) + (elem funcref + (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8)) + (elem (i32.const 12) 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.copy (i32.const 28) (i32.const 1) (i32.const 3)) + )) + +(assert_trap (invoke "test") "out of bounds") + +(module + (table 30 30 funcref) + (elem (i32.const 2) 3 1 4 1) + (elem funcref + (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8)) + (elem (i32.const 12) 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.copy (i32.const 0xFFFFFFFE) (i32.const 1) (i32.const 2)) + )) + +(assert_trap (invoke "test") "out of bounds") + +(module + (table 30 30 funcref) + (elem (i32.const 2) 3 1 4 1) + (elem funcref + (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8)) + (elem (i32.const 12) 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.copy (i32.const 15) (i32.const 25) (i32.const 6)) + )) + +(assert_trap (invoke "test") "out of bounds") + +(module + (table 30 30 funcref) + (elem (i32.const 2) 3 1 4 1) + (elem funcref + (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8)) + (elem (i32.const 12) 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.copy (i32.const 15) (i32.const 0xFFFFFFFE) (i32.const 2)) + )) + +(assert_trap (invoke "test") "out of bounds") + +(module + (table 30 30 funcref) + (elem (i32.const 2) 3 1 4 1) + (elem funcref + (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8)) + (elem (i32.const 12) 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.copy (i32.const 15) (i32.const 25) (i32.const 0)) + )) + +(invoke "test") + +(module + (table 30 30 funcref) + (elem (i32.const 2) 3 1 4 1) + (elem funcref + (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8)) + (elem (i32.const 12) 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.copy (i32.const 30) (i32.const 15) (i32.const 0)) + )) + +(invoke "test") + +(module + (table 30 30 funcref) + (elem (i32.const 2) 3 1 4 1) + (elem funcref + (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8)) + (elem (i32.const 12) 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.copy (i32.const 31) (i32.const 15) (i32.const 0)) + )) + +(assert_trap (invoke "test") "out of bounds") + +(module + (table 30 30 funcref) + (elem (i32.const 2) 3 1 4 1) + (elem funcref + (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8)) + (elem (i32.const 12) 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.copy (i32.const 15) (i32.const 30) (i32.const 0)) + )) + +(invoke "test") + +(module + (table 30 30 funcref) + (elem (i32.const 2) 3 1 4 1) + (elem funcref + (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8)) + (elem (i32.const 12) 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.copy (i32.const 15) (i32.const 31) (i32.const 0)) + )) + +(assert_trap (invoke "test") "out of bounds") + +(module + (table 30 30 funcref) + (elem (i32.const 2) 3 1 4 1) + (elem funcref + (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8)) + (elem (i32.const 12) 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.copy (i32.const 30) (i32.const 30) (i32.const 0)) + )) + +(invoke "test") + +(module + (table 30 30 funcref) + (elem (i32.const 2) 3 1 4 1) + (elem funcref + (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8)) + (elem (i32.const 12) 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.copy (i32.const 31) (i32.const 31) (i32.const 0)) + )) + +(assert_trap (invoke "test") "out of bounds") + +(module + (type (func (result i32))) + (table 32 64 funcref) + (elem (i32.const 0) + $f0 $f1 $f2 $f3 $f4 $f5 $f6 $f7) + (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 $targetOffs i32) (param $srcOffs i32) (param $len i32) + (table.copy (local.get $targetOffs) (local.get $srcOffs) (local.get $len)))) + +(assert_trap (invoke "run" (i32.const 24) (i32.const 0) (i32.const 16)) + "out of bounds") +(assert_return (invoke "test" (i32.const 0)) (i32.const 0)) +(assert_return (invoke "test" (i32.const 1)) (i32.const 1)) +(assert_return (invoke "test" (i32.const 2)) (i32.const 2)) +(assert_return (invoke "test" (i32.const 3)) (i32.const 3)) +(assert_return (invoke "test" (i32.const 4)) (i32.const 4)) +(assert_return (invoke "test" (i32.const 5)) (i32.const 5)) +(assert_return (invoke "test" (i32.const 6)) (i32.const 6)) +(assert_return (invoke "test" (i32.const 7)) (i32.const 7)) +(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 (i32.const 0) + $f0 $f1 $f2 $f3 $f4 $f5 $f6 $f7 $f8) + (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 $targetOffs i32) (param $srcOffs i32) (param $len i32) + (table.copy (local.get $targetOffs) (local.get $srcOffs) (local.get $len)))) + +(assert_trap (invoke "run" (i32.const 23) (i32.const 0) (i32.const 15)) + "out of bounds") +(assert_return (invoke "test" (i32.const 0)) (i32.const 0)) +(assert_return (invoke "test" (i32.const 1)) (i32.const 1)) +(assert_return (invoke "test" (i32.const 2)) (i32.const 2)) +(assert_return (invoke "test" (i32.const 3)) (i32.const 3)) +(assert_return (invoke "test" (i32.const 4)) (i32.const 4)) +(assert_return (invoke "test" (i32.const 5)) (i32.const 5)) +(assert_return (invoke "test" (i32.const 6)) (i32.const 6)) +(assert_return (invoke "test" (i32.const 7)) (i32.const 7)) +(assert_return (invoke "test" (i32.const 8)) (i32.const 8)) +(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 (i32.const 24) + $f0 $f1 $f2 $f3 $f4 $f5 $f6 $f7) + (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 $targetOffs i32) (param $srcOffs i32) (param $len i32) + (table.copy (local.get $targetOffs) (local.get $srcOffs) (local.get $len)))) + +(assert_trap (invoke "run" (i32.const 0) (i32.const 24) (i32.const 16)) + "out of bounds") +(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_return (invoke "test" (i32.const 24)) (i32.const 0)) +(assert_return (invoke "test" (i32.const 25)) (i32.const 1)) +(assert_return (invoke "test" (i32.const 26)) (i32.const 2)) +(assert_return (invoke "test" (i32.const 27)) (i32.const 3)) +(assert_return (invoke "test" (i32.const 28)) (i32.const 4)) +(assert_return (invoke "test" (i32.const 29)) (i32.const 5)) +(assert_return (invoke "test" (i32.const 30)) (i32.const 6)) +(assert_return (invoke "test" (i32.const 31)) (i32.const 7)) + +(module + (type (func (result i32))) + (table 32 64 funcref) + (elem (i32.const 23) + $f0 $f1 $f2 $f3 $f4 $f5 $f6 $f7 $f8) + (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 $targetOffs i32) (param $srcOffs i32) (param $len i32) + (table.copy (local.get $targetOffs) (local.get $srcOffs) (local.get $len)))) + +(assert_trap (invoke "run" (i32.const 0) (i32.const 23) (i32.const 15)) + "out of bounds") +(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_return (invoke "test" (i32.const 23)) (i32.const 0)) +(assert_return (invoke "test" (i32.const 24)) (i32.const 1)) +(assert_return (invoke "test" (i32.const 25)) (i32.const 2)) +(assert_return (invoke "test" (i32.const 26)) (i32.const 3)) +(assert_return (invoke "test" (i32.const 27)) (i32.const 4)) +(assert_return (invoke "test" (i32.const 28)) (i32.const 5)) +(assert_return (invoke "test" (i32.const 29)) (i32.const 6)) +(assert_return (invoke "test" (i32.const 30)) (i32.const 7)) +(assert_return (invoke "test" (i32.const 31)) (i32.const 8)) + +(module + (type (func (result i32))) + (table 32 64 funcref) + (elem (i32.const 11) + $f0 $f1 $f2 $f3 $f4 $f5 $f6 $f7) + (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 $targetOffs i32) (param $srcOffs i32) (param $len i32) + (table.copy (local.get $targetOffs) (local.get $srcOffs) (local.get $len)))) + +(assert_trap (invoke "run" (i32.const 24) (i32.const 11) (i32.const 16)) + "out of bounds") +(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_return (invoke "test" (i32.const 11)) (i32.const 0)) +(assert_return (invoke "test" (i32.const 12)) (i32.const 1)) +(assert_return (invoke "test" (i32.const 13)) (i32.const 2)) +(assert_return (invoke "test" (i32.const 14)) (i32.const 3)) +(assert_return (invoke "test" (i32.const 15)) (i32.const 4)) +(assert_return (invoke "test" (i32.const 16)) (i32.const 5)) +(assert_return (invoke "test" (i32.const 17)) (i32.const 6)) +(assert_return (invoke "test" (i32.const 18)) (i32.const 7)) +(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 (i32.const 24) + $f0 $f1 $f2 $f3 $f4 $f5 $f6 $f7) + (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 $targetOffs i32) (param $srcOffs i32) (param $len i32) + (table.copy (local.get $targetOffs) (local.get $srcOffs) (local.get $len)))) + +(assert_trap (invoke "run" (i32.const 11) (i32.const 24) (i32.const 16)) + "out of bounds") +(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_return (invoke "test" (i32.const 24)) (i32.const 0)) +(assert_return (invoke "test" (i32.const 25)) (i32.const 1)) +(assert_return (invoke "test" (i32.const 26)) (i32.const 2)) +(assert_return (invoke "test" (i32.const 27)) (i32.const 3)) +(assert_return (invoke "test" (i32.const 28)) (i32.const 4)) +(assert_return (invoke "test" (i32.const 29)) (i32.const 5)) +(assert_return (invoke "test" (i32.const 30)) (i32.const 6)) +(assert_return (invoke "test" (i32.const 31)) (i32.const 7)) + +(module + (type (func (result i32))) + (table 32 64 funcref) + (elem (i32.const 21) + $f0 $f1 $f2 $f3 $f4 $f5 $f6 $f7) + (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 $targetOffs i32) (param $srcOffs i32) (param $len i32) + (table.copy (local.get $targetOffs) (local.get $srcOffs) (local.get $len)))) + +(assert_trap (invoke "run" (i32.const 24) (i32.const 21) (i32.const 16)) + "out of bounds") +(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_return (invoke "test" (i32.const 21)) (i32.const 0)) +(assert_return (invoke "test" (i32.const 22)) (i32.const 1)) +(assert_return (invoke "test" (i32.const 23)) (i32.const 2)) +(assert_return (invoke "test" (i32.const 24)) (i32.const 3)) +(assert_return (invoke "test" (i32.const 25)) (i32.const 4)) +(assert_return (invoke "test" (i32.const 26)) (i32.const 5)) +(assert_return (invoke "test" (i32.const 27)) (i32.const 6)) +(assert_return (invoke "test" (i32.const 28)) (i32.const 7)) +(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 (i32.const 24) + $f0 $f1 $f2 $f3 $f4 $f5 $f6 $f7) + (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 $targetOffs i32) (param $srcOffs i32) (param $len i32) + (table.copy (local.get $targetOffs) (local.get $srcOffs) (local.get $len)))) + +(assert_trap (invoke "run" (i32.const 21) (i32.const 24) (i32.const 16)) + "out of bounds") +(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_return (invoke "test" (i32.const 24)) (i32.const 0)) +(assert_return (invoke "test" (i32.const 25)) (i32.const 1)) +(assert_return (invoke "test" (i32.const 26)) (i32.const 2)) +(assert_return (invoke "test" (i32.const 27)) (i32.const 3)) +(assert_return (invoke "test" (i32.const 28)) (i32.const 4)) +(assert_return (invoke "test" (i32.const 29)) (i32.const 5)) +(assert_return (invoke "test" (i32.const 30)) (i32.const 6)) +(assert_return (invoke "test" (i32.const 31)) (i32.const 7)) + +(module + (type (func (result i32))) + (table 32 64 funcref) + (elem (i32.const 21) + $f0 $f1 $f2 $f3 $f4 $f5 $f6 $f7 $f8 $f9 $f10) + (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 $targetOffs i32) (param $srcOffs i32) (param $len i32) + (table.copy (local.get $targetOffs) (local.get $srcOffs) (local.get $len)))) + +(assert_trap (invoke "run" (i32.const 21) (i32.const 21) (i32.const 16)) + "out of bounds") +(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_return (invoke "test" (i32.const 21)) (i32.const 0)) +(assert_return (invoke "test" (i32.const 22)) (i32.const 1)) +(assert_return (invoke "test" (i32.const 23)) (i32.const 2)) +(assert_return (invoke "test" (i32.const 24)) (i32.const 3)) +(assert_return (invoke "test" (i32.const 25)) (i32.const 4)) +(assert_return (invoke "test" (i32.const 26)) (i32.const 5)) +(assert_return (invoke "test" (i32.const 27)) (i32.const 6)) +(assert_return (invoke "test" (i32.const 28)) (i32.const 7)) +(assert_return (invoke "test" (i32.const 29)) (i32.const 8)) +(assert_return (invoke "test" (i32.const 30)) (i32.const 9)) +(assert_return (invoke "test" (i32.const 31)) (i32.const 10)) + +(module + (type (func (result i32))) + (table 128 128 funcref) + (elem (i32.const 112) + $f0 $f1 $f2 $f3 $f4 $f5 $f6 $f7 $f8 $f9 $f10 $f11 $f12 $f13 $f14 $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 $targetOffs i32) (param $srcOffs i32) (param $len i32) + (table.copy (local.get $targetOffs) (local.get $srcOffs) (local.get $len)))) + +(assert_trap (invoke "run" (i32.const 0) (i32.const 112) (i32.const 4294967264)) + "out of bounds") +(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_return (invoke "test" (i32.const 112)) (i32.const 0)) +(assert_return (invoke "test" (i32.const 113)) (i32.const 1)) +(assert_return (invoke "test" (i32.const 114)) (i32.const 2)) +(assert_return (invoke "test" (i32.const 115)) (i32.const 3)) +(assert_return (invoke "test" (i32.const 116)) (i32.const 4)) +(assert_return (invoke "test" (i32.const 117)) (i32.const 5)) +(assert_return (invoke "test" (i32.const 118)) (i32.const 6)) +(assert_return (invoke "test" (i32.const 119)) (i32.const 7)) +(assert_return (invoke "test" (i32.const 120)) (i32.const 8)) +(assert_return (invoke "test" (i32.const 121)) (i32.const 9)) +(assert_return (invoke "test" (i32.const 122)) (i32.const 10)) +(assert_return (invoke "test" (i32.const 123)) (i32.const 11)) +(assert_return (invoke "test" (i32.const 124)) (i32.const 12)) +(assert_return (invoke "test" (i32.const 125)) (i32.const 13)) +(assert_return (invoke "test" (i32.const 126)) (i32.const 14)) +(assert_return (invoke "test" (i32.const 127)) (i32.const 15)) + +(module + (type (func (result i32))) + (table 128 128 funcref) + (elem (i32.const 0) + $f0 $f1 $f2 $f3 $f4 $f5 $f6 $f7 $f8 $f9 $f10 $f11 $f12 $f13 $f14 $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 $targetOffs i32) (param $srcOffs i32) (param $len i32) + (table.copy (local.get $targetOffs) (local.get $srcOffs) (local.get $len)))) + +(assert_trap (invoke "run" (i32.const 112) (i32.const 0) (i32.const 4294967264)) + "out of bounds") +(assert_return (invoke "test" (i32.const 0)) (i32.const 0)) +(assert_return (invoke "test" (i32.const 1)) (i32.const 1)) +(assert_return (invoke "test" (i32.const 2)) (i32.const 2)) +(assert_return (invoke "test" (i32.const 3)) (i32.const 3)) +(assert_return (invoke "test" (i32.const 4)) (i32.const 4)) +(assert_return (invoke "test" (i32.const 5)) (i32.const 5)) +(assert_return (invoke "test" (i32.const 6)) (i32.const 6)) +(assert_return (invoke "test" (i32.const 7)) (i32.const 7)) +(assert_return (invoke "test" (i32.const 8)) (i32.const 8)) +(assert_return (invoke "test" (i32.const 9)) (i32.const 9)) +(assert_return (invoke "test" (i32.const 10)) (i32.const 10)) +(assert_return (invoke "test" (i32.const 11)) (i32.const 11)) +(assert_return (invoke "test" (i32.const 12)) (i32.const 12)) +(assert_return (invoke "test" (i32.const 13)) (i32.const 13)) +(assert_return (invoke "test" (i32.const 14)) (i32.const 14)) +(assert_return (invoke "test" (i32.const 15)) (i32.const 15)) +(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") diff --git a/runtime/near-vm/tests/wast/spec/proposals/reference-types/table_fill.wast b/runtime/near-vm/tests/wast/spec/proposals/reference-types/table_fill.wast new file mode 100644 index 00000000000..7aff20246cb --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/proposals/reference-types/table_fill.wast @@ -0,0 +1,153 @@ +(module + (table $t 10 anyref) + + (func (export "fill") (param $i i32) (param $r anyref) (param $n i32) + (table.fill $t (local.get $i) (local.get $r) (local.get $n)) + ) + + (func (export "get") (param $i i32) (result anyref) + (table.get $t (local.get $i)) + ) +) + +(assert_return (invoke "get" (i32.const 1)) (ref.null)) +(assert_return (invoke "get" (i32.const 2)) (ref.null)) +(assert_return (invoke "get" (i32.const 3)) (ref.null)) +(assert_return (invoke "get" (i32.const 4)) (ref.null)) +(assert_return (invoke "get" (i32.const 5)) (ref.null)) + +(assert_return (invoke "fill" (i32.const 2) (ref.host 1) (i32.const 3))) +(assert_return (invoke "get" (i32.const 1)) (ref.null)) +(assert_return (invoke "get" (i32.const 2)) (ref.host 1)) +(assert_return (invoke "get" (i32.const 3)) (ref.host 1)) +(assert_return (invoke "get" (i32.const 4)) (ref.host 1)) +(assert_return (invoke "get" (i32.const 5)) (ref.null)) + +(assert_return (invoke "fill" (i32.const 4) (ref.host 2) (i32.const 2))) +(assert_return (invoke "get" (i32.const 3)) (ref.host 1)) +(assert_return (invoke "get" (i32.const 4)) (ref.host 2)) +(assert_return (invoke "get" (i32.const 5)) (ref.host 2)) +(assert_return (invoke "get" (i32.const 6)) (ref.null)) + +(assert_return (invoke "fill" (i32.const 4) (ref.host 3) (i32.const 0))) +(assert_return (invoke "get" (i32.const 3)) (ref.host 1)) +(assert_return (invoke "get" (i32.const 4)) (ref.host 2)) +(assert_return (invoke "get" (i32.const 5)) (ref.host 2)) + +(assert_return (invoke "fill" (i32.const 8) (ref.host 4) (i32.const 2))) +(assert_return (invoke "get" (i32.const 7)) (ref.null)) +(assert_return (invoke "get" (i32.const 8)) (ref.host 4)) +(assert_return (invoke "get" (i32.const 9)) (ref.host 4)) + +(assert_return (invoke "fill" (i32.const 9) (ref.null) (i32.const 1))) +(assert_return (invoke "get" (i32.const 8)) (ref.host 4)) +(assert_return (invoke "get" (i32.const 9)) (ref.null)) + +(assert_return (invoke "fill" (i32.const 10) (ref.host 5) (i32.const 0))) +(assert_return (invoke "get" (i32.const 9)) (ref.null)) + +(assert_trap + (invoke "fill" (i32.const 8) (ref.host 6) (i32.const 3)) + "out of bounds" +) +(assert_return (invoke "get" (i32.const 7)) (ref.null)) +(assert_return (invoke "get" (i32.const 8)) (ref.host 4)) +(assert_return (invoke "get" (i32.const 9)) (ref.null)) + +(assert_trap + (invoke "fill" (i32.const 11) (ref.null) (i32.const 0)) + "out of bounds" +) + +(assert_trap + (invoke "fill" (i32.const 11) (ref.null) (i32.const 10)) + "out of bounds" +) + + +;; Type errors + +(assert_invalid + (module + (table $t 10 anyref) + (func $type-index-value-length-empty-vs-i32-i32 + (table.fill $t) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (table $t 10 anyref) + (func $type-index-empty-vs-i32 + (table.fill $t (ref.null) (i32.const 1)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (table $t 10 anyref) + (func $type-value-empty-vs + (table.fill $t (i32.const 1) (i32.const 1)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (table $t 10 anyref) + (func $type-length-empty-vs-i32 + (table.fill $t (i32.const 1) (ref.null)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (table $t 0 anyref) + (func $type-index-f32-vs-i32 + (table.fill $t (f32.const 1) (ref.null) (i32.const 1)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (table $t 0 funcref) + (func $type-value-vs-funcref (param $r anyref) + (table.fill $t (i32.const 1) (local.get $r) (i32.const 1)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (table $t 0 anyref) + (func $type-length-f32-vs-i32 + (table.fill $t (i32.const 1) (ref.null) (f32.const 1)) + ) + ) + "type mismatch" +) + +(assert_invalid + (module + (table $t1 1 anyref) + (table $t2 1 funcref) + (func $type-value-anyref-vs-funcref-multi (param $r anyref) + (table.fill $t2 (i32.const 0) (local.get $r) (i32.const 1)) + ) + ) + "type mismatch" +) + +(assert_invalid + (module + (table $t 1 anyref) + (func $type-result-empty-vs-num (result i32) + (table.fill $t (i32.const 0) (ref.null) (i32.const 1)) + ) + ) + "type mismatch" +) diff --git a/runtime/near-vm/tests/wast/spec/proposals/reference-types/table_get.wast b/runtime/near-vm/tests/wast/spec/proposals/reference-types/table_get.wast new file mode 100644 index 00000000000..c95fce7232d --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/proposals/reference-types/table_get.wast @@ -0,0 +1,88 @@ +(module + (table $t2 2 anyref) + (table $t3 3 funcref) + (elem (table $t3) (i32.const 1) func $dummy) + (func $dummy) + + (func (export "init") (param $r anyref) + (table.set $t2 (i32.const 1) (local.get $r)) + (table.set $t3 (i32.const 2) (table.get $t3 (i32.const 1))) + ) + + (func (export "get-anyref") (param $i i32) (result anyref) + (table.get $t2 (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.host 1)) + +(assert_return (invoke "get-anyref" (i32.const 0)) (ref.null)) +(assert_return (invoke "get-anyref" (i32.const 1)) (ref.host 1)) + +(assert_return (invoke "get-funcref" (i32.const 0)) (ref.null)) +(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-anyref" (i32.const 2)) "out of bounds") +(assert_trap (invoke "get-funcref" (i32.const 3)) "out of bounds") +(assert_trap (invoke "get-anyref" (i32.const -1)) "out of bounds") +(assert_trap (invoke "get-funcref" (i32.const -1)) "out of bounds") + + +;; Type errors + +(assert_invalid + (module + (table $t 10 anyref) + (func $type-index-empty-vs-i32 (result anyref) + (table.get $t) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (table $t 10 anyref) + (func $type-index-f32-vs-i32 (result anyref) + (table.get $t (f32.const 1)) + ) + ) + "type mismatch" +) + +(assert_invalid + (module + (table $t 10 anyref) + (func $type-result-anyref-vs-empty + (table.get $t (i32.const 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (table $t 10 anyref) + (func $type-result-anyref-vs-funcref (result funcref) + (table.get $t (i32.const 1)) + ) + ) + "type mismatch" +) + +(assert_invalid + (module + (table $t1 1 funcref) + (table $t2 1 anyref) + (func $type-result-anyref-vs-funcref-multi (result funcref) + (table.get $t2 (i32.const 0)) + ) + ) + "type mismatch" +) diff --git a/runtime/near-vm/tests/wast/spec/proposals/reference-types/table_grow.wast b/runtime/near-vm/tests/wast/spec/proposals/reference-types/table_grow.wast new file mode 100644 index 00000000000..91fc096f450 --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/proposals/reference-types/table_grow.wast @@ -0,0 +1,173 @@ +(module + (table $t 0 anyref) + + (func (export "get") (param $i i32) (result anyref) (table.get $t (local.get $i))) + (func (export "set") (param $i i32) (param $r anyref) (table.set $t (local.get $i) (local.get $r))) + + (func (export "grow") (param $sz i32) (param $init anyref) (result i32) + (table.grow $t (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.host 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)) (i32.const 0)) +(assert_return (invoke "size") (i32.const 1)) +(assert_return (invoke "get" (i32.const 0)) (ref.null)) +(assert_return (invoke "set" (i32.const 0) (ref.host 2))) +(assert_return (invoke "get" (i32.const 0)) (ref.host 2)) +(assert_trap (invoke "set" (i32.const 1) (ref.host 2)) "out of bounds table access") +(assert_trap (invoke "get" (i32.const 1)) "out of bounds table access") + +(assert_return (invoke "grow" (i32.const 4) (ref.host 3)) (i32.const 1)) +(assert_return (invoke "size") (i32.const 5)) +(assert_return (invoke "get" (i32.const 0)) (ref.host 2)) +(assert_return (invoke "set" (i32.const 0) (ref.host 2))) +(assert_return (invoke "get" (i32.const 0)) (ref.host 2)) +(assert_return (invoke "get" (i32.const 1)) (ref.host 3)) +(assert_return (invoke "get" (i32.const 4)) (ref.host 3)) +(assert_return (invoke "set" (i32.const 4) (ref.host 4))) +(assert_return (invoke "get" (i32.const 4)) (ref.host 4)) +(assert_trap (invoke "set" (i32.const 5) (ref.host 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 anyref) + (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 anyref) + (func (export "grow") (param i32) (result i32) + (table.grow $t (ref.null) (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 anyref) + (func (export "grow") (param i32) (result i32) + (table.grow $t (ref.null) (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 anyref) + (func (export "grow") (param i32) (result i32) + (table.grow $t (ref.null) (local.get 0)) + ) + (elem declare func 1) + (func (export "check-table-null") (param i32 i32) (result anyref) + (local anyref) + (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)) +(assert_return (invoke "grow" (i32.const 10)) (i32.const 10)) +(assert_return (invoke "check-table-null" (i32.const 0) (i32.const 19)) (ref.null)) + + +;; Type errors + +(assert_invalid + (module + (table $t 0 anyref) + (func $type-init-size-empty-vs-i32-anyref (result i32) + (table.grow $t) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (table $t 0 anyref) + (func $type-size-empty-vs-i32 (result i32) + (table.grow $t (ref.null)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (table $t 0 anyref) + (func $type-init-empty-vs-anyref (result i32) + (table.grow $t (i32.const 1)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (table $t 0 anyref) + (func $type-size-f32-vs-i32 (result i32) + (table.grow $t (ref.null) (f32.const 1)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (table $t 0 funcref) + (func $type-init-anyref-vs-funcref (param $r anyref) (result i32) + (table.grow $t (local.get $r) (i32.const 1)) + ) + ) + "type mismatch" +) + +(assert_invalid + (module + (table $t 1 anyref) + (func $type-result-i32-vs-empty + (table.grow $t (ref.null) (i32.const 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (table $t 1 anyref) + (func $type-result-i32-vs-f32 (result f32) + (table.grow $t (ref.null) (i32.const 0)) + ) + ) + "type mismatch" +) diff --git a/runtime/near-vm/tests/wast/spec/proposals/reference-types/table_init.wast b/runtime/near-vm/tests/wast/spec/proposals/reference-types/table_init.wast new file mode 100644 index 00000000000..80eaf065d8c --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/proposals/reference-types/table_init.wast @@ -0,0 +1,1752 @@ +;; +;; Generated by ../meta/generate_table_init.js +;; + +(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 + (import "a" "ef0" (func (result i32))) ;; index 0 + (import "a" "ef1" (func (result i32))) + (import "a" "ef2" (func (result i32))) + (import "a" "ef3" (func (result i32))) + (import "a" "ef4" (func (result i32))) ;; index 4 + (table 30 30 funcref) + (elem (i32.const 2) 3 1 4 1) + (elem funcref + (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8)) + (elem (i32.const 12) 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 1 (i32.const 7) (i32.const 0) (i32.const 4))) + (func (export "check") (param i32) (result i32) + (call_indirect (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 + (import "a" "ef0" (func (result i32))) ;; index 0 + (import "a" "ef1" (func (result i32))) + (import "a" "ef2" (func (result i32))) + (import "a" "ef3" (func (result i32))) + (import "a" "ef4" (func (result i32))) ;; index 4 + (table 30 30 funcref) + (elem (i32.const 2) 3 1 4 1) + (elem funcref + (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8)) + (elem (i32.const 12) 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 3 (i32.const 15) (i32.const 1) (i32.const 3))) + (func (export "check") (param i32) (result i32) + (call_indirect (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 + (import "a" "ef0" (func (result i32))) ;; index 0 + (import "a" "ef1" (func (result i32))) + (import "a" "ef2" (func (result i32))) + (import "a" "ef3" (func (result i32))) + (import "a" "ef4" (func (result i32))) ;; index 4 + (table 30 30 funcref) + (elem (i32.const 2) 3 1 4 1) + (elem funcref + (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8)) + (elem (i32.const 12) 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 1 (i32.const 7) (i32.const 0) (i32.const 4)) + (elem.drop 1) + (table.init 3 (i32.const 15) (i32.const 1) (i32.const 3)) + (elem.drop 3) + (table.copy (i32.const 20) (i32.const 15) (i32.const 5)) + (table.copy (i32.const 21) (i32.const 29) (i32.const 1)) + (table.copy (i32.const 24) (i32.const 10) (i32.const 1)) + (table.copy (i32.const 13) (i32.const 11) (i32.const 4)) + (table.copy (i32.const 19) (i32.const 20) (i32.const 5))) + (func (export "check") (param i32) (result i32) + (call_indirect (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 table 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 table 0") + +(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 30 30 funcref) + (elem (i32.const 2) 3 1 4 1) + (elem funcref + (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8)) + (elem (i32.const 12) 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 30 30 funcref) + (elem (i32.const 2) 3 1 4 1) + (elem funcref + (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8)) + (elem (i32.const 12) 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") + +(module + (table 30 30 funcref) + (elem (i32.const 2) 3 1 4 1) + (elem funcref + (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8)) + (elem (i32.const 12) 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 30 30 funcref) + (elem (i32.const 2) 3 1 4 1) + (elem funcref + (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8)) + (elem (i32.const 12) 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 30 30 funcref) + (elem (i32.const 2) 3 1 4 1) + (elem funcref + (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8)) + (elem (i32.const 12) 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") + +(module + (table 30 30 funcref) + (elem (i32.const 2) 3 1 4 1) + (elem funcref + (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8)) + (elem (i32.const 12) 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") + +(module + (table 30 30 funcref) + (elem (i32.const 2) 3 1 4 1) + (elem funcref + (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8)) + (elem (i32.const 12) 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") + +(module + (table 30 30 funcref) + (elem (i32.const 2) 3 1 4 1) + (elem funcref + (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8)) + (elem (i32.const 12) 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 28) (i32.const 1) (i32.const 3)) + )) +(assert_trap (invoke "test") "out of bounds") + +(module + (table 30 30 funcref) + (elem (i32.const 2) 3 1 4 1) + (elem funcref + (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8)) + (elem (i32.const 12) 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 4) (i32.const 0)) + )) +(invoke "test") + +(module + (table 30 30 funcref) + (elem (i32.const 2) 3 1 4 1) + (elem funcref + (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8)) + (elem (i32.const 12) 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 5) (i32.const 0)) + )) +(assert_trap (invoke "test") "out of bounds") + +(module + (table 30 30 funcref) + (elem (i32.const 2) 3 1 4 1) + (elem funcref + (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8)) + (elem (i32.const 12) 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 30) (i32.const 2) (i32.const 0)) + )) +(invoke "test") + +(module + (table 30 30 funcref) + (elem (i32.const 2) 3 1 4 1) + (elem funcref + (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8)) + (elem (i32.const 12) 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 31) (i32.const 2) (i32.const 0)) + )) +(assert_trap (invoke "test") "out of bounds") + +(module + (table 30 30 funcref) + (elem (i32.const 2) 3 1 4 1) + (elem funcref + (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8)) + (elem (i32.const 12) 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 30) (i32.const 4) (i32.const 0)) + )) +(invoke "test") + +(module + (table 30 30 funcref) + (elem (i32.const 2) 3 1 4 1) + (elem funcref + (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8)) + (elem (i32.const 12) 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 31) (i32.const 5) (i32.const 0)) + )) +(assert_trap (invoke "test") "out of bounds") + +(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") +(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") +(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") +(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") +(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") +(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") +(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") diff --git a/runtime/near-vm/tests/wast/spec/proposals/reference-types/table_set.wast b/runtime/near-vm/tests/wast/spec/proposals/reference-types/table_set.wast new file mode 100644 index 00000000000..848830e2fb3 --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/proposals/reference-types/table_set.wast @@ -0,0 +1,119 @@ +(module + (table $t2 1 anyref) + (table $t3 2 funcref) + (elem (table $t3) (i32.const 1) func $dummy) + (func $dummy) + + (func (export "get-anyref") (param $i i32) (result anyref) + (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-anyref") (param $i i32) (param $r anyref) + (table.set $t2 (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-anyref" (i32.const 0)) (ref.null)) +(assert_return (invoke "set-anyref" (i32.const 0) (ref.host 1))) +(assert_return (invoke "get-anyref" (i32.const 0)) (ref.host 1)) +(assert_return (invoke "set-anyref" (i32.const 0) (ref.null))) +(assert_return (invoke "get-anyref" (i32.const 0)) (ref.null)) + +(assert_return (invoke "get-funcref" (i32.const 0)) (ref.null)) +(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))) +(assert_return (invoke "get-funcref" (i32.const 0)) (ref.null)) + +(assert_trap (invoke "set-anyref" (i32.const 2) (ref.null)) "out of bounds") +(assert_trap (invoke "set-funcref" (i32.const 3) (ref.null)) "out of bounds") +(assert_trap (invoke "set-anyref" (i32.const -1) (ref.null)) "out of bounds") +(assert_trap (invoke "set-funcref" (i32.const -1) (ref.null)) "out of bounds") + +(assert_trap (invoke "set-anyref" (i32.const 2) (ref.host 0)) "out of bounds") +(assert_trap (invoke "set-funcref-from" (i32.const 3) (i32.const 1)) "out of bounds") +(assert_trap (invoke "set-anyref" (i32.const -1) (ref.host 0)) "out of bounds") +(assert_trap (invoke "set-funcref-from" (i32.const -1) (i32.const 1)) "out of bounds") + + +;; Type errors + +(assert_invalid + (module + (table $t 10 anyref) + (func $type-index-value-empty-vs-i32-anyref + (table.set $t) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (table $t 10 anyref) + (func $type-index-empty-vs-i32 + (table.set $t (ref.null)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (table $t 10 anyref) + (func $type-value-empty-vs-anyref + (table.set $t (i32.const 1)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (table $t 10 anyref) + (func $type-size-f32-vs-i32 + (table.set $t (f32.const 1) (ref.null)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (table $t 10 funcref) + (func $type-value-anyref-vs-funcref (param $r anyref) + (table.set $t (i32.const 1) (local.get $r)) + ) + ) + "type mismatch" +) + +(assert_invalid + (module + (table $t1 1 anyref) + (table $t2 1 funcref) + (func $type-value-anyref-vs-funcref-multi (param $r anyref) + (table.set $t2 (i32.const 0) (local.get $r)) + ) + ) + "type mismatch" +) + +(assert_invalid + (module + (table $t 10 anyref) + (func $type-result-empty-vs-num (result i32) + (table.set $t (i32.const 0) (ref.null)) + ) + ) + "type mismatch" +) diff --git a/runtime/near-vm/tests/wast/spec/proposals/reference-types/table_size.wast b/runtime/near-vm/tests/wast/spec/proposals/reference-types/table_size.wast new file mode 100644 index 00000000000..5817104a4c5 --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/proposals/reference-types/table_size.wast @@ -0,0 +1,86 @@ +(module + (table $t0 0 anyref) + (table $t1 1 anyref) + (table $t2 0 2 anyref) + (table $t3 3 8 anyref) + + (func (export "size-t0") (result i32) (table.size $t0)) + (func (export "size-t1") (result i32) (table.size $t1)) + (func (export "size-t2") (result i32) (table.size $t2)) + (func (export "size-t3") (result i32) (table.size $t3)) + + (func (export "grow-t0") (param $sz i32) + (drop (table.grow $t0 (ref.null) (local.get $sz))) + ) + (func (export "grow-t1") (param $sz i32) + (drop (table.grow $t1 (ref.null) (local.get $sz))) + ) + (func (export "grow-t2") (param $sz i32) + (drop (table.grow $t2 (ref.null) (local.get $sz))) + ) + (func (export "grow-t3") (param $sz i32) + (drop (table.grow $t3 (ref.null) (local.get $sz))) + ) +) + +(assert_return (invoke "size-t0") (i32.const 0)) +(assert_return (invoke "grow-t0" (i32.const 1))) +(assert_return (invoke "size-t0") (i32.const 1)) +(assert_return (invoke "grow-t0" (i32.const 4))) +(assert_return (invoke "size-t0") (i32.const 5)) +(assert_return (invoke "grow-t0" (i32.const 0))) +(assert_return (invoke "size-t0") (i32.const 5)) + +(assert_return (invoke "size-t1") (i32.const 1)) +(assert_return (invoke "grow-t1" (i32.const 1))) +(assert_return (invoke "size-t1") (i32.const 2)) +(assert_return (invoke "grow-t1" (i32.const 4))) +(assert_return (invoke "size-t1") (i32.const 6)) +(assert_return (invoke "grow-t1" (i32.const 0))) +(assert_return (invoke "size-t1") (i32.const 6)) + +(assert_return (invoke "size-t2") (i32.const 0)) +(assert_return (invoke "grow-t2" (i32.const 3))) +(assert_return (invoke "size-t2") (i32.const 0)) +(assert_return (invoke "grow-t2" (i32.const 1))) +(assert_return (invoke "size-t2") (i32.const 1)) +(assert_return (invoke "grow-t2" (i32.const 0))) +(assert_return (invoke "size-t2") (i32.const 1)) +(assert_return (invoke "grow-t2" (i32.const 4))) +(assert_return (invoke "size-t2") (i32.const 1)) +(assert_return (invoke "grow-t2" (i32.const 1))) +(assert_return (invoke "size-t2") (i32.const 2)) + +(assert_return (invoke "size-t3") (i32.const 3)) +(assert_return (invoke "grow-t3" (i32.const 1))) +(assert_return (invoke "size-t3") (i32.const 4)) +(assert_return (invoke "grow-t3" (i32.const 3))) +(assert_return (invoke "size-t3") (i32.const 7)) +(assert_return (invoke "grow-t3" (i32.const 0))) +(assert_return (invoke "size-t3") (i32.const 7)) +(assert_return (invoke "grow-t3" (i32.const 2))) +(assert_return (invoke "size-t3") (i32.const 7)) +(assert_return (invoke "grow-t3" (i32.const 1))) +(assert_return (invoke "size-t3") (i32.const 8)) + + +;; Type errors + +(assert_invalid + (module + (table $t 1 anyref) + (func $type-result-i32-vs-empty + (table.size $t) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (table $t 1 anyref) + (func $type-result-i32-vs-f32 (result f32) + (table.size $t) + ) + ) + "type mismatch" +) diff --git a/runtime/near-vm/tests/wast/spec/proposals/reference-types/unreached-invalid.wast b/runtime/near-vm/tests/wast/spec/proposals/reference-types/unreached-invalid.wast new file mode 100644 index 00000000000..3ddd77385f3 --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/proposals/reference-types/unreached-invalid.wast @@ -0,0 +1,695 @@ +;; Failures in unreachable code. + +(assert_invalid + (module (func $local-index (unreachable) (drop (local.get 0)))) + "unknown local" +) +(assert_invalid + (module (func $global-index (unreachable) (drop (global.get 0)))) + "unknown global" +) +(assert_invalid + (module (func $func-index (unreachable) (call 1))) + "unknown function" +) +(assert_invalid + (module (func $label-index (unreachable) (br 1))) + "unknown label" +) + +(assert_invalid + (module (func $type-num-vs-num + (unreachable) (drop (i64.eqz (i32.const 0)))) + ) + "type mismatch" +) +(assert_invalid + (module (func $type-poly-num-vs-num (result i32) + (unreachable) (i64.const 0) (i32.const 0) (select) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-poly-transitive-num-vs-num (result i32) + (unreachable) + (i64.const 0) (i32.const 0) (select) + (i32.const 0) (i32.const 0) (select) + )) + "type mismatch" +) + +(assert_invalid + (module (func $type-unconsumed-const (unreachable) (i32.const 0))) + "type mismatch" +) +(assert_invalid + (module (func $type-unconsumed-result (unreachable) (i32.eqz))) + "type mismatch" +) +(assert_invalid + (module (func $type-unconsumed-result2 + (unreachable) (i32.const 0) (i32.add) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-unconsumed-poly0 (unreachable) (select))) + "type mismatch" +) +(assert_invalid + (module (func $type-unconsumed-poly1 (unreachable) (i32.const 0) (select))) + "type mismatch" +) +(assert_invalid + (module (func $type-unconsumed-poly2 + (unreachable) (i32.const 0) (i32.const 0) (select) + )) + "type mismatch" +) + +(assert_invalid + (module (func $type-unary-num-vs-void-after-break + (block (br 0) (block (drop (i32.eqz (nop))))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-unary-num-vs-num-after-break + (block (br 0) (drop (i32.eqz (f32.const 1)))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-binary-num-vs-void-after-break + (block (br 0) (block (drop (f32.eq (i32.const 1))))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-binary-num-vs-num-after-break + (block (br 0) (drop (f32.eq (i32.const 1) (f32.const 0)))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-block-value-num-vs-void-after-break + (block (br 0) (i32.const 1)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-block-value-num-vs-num-after-break (result i32) + (block (result i32) (i32.const 1) (br 0) (f32.const 0)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-loop-value-num-vs-void-after-break + (block (loop (br 1) (i32.const 1))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-loop-value-num-vs-num-after-break (result i32) + (loop (result i32) (br 1 (i32.const 1)) (f32.const 0)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-func-value-num-vs-void-after-break + (br 0) (i32.const 1) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-func-value-num-vs-num-after-break (result i32) + (br 0 (i32.const 1)) (f32.const 0) + )) + "type mismatch" +) + +(assert_invalid + (module (func $type-unary-num-vs-void-after-return + (return) (block (drop (i32.eqz (nop)))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-unary-num-vs-num-after-return + (return) (drop (i32.eqz (f32.const 1))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-binary-num-vs-void-after-return + (return) (block (drop (f32.eq (i32.const 1)))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-binary-num-vs-num-after-return + (return) (drop (f32.eq (i32.const 1) (f32.const 0))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-block-value-num-vs-void-after-return + (block (return) (i32.const 1)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-block-value-num-vs-num-after-return (result i32) + (block (result i32) (i32.const 1) (return (i32.const 0)) (f32.const 0)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-loop-value-num-vs-void-after-return + (block (loop (return) (i32.const 1))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-loop-value-num-vs-num-after-return (result i32) + (loop (result i32) (return (i32.const 1)) (f32.const 0)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-func-value-num-vs-void-after-return + (return) (i32.const 1) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-func-value-num-vs-num-after-return (result i32) + (return (i32.const 1)) (f32.const 0) + )) + "type mismatch" +) + +(assert_invalid + (module (func $type-unary-num-vs-void-after-unreachable + (unreachable) (block (drop (i32.eqz (nop)))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-unary-num-vs-void-in-loop-after-unreachable + (unreachable) (loop (drop (i32.eqz (nop)))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-unary-num-vs-void-in-i32-loop-after-unreachable + (unreachable) (loop (result i32) (i32.eqz (nop))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-unary-num-vs-num-after-unreachable + (unreachable) (drop (i32.eqz (f32.const 1))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-binary-num-vs-void-after-unreachable + (unreachable) (block (drop (f32.eq (i32.const 1)))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-binary-num-vs-num-after-unreachable + (unreachable) (drop (f32.eq (i32.const 1) (f32.const 0))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-block-value-num-vs-void-after-unreachable + (block (unreachable) (i32.const 1)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-block-value-num-vs-num-after-unreachable (result i32) + (block (result i32) (i32.const 1) (unreachable) (f32.const 0)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-loop-value-num-vs-void-after-unreachable + (block (loop (unreachable) (i32.const 1))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-loop-value-num-vs-num-after-unreachable (result i32) + (loop (result i32) (unreachable) (f32.const 0)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-func-value-num-vs-void-after-unreachable + (unreachable) (i32.const 1) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-func-value-num-vs-num-after-unreachable (result i32) + (unreachable) (f32.const 0) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-unary-num-vs-void-in-if-after-unreachable + (unreachable) (if (i32.const 0) (then (drop (i32.eqz (nop))))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-unary-num-vs-void-in-else-after-unreachable + (unreachable) (if (i32.const 0) (then (nop)) (else (drop (i32.eqz (nop))))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-unary-num-vs-void-in-else-after-unreachable-if + (if (i32.const 0) (then (unreachable)) (else (drop (i32.eqz (nop))))) + )) + "type mismatch" +) + +(assert_invalid + (module (func $type-unary-num-vs-void-after-nested-unreachable + (block (unreachable)) (block (drop (i32.eqz (nop)))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-unary-num-vs-num-after-nested-unreachable + (block (unreachable)) (drop (i32.eqz (f32.const 1))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-binary-num-vs-void-after-nested-unreachable + (block (unreachable)) (block (drop (f32.eq (i32.const 1)))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-binary-num-vs-num-after-nested-unreachable + (block (unreachable)) (drop (f32.eq (i32.const 1) (f32.const 0))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-block-value-num-vs-void-after-nested-unreachable + (block (block (unreachable)) (i32.const 1)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-block-value-num-vs-num-after-nested-unreachable + (result i32) + (block (result i32) (i32.const 1) (block (unreachable)) (f32.const 0)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-loop-value-num-vs-void-after-nested-unreachable + (block (loop (block (unreachable)) (i32.const 1))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-loop-value-num-vs-num-after-nested-unreachable + (result i32) + (loop (result i32) (block (unreachable)) (f32.const 0)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-func-value-num-vs-void-after-nested-unreachable + (block (unreachable)) (i32.const 1) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-func-value-num-vs-num-after-nested-unreachable + (result i32) + (block (unreachable)) (f32.const 0) + )) + "type mismatch" +) + +(assert_invalid + (module (func $type-unary-num-vs-void-after-infinite-loop + (loop (br 0)) (block (drop (i32.eqz (nop)))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-unary-num-vs-num-after-infinite-loop + (loop (br 0)) (drop (i32.eqz (f32.const 1))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-binary-num-vs-void-after-infinite-loop + (loop (br 0)) (block (drop (f32.eq (i32.const 1)))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-binary-num-vs-num-after-infinite-loop + (loop (br 0)) (drop (f32.eq (i32.const 1) (f32.const 0))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-block-value-num-vs-void-after-infinite-loop + (block (loop (br 0)) (i32.const 1)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-block-value-num-vs-num-after-infinite-loop (result i32) + (block (result i32) (i32.const 1) (loop (br 0)) (f32.const 0)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-loop-value-num-vs-void-after-infinite-loop + (block (loop (loop (br 0)) (i32.const 1))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-loop-value-num-vs-num-after-infinite-loop (result i32) + (loop (result i32) (loop (br 0)) (f32.const 0)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-func-value-num-vs-void-after-infinite-loop + (loop (br 0)) (i32.const 1) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-func-value-num-vs-num-after-infinite-loop (result i32) + (loop (br 0)) (f32.const 0) + )) + "type mismatch" +) + +(assert_invalid + (module (func $type-unary-num-vs-void-in-dead-body + (if (i32.const 0) (then (drop (i32.eqz (nop))))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-unary-num-vs-num-in-dead-body + (if (i32.const 0) (then (drop (i32.eqz (f32.const 1))))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-binary-num-vs-void-in-dead-body + (if (i32.const 0) (then (drop (f32.eq (i32.const 1))))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-binary-num-vs-num-in-dead-body + (if (i32.const 0) (then (drop (f32.eq (i32.const 1) (f32.const 0))))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-if-value-num-vs-void-in-dead-body + (if (i32.const 0) (then (i32.const 1))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-if-value-num-vs-num-in-dead-body (result i32) + (if (result i32) (i32.const 0) (then (f32.const 0))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-block-value-num-vs-void-in-dead-body + (if (i32.const 0) (then (block (i32.const 1)))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-block-value-num-vs-num-in-dead-body (result i32) + (if (result i32) (i32.const 0) (then (block (result i32) (f32.const 0)))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-block-value-num-vs-void-in-dead-body + (if (i32.const 0) (then (loop (i32.const 1)))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-block-value-num-vs-num-in-dead-body (result i32) + (if (result i32) (i32.const 0) (then (loop (result i32) (f32.const 0)))) + )) + "type mismatch" +) + +(assert_invalid + (module (func $type-return-second-num-vs-num (result i32) + (return (i32.const 1)) (return (f64.const 1)) + )) + "type mismatch" +) + +(assert_invalid + (module (func $type-br-second-num-vs-num (result i32) + (block (result i32) (br 0 (i32.const 1)) (br 0 (f64.const 1))) + )) + "type mismatch" +) + +(assert_invalid + (module (func $type-br_if-cond-num-vs-num-after-unreachable + (block (br_if 0 (unreachable) (f32.const 0))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-br_if-num-vs-void-after-unreachable (result i32) + (block (result i32) + (block (unreachable) (br_if 1 (i32.const 0) (i32.const 0))) + ) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-br_if-num-vs-num-after-unreachable (result i32) + (block (result i32) + (block (result f32) (unreachable) (br_if 1 (i32.const 0) (i32.const 0))) + (drop) (i32.const 0) + ) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-br_if-num2-vs-num-after-unreachable (result i32) + (block (result i32) + (unreachable) (br_if 0 (i32.const 0) (i32.const 0)) (i32.const 0) + ) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-br_table-num-vs-num-after-unreachable + (block (br_table 0 (unreachable) (f32.const 1))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-br_table-label-num-vs-num-after-unreachable (result i32) + (block (result i32) (unreachable) (br_table 0 (f32.const 0) (i32.const 1))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-br_table-label-num-vs-label-void-after-unreachable + (block + (block (result f32) + (unreachable) + (br_table 0 1 0 (i32.const 1)) + ) + (drop) + ) + )) + "type mismatch" +) + +(assert_invalid + (module (func $type-block-value-nested-unreachable-num-vs-void + (block (i32.const 3) (block (unreachable))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-block-value-nested-unreachable-void-vs-num (result i32) + (block (block (unreachable))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-block-value-nested-unreachable-num-vs-num (result i32) + (block (result i64) (i64.const 0) (block (unreachable))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-block-value-nested-unreachable-num2-vs-void (result i32) + (block (i32.const 3) (block (i64.const 1) (unreachable))) (i32.const 9) + )) + "type mismatch" +) + +(assert_invalid + (module (func $type-block-value-nested-br-num-vs-void + (block (i32.const 3) (block (br 1))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-block-value-nested-br-void-vs-num (result i32) + (block (result i32) (block (br 1 (i32.const 0)))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-block-value-nested-br-num-vs-num (result i32) + (block (result i32) (i64.const 0) (block (br 1 (i32.const 0)))) + )) + "type mismatch" +) + +(assert_invalid + (module (func $type-block-value-nested2-br-num-vs-void + (block (block (i32.const 3) (block (br 2)))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-block-value-nested2-br-void-vs-num (result i32) + (block (result i32) (block (block (br 2 (i32.const 0))))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-block-value-nested2-br-num-vs-num (result i32) + (block (result i32) + (block (result i64) (i64.const 0) (block (br 2 (i32.const 0)))) + ) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-block-value-nested2-br-num2-vs-void (result i32) + (block (i32.const 3) (block (i64.const 1) (br 1))) (i32.const 9) + )) + "type mismatch" +) + +(assert_invalid + (module (func $type-block-value-nested-return-num-vs-void + (block (i32.const 3) (block (return))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-block-value-nested-return-void-vs-num (result i32) + (block (block (return (i32.const 0)))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-block-value-nested-return-num-vs-num (result i32) + (block (result i64) (i64.const 0) (block (return (i32.const 0)))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-block-value-nested-return-num2-vs-void (result i32) + (block (i32.const 3) (block (i64.const 1) (return (i32.const 0)))) + (i32.const 9) + )) + "type mismatch" +) + +(assert_invalid + (module (func $type-loop-value-nested-unreachable-num-vs-void + (loop (i32.const 3) (block (unreachable))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-loop-value-nested-unreachable-void-vs-num (result i32) + (loop (block (unreachable))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-loop-value-nested-unreachable-num-vs-num (result i32) + (loop (result i64) (i64.const 0) (block (unreachable))) + )) + "type mismatch" +) + +(assert_invalid + (module (func $type-cont-last-void-vs-empty (result i32) + (loop (br 0 (nop))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-cont-last-num-vs-empty (result i32) + (loop (br 0 (i32.const 0))) + )) + "type mismatch" +) + +(assert_invalid + (module (func $tee-local-unreachable-value + (local i32) + (local.tee 0 (unreachable)) + )) + "type mismatch" +) +(assert_invalid + (module (func $br_if-unreachable (result i32) + (block (result i32) + (block + (br_if 1 (unreachable) (i32.const 0)) + ) + (i32.const 0) + ) + )) + "type mismatch" +) +(assert_invalid + (module + (func $type-br_if-after-unreachable (result i64) + unreachable + br_if 0 + i64.extend_i32_u + ) + ) + "type mismatch" +) diff --git a/runtime/near-vm/tests/wast/spec/proposals/sign-extension-ops/i32.wast b/runtime/near-vm/tests/wast/spec/proposals/sign-extension-ops/i32.wast new file mode 100644 index 00000000000..32862c34755 --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/proposals/sign-extension-ops/i32.wast @@ -0,0 +1,976 @@ +;; i32 operations + +(module + (func (export "add") (param $x i32) (param $y i32) (result i32) (i32.add (local.get $x) (local.get $y))) + (func (export "sub") (param $x i32) (param $y i32) (result i32) (i32.sub (local.get $x) (local.get $y))) + (func (export "mul") (param $x i32) (param $y i32) (result i32) (i32.mul (local.get $x) (local.get $y))) + (func (export "div_s") (param $x i32) (param $y i32) (result i32) (i32.div_s (local.get $x) (local.get $y))) + (func (export "div_u") (param $x i32) (param $y i32) (result i32) (i32.div_u (local.get $x) (local.get $y))) + (func (export "rem_s") (param $x i32) (param $y i32) (result i32) (i32.rem_s (local.get $x) (local.get $y))) + (func (export "rem_u") (param $x i32) (param $y i32) (result i32) (i32.rem_u (local.get $x) (local.get $y))) + (func (export "and") (param $x i32) (param $y i32) (result i32) (i32.and (local.get $x) (local.get $y))) + (func (export "or") (param $x i32) (param $y i32) (result i32) (i32.or (local.get $x) (local.get $y))) + (func (export "xor") (param $x i32) (param $y i32) (result i32) (i32.xor (local.get $x) (local.get $y))) + (func (export "shl") (param $x i32) (param $y i32) (result i32) (i32.shl (local.get $x) (local.get $y))) + (func (export "shr_s") (param $x i32) (param $y i32) (result i32) (i32.shr_s (local.get $x) (local.get $y))) + (func (export "shr_u") (param $x i32) (param $y i32) (result i32) (i32.shr_u (local.get $x) (local.get $y))) + (func (export "rotl") (param $x i32) (param $y i32) (result i32) (i32.rotl (local.get $x) (local.get $y))) + (func (export "rotr") (param $x i32) (param $y i32) (result i32) (i32.rotr (local.get $x) (local.get $y))) + (func (export "clz") (param $x i32) (result i32) (i32.clz (local.get $x))) + (func (export "ctz") (param $x i32) (result i32) (i32.ctz (local.get $x))) + (func (export "popcnt") (param $x i32) (result i32) (i32.popcnt (local.get $x))) + (func (export "extend8_s") (param $x i32) (result i32) (i32.extend8_s (local.get $x))) + (func (export "extend16_s") (param $x i32) (result i32) (i32.extend16_s (local.get $x))) + (func (export "eqz") (param $x i32) (result i32) (i32.eqz (local.get $x))) + (func (export "eq") (param $x i32) (param $y i32) (result i32) (i32.eq (local.get $x) (local.get $y))) + (func (export "ne") (param $x i32) (param $y i32) (result i32) (i32.ne (local.get $x) (local.get $y))) + (func (export "lt_s") (param $x i32) (param $y i32) (result i32) (i32.lt_s (local.get $x) (local.get $y))) + (func (export "lt_u") (param $x i32) (param $y i32) (result i32) (i32.lt_u (local.get $x) (local.get $y))) + (func (export "le_s") (param $x i32) (param $y i32) (result i32) (i32.le_s (local.get $x) (local.get $y))) + (func (export "le_u") (param $x i32) (param $y i32) (result i32) (i32.le_u (local.get $x) (local.get $y))) + (func (export "gt_s") (param $x i32) (param $y i32) (result i32) (i32.gt_s (local.get $x) (local.get $y))) + (func (export "gt_u") (param $x i32) (param $y i32) (result i32) (i32.gt_u (local.get $x) (local.get $y))) + (func (export "ge_s") (param $x i32) (param $y i32) (result i32) (i32.ge_s (local.get $x) (local.get $y))) + (func (export "ge_u") (param $x i32) (param $y i32) (result i32) (i32.ge_u (local.get $x) (local.get $y))) +) + +(assert_return (invoke "add" (i32.const 1) (i32.const 1)) (i32.const 2)) +(assert_return (invoke "add" (i32.const 1) (i32.const 0)) (i32.const 1)) +(assert_return (invoke "add" (i32.const -1) (i32.const -1)) (i32.const -2)) +(assert_return (invoke "add" (i32.const -1) (i32.const 1)) (i32.const 0)) +(assert_return (invoke "add" (i32.const 0x7fffffff) (i32.const 1)) (i32.const 0x80000000)) +(assert_return (invoke "add" (i32.const 0x80000000) (i32.const -1)) (i32.const 0x7fffffff)) +(assert_return (invoke "add" (i32.const 0x80000000) (i32.const 0x80000000)) (i32.const 0)) +(assert_return (invoke "add" (i32.const 0x3fffffff) (i32.const 1)) (i32.const 0x40000000)) + +(assert_return (invoke "sub" (i32.const 1) (i32.const 1)) (i32.const 0)) +(assert_return (invoke "sub" (i32.const 1) (i32.const 0)) (i32.const 1)) +(assert_return (invoke "sub" (i32.const -1) (i32.const -1)) (i32.const 0)) +(assert_return (invoke "sub" (i32.const 0x7fffffff) (i32.const -1)) (i32.const 0x80000000)) +(assert_return (invoke "sub" (i32.const 0x80000000) (i32.const 1)) (i32.const 0x7fffffff)) +(assert_return (invoke "sub" (i32.const 0x80000000) (i32.const 0x80000000)) (i32.const 0)) +(assert_return (invoke "sub" (i32.const 0x3fffffff) (i32.const -1)) (i32.const 0x40000000)) + +(assert_return (invoke "mul" (i32.const 1) (i32.const 1)) (i32.const 1)) +(assert_return (invoke "mul" (i32.const 1) (i32.const 0)) (i32.const 0)) +(assert_return (invoke "mul" (i32.const -1) (i32.const -1)) (i32.const 1)) +(assert_return (invoke "mul" (i32.const 0x10000000) (i32.const 4096)) (i32.const 0)) +(assert_return (invoke "mul" (i32.const 0x80000000) (i32.const 0)) (i32.const 0)) +(assert_return (invoke "mul" (i32.const 0x80000000) (i32.const -1)) (i32.const 0x80000000)) +(assert_return (invoke "mul" (i32.const 0x7fffffff) (i32.const -1)) (i32.const 0x80000001)) +(assert_return (invoke "mul" (i32.const 0x01234567) (i32.const 0x76543210)) (i32.const 0x358e7470)) +(assert_return (invoke "mul" (i32.const 0x7fffffff) (i32.const 0x7fffffff)) (i32.const 1)) + +(assert_trap (invoke "div_s" (i32.const 1) (i32.const 0)) "integer divide by zero") +(assert_trap (invoke "div_s" (i32.const 0) (i32.const 0)) "integer divide by zero") +(assert_trap (invoke "div_s" (i32.const 0x80000000) (i32.const -1)) "integer overflow") +(assert_trap (invoke "div_s" (i32.const 0x80000000) (i32.const 0)) "integer divide by zero") +(assert_return (invoke "div_s" (i32.const 1) (i32.const 1)) (i32.const 1)) +(assert_return (invoke "div_s" (i32.const 0) (i32.const 1)) (i32.const 0)) +(assert_return (invoke "div_s" (i32.const 0) (i32.const -1)) (i32.const 0)) +(assert_return (invoke "div_s" (i32.const -1) (i32.const -1)) (i32.const 1)) +(assert_return (invoke "div_s" (i32.const 0x80000000) (i32.const 2)) (i32.const 0xc0000000)) +(assert_return (invoke "div_s" (i32.const 0x80000001) (i32.const 1000)) (i32.const 0xffdf3b65)) +(assert_return (invoke "div_s" (i32.const 5) (i32.const 2)) (i32.const 2)) +(assert_return (invoke "div_s" (i32.const -5) (i32.const 2)) (i32.const -2)) +(assert_return (invoke "div_s" (i32.const 5) (i32.const -2)) (i32.const -2)) +(assert_return (invoke "div_s" (i32.const -5) (i32.const -2)) (i32.const 2)) +(assert_return (invoke "div_s" (i32.const 7) (i32.const 3)) (i32.const 2)) +(assert_return (invoke "div_s" (i32.const -7) (i32.const 3)) (i32.const -2)) +(assert_return (invoke "div_s" (i32.const 7) (i32.const -3)) (i32.const -2)) +(assert_return (invoke "div_s" (i32.const -7) (i32.const -3)) (i32.const 2)) +(assert_return (invoke "div_s" (i32.const 11) (i32.const 5)) (i32.const 2)) +(assert_return (invoke "div_s" (i32.const 17) (i32.const 7)) (i32.const 2)) + +(assert_trap (invoke "div_u" (i32.const 1) (i32.const 0)) "integer divide by zero") +(assert_trap (invoke "div_u" (i32.const 0) (i32.const 0)) "integer divide by zero") +(assert_return (invoke "div_u" (i32.const 1) (i32.const 1)) (i32.const 1)) +(assert_return (invoke "div_u" (i32.const 0) (i32.const 1)) (i32.const 0)) +(assert_return (invoke "div_u" (i32.const -1) (i32.const -1)) (i32.const 1)) +(assert_return (invoke "div_u" (i32.const 0x80000000) (i32.const -1)) (i32.const 0)) +(assert_return (invoke "div_u" (i32.const 0x80000000) (i32.const 2)) (i32.const 0x40000000)) +(assert_return (invoke "div_u" (i32.const 0x8ff00ff0) (i32.const 0x10001)) (i32.const 0x8fef)) +(assert_return (invoke "div_u" (i32.const 0x80000001) (i32.const 1000)) (i32.const 0x20c49b)) +(assert_return (invoke "div_u" (i32.const 5) (i32.const 2)) (i32.const 2)) +(assert_return (invoke "div_u" (i32.const -5) (i32.const 2)) (i32.const 0x7ffffffd)) +(assert_return (invoke "div_u" (i32.const 5) (i32.const -2)) (i32.const 0)) +(assert_return (invoke "div_u" (i32.const -5) (i32.const -2)) (i32.const 0)) +(assert_return (invoke "div_u" (i32.const 7) (i32.const 3)) (i32.const 2)) +(assert_return (invoke "div_u" (i32.const 11) (i32.const 5)) (i32.const 2)) +(assert_return (invoke "div_u" (i32.const 17) (i32.const 7)) (i32.const 2)) + +(assert_trap (invoke "rem_s" (i32.const 1) (i32.const 0)) "integer divide by zero") +(assert_trap (invoke "rem_s" (i32.const 0) (i32.const 0)) "integer divide by zero") +(assert_return (invoke "rem_s" (i32.const 0x7fffffff) (i32.const -1)) (i32.const 0)) +(assert_return (invoke "rem_s" (i32.const 1) (i32.const 1)) (i32.const 0)) +(assert_return (invoke "rem_s" (i32.const 0) (i32.const 1)) (i32.const 0)) +(assert_return (invoke "rem_s" (i32.const 0) (i32.const -1)) (i32.const 0)) +(assert_return (invoke "rem_s" (i32.const -1) (i32.const -1)) (i32.const 0)) +(assert_return (invoke "rem_s" (i32.const 0x80000000) (i32.const -1)) (i32.const 0)) +(assert_return (invoke "rem_s" (i32.const 0x80000000) (i32.const 2)) (i32.const 0)) +(assert_return (invoke "rem_s" (i32.const 0x80000001) (i32.const 1000)) (i32.const -647)) +(assert_return (invoke "rem_s" (i32.const 5) (i32.const 2)) (i32.const 1)) +(assert_return (invoke "rem_s" (i32.const -5) (i32.const 2)) (i32.const -1)) +(assert_return (invoke "rem_s" (i32.const 5) (i32.const -2)) (i32.const 1)) +(assert_return (invoke "rem_s" (i32.const -5) (i32.const -2)) (i32.const -1)) +(assert_return (invoke "rem_s" (i32.const 7) (i32.const 3)) (i32.const 1)) +(assert_return (invoke "rem_s" (i32.const -7) (i32.const 3)) (i32.const -1)) +(assert_return (invoke "rem_s" (i32.const 7) (i32.const -3)) (i32.const 1)) +(assert_return (invoke "rem_s" (i32.const -7) (i32.const -3)) (i32.const -1)) +(assert_return (invoke "rem_s" (i32.const 11) (i32.const 5)) (i32.const 1)) +(assert_return (invoke "rem_s" (i32.const 17) (i32.const 7)) (i32.const 3)) + +(assert_trap (invoke "rem_u" (i32.const 1) (i32.const 0)) "integer divide by zero") +(assert_trap (invoke "rem_u" (i32.const 0) (i32.const 0)) "integer divide by zero") +(assert_return (invoke "rem_u" (i32.const 1) (i32.const 1)) (i32.const 0)) +(assert_return (invoke "rem_u" (i32.const 0) (i32.const 1)) (i32.const 0)) +(assert_return (invoke "rem_u" (i32.const -1) (i32.const -1)) (i32.const 0)) +(assert_return (invoke "rem_u" (i32.const 0x80000000) (i32.const -1)) (i32.const 0x80000000)) +(assert_return (invoke "rem_u" (i32.const 0x80000000) (i32.const 2)) (i32.const 0)) +(assert_return (invoke "rem_u" (i32.const 0x8ff00ff0) (i32.const 0x10001)) (i32.const 0x8001)) +(assert_return (invoke "rem_u" (i32.const 0x80000001) (i32.const 1000)) (i32.const 649)) +(assert_return (invoke "rem_u" (i32.const 5) (i32.const 2)) (i32.const 1)) +(assert_return (invoke "rem_u" (i32.const -5) (i32.const 2)) (i32.const 1)) +(assert_return (invoke "rem_u" (i32.const 5) (i32.const -2)) (i32.const 5)) +(assert_return (invoke "rem_u" (i32.const -5) (i32.const -2)) (i32.const -5)) +(assert_return (invoke "rem_u" (i32.const 7) (i32.const 3)) (i32.const 1)) +(assert_return (invoke "rem_u" (i32.const 11) (i32.const 5)) (i32.const 1)) +(assert_return (invoke "rem_u" (i32.const 17) (i32.const 7)) (i32.const 3)) + +(assert_return (invoke "and" (i32.const 1) (i32.const 0)) (i32.const 0)) +(assert_return (invoke "and" (i32.const 0) (i32.const 1)) (i32.const 0)) +(assert_return (invoke "and" (i32.const 1) (i32.const 1)) (i32.const 1)) +(assert_return (invoke "and" (i32.const 0) (i32.const 0)) (i32.const 0)) +(assert_return (invoke "and" (i32.const 0x7fffffff) (i32.const 0x80000000)) (i32.const 0)) +(assert_return (invoke "and" (i32.const 0x7fffffff) (i32.const -1)) (i32.const 0x7fffffff)) +(assert_return (invoke "and" (i32.const 0xf0f0ffff) (i32.const 0xfffff0f0)) (i32.const 0xf0f0f0f0)) +(assert_return (invoke "and" (i32.const 0xffffffff) (i32.const 0xffffffff)) (i32.const 0xffffffff)) + +(assert_return (invoke "or" (i32.const 1) (i32.const 0)) (i32.const 1)) +(assert_return (invoke "or" (i32.const 0) (i32.const 1)) (i32.const 1)) +(assert_return (invoke "or" (i32.const 1) (i32.const 1)) (i32.const 1)) +(assert_return (invoke "or" (i32.const 0) (i32.const 0)) (i32.const 0)) +(assert_return (invoke "or" (i32.const 0x7fffffff) (i32.const 0x80000000)) (i32.const -1)) +(assert_return (invoke "or" (i32.const 0x80000000) (i32.const 0)) (i32.const 0x80000000)) +(assert_return (invoke "or" (i32.const 0xf0f0ffff) (i32.const 0xfffff0f0)) (i32.const 0xffffffff)) +(assert_return (invoke "or" (i32.const 0xffffffff) (i32.const 0xffffffff)) (i32.const 0xffffffff)) + +(assert_return (invoke "xor" (i32.const 1) (i32.const 0)) (i32.const 1)) +(assert_return (invoke "xor" (i32.const 0) (i32.const 1)) (i32.const 1)) +(assert_return (invoke "xor" (i32.const 1) (i32.const 1)) (i32.const 0)) +(assert_return (invoke "xor" (i32.const 0) (i32.const 0)) (i32.const 0)) +(assert_return (invoke "xor" (i32.const 0x7fffffff) (i32.const 0x80000000)) (i32.const -1)) +(assert_return (invoke "xor" (i32.const 0x80000000) (i32.const 0)) (i32.const 0x80000000)) +(assert_return (invoke "xor" (i32.const -1) (i32.const 0x80000000)) (i32.const 0x7fffffff)) +(assert_return (invoke "xor" (i32.const -1) (i32.const 0x7fffffff)) (i32.const 0x80000000)) +(assert_return (invoke "xor" (i32.const 0xf0f0ffff) (i32.const 0xfffff0f0)) (i32.const 0x0f0f0f0f)) +(assert_return (invoke "xor" (i32.const 0xffffffff) (i32.const 0xffffffff)) (i32.const 0)) + +(assert_return (invoke "shl" (i32.const 1) (i32.const 1)) (i32.const 2)) +(assert_return (invoke "shl" (i32.const 1) (i32.const 0)) (i32.const 1)) +(assert_return (invoke "shl" (i32.const 0x7fffffff) (i32.const 1)) (i32.const 0xfffffffe)) +(assert_return (invoke "shl" (i32.const 0xffffffff) (i32.const 1)) (i32.const 0xfffffffe)) +(assert_return (invoke "shl" (i32.const 0x80000000) (i32.const 1)) (i32.const 0)) +(assert_return (invoke "shl" (i32.const 0x40000000) (i32.const 1)) (i32.const 0x80000000)) +(assert_return (invoke "shl" (i32.const 1) (i32.const 31)) (i32.const 0x80000000)) +(assert_return (invoke "shl" (i32.const 1) (i32.const 32)) (i32.const 1)) +(assert_return (invoke "shl" (i32.const 1) (i32.const 33)) (i32.const 2)) +(assert_return (invoke "shl" (i32.const 1) (i32.const -1)) (i32.const 0x80000000)) +(assert_return (invoke "shl" (i32.const 1) (i32.const 0x7fffffff)) (i32.const 0x80000000)) + +(assert_return (invoke "shr_s" (i32.const 1) (i32.const 1)) (i32.const 0)) +(assert_return (invoke "shr_s" (i32.const 1) (i32.const 0)) (i32.const 1)) +(assert_return (invoke "shr_s" (i32.const -1) (i32.const 1)) (i32.const -1)) +(assert_return (invoke "shr_s" (i32.const 0x7fffffff) (i32.const 1)) (i32.const 0x3fffffff)) +(assert_return (invoke "shr_s" (i32.const 0x80000000) (i32.const 1)) (i32.const 0xc0000000)) +(assert_return (invoke "shr_s" (i32.const 0x40000000) (i32.const 1)) (i32.const 0x20000000)) +(assert_return (invoke "shr_s" (i32.const 1) (i32.const 32)) (i32.const 1)) +(assert_return (invoke "shr_s" (i32.const 1) (i32.const 33)) (i32.const 0)) +(assert_return (invoke "shr_s" (i32.const 1) (i32.const -1)) (i32.const 0)) +(assert_return (invoke "shr_s" (i32.const 1) (i32.const 0x7fffffff)) (i32.const 0)) +(assert_return (invoke "shr_s" (i32.const 1) (i32.const 0x80000000)) (i32.const 1)) +(assert_return (invoke "shr_s" (i32.const 0x80000000) (i32.const 31)) (i32.const -1)) +(assert_return (invoke "shr_s" (i32.const -1) (i32.const 32)) (i32.const -1)) +(assert_return (invoke "shr_s" (i32.const -1) (i32.const 33)) (i32.const -1)) +(assert_return (invoke "shr_s" (i32.const -1) (i32.const -1)) (i32.const -1)) +(assert_return (invoke "shr_s" (i32.const -1) (i32.const 0x7fffffff)) (i32.const -1)) +(assert_return (invoke "shr_s" (i32.const -1) (i32.const 0x80000000)) (i32.const -1)) + +(assert_return (invoke "shr_u" (i32.const 1) (i32.const 1)) (i32.const 0)) +(assert_return (invoke "shr_u" (i32.const 1) (i32.const 0)) (i32.const 1)) +(assert_return (invoke "shr_u" (i32.const -1) (i32.const 1)) (i32.const 0x7fffffff)) +(assert_return (invoke "shr_u" (i32.const 0x7fffffff) (i32.const 1)) (i32.const 0x3fffffff)) +(assert_return (invoke "shr_u" (i32.const 0x80000000) (i32.const 1)) (i32.const 0x40000000)) +(assert_return (invoke "shr_u" (i32.const 0x40000000) (i32.const 1)) (i32.const 0x20000000)) +(assert_return (invoke "shr_u" (i32.const 1) (i32.const 32)) (i32.const 1)) +(assert_return (invoke "shr_u" (i32.const 1) (i32.const 33)) (i32.const 0)) +(assert_return (invoke "shr_u" (i32.const 1) (i32.const -1)) (i32.const 0)) +(assert_return (invoke "shr_u" (i32.const 1) (i32.const 0x7fffffff)) (i32.const 0)) +(assert_return (invoke "shr_u" (i32.const 1) (i32.const 0x80000000)) (i32.const 1)) +(assert_return (invoke "shr_u" (i32.const 0x80000000) (i32.const 31)) (i32.const 1)) +(assert_return (invoke "shr_u" (i32.const -1) (i32.const 32)) (i32.const -1)) +(assert_return (invoke "shr_u" (i32.const -1) (i32.const 33)) (i32.const 0x7fffffff)) +(assert_return (invoke "shr_u" (i32.const -1) (i32.const -1)) (i32.const 1)) +(assert_return (invoke "shr_u" (i32.const -1) (i32.const 0x7fffffff)) (i32.const 1)) +(assert_return (invoke "shr_u" (i32.const -1) (i32.const 0x80000000)) (i32.const -1)) + +(assert_return (invoke "rotl" (i32.const 1) (i32.const 1)) (i32.const 2)) +(assert_return (invoke "rotl" (i32.const 1) (i32.const 0)) (i32.const 1)) +(assert_return (invoke "rotl" (i32.const -1) (i32.const 1)) (i32.const -1)) +(assert_return (invoke "rotl" (i32.const 1) (i32.const 32)) (i32.const 1)) +(assert_return (invoke "rotl" (i32.const 0xabcd9876) (i32.const 1)) (i32.const 0x579b30ed)) +(assert_return (invoke "rotl" (i32.const 0xfe00dc00) (i32.const 4)) (i32.const 0xe00dc00f)) +(assert_return (invoke "rotl" (i32.const 0xb0c1d2e3) (i32.const 5)) (i32.const 0x183a5c76)) +(assert_return (invoke "rotl" (i32.const 0x00008000) (i32.const 37)) (i32.const 0x00100000)) +(assert_return (invoke "rotl" (i32.const 0xb0c1d2e3) (i32.const 0xff05)) (i32.const 0x183a5c76)) +(assert_return (invoke "rotl" (i32.const 0x769abcdf) (i32.const 0xffffffed)) (i32.const 0x579beed3)) +(assert_return (invoke "rotl" (i32.const 0x769abcdf) (i32.const 0x8000000d)) (i32.const 0x579beed3)) +(assert_return (invoke "rotl" (i32.const 1) (i32.const 31)) (i32.const 0x80000000)) +(assert_return (invoke "rotl" (i32.const 0x80000000) (i32.const 1)) (i32.const 1)) + +(assert_return (invoke "rotr" (i32.const 1) (i32.const 1)) (i32.const 0x80000000)) +(assert_return (invoke "rotr" (i32.const 1) (i32.const 0)) (i32.const 1)) +(assert_return (invoke "rotr" (i32.const -1) (i32.const 1)) (i32.const -1)) +(assert_return (invoke "rotr" (i32.const 1) (i32.const 32)) (i32.const 1)) +(assert_return (invoke "rotr" (i32.const 0xff00cc00) (i32.const 1)) (i32.const 0x7f806600)) +(assert_return (invoke "rotr" (i32.const 0x00080000) (i32.const 4)) (i32.const 0x00008000)) +(assert_return (invoke "rotr" (i32.const 0xb0c1d2e3) (i32.const 5)) (i32.const 0x1d860e97)) +(assert_return (invoke "rotr" (i32.const 0x00008000) (i32.const 37)) (i32.const 0x00000400)) +(assert_return (invoke "rotr" (i32.const 0xb0c1d2e3) (i32.const 0xff05)) (i32.const 0x1d860e97)) +(assert_return (invoke "rotr" (i32.const 0x769abcdf) (i32.const 0xffffffed)) (i32.const 0xe6fbb4d5)) +(assert_return (invoke "rotr" (i32.const 0x769abcdf) (i32.const 0x8000000d)) (i32.const 0xe6fbb4d5)) +(assert_return (invoke "rotr" (i32.const 1) (i32.const 31)) (i32.const 2)) +(assert_return (invoke "rotr" (i32.const 0x80000000) (i32.const 31)) (i32.const 1)) + +(assert_return (invoke "clz" (i32.const 0xffffffff)) (i32.const 0)) +(assert_return (invoke "clz" (i32.const 0)) (i32.const 32)) +(assert_return (invoke "clz" (i32.const 0x00008000)) (i32.const 16)) +(assert_return (invoke "clz" (i32.const 0xff)) (i32.const 24)) +(assert_return (invoke "clz" (i32.const 0x80000000)) (i32.const 0)) +(assert_return (invoke "clz" (i32.const 1)) (i32.const 31)) +(assert_return (invoke "clz" (i32.const 2)) (i32.const 30)) +(assert_return (invoke "clz" (i32.const 0x7fffffff)) (i32.const 1)) + +(assert_return (invoke "ctz" (i32.const -1)) (i32.const 0)) +(assert_return (invoke "ctz" (i32.const 0)) (i32.const 32)) +(assert_return (invoke "ctz" (i32.const 0x00008000)) (i32.const 15)) +(assert_return (invoke "ctz" (i32.const 0x00010000)) (i32.const 16)) +(assert_return (invoke "ctz" (i32.const 0x80000000)) (i32.const 31)) +(assert_return (invoke "ctz" (i32.const 0x7fffffff)) (i32.const 0)) + +(assert_return (invoke "popcnt" (i32.const -1)) (i32.const 32)) +(assert_return (invoke "popcnt" (i32.const 0)) (i32.const 0)) +(assert_return (invoke "popcnt" (i32.const 0x00008000)) (i32.const 1)) +(assert_return (invoke "popcnt" (i32.const 0x80008000)) (i32.const 2)) +(assert_return (invoke "popcnt" (i32.const 0x7fffffff)) (i32.const 31)) +(assert_return (invoke "popcnt" (i32.const 0xAAAAAAAA)) (i32.const 16)) +(assert_return (invoke "popcnt" (i32.const 0x55555555)) (i32.const 16)) +(assert_return (invoke "popcnt" (i32.const 0xDEADBEEF)) (i32.const 24)) + +(assert_return (invoke "extend8_s" (i32.const 0)) (i32.const 0)) +(assert_return (invoke "extend8_s" (i32.const 0x7f)) (i32.const 127)) +(assert_return (invoke "extend8_s" (i32.const 0x80)) (i32.const -128)) +(assert_return (invoke "extend8_s" (i32.const 0xff)) (i32.const -1)) +(assert_return (invoke "extend8_s" (i32.const 0x012345_00)) (i32.const 0)) +(assert_return (invoke "extend8_s" (i32.const 0xfedcba_80)) (i32.const -0x80)) +(assert_return (invoke "extend8_s" (i32.const -1)) (i32.const -1)) + +(assert_return (invoke "extend16_s" (i32.const 0)) (i32.const 0)) +(assert_return (invoke "extend16_s" (i32.const 0x7fff)) (i32.const 32767)) +(assert_return (invoke "extend16_s" (i32.const 0x8000)) (i32.const -32768)) +(assert_return (invoke "extend16_s" (i32.const 0xffff)) (i32.const -1)) +(assert_return (invoke "extend16_s" (i32.const 0x0123_0000)) (i32.const 0)) +(assert_return (invoke "extend16_s" (i32.const 0xfedc_8000)) (i32.const -0x8000)) +(assert_return (invoke "extend16_s" (i32.const -1)) (i32.const -1)) + +(assert_return (invoke "eqz" (i32.const 0)) (i32.const 1)) +(assert_return (invoke "eqz" (i32.const 1)) (i32.const 0)) +(assert_return (invoke "eqz" (i32.const 0x80000000)) (i32.const 0)) +(assert_return (invoke "eqz" (i32.const 0x7fffffff)) (i32.const 0)) +(assert_return (invoke "eqz" (i32.const 0xffffffff)) (i32.const 0)) + +(assert_return (invoke "eq" (i32.const 0) (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 1)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 0x80000000) (i32.const 0x80000000)) (i32.const 1)) +(assert_return (invoke "eq" (i32.const 0x7fffffff) (i32.const 0x7fffffff)) (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 0)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 0) (i32.const 1)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 0x80000000) (i32.const 0)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 0) (i32.const 0x80000000)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 0x80000000) (i32.const -1)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const -1) (i32.const 0x80000000)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 0x80000000) (i32.const 0x7fffffff)) (i32.const 0)) +(assert_return (invoke "eq" (i32.const 0x7fffffff) (i32.const 0x80000000)) (i32.const 0)) + +(assert_return (invoke "ne" (i32.const 0) (i32.const 0)) (i32.const 0)) +(assert_return (invoke "ne" (i32.const 1) (i32.const 1)) (i32.const 0)) +(assert_return (invoke "ne" (i32.const -1) (i32.const 1)) (i32.const 1)) +(assert_return (invoke "ne" (i32.const 0x80000000) (i32.const 0x80000000)) (i32.const 0)) +(assert_return (invoke "ne" (i32.const 0x7fffffff) (i32.const 0x7fffffff)) (i32.const 0)) +(assert_return (invoke "ne" (i32.const -1) (i32.const -1)) (i32.const 0)) +(assert_return (invoke "ne" (i32.const 1) (i32.const 0)) (i32.const 1)) +(assert_return (invoke "ne" (i32.const 0) (i32.const 1)) (i32.const 1)) +(assert_return (invoke "ne" (i32.const 0x80000000) (i32.const 0)) (i32.const 1)) +(assert_return (invoke "ne" (i32.const 0) (i32.const 0x80000000)) (i32.const 1)) +(assert_return (invoke "ne" (i32.const 0x80000000) (i32.const -1)) (i32.const 1)) +(assert_return (invoke "ne" (i32.const -1) (i32.const 0x80000000)) (i32.const 1)) +(assert_return (invoke "ne" (i32.const 0x80000000) (i32.const 0x7fffffff)) (i32.const 1)) +(assert_return (invoke "ne" (i32.const 0x7fffffff) (i32.const 0x80000000)) (i32.const 1)) + +(assert_return (invoke "lt_s" (i32.const 0) (i32.const 0)) (i32.const 0)) +(assert_return (invoke "lt_s" (i32.const 1) (i32.const 1)) (i32.const 0)) +(assert_return (invoke "lt_s" (i32.const -1) (i32.const 1)) (i32.const 1)) +(assert_return (invoke "lt_s" (i32.const 0x80000000) (i32.const 0x80000000)) (i32.const 0)) +(assert_return (invoke "lt_s" (i32.const 0x7fffffff) (i32.const 0x7fffffff)) (i32.const 0)) +(assert_return (invoke "lt_s" (i32.const -1) (i32.const -1)) (i32.const 0)) +(assert_return (invoke "lt_s" (i32.const 1) (i32.const 0)) (i32.const 0)) +(assert_return (invoke "lt_s" (i32.const 0) (i32.const 1)) (i32.const 1)) +(assert_return (invoke "lt_s" (i32.const 0x80000000) (i32.const 0)) (i32.const 1)) +(assert_return (invoke "lt_s" (i32.const 0) (i32.const 0x80000000)) (i32.const 0)) +(assert_return (invoke "lt_s" (i32.const 0x80000000) (i32.const -1)) (i32.const 1)) +(assert_return (invoke "lt_s" (i32.const -1) (i32.const 0x80000000)) (i32.const 0)) +(assert_return (invoke "lt_s" (i32.const 0x80000000) (i32.const 0x7fffffff)) (i32.const 1)) +(assert_return (invoke "lt_s" (i32.const 0x7fffffff) (i32.const 0x80000000)) (i32.const 0)) + +(assert_return (invoke "lt_u" (i32.const 0) (i32.const 0)) (i32.const 0)) +(assert_return (invoke "lt_u" (i32.const 1) (i32.const 1)) (i32.const 0)) +(assert_return (invoke "lt_u" (i32.const -1) (i32.const 1)) (i32.const 0)) +(assert_return (invoke "lt_u" (i32.const 0x80000000) (i32.const 0x80000000)) (i32.const 0)) +(assert_return (invoke "lt_u" (i32.const 0x7fffffff) (i32.const 0x7fffffff)) (i32.const 0)) +(assert_return (invoke "lt_u" (i32.const -1) (i32.const -1)) (i32.const 0)) +(assert_return (invoke "lt_u" (i32.const 1) (i32.const 0)) (i32.const 0)) +(assert_return (invoke "lt_u" (i32.const 0) (i32.const 1)) (i32.const 1)) +(assert_return (invoke "lt_u" (i32.const 0x80000000) (i32.const 0)) (i32.const 0)) +(assert_return (invoke "lt_u" (i32.const 0) (i32.const 0x80000000)) (i32.const 1)) +(assert_return (invoke "lt_u" (i32.const 0x80000000) (i32.const -1)) (i32.const 1)) +(assert_return (invoke "lt_u" (i32.const -1) (i32.const 0x80000000)) (i32.const 0)) +(assert_return (invoke "lt_u" (i32.const 0x80000000) (i32.const 0x7fffffff)) (i32.const 0)) +(assert_return (invoke "lt_u" (i32.const 0x7fffffff) (i32.const 0x80000000)) (i32.const 1)) + +(assert_return (invoke "le_s" (i32.const 0) (i32.const 0)) (i32.const 1)) +(assert_return (invoke "le_s" (i32.const 1) (i32.const 1)) (i32.const 1)) +(assert_return (invoke "le_s" (i32.const -1) (i32.const 1)) (i32.const 1)) +(assert_return (invoke "le_s" (i32.const 0x80000000) (i32.const 0x80000000)) (i32.const 1)) +(assert_return (invoke "le_s" (i32.const 0x7fffffff) (i32.const 0x7fffffff)) (i32.const 1)) +(assert_return (invoke "le_s" (i32.const -1) (i32.const -1)) (i32.const 1)) +(assert_return (invoke "le_s" (i32.const 1) (i32.const 0)) (i32.const 0)) +(assert_return (invoke "le_s" (i32.const 0) (i32.const 1)) (i32.const 1)) +(assert_return (invoke "le_s" (i32.const 0x80000000) (i32.const 0)) (i32.const 1)) +(assert_return (invoke "le_s" (i32.const 0) (i32.const 0x80000000)) (i32.const 0)) +(assert_return (invoke "le_s" (i32.const 0x80000000) (i32.const -1)) (i32.const 1)) +(assert_return (invoke "le_s" (i32.const -1) (i32.const 0x80000000)) (i32.const 0)) +(assert_return (invoke "le_s" (i32.const 0x80000000) (i32.const 0x7fffffff)) (i32.const 1)) +(assert_return (invoke "le_s" (i32.const 0x7fffffff) (i32.const 0x80000000)) (i32.const 0)) + +(assert_return (invoke "le_u" (i32.const 0) (i32.const 0)) (i32.const 1)) +(assert_return (invoke "le_u" (i32.const 1) (i32.const 1)) (i32.const 1)) +(assert_return (invoke "le_u" (i32.const -1) (i32.const 1)) (i32.const 0)) +(assert_return (invoke "le_u" (i32.const 0x80000000) (i32.const 0x80000000)) (i32.const 1)) +(assert_return (invoke "le_u" (i32.const 0x7fffffff) (i32.const 0x7fffffff)) (i32.const 1)) +(assert_return (invoke "le_u" (i32.const -1) (i32.const -1)) (i32.const 1)) +(assert_return (invoke "le_u" (i32.const 1) (i32.const 0)) (i32.const 0)) +(assert_return (invoke "le_u" (i32.const 0) (i32.const 1)) (i32.const 1)) +(assert_return (invoke "le_u" (i32.const 0x80000000) (i32.const 0)) (i32.const 0)) +(assert_return (invoke "le_u" (i32.const 0) (i32.const 0x80000000)) (i32.const 1)) +(assert_return (invoke "le_u" (i32.const 0x80000000) (i32.const -1)) (i32.const 1)) +(assert_return (invoke "le_u" (i32.const -1) (i32.const 0x80000000)) (i32.const 0)) +(assert_return (invoke "le_u" (i32.const 0x80000000) (i32.const 0x7fffffff)) (i32.const 0)) +(assert_return (invoke "le_u" (i32.const 0x7fffffff) (i32.const 0x80000000)) (i32.const 1)) + +(assert_return (invoke "gt_s" (i32.const 0) (i32.const 0)) (i32.const 0)) +(assert_return (invoke "gt_s" (i32.const 1) (i32.const 1)) (i32.const 0)) +(assert_return (invoke "gt_s" (i32.const -1) (i32.const 1)) (i32.const 0)) +(assert_return (invoke "gt_s" (i32.const 0x80000000) (i32.const 0x80000000)) (i32.const 0)) +(assert_return (invoke "gt_s" (i32.const 0x7fffffff) (i32.const 0x7fffffff)) (i32.const 0)) +(assert_return (invoke "gt_s" (i32.const -1) (i32.const -1)) (i32.const 0)) +(assert_return (invoke "gt_s" (i32.const 1) (i32.const 0)) (i32.const 1)) +(assert_return (invoke "gt_s" (i32.const 0) (i32.const 1)) (i32.const 0)) +(assert_return (invoke "gt_s" (i32.const 0x80000000) (i32.const 0)) (i32.const 0)) +(assert_return (invoke "gt_s" (i32.const 0) (i32.const 0x80000000)) (i32.const 1)) +(assert_return (invoke "gt_s" (i32.const 0x80000000) (i32.const -1)) (i32.const 0)) +(assert_return (invoke "gt_s" (i32.const -1) (i32.const 0x80000000)) (i32.const 1)) +(assert_return (invoke "gt_s" (i32.const 0x80000000) (i32.const 0x7fffffff)) (i32.const 0)) +(assert_return (invoke "gt_s" (i32.const 0x7fffffff) (i32.const 0x80000000)) (i32.const 1)) + +(assert_return (invoke "gt_u" (i32.const 0) (i32.const 0)) (i32.const 0)) +(assert_return (invoke "gt_u" (i32.const 1) (i32.const 1)) (i32.const 0)) +(assert_return (invoke "gt_u" (i32.const -1) (i32.const 1)) (i32.const 1)) +(assert_return (invoke "gt_u" (i32.const 0x80000000) (i32.const 0x80000000)) (i32.const 0)) +(assert_return (invoke "gt_u" (i32.const 0x7fffffff) (i32.const 0x7fffffff)) (i32.const 0)) +(assert_return (invoke "gt_u" (i32.const -1) (i32.const -1)) (i32.const 0)) +(assert_return (invoke "gt_u" (i32.const 1) (i32.const 0)) (i32.const 1)) +(assert_return (invoke "gt_u" (i32.const 0) (i32.const 1)) (i32.const 0)) +(assert_return (invoke "gt_u" (i32.const 0x80000000) (i32.const 0)) (i32.const 1)) +(assert_return (invoke "gt_u" (i32.const 0) (i32.const 0x80000000)) (i32.const 0)) +(assert_return (invoke "gt_u" (i32.const 0x80000000) (i32.const -1)) (i32.const 0)) +(assert_return (invoke "gt_u" (i32.const -1) (i32.const 0x80000000)) (i32.const 1)) +(assert_return (invoke "gt_u" (i32.const 0x80000000) (i32.const 0x7fffffff)) (i32.const 1)) +(assert_return (invoke "gt_u" (i32.const 0x7fffffff) (i32.const 0x80000000)) (i32.const 0)) + +(assert_return (invoke "ge_s" (i32.const 0) (i32.const 0)) (i32.const 1)) +(assert_return (invoke "ge_s" (i32.const 1) (i32.const 1)) (i32.const 1)) +(assert_return (invoke "ge_s" (i32.const -1) (i32.const 1)) (i32.const 0)) +(assert_return (invoke "ge_s" (i32.const 0x80000000) (i32.const 0x80000000)) (i32.const 1)) +(assert_return (invoke "ge_s" (i32.const 0x7fffffff) (i32.const 0x7fffffff)) (i32.const 1)) +(assert_return (invoke "ge_s" (i32.const -1) (i32.const -1)) (i32.const 1)) +(assert_return (invoke "ge_s" (i32.const 1) (i32.const 0)) (i32.const 1)) +(assert_return (invoke "ge_s" (i32.const 0) (i32.const 1)) (i32.const 0)) +(assert_return (invoke "ge_s" (i32.const 0x80000000) (i32.const 0)) (i32.const 0)) +(assert_return (invoke "ge_s" (i32.const 0) (i32.const 0x80000000)) (i32.const 1)) +(assert_return (invoke "ge_s" (i32.const 0x80000000) (i32.const -1)) (i32.const 0)) +(assert_return (invoke "ge_s" (i32.const -1) (i32.const 0x80000000)) (i32.const 1)) +(assert_return (invoke "ge_s" (i32.const 0x80000000) (i32.const 0x7fffffff)) (i32.const 0)) +(assert_return (invoke "ge_s" (i32.const 0x7fffffff) (i32.const 0x80000000)) (i32.const 1)) + +(assert_return (invoke "ge_u" (i32.const 0) (i32.const 0)) (i32.const 1)) +(assert_return (invoke "ge_u" (i32.const 1) (i32.const 1)) (i32.const 1)) +(assert_return (invoke "ge_u" (i32.const -1) (i32.const 1)) (i32.const 1)) +(assert_return (invoke "ge_u" (i32.const 0x80000000) (i32.const 0x80000000)) (i32.const 1)) +(assert_return (invoke "ge_u" (i32.const 0x7fffffff) (i32.const 0x7fffffff)) (i32.const 1)) +(assert_return (invoke "ge_u" (i32.const -1) (i32.const -1)) (i32.const 1)) +(assert_return (invoke "ge_u" (i32.const 1) (i32.const 0)) (i32.const 1)) +(assert_return (invoke "ge_u" (i32.const 0) (i32.const 1)) (i32.const 0)) +(assert_return (invoke "ge_u" (i32.const 0x80000000) (i32.const 0)) (i32.const 1)) +(assert_return (invoke "ge_u" (i32.const 0) (i32.const 0x80000000)) (i32.const 0)) +(assert_return (invoke "ge_u" (i32.const 0x80000000) (i32.const -1)) (i32.const 0)) +(assert_return (invoke "ge_u" (i32.const -1) (i32.const 0x80000000)) (i32.const 1)) +(assert_return (invoke "ge_u" (i32.const 0x80000000) (i32.const 0x7fffffff)) (i32.const 1)) +(assert_return (invoke "ge_u" (i32.const 0x7fffffff) (i32.const 0x80000000)) (i32.const 0)) + + +(assert_invalid + (module + (func $type-unary-operand-empty + (i32.eqz) (drop) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-unary-operand-empty-in-block + (i32.const 0) + (block (i32.eqz) (drop)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-unary-operand-empty-in-loop + (i32.const 0) + (loop (i32.eqz) (drop)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-unary-operand-empty-in-if + (i32.const 0) (i32.const 0) + (if (then (i32.eqz) (drop))) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-unary-operand-empty-in-else + (i32.const 0) (i32.const 0) + (if (result i32) (then (i32.const 0)) (else (i32.eqz))) (drop) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-unary-operand-empty-in-br + (i32.const 0) + (block (br 0 (i32.eqz)) (drop)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-unary-operand-empty-in-br_if + (i32.const 0) + (block (br_if 0 (i32.eqz) (i32.const 1)) (drop)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-unary-operand-empty-in-br_table + (i32.const 0) + (block (br_table 0 (i32.eqz)) (drop)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-unary-operand-empty-in-return + (return (i32.eqz)) (drop) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-unary-operand-empty-in-select + (select (i32.eqz) (i32.const 1) (i32.const 2)) (drop) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-unary-operand-empty-in-call + (call 1 (i32.eqz)) (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-unary-operand-empty-in-call_indirect + (block (result i32) + (call_indirect (type $sig) + (i32.eqz) (i32.const 0) + ) + (drop) + ) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-unary-operand-empty-in-local.set + (local i32) + (local.set 0 (i32.eqz)) (local.get 0) (drop) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-unary-operand-empty-in-local.tee + (local i32) + (local.tee 0 (i32.eqz)) (drop) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (global $x (mut i32) (i32.const 0)) + (func $type-unary-operand-empty-in-global.set + (global.set $x (i32.eqz)) (global.get $x) (drop) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (memory 0) + (func $type-unary-operand-empty-in-memory.grow + (memory.grow (i32.eqz)) (drop) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (memory 0) + (func $type-unary-operand-empty-in-load + (i32.load (i32.eqz)) (drop) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (memory 1) + (func $type-unary-operand-empty-in-store + (i32.store (i32.eqz) (i32.const 1)) + ) + ) + "type mismatch" +) + +(assert_invalid + (module + (func $type-binary-1st-operand-empty + (i32.add) (drop) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-binary-2nd-operand-empty + (i32.const 0) (i32.add) (drop) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-binary-1st-operand-empty-in-block + (i32.const 0) (i32.const 0) + (block (i32.add) (drop)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-binary-2nd-operand-empty-in-block + (i32.const 0) + (block (i32.const 0) (i32.add) (drop)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-binary-1st-operand-empty-in-loop + (i32.const 0) (i32.const 0) + (loop (i32.add) (drop)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-binary-2nd-operand-empty-in-loop + (i32.const 0) + (loop (i32.const 0) (i32.add) (drop)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-binary-1st-operand-empty-in-if + (i32.const 0) (i32.const 0) (i32.const 0) + (if (i32.add) (then (drop))) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-binary-2nd-operand-empty-in-if + (i32.const 0) (i32.const 0) + (if (i32.const 0) (then (i32.add)) (else (drop))) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-binary-1st-operand-empty-in-else + (i32.const 0) (i32.const 0) (i32.const 0) + (if (result i32) (then (i32.const 0)) (else (i32.add) (i32.const 0))) + (drop) (drop) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-binary-2nd-operand-empty-in-else + (i32.const 0) (i32.const 0) + (if (result i32) (then (i32.const 0)) (else (i32.add))) + (drop) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-binary-1st-operand-empty-in-br + (i32.const 0) (i32.const 0) + (block (br 0 (i32.add)) (drop)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-binary-2nd-operand-empty-in-br + (i32.const 0) + (block (br 0 (i32.const 0) (i32.add)) (drop)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-binary-1st-operand-empty-in-br_if + (i32.const 0) (i32.const 0) + (block (br_if 0 (i32.add) (i32.const 1)) (drop)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-binary-2nd-operand-empty-in-br_if + (i32.const 0) + (block (br_if 0 (i32.const 0) (i32.add) (i32.const 1)) (drop)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-binary-1st-operand-empty-in-br_table + (i32.const 0) (i32.const 0) + (block (br_table 0 (i32.add)) (drop)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-binary-2nd-operand-empty-in-br_table + (i32.const 0) + (block (br_table 0 (i32.const 0) (i32.add)) (drop)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-binary-1st-operand-empty-in-return + (return (i32.add)) (drop) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-binary-2nd-operand-empty-in-return + (return (i32.const 0) (i32.add)) (drop) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-binary-1st-operand-empty-in-select + (select (i32.add) (i32.const 1) (i32.const 2)) (drop) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-binary-2nd-operand-empty-in-select + (select (i32.const 0) (i32.add) (i32.const 1) (i32.const 2)) (drop) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-binary-1st-operand-empty-in-call + (call 1 (i32.add)) (drop) + ) + (func (param i32 i32) (result i32) (local.get 0)) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-binary-2nd-operand-empty-in-call + (call 1 (i32.const 0) (i32.add)) (drop) + ) + (func (param i32 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-binary-1st-operand-empty-in-call_indirect + (block (result i32) + (call_indirect (type $sig) + (i32.add) (i32.const 0) + ) + (drop) + ) + ) + ) + "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-binary-2nd-operand-empty-in-call_indirect + (block (result i32) + (call_indirect (type $sig) + (i32.const 0) (i32.add) (i32.const 0) + ) + (drop) + ) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-binary-1st-operand-empty-in-local.set + (local i32) + (local.set 0 (i32.add)) (local.get 0) (drop) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-binary-2nd-operand-empty-in-local.set + (local i32) + (local.set 0 (i32.const 0) (i32.add)) (local.get 0) (drop) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-binary-1st-operand-empty-in-local.tee + (local i32) + (local.tee 0 (i32.add)) (drop) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-binary-2nd-operand-empty-in-local.tee + (local i32) + (local.tee 0 (i32.const 0) (i32.add)) (drop) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (global $x (mut i32) (i32.const 0)) + (func $type-binary-1st-operand-empty-in-global.set + (global.set $x (i32.add)) (global.get $x) (drop) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (global $x (mut i32) (i32.const 0)) + (func $type-binary-2nd-operand-empty-in-global.set + (global.set $x (i32.const 0) (i32.add)) (global.get $x) (drop) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (memory 0) + (func $type-binary-1st-operand-empty-in-memory.grow + (memory.grow (i32.add)) (drop) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (memory 0) + (func $type-binary-2nd-operand-empty-in-memory.grow + (memory.grow (i32.const 0) (i32.add)) (drop) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (memory 0) + (func $type-binary-1st-operand-empty-in-load + (i32.load (i32.add)) (drop) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (memory 0) + (func $type-binary-2nd-operand-empty-in-load + (i32.load (i32.const 0) (i32.add)) (drop) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (memory 1) + (func $type-binary-1st-operand-empty-in-store + (i32.store (i32.add) (i32.const 1)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (memory 1) + (func $type-binary-2nd-operand-empty-in-store + (i32.store (i32.const 1) (i32.add) (i32.const 0)) + ) + ) + "type mismatch" +) + + +;; Type check + +(assert_invalid (module (func (result i32) (i32.add (i64.const 0) (f32.const 0)))) "type mismatch") +(assert_invalid (module (func (result i32) (i32.and (i64.const 0) (f32.const 0)))) "type mismatch") +(assert_invalid (module (func (result i32) (i32.div_s (i64.const 0) (f32.const 0)))) "type mismatch") +(assert_invalid (module (func (result i32) (i32.div_u (i64.const 0) (f32.const 0)))) "type mismatch") +(assert_invalid (module (func (result i32) (i32.mul (i64.const 0) (f32.const 0)))) "type mismatch") +(assert_invalid (module (func (result i32) (i32.or (i64.const 0) (f32.const 0)))) "type mismatch") +(assert_invalid (module (func (result i32) (i32.rem_s (i64.const 0) (f32.const 0)))) "type mismatch") +(assert_invalid (module (func (result i32) (i32.rem_u (i64.const 0) (f32.const 0)))) "type mismatch") +(assert_invalid (module (func (result i32) (i32.rotl (i64.const 0) (f32.const 0)))) "type mismatch") +(assert_invalid (module (func (result i32) (i32.rotr (i64.const 0) (f32.const 0)))) "type mismatch") +(assert_invalid (module (func (result i32) (i32.shl (i64.const 0) (f32.const 0)))) "type mismatch") +(assert_invalid (module (func (result i32) (i32.shr_s (i64.const 0) (f32.const 0)))) "type mismatch") +(assert_invalid (module (func (result i32) (i32.shr_u (i64.const 0) (f32.const 0)))) "type mismatch") +(assert_invalid (module (func (result i32) (i32.sub (i64.const 0) (f32.const 0)))) "type mismatch") +(assert_invalid (module (func (result i32) (i32.xor (i64.const 0) (f32.const 0)))) "type mismatch") +(assert_invalid (module (func (result i32) (i32.eqz (i64.const 0)))) "type mismatch") +(assert_invalid (module (func (result i32) (i32.clz (i64.const 0)))) "type mismatch") +(assert_invalid (module (func (result i32) (i32.ctz (i64.const 0)))) "type mismatch") +(assert_invalid (module (func (result i32) (i32.popcnt (i64.const 0)))) "type mismatch") +(assert_invalid (module (func (result i32) (i32.eq (i64.const 0) (f32.const 0)))) "type mismatch") +(assert_invalid (module (func (result i32) (i32.ge_s (i64.const 0) (f32.const 0)))) "type mismatch") +(assert_invalid (module (func (result i32) (i32.ge_u (i64.const 0) (f32.const 0)))) "type mismatch") +(assert_invalid (module (func (result i32) (i32.gt_s (i64.const 0) (f32.const 0)))) "type mismatch") +(assert_invalid (module (func (result i32) (i32.gt_u (i64.const 0) (f32.const 0)))) "type mismatch") +(assert_invalid (module (func (result i32) (i32.le_s (i64.const 0) (f32.const 0)))) "type mismatch") +(assert_invalid (module (func (result i32) (i32.le_u (i64.const 0) (f32.const 0)))) "type mismatch") +(assert_invalid (module (func (result i32) (i32.lt_s (i64.const 0) (f32.const 0)))) "type mismatch") +(assert_invalid (module (func (result i32) (i32.lt_u (i64.const 0) (f32.const 0)))) "type mismatch") +(assert_invalid (module (func (result i32) (i32.ne (i64.const 0) (f32.const 0)))) "type mismatch") diff --git a/runtime/near-vm/tests/wast/spec/proposals/sign-extension-ops/i64.wast b/runtime/near-vm/tests/wast/spec/proposals/sign-extension-ops/i64.wast new file mode 100644 index 00000000000..baeed0ce1ba --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/proposals/sign-extension-ops/i64.wast @@ -0,0 +1,485 @@ +;; i64 operations + +(module + (func (export "add") (param $x i64) (param $y i64) (result i64) (i64.add (local.get $x) (local.get $y))) + (func (export "sub") (param $x i64) (param $y i64) (result i64) (i64.sub (local.get $x) (local.get $y))) + (func (export "mul") (param $x i64) (param $y i64) (result i64) (i64.mul (local.get $x) (local.get $y))) + (func (export "div_s") (param $x i64) (param $y i64) (result i64) (i64.div_s (local.get $x) (local.get $y))) + (func (export "div_u") (param $x i64) (param $y i64) (result i64) (i64.div_u (local.get $x) (local.get $y))) + (func (export "rem_s") (param $x i64) (param $y i64) (result i64) (i64.rem_s (local.get $x) (local.get $y))) + (func (export "rem_u") (param $x i64) (param $y i64) (result i64) (i64.rem_u (local.get $x) (local.get $y))) + (func (export "and") (param $x i64) (param $y i64) (result i64) (i64.and (local.get $x) (local.get $y))) + (func (export "or") (param $x i64) (param $y i64) (result i64) (i64.or (local.get $x) (local.get $y))) + (func (export "xor") (param $x i64) (param $y i64) (result i64) (i64.xor (local.get $x) (local.get $y))) + (func (export "shl") (param $x i64) (param $y i64) (result i64) (i64.shl (local.get $x) (local.get $y))) + (func (export "shr_s") (param $x i64) (param $y i64) (result i64) (i64.shr_s (local.get $x) (local.get $y))) + (func (export "shr_u") (param $x i64) (param $y i64) (result i64) (i64.shr_u (local.get $x) (local.get $y))) + (func (export "rotl") (param $x i64) (param $y i64) (result i64) (i64.rotl (local.get $x) (local.get $y))) + (func (export "rotr") (param $x i64) (param $y i64) (result i64) (i64.rotr (local.get $x) (local.get $y))) + (func (export "clz") (param $x i64) (result i64) (i64.clz (local.get $x))) + (func (export "ctz") (param $x i64) (result i64) (i64.ctz (local.get $x))) + (func (export "popcnt") (param $x i64) (result i64) (i64.popcnt (local.get $x))) + (func (export "extend8_s") (param $x i64) (result i64) (i64.extend8_s (local.get $x))) + (func (export "extend16_s") (param $x i64) (result i64) (i64.extend16_s (local.get $x))) + (func (export "extend32_s") (param $x i64) (result i64) (i64.extend32_s (local.get $x))) + (func (export "eqz") (param $x i64) (result i32) (i64.eqz (local.get $x))) + (func (export "eq") (param $x i64) (param $y i64) (result i32) (i64.eq (local.get $x) (local.get $y))) + (func (export "ne") (param $x i64) (param $y i64) (result i32) (i64.ne (local.get $x) (local.get $y))) + (func (export "lt_s") (param $x i64) (param $y i64) (result i32) (i64.lt_s (local.get $x) (local.get $y))) + (func (export "lt_u") (param $x i64) (param $y i64) (result i32) (i64.lt_u (local.get $x) (local.get $y))) + (func (export "le_s") (param $x i64) (param $y i64) (result i32) (i64.le_s (local.get $x) (local.get $y))) + (func (export "le_u") (param $x i64) (param $y i64) (result i32) (i64.le_u (local.get $x) (local.get $y))) + (func (export "gt_s") (param $x i64) (param $y i64) (result i32) (i64.gt_s (local.get $x) (local.get $y))) + (func (export "gt_u") (param $x i64) (param $y i64) (result i32) (i64.gt_u (local.get $x) (local.get $y))) + (func (export "ge_s") (param $x i64) (param $y i64) (result i32) (i64.ge_s (local.get $x) (local.get $y))) + (func (export "ge_u") (param $x i64) (param $y i64) (result i32) (i64.ge_u (local.get $x) (local.get $y))) +) + +(assert_return (invoke "add" (i64.const 1) (i64.const 1)) (i64.const 2)) +(assert_return (invoke "add" (i64.const 1) (i64.const 0)) (i64.const 1)) +(assert_return (invoke "add" (i64.const -1) (i64.const -1)) (i64.const -2)) +(assert_return (invoke "add" (i64.const -1) (i64.const 1)) (i64.const 0)) +(assert_return (invoke "add" (i64.const 0x7fffffffffffffff) (i64.const 1)) (i64.const 0x8000000000000000)) +(assert_return (invoke "add" (i64.const 0x8000000000000000) (i64.const -1)) (i64.const 0x7fffffffffffffff)) +(assert_return (invoke "add" (i64.const 0x8000000000000000) (i64.const 0x8000000000000000)) (i64.const 0)) +(assert_return (invoke "add" (i64.const 0x3fffffff) (i64.const 1)) (i64.const 0x40000000)) + +(assert_return (invoke "sub" (i64.const 1) (i64.const 1)) (i64.const 0)) +(assert_return (invoke "sub" (i64.const 1) (i64.const 0)) (i64.const 1)) +(assert_return (invoke "sub" (i64.const -1) (i64.const -1)) (i64.const 0)) +(assert_return (invoke "sub" (i64.const 0x7fffffffffffffff) (i64.const -1)) (i64.const 0x8000000000000000)) +(assert_return (invoke "sub" (i64.const 0x8000000000000000) (i64.const 1)) (i64.const 0x7fffffffffffffff)) +(assert_return (invoke "sub" (i64.const 0x8000000000000000) (i64.const 0x8000000000000000)) (i64.const 0)) +(assert_return (invoke "sub" (i64.const 0x3fffffff) (i64.const -1)) (i64.const 0x40000000)) + +(assert_return (invoke "mul" (i64.const 1) (i64.const 1)) (i64.const 1)) +(assert_return (invoke "mul" (i64.const 1) (i64.const 0)) (i64.const 0)) +(assert_return (invoke "mul" (i64.const -1) (i64.const -1)) (i64.const 1)) +(assert_return (invoke "mul" (i64.const 0x1000000000000000) (i64.const 4096)) (i64.const 0)) +(assert_return (invoke "mul" (i64.const 0x8000000000000000) (i64.const 0)) (i64.const 0)) +(assert_return (invoke "mul" (i64.const 0x8000000000000000) (i64.const -1)) (i64.const 0x8000000000000000)) +(assert_return (invoke "mul" (i64.const 0x7fffffffffffffff) (i64.const -1)) (i64.const 0x8000000000000001)) +(assert_return (invoke "mul" (i64.const 0x0123456789abcdef) (i64.const 0xfedcba9876543210)) (i64.const 0x2236d88fe5618cf0)) +(assert_return (invoke "mul" (i64.const 0x7fffffffffffffff) (i64.const 0x7fffffffffffffff)) (i64.const 1)) + +(assert_trap (invoke "div_s" (i64.const 1) (i64.const 0)) "integer divide by zero") +(assert_trap (invoke "div_s" (i64.const 0) (i64.const 0)) "integer divide by zero") +(assert_trap (invoke "div_s" (i64.const 0x8000000000000000) (i64.const -1)) "integer overflow") +(assert_trap (invoke "div_s" (i64.const 0x8000000000000000) (i64.const 0)) "integer divide by zero") +(assert_return (invoke "div_s" (i64.const 1) (i64.const 1)) (i64.const 1)) +(assert_return (invoke "div_s" (i64.const 0) (i64.const 1)) (i64.const 0)) +(assert_return (invoke "div_s" (i64.const 0) (i64.const -1)) (i64.const 0)) +(assert_return (invoke "div_s" (i64.const -1) (i64.const -1)) (i64.const 1)) +(assert_return (invoke "div_s" (i64.const 0x8000000000000000) (i64.const 2)) (i64.const 0xc000000000000000)) +(assert_return (invoke "div_s" (i64.const 0x8000000000000001) (i64.const 1000)) (i64.const 0xffdf3b645a1cac09)) +(assert_return (invoke "div_s" (i64.const 5) (i64.const 2)) (i64.const 2)) +(assert_return (invoke "div_s" (i64.const -5) (i64.const 2)) (i64.const -2)) +(assert_return (invoke "div_s" (i64.const 5) (i64.const -2)) (i64.const -2)) +(assert_return (invoke "div_s" (i64.const -5) (i64.const -2)) (i64.const 2)) +(assert_return (invoke "div_s" (i64.const 7) (i64.const 3)) (i64.const 2)) +(assert_return (invoke "div_s" (i64.const -7) (i64.const 3)) (i64.const -2)) +(assert_return (invoke "div_s" (i64.const 7) (i64.const -3)) (i64.const -2)) +(assert_return (invoke "div_s" (i64.const -7) (i64.const -3)) (i64.const 2)) +(assert_return (invoke "div_s" (i64.const 11) (i64.const 5)) (i64.const 2)) +(assert_return (invoke "div_s" (i64.const 17) (i64.const 7)) (i64.const 2)) + +(assert_trap (invoke "div_u" (i64.const 1) (i64.const 0)) "integer divide by zero") +(assert_trap (invoke "div_u" (i64.const 0) (i64.const 0)) "integer divide by zero") +(assert_return (invoke "div_u" (i64.const 1) (i64.const 1)) (i64.const 1)) +(assert_return (invoke "div_u" (i64.const 0) (i64.const 1)) (i64.const 0)) +(assert_return (invoke "div_u" (i64.const -1) (i64.const -1)) (i64.const 1)) +(assert_return (invoke "div_u" (i64.const 0x8000000000000000) (i64.const -1)) (i64.const 0)) +(assert_return (invoke "div_u" (i64.const 0x8000000000000000) (i64.const 2)) (i64.const 0x4000000000000000)) +(assert_return (invoke "div_u" (i64.const 0x8ff00ff00ff00ff0) (i64.const 0x100000001)) (i64.const 0x8ff00fef)) +(assert_return (invoke "div_u" (i64.const 0x8000000000000001) (i64.const 1000)) (i64.const 0x20c49ba5e353f7)) +(assert_return (invoke "div_u" (i64.const 5) (i64.const 2)) (i64.const 2)) +(assert_return (invoke "div_u" (i64.const -5) (i64.const 2)) (i64.const 0x7ffffffffffffffd)) +(assert_return (invoke "div_u" (i64.const 5) (i64.const -2)) (i64.const 0)) +(assert_return (invoke "div_u" (i64.const -5) (i64.const -2)) (i64.const 0)) +(assert_return (invoke "div_u" (i64.const 7) (i64.const 3)) (i64.const 2)) +(assert_return (invoke "div_u" (i64.const 11) (i64.const 5)) (i64.const 2)) +(assert_return (invoke "div_u" (i64.const 17) (i64.const 7)) (i64.const 2)) + +(assert_trap (invoke "rem_s" (i64.const 1) (i64.const 0)) "integer divide by zero") +(assert_trap (invoke "rem_s" (i64.const 0) (i64.const 0)) "integer divide by zero") +(assert_return (invoke "rem_s" (i64.const 0x7fffffffffffffff) (i64.const -1)) (i64.const 0)) +(assert_return (invoke "rem_s" (i64.const 1) (i64.const 1)) (i64.const 0)) +(assert_return (invoke "rem_s" (i64.const 0) (i64.const 1)) (i64.const 0)) +(assert_return (invoke "rem_s" (i64.const 0) (i64.const -1)) (i64.const 0)) +(assert_return (invoke "rem_s" (i64.const -1) (i64.const -1)) (i64.const 0)) +(assert_return (invoke "rem_s" (i64.const 0x8000000000000000) (i64.const -1)) (i64.const 0)) +(assert_return (invoke "rem_s" (i64.const 0x8000000000000000) (i64.const 2)) (i64.const 0)) +(assert_return (invoke "rem_s" (i64.const 0x8000000000000001) (i64.const 1000)) (i64.const -807)) +(assert_return (invoke "rem_s" (i64.const 5) (i64.const 2)) (i64.const 1)) +(assert_return (invoke "rem_s" (i64.const -5) (i64.const 2)) (i64.const -1)) +(assert_return (invoke "rem_s" (i64.const 5) (i64.const -2)) (i64.const 1)) +(assert_return (invoke "rem_s" (i64.const -5) (i64.const -2)) (i64.const -1)) +(assert_return (invoke "rem_s" (i64.const 7) (i64.const 3)) (i64.const 1)) +(assert_return (invoke "rem_s" (i64.const -7) (i64.const 3)) (i64.const -1)) +(assert_return (invoke "rem_s" (i64.const 7) (i64.const -3)) (i64.const 1)) +(assert_return (invoke "rem_s" (i64.const -7) (i64.const -3)) (i64.const -1)) +(assert_return (invoke "rem_s" (i64.const 11) (i64.const 5)) (i64.const 1)) +(assert_return (invoke "rem_s" (i64.const 17) (i64.const 7)) (i64.const 3)) + +(assert_trap (invoke "rem_u" (i64.const 1) (i64.const 0)) "integer divide by zero") +(assert_trap (invoke "rem_u" (i64.const 0) (i64.const 0)) "integer divide by zero") +(assert_return (invoke "rem_u" (i64.const 1) (i64.const 1)) (i64.const 0)) +(assert_return (invoke "rem_u" (i64.const 0) (i64.const 1)) (i64.const 0)) +(assert_return (invoke "rem_u" (i64.const -1) (i64.const -1)) (i64.const 0)) +(assert_return (invoke "rem_u" (i64.const 0x8000000000000000) (i64.const -1)) (i64.const 0x8000000000000000)) +(assert_return (invoke "rem_u" (i64.const 0x8000000000000000) (i64.const 2)) (i64.const 0)) +(assert_return (invoke "rem_u" (i64.const 0x8ff00ff00ff00ff0) (i64.const 0x100000001)) (i64.const 0x80000001)) +(assert_return (invoke "rem_u" (i64.const 0x8000000000000001) (i64.const 1000)) (i64.const 809)) +(assert_return (invoke "rem_u" (i64.const 5) (i64.const 2)) (i64.const 1)) +(assert_return (invoke "rem_u" (i64.const -5) (i64.const 2)) (i64.const 1)) +(assert_return (invoke "rem_u" (i64.const 5) (i64.const -2)) (i64.const 5)) +(assert_return (invoke "rem_u" (i64.const -5) (i64.const -2)) (i64.const -5)) +(assert_return (invoke "rem_u" (i64.const 7) (i64.const 3)) (i64.const 1)) +(assert_return (invoke "rem_u" (i64.const 11) (i64.const 5)) (i64.const 1)) +(assert_return (invoke "rem_u" (i64.const 17) (i64.const 7)) (i64.const 3)) + +(assert_return (invoke "and" (i64.const 1) (i64.const 0)) (i64.const 0)) +(assert_return (invoke "and" (i64.const 0) (i64.const 1)) (i64.const 0)) +(assert_return (invoke "and" (i64.const 1) (i64.const 1)) (i64.const 1)) +(assert_return (invoke "and" (i64.const 0) (i64.const 0)) (i64.const 0)) +(assert_return (invoke "and" (i64.const 0x7fffffffffffffff) (i64.const 0x8000000000000000)) (i64.const 0)) +(assert_return (invoke "and" (i64.const 0x7fffffffffffffff) (i64.const -1)) (i64.const 0x7fffffffffffffff)) +(assert_return (invoke "and" (i64.const 0xf0f0ffff) (i64.const 0xfffff0f0)) (i64.const 0xf0f0f0f0)) +(assert_return (invoke "and" (i64.const 0xffffffffffffffff) (i64.const 0xffffffffffffffff)) (i64.const 0xffffffffffffffff)) + +(assert_return (invoke "or" (i64.const 1) (i64.const 0)) (i64.const 1)) +(assert_return (invoke "or" (i64.const 0) (i64.const 1)) (i64.const 1)) +(assert_return (invoke "or" (i64.const 1) (i64.const 1)) (i64.const 1)) +(assert_return (invoke "or" (i64.const 0) (i64.const 0)) (i64.const 0)) +(assert_return (invoke "or" (i64.const 0x7fffffffffffffff) (i64.const 0x8000000000000000)) (i64.const -1)) +(assert_return (invoke "or" (i64.const 0x8000000000000000) (i64.const 0)) (i64.const 0x8000000000000000)) +(assert_return (invoke "or" (i64.const 0xf0f0ffff) (i64.const 0xfffff0f0)) (i64.const 0xffffffff)) +(assert_return (invoke "or" (i64.const 0xffffffffffffffff) (i64.const 0xffffffffffffffff)) (i64.const 0xffffffffffffffff)) + +(assert_return (invoke "xor" (i64.const 1) (i64.const 0)) (i64.const 1)) +(assert_return (invoke "xor" (i64.const 0) (i64.const 1)) (i64.const 1)) +(assert_return (invoke "xor" (i64.const 1) (i64.const 1)) (i64.const 0)) +(assert_return (invoke "xor" (i64.const 0) (i64.const 0)) (i64.const 0)) +(assert_return (invoke "xor" (i64.const 0x7fffffffffffffff) (i64.const 0x8000000000000000)) (i64.const -1)) +(assert_return (invoke "xor" (i64.const 0x8000000000000000) (i64.const 0)) (i64.const 0x8000000000000000)) +(assert_return (invoke "xor" (i64.const -1) (i64.const 0x8000000000000000)) (i64.const 0x7fffffffffffffff)) +(assert_return (invoke "xor" (i64.const -1) (i64.const 0x7fffffffffffffff)) (i64.const 0x8000000000000000)) +(assert_return (invoke "xor" (i64.const 0xf0f0ffff) (i64.const 0xfffff0f0)) (i64.const 0x0f0f0f0f)) +(assert_return (invoke "xor" (i64.const 0xffffffffffffffff) (i64.const 0xffffffffffffffff)) (i64.const 0)) + +(assert_return (invoke "shl" (i64.const 1) (i64.const 1)) (i64.const 2)) +(assert_return (invoke "shl" (i64.const 1) (i64.const 0)) (i64.const 1)) +(assert_return (invoke "shl" (i64.const 0x7fffffffffffffff) (i64.const 1)) (i64.const 0xfffffffffffffffe)) +(assert_return (invoke "shl" (i64.const 0xffffffffffffffff) (i64.const 1)) (i64.const 0xfffffffffffffffe)) +(assert_return (invoke "shl" (i64.const 0x8000000000000000) (i64.const 1)) (i64.const 0)) +(assert_return (invoke "shl" (i64.const 0x4000000000000000) (i64.const 1)) (i64.const 0x8000000000000000)) +(assert_return (invoke "shl" (i64.const 1) (i64.const 63)) (i64.const 0x8000000000000000)) +(assert_return (invoke "shl" (i64.const 1) (i64.const 64)) (i64.const 1)) +(assert_return (invoke "shl" (i64.const 1) (i64.const 65)) (i64.const 2)) +(assert_return (invoke "shl" (i64.const 1) (i64.const -1)) (i64.const 0x8000000000000000)) +(assert_return (invoke "shl" (i64.const 1) (i64.const 0x7fffffffffffffff)) (i64.const 0x8000000000000000)) + +(assert_return (invoke "shr_s" (i64.const 1) (i64.const 1)) (i64.const 0)) +(assert_return (invoke "shr_s" (i64.const 1) (i64.const 0)) (i64.const 1)) +(assert_return (invoke "shr_s" (i64.const -1) (i64.const 1)) (i64.const -1)) +(assert_return (invoke "shr_s" (i64.const 0x7fffffffffffffff) (i64.const 1)) (i64.const 0x3fffffffffffffff)) +(assert_return (invoke "shr_s" (i64.const 0x8000000000000000) (i64.const 1)) (i64.const 0xc000000000000000)) +(assert_return (invoke "shr_s" (i64.const 0x4000000000000000) (i64.const 1)) (i64.const 0x2000000000000000)) +(assert_return (invoke "shr_s" (i64.const 1) (i64.const 64)) (i64.const 1)) +(assert_return (invoke "shr_s" (i64.const 1) (i64.const 65)) (i64.const 0)) +(assert_return (invoke "shr_s" (i64.const 1) (i64.const -1)) (i64.const 0)) +(assert_return (invoke "shr_s" (i64.const 1) (i64.const 0x7fffffffffffffff)) (i64.const 0)) +(assert_return (invoke "shr_s" (i64.const 1) (i64.const 0x8000000000000000)) (i64.const 1)) +(assert_return (invoke "shr_s" (i64.const 0x8000000000000000) (i64.const 63)) (i64.const -1)) +(assert_return (invoke "shr_s" (i64.const -1) (i64.const 64)) (i64.const -1)) +(assert_return (invoke "shr_s" (i64.const -1) (i64.const 65)) (i64.const -1)) +(assert_return (invoke "shr_s" (i64.const -1) (i64.const -1)) (i64.const -1)) +(assert_return (invoke "shr_s" (i64.const -1) (i64.const 0x7fffffffffffffff)) (i64.const -1)) +(assert_return (invoke "shr_s" (i64.const -1) (i64.const 0x8000000000000000)) (i64.const -1)) + +(assert_return (invoke "shr_u" (i64.const 1) (i64.const 1)) (i64.const 0)) +(assert_return (invoke "shr_u" (i64.const 1) (i64.const 0)) (i64.const 1)) +(assert_return (invoke "shr_u" (i64.const -1) (i64.const 1)) (i64.const 0x7fffffffffffffff)) +(assert_return (invoke "shr_u" (i64.const 0x7fffffffffffffff) (i64.const 1)) (i64.const 0x3fffffffffffffff)) +(assert_return (invoke "shr_u" (i64.const 0x8000000000000000) (i64.const 1)) (i64.const 0x4000000000000000)) +(assert_return (invoke "shr_u" (i64.const 0x4000000000000000) (i64.const 1)) (i64.const 0x2000000000000000)) +(assert_return (invoke "shr_u" (i64.const 1) (i64.const 64)) (i64.const 1)) +(assert_return (invoke "shr_u" (i64.const 1) (i64.const 65)) (i64.const 0)) +(assert_return (invoke "shr_u" (i64.const 1) (i64.const -1)) (i64.const 0)) +(assert_return (invoke "shr_u" (i64.const 1) (i64.const 0x7fffffffffffffff)) (i64.const 0)) +(assert_return (invoke "shr_u" (i64.const 1) (i64.const 0x8000000000000000)) (i64.const 1)) +(assert_return (invoke "shr_u" (i64.const 0x8000000000000000) (i64.const 63)) (i64.const 1)) +(assert_return (invoke "shr_u" (i64.const -1) (i64.const 64)) (i64.const -1)) +(assert_return (invoke "shr_u" (i64.const -1) (i64.const 65)) (i64.const 0x7fffffffffffffff)) +(assert_return (invoke "shr_u" (i64.const -1) (i64.const -1)) (i64.const 1)) +(assert_return (invoke "shr_u" (i64.const -1) (i64.const 0x7fffffffffffffff)) (i64.const 1)) +(assert_return (invoke "shr_u" (i64.const -1) (i64.const 0x8000000000000000)) (i64.const -1)) + +(assert_return (invoke "rotl" (i64.const 1) (i64.const 1)) (i64.const 2)) +(assert_return (invoke "rotl" (i64.const 1) (i64.const 0)) (i64.const 1)) +(assert_return (invoke "rotl" (i64.const -1) (i64.const 1)) (i64.const -1)) +(assert_return (invoke "rotl" (i64.const 1) (i64.const 64)) (i64.const 1)) +(assert_return (invoke "rotl" (i64.const 0xabcd987602468ace) (i64.const 1)) (i64.const 0x579b30ec048d159d)) +(assert_return (invoke "rotl" (i64.const 0xfe000000dc000000) (i64.const 4)) (i64.const 0xe000000dc000000f)) +(assert_return (invoke "rotl" (i64.const 0xabcd1234ef567809) (i64.const 53)) (i64.const 0x013579a2469deacf)) +(assert_return (invoke "rotl" (i64.const 0xabd1234ef567809c) (i64.const 63)) (i64.const 0x55e891a77ab3c04e)) +(assert_return (invoke "rotl" (i64.const 0xabcd1234ef567809) (i64.const 0xf5)) (i64.const 0x013579a2469deacf)) +(assert_return (invoke "rotl" (i64.const 0xabcd7294ef567809) (i64.const 0xffffffffffffffed)) (i64.const 0xcf013579ae529dea)) +(assert_return (invoke "rotl" (i64.const 0xabd1234ef567809c) (i64.const 0x800000000000003f)) (i64.const 0x55e891a77ab3c04e)) +(assert_return (invoke "rotl" (i64.const 1) (i64.const 63)) (i64.const 0x8000000000000000)) +(assert_return (invoke "rotl" (i64.const 0x8000000000000000) (i64.const 1)) (i64.const 1)) + +(assert_return (invoke "rotr" (i64.const 1) (i64.const 1)) (i64.const 0x8000000000000000)) +(assert_return (invoke "rotr" (i64.const 1) (i64.const 0)) (i64.const 1)) +(assert_return (invoke "rotr" (i64.const -1) (i64.const 1)) (i64.const -1)) +(assert_return (invoke "rotr" (i64.const 1) (i64.const 64)) (i64.const 1)) +(assert_return (invoke "rotr" (i64.const 0xabcd987602468ace) (i64.const 1)) (i64.const 0x55e6cc3b01234567)) +(assert_return (invoke "rotr" (i64.const 0xfe000000dc000000) (i64.const 4)) (i64.const 0x0fe000000dc00000)) +(assert_return (invoke "rotr" (i64.const 0xabcd1234ef567809) (i64.const 53)) (i64.const 0x6891a77ab3c04d5e)) +(assert_return (invoke "rotr" (i64.const 0xabd1234ef567809c) (i64.const 63)) (i64.const 0x57a2469deacf0139)) +(assert_return (invoke "rotr" (i64.const 0xabcd1234ef567809) (i64.const 0xf5)) (i64.const 0x6891a77ab3c04d5e)) +(assert_return (invoke "rotr" (i64.const 0xabcd7294ef567809) (i64.const 0xffffffffffffffed)) (i64.const 0x94a77ab3c04d5e6b)) +(assert_return (invoke "rotr" (i64.const 0xabd1234ef567809c) (i64.const 0x800000000000003f)) (i64.const 0x57a2469deacf0139)) +(assert_return (invoke "rotr" (i64.const 1) (i64.const 63)) (i64.const 2)) +(assert_return (invoke "rotr" (i64.const 0x8000000000000000) (i64.const 63)) (i64.const 1)) + +(assert_return (invoke "clz" (i64.const 0xffffffffffffffff)) (i64.const 0)) +(assert_return (invoke "clz" (i64.const 0)) (i64.const 64)) +(assert_return (invoke "clz" (i64.const 0x00008000)) (i64.const 48)) +(assert_return (invoke "clz" (i64.const 0xff)) (i64.const 56)) +(assert_return (invoke "clz" (i64.const 0x8000000000000000)) (i64.const 0)) +(assert_return (invoke "clz" (i64.const 1)) (i64.const 63)) +(assert_return (invoke "clz" (i64.const 2)) (i64.const 62)) +(assert_return (invoke "clz" (i64.const 0x7fffffffffffffff)) (i64.const 1)) + +(assert_return (invoke "ctz" (i64.const -1)) (i64.const 0)) +(assert_return (invoke "ctz" (i64.const 0)) (i64.const 64)) +(assert_return (invoke "ctz" (i64.const 0x00008000)) (i64.const 15)) +(assert_return (invoke "ctz" (i64.const 0x00010000)) (i64.const 16)) +(assert_return (invoke "ctz" (i64.const 0x8000000000000000)) (i64.const 63)) +(assert_return (invoke "ctz" (i64.const 0x7fffffffffffffff)) (i64.const 0)) + +(assert_return (invoke "popcnt" (i64.const -1)) (i64.const 64)) +(assert_return (invoke "popcnt" (i64.const 0)) (i64.const 0)) +(assert_return (invoke "popcnt" (i64.const 0x00008000)) (i64.const 1)) +(assert_return (invoke "popcnt" (i64.const 0x8000800080008000)) (i64.const 4)) +(assert_return (invoke "popcnt" (i64.const 0x7fffffffffffffff)) (i64.const 63)) +(assert_return (invoke "popcnt" (i64.const 0xAAAAAAAA55555555)) (i64.const 32)) +(assert_return (invoke "popcnt" (i64.const 0x99999999AAAAAAAA)) (i64.const 32)) +(assert_return (invoke "popcnt" (i64.const 0xDEADBEEFDEADBEEF)) (i64.const 48)) + +(assert_return (invoke "extend8_s" (i64.const 0)) (i64.const 0)) +(assert_return (invoke "extend8_s" (i64.const 0x7f)) (i64.const 127)) +(assert_return (invoke "extend8_s" (i64.const 0x80)) (i64.const -128)) +(assert_return (invoke "extend8_s" (i64.const 0xff)) (i64.const -1)) +(assert_return (invoke "extend8_s" (i64.const 0x01234567_89abcd_00)) (i64.const 0)) +(assert_return (invoke "extend8_s" (i64.const 0xfedcba98_765432_80)) (i64.const -0x80)) +(assert_return (invoke "extend8_s" (i64.const -1)) (i64.const -1)) + +(assert_return (invoke "extend16_s" (i64.const 0)) (i64.const 0)) +(assert_return (invoke "extend16_s" (i64.const 0x7fff)) (i64.const 32767)) +(assert_return (invoke "extend16_s" (i64.const 0x8000)) (i64.const -32768)) +(assert_return (invoke "extend16_s" (i64.const 0xffff)) (i64.const -1)) +(assert_return (invoke "extend16_s" (i64.const 0x12345678_9abc_0000)) (i64.const 0)) +(assert_return (invoke "extend16_s" (i64.const 0xfedcba98_7654_8000)) (i64.const -0x8000)) +(assert_return (invoke "extend16_s" (i64.const -1)) (i64.const -1)) + +(assert_return (invoke "extend32_s" (i64.const 0)) (i64.const 0)) +(assert_return (invoke "extend32_s" (i64.const 0x7fff)) (i64.const 32767)) +(assert_return (invoke "extend32_s" (i64.const 0x8000)) (i64.const 32768)) +(assert_return (invoke "extend32_s" (i64.const 0xffff)) (i64.const 65535)) +(assert_return (invoke "extend32_s" (i64.const 0x7fffffff)) (i64.const 0x7fffffff)) +(assert_return (invoke "extend32_s" (i64.const 0x80000000)) (i64.const -0x80000000)) +(assert_return (invoke "extend32_s" (i64.const 0xffffffff)) (i64.const -1)) +(assert_return (invoke "extend32_s" (i64.const 0x01234567_00000000)) (i64.const 0)) +(assert_return (invoke "extend32_s" (i64.const 0xfedcba98_80000000)) (i64.const -0x80000000)) +(assert_return (invoke "extend32_s" (i64.const -1)) (i64.const -1)) + +(assert_return (invoke "eqz" (i64.const 0)) (i32.const 1)) +(assert_return (invoke "eqz" (i64.const 1)) (i32.const 0)) +(assert_return (invoke "eqz" (i64.const 0x8000000000000000)) (i32.const 0)) +(assert_return (invoke "eqz" (i64.const 0x7fffffffffffffff)) (i32.const 0)) +(assert_return (invoke "eqz" (i64.const 0xffffffffffffffff)) (i32.const 0)) + +(assert_return (invoke "eq" (i64.const 0) (i64.const 0)) (i32.const 1)) +(assert_return (invoke "eq" (i64.const 1) (i64.const 1)) (i32.const 1)) +(assert_return (invoke "eq" (i64.const -1) (i64.const 1)) (i32.const 0)) +(assert_return (invoke "eq" (i64.const 0x8000000000000000) (i64.const 0x8000000000000000)) (i32.const 1)) +(assert_return (invoke "eq" (i64.const 0x7fffffffffffffff) (i64.const 0x7fffffffffffffff)) (i32.const 1)) +(assert_return (invoke "eq" (i64.const -1) (i64.const -1)) (i32.const 1)) +(assert_return (invoke "eq" (i64.const 1) (i64.const 0)) (i32.const 0)) +(assert_return (invoke "eq" (i64.const 0) (i64.const 1)) (i32.const 0)) +(assert_return (invoke "eq" (i64.const 0x8000000000000000) (i64.const 0)) (i32.const 0)) +(assert_return (invoke "eq" (i64.const 0) (i64.const 0x8000000000000000)) (i32.const 0)) +(assert_return (invoke "eq" (i64.const 0x8000000000000000) (i64.const -1)) (i32.const 0)) +(assert_return (invoke "eq" (i64.const -1) (i64.const 0x8000000000000000)) (i32.const 0)) +(assert_return (invoke "eq" (i64.const 0x8000000000000000) (i64.const 0x7fffffffffffffff)) (i32.const 0)) +(assert_return (invoke "eq" (i64.const 0x7fffffffffffffff) (i64.const 0x8000000000000000)) (i32.const 0)) + +(assert_return (invoke "ne" (i64.const 0) (i64.const 0)) (i32.const 0)) +(assert_return (invoke "ne" (i64.const 1) (i64.const 1)) (i32.const 0)) +(assert_return (invoke "ne" (i64.const -1) (i64.const 1)) (i32.const 1)) +(assert_return (invoke "ne" (i64.const 0x8000000000000000) (i64.const 0x8000000000000000)) (i32.const 0)) +(assert_return (invoke "ne" (i64.const 0x7fffffffffffffff) (i64.const 0x7fffffffffffffff)) (i32.const 0)) +(assert_return (invoke "ne" (i64.const -1) (i64.const -1)) (i32.const 0)) +(assert_return (invoke "ne" (i64.const 1) (i64.const 0)) (i32.const 1)) +(assert_return (invoke "ne" (i64.const 0) (i64.const 1)) (i32.const 1)) +(assert_return (invoke "ne" (i64.const 0x8000000000000000) (i64.const 0)) (i32.const 1)) +(assert_return (invoke "ne" (i64.const 0) (i64.const 0x8000000000000000)) (i32.const 1)) +(assert_return (invoke "ne" (i64.const 0x8000000000000000) (i64.const -1)) (i32.const 1)) +(assert_return (invoke "ne" (i64.const -1) (i64.const 0x8000000000000000)) (i32.const 1)) +(assert_return (invoke "ne" (i64.const 0x8000000000000000) (i64.const 0x7fffffffffffffff)) (i32.const 1)) +(assert_return (invoke "ne" (i64.const 0x7fffffffffffffff) (i64.const 0x8000000000000000)) (i32.const 1)) + +(assert_return (invoke "lt_s" (i64.const 0) (i64.const 0)) (i32.const 0)) +(assert_return (invoke "lt_s" (i64.const 1) (i64.const 1)) (i32.const 0)) +(assert_return (invoke "lt_s" (i64.const -1) (i64.const 1)) (i32.const 1)) +(assert_return (invoke "lt_s" (i64.const 0x8000000000000000) (i64.const 0x8000000000000000)) (i32.const 0)) +(assert_return (invoke "lt_s" (i64.const 0x7fffffffffffffff) (i64.const 0x7fffffffffffffff)) (i32.const 0)) +(assert_return (invoke "lt_s" (i64.const -1) (i64.const -1)) (i32.const 0)) +(assert_return (invoke "lt_s" (i64.const 1) (i64.const 0)) (i32.const 0)) +(assert_return (invoke "lt_s" (i64.const 0) (i64.const 1)) (i32.const 1)) +(assert_return (invoke "lt_s" (i64.const 0x8000000000000000) (i64.const 0)) (i32.const 1)) +(assert_return (invoke "lt_s" (i64.const 0) (i64.const 0x8000000000000000)) (i32.const 0)) +(assert_return (invoke "lt_s" (i64.const 0x8000000000000000) (i64.const -1)) (i32.const 1)) +(assert_return (invoke "lt_s" (i64.const -1) (i64.const 0x8000000000000000)) (i32.const 0)) +(assert_return (invoke "lt_s" (i64.const 0x8000000000000000) (i64.const 0x7fffffffffffffff)) (i32.const 1)) +(assert_return (invoke "lt_s" (i64.const 0x7fffffffffffffff) (i64.const 0x8000000000000000)) (i32.const 0)) + +(assert_return (invoke "lt_u" (i64.const 0) (i64.const 0)) (i32.const 0)) +(assert_return (invoke "lt_u" (i64.const 1) (i64.const 1)) (i32.const 0)) +(assert_return (invoke "lt_u" (i64.const -1) (i64.const 1)) (i32.const 0)) +(assert_return (invoke "lt_u" (i64.const 0x8000000000000000) (i64.const 0x8000000000000000)) (i32.const 0)) +(assert_return (invoke "lt_u" (i64.const 0x7fffffffffffffff) (i64.const 0x7fffffffffffffff)) (i32.const 0)) +(assert_return (invoke "lt_u" (i64.const -1) (i64.const -1)) (i32.const 0)) +(assert_return (invoke "lt_u" (i64.const 1) (i64.const 0)) (i32.const 0)) +(assert_return (invoke "lt_u" (i64.const 0) (i64.const 1)) (i32.const 1)) +(assert_return (invoke "lt_u" (i64.const 0x8000000000000000) (i64.const 0)) (i32.const 0)) +(assert_return (invoke "lt_u" (i64.const 0) (i64.const 0x8000000000000000)) (i32.const 1)) +(assert_return (invoke "lt_u" (i64.const 0x8000000000000000) (i64.const -1)) (i32.const 1)) +(assert_return (invoke "lt_u" (i64.const -1) (i64.const 0x8000000000000000)) (i32.const 0)) +(assert_return (invoke "lt_u" (i64.const 0x8000000000000000) (i64.const 0x7fffffffffffffff)) (i32.const 0)) +(assert_return (invoke "lt_u" (i64.const 0x7fffffffffffffff) (i64.const 0x8000000000000000)) (i32.const 1)) + +(assert_return (invoke "le_s" (i64.const 0) (i64.const 0)) (i32.const 1)) +(assert_return (invoke "le_s" (i64.const 1) (i64.const 1)) (i32.const 1)) +(assert_return (invoke "le_s" (i64.const -1) (i64.const 1)) (i32.const 1)) +(assert_return (invoke "le_s" (i64.const 0x8000000000000000) (i64.const 0x8000000000000000)) (i32.const 1)) +(assert_return (invoke "le_s" (i64.const 0x7fffffffffffffff) (i64.const 0x7fffffffffffffff)) (i32.const 1)) +(assert_return (invoke "le_s" (i64.const -1) (i64.const -1)) (i32.const 1)) +(assert_return (invoke "le_s" (i64.const 1) (i64.const 0)) (i32.const 0)) +(assert_return (invoke "le_s" (i64.const 0) (i64.const 1)) (i32.const 1)) +(assert_return (invoke "le_s" (i64.const 0x8000000000000000) (i64.const 0)) (i32.const 1)) +(assert_return (invoke "le_s" (i64.const 0) (i64.const 0x8000000000000000)) (i32.const 0)) +(assert_return (invoke "le_s" (i64.const 0x8000000000000000) (i64.const -1)) (i32.const 1)) +(assert_return (invoke "le_s" (i64.const -1) (i64.const 0x8000000000000000)) (i32.const 0)) +(assert_return (invoke "le_s" (i64.const 0x8000000000000000) (i64.const 0x7fffffffffffffff)) (i32.const 1)) +(assert_return (invoke "le_s" (i64.const 0x7fffffffffffffff) (i64.const 0x8000000000000000)) (i32.const 0)) + +(assert_return (invoke "le_u" (i64.const 0) (i64.const 0)) (i32.const 1)) +(assert_return (invoke "le_u" (i64.const 1) (i64.const 1)) (i32.const 1)) +(assert_return (invoke "le_u" (i64.const -1) (i64.const 1)) (i32.const 0)) +(assert_return (invoke "le_u" (i64.const 0x8000000000000000) (i64.const 0x8000000000000000)) (i32.const 1)) +(assert_return (invoke "le_u" (i64.const 0x7fffffffffffffff) (i64.const 0x7fffffffffffffff)) (i32.const 1)) +(assert_return (invoke "le_u" (i64.const -1) (i64.const -1)) (i32.const 1)) +(assert_return (invoke "le_u" (i64.const 1) (i64.const 0)) (i32.const 0)) +(assert_return (invoke "le_u" (i64.const 0) (i64.const 1)) (i32.const 1)) +(assert_return (invoke "le_u" (i64.const 0x8000000000000000) (i64.const 0)) (i32.const 0)) +(assert_return (invoke "le_u" (i64.const 0) (i64.const 0x8000000000000000)) (i32.const 1)) +(assert_return (invoke "le_u" (i64.const 0x8000000000000000) (i64.const -1)) (i32.const 1)) +(assert_return (invoke "le_u" (i64.const -1) (i64.const 0x8000000000000000)) (i32.const 0)) +(assert_return (invoke "le_u" (i64.const 0x8000000000000000) (i64.const 0x7fffffffffffffff)) (i32.const 0)) +(assert_return (invoke "le_u" (i64.const 0x7fffffffffffffff) (i64.const 0x8000000000000000)) (i32.const 1)) + +(assert_return (invoke "gt_s" (i64.const 0) (i64.const 0)) (i32.const 0)) +(assert_return (invoke "gt_s" (i64.const 1) (i64.const 1)) (i32.const 0)) +(assert_return (invoke "gt_s" (i64.const -1) (i64.const 1)) (i32.const 0)) +(assert_return (invoke "gt_s" (i64.const 0x8000000000000000) (i64.const 0x8000000000000000)) (i32.const 0)) +(assert_return (invoke "gt_s" (i64.const 0x7fffffffffffffff) (i64.const 0x7fffffffffffffff)) (i32.const 0)) +(assert_return (invoke "gt_s" (i64.const -1) (i64.const -1)) (i32.const 0)) +(assert_return (invoke "gt_s" (i64.const 1) (i64.const 0)) (i32.const 1)) +(assert_return (invoke "gt_s" (i64.const 0) (i64.const 1)) (i32.const 0)) +(assert_return (invoke "gt_s" (i64.const 0x8000000000000000) (i64.const 0)) (i32.const 0)) +(assert_return (invoke "gt_s" (i64.const 0) (i64.const 0x8000000000000000)) (i32.const 1)) +(assert_return (invoke "gt_s" (i64.const 0x8000000000000000) (i64.const -1)) (i32.const 0)) +(assert_return (invoke "gt_s" (i64.const -1) (i64.const 0x8000000000000000)) (i32.const 1)) +(assert_return (invoke "gt_s" (i64.const 0x8000000000000000) (i64.const 0x7fffffffffffffff)) (i32.const 0)) +(assert_return (invoke "gt_s" (i64.const 0x7fffffffffffffff) (i64.const 0x8000000000000000)) (i32.const 1)) + +(assert_return (invoke "gt_u" (i64.const 0) (i64.const 0)) (i32.const 0)) +(assert_return (invoke "gt_u" (i64.const 1) (i64.const 1)) (i32.const 0)) +(assert_return (invoke "gt_u" (i64.const -1) (i64.const 1)) (i32.const 1)) +(assert_return (invoke "gt_u" (i64.const 0x8000000000000000) (i64.const 0x8000000000000000)) (i32.const 0)) +(assert_return (invoke "gt_u" (i64.const 0x7fffffffffffffff) (i64.const 0x7fffffffffffffff)) (i32.const 0)) +(assert_return (invoke "gt_u" (i64.const -1) (i64.const -1)) (i32.const 0)) +(assert_return (invoke "gt_u" (i64.const 1) (i64.const 0)) (i32.const 1)) +(assert_return (invoke "gt_u" (i64.const 0) (i64.const 1)) (i32.const 0)) +(assert_return (invoke "gt_u" (i64.const 0x8000000000000000) (i64.const 0)) (i32.const 1)) +(assert_return (invoke "gt_u" (i64.const 0) (i64.const 0x8000000000000000)) (i32.const 0)) +(assert_return (invoke "gt_u" (i64.const 0x8000000000000000) (i64.const -1)) (i32.const 0)) +(assert_return (invoke "gt_u" (i64.const -1) (i64.const 0x8000000000000000)) (i32.const 1)) +(assert_return (invoke "gt_u" (i64.const 0x8000000000000000) (i64.const 0x7fffffffffffffff)) (i32.const 1)) +(assert_return (invoke "gt_u" (i64.const 0x7fffffffffffffff) (i64.const 0x8000000000000000)) (i32.const 0)) + +(assert_return (invoke "ge_s" (i64.const 0) (i64.const 0)) (i32.const 1)) +(assert_return (invoke "ge_s" (i64.const 1) (i64.const 1)) (i32.const 1)) +(assert_return (invoke "ge_s" (i64.const -1) (i64.const 1)) (i32.const 0)) +(assert_return (invoke "ge_s" (i64.const 0x8000000000000000) (i64.const 0x8000000000000000)) (i32.const 1)) +(assert_return (invoke "ge_s" (i64.const 0x7fffffffffffffff) (i64.const 0x7fffffffffffffff)) (i32.const 1)) +(assert_return (invoke "ge_s" (i64.const -1) (i64.const -1)) (i32.const 1)) +(assert_return (invoke "ge_s" (i64.const 1) (i64.const 0)) (i32.const 1)) +(assert_return (invoke "ge_s" (i64.const 0) (i64.const 1)) (i32.const 0)) +(assert_return (invoke "ge_s" (i64.const 0x8000000000000000) (i64.const 0)) (i32.const 0)) +(assert_return (invoke "ge_s" (i64.const 0) (i64.const 0x8000000000000000)) (i32.const 1)) +(assert_return (invoke "ge_s" (i64.const 0x8000000000000000) (i64.const -1)) (i32.const 0)) +(assert_return (invoke "ge_s" (i64.const -1) (i64.const 0x8000000000000000)) (i32.const 1)) +(assert_return (invoke "ge_s" (i64.const 0x8000000000000000) (i64.const 0x7fffffffffffffff)) (i32.const 0)) +(assert_return (invoke "ge_s" (i64.const 0x7fffffffffffffff) (i64.const 0x8000000000000000)) (i32.const 1)) + +(assert_return (invoke "ge_u" (i64.const 0) (i64.const 0)) (i32.const 1)) +(assert_return (invoke "ge_u" (i64.const 1) (i64.const 1)) (i32.const 1)) +(assert_return (invoke "ge_u" (i64.const -1) (i64.const 1)) (i32.const 1)) +(assert_return (invoke "ge_u" (i64.const 0x8000000000000000) (i64.const 0x8000000000000000)) (i32.const 1)) +(assert_return (invoke "ge_u" (i64.const 0x7fffffffffffffff) (i64.const 0x7fffffffffffffff)) (i32.const 1)) +(assert_return (invoke "ge_u" (i64.const -1) (i64.const -1)) (i32.const 1)) +(assert_return (invoke "ge_u" (i64.const 1) (i64.const 0)) (i32.const 1)) +(assert_return (invoke "ge_u" (i64.const 0) (i64.const 1)) (i32.const 0)) +(assert_return (invoke "ge_u" (i64.const 0x8000000000000000) (i64.const 0)) (i32.const 1)) +(assert_return (invoke "ge_u" (i64.const 0) (i64.const 0x8000000000000000)) (i32.const 0)) +(assert_return (invoke "ge_u" (i64.const 0x8000000000000000) (i64.const -1)) (i32.const 0)) +(assert_return (invoke "ge_u" (i64.const -1) (i64.const 0x8000000000000000)) (i32.const 1)) +(assert_return (invoke "ge_u" (i64.const 0x8000000000000000) (i64.const 0x7fffffffffffffff)) (i32.const 1)) +(assert_return (invoke "ge_u" (i64.const 0x7fffffffffffffff) (i64.const 0x8000000000000000)) (i32.const 0)) + + +;; Type check + +(assert_invalid (module (func (result i64) (i64.add (i32.const 0) (f32.const 0)))) "type mismatch") +(assert_invalid (module (func (result i64) (i64.and (i32.const 0) (f32.const 0)))) "type mismatch") +(assert_invalid (module (func (result i64) (i64.div_s (i32.const 0) (f32.const 0)))) "type mismatch") +(assert_invalid (module (func (result i64) (i64.div_u (i32.const 0) (f32.const 0)))) "type mismatch") +(assert_invalid (module (func (result i64) (i64.mul (i32.const 0) (f32.const 0)))) "type mismatch") +(assert_invalid (module (func (result i64) (i64.or (i32.const 0) (f32.const 0)))) "type mismatch") +(assert_invalid (module (func (result i64) (i64.rem_s (i32.const 0) (f32.const 0)))) "type mismatch") +(assert_invalid (module (func (result i64) (i64.rem_u (i32.const 0) (f32.const 0)))) "type mismatch") +(assert_invalid (module (func (result i64) (i64.rotl (i32.const 0) (f32.const 0)))) "type mismatch") +(assert_invalid (module (func (result i64) (i64.rotr (i32.const 0) (f32.const 0)))) "type mismatch") +(assert_invalid (module (func (result i64) (i64.shl (i32.const 0) (f32.const 0)))) "type mismatch") +(assert_invalid (module (func (result i64) (i64.shr_s (i32.const 0) (f32.const 0)))) "type mismatch") +(assert_invalid (module (func (result i64) (i64.shr_u (i32.const 0) (f32.const 0)))) "type mismatch") +(assert_invalid (module (func (result i64) (i64.sub (i32.const 0) (f32.const 0)))) "type mismatch") +(assert_invalid (module (func (result i64) (i64.xor (i32.const 0) (f32.const 0)))) "type mismatch") +(assert_invalid (module (func (result i64) (i64.eqz (i32.const 0)))) "type mismatch") +(assert_invalid (module (func (result i64) (i64.clz (i32.const 0)))) "type mismatch") +(assert_invalid (module (func (result i64) (i64.ctz (i32.const 0)))) "type mismatch") +(assert_invalid (module (func (result i64) (i64.popcnt (i32.const 0)))) "type mismatch") +(assert_invalid (module (func (result i64) (i64.eq (i32.const 0) (f32.const 0)))) "type mismatch") +(assert_invalid (module (func (result i64) (i64.ge_s (i32.const 0) (f32.const 0)))) "type mismatch") +(assert_invalid (module (func (result i64) (i64.ge_u (i32.const 0) (f32.const 0)))) "type mismatch") +(assert_invalid (module (func (result i64) (i64.gt_s (i32.const 0) (f32.const 0)))) "type mismatch") +(assert_invalid (module (func (result i64) (i64.gt_u (i32.const 0) (f32.const 0)))) "type mismatch") +(assert_invalid (module (func (result i64) (i64.le_s (i32.const 0) (f32.const 0)))) "type mismatch") +(assert_invalid (module (func (result i64) (i64.le_u (i32.const 0) (f32.const 0)))) "type mismatch") +(assert_invalid (module (func (result i64) (i64.lt_s (i32.const 0) (f32.const 0)))) "type mismatch") +(assert_invalid (module (func (result i64) (i64.lt_u (i32.const 0) (f32.const 0)))) "type mismatch") +(assert_invalid (module (func (result i64) (i64.ne (i32.const 0) (f32.const 0)))) "type mismatch") diff --git a/runtime/near-vm/tests/wast/spec/proposals/simd/simd_address.wast b/runtime/near-vm/tests/wast/spec/proposals/simd/simd_address.wast new file mode 100644 index 00000000000..9e023008bba --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/proposals/simd/simd_address.wast @@ -0,0 +1,157 @@ +;; Load/Store v128 data with different valid offset/alignment + +(module + (memory 1) + (data (i32.const 0) "\00\01\02\03\04\05\06\07\08\09\10\11\12\13\14\15") + (data (offset (i32.const 65505)) "\16\17\18\19\20\21\22\23\24\25\26\27\28\29\30\31") + + (func (export "load_data_1") (param $i i32) (result v128) + (v128.load offset=0 (local.get $i)) ;; 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x10 0x11 0x12 0x13 0x14 0x15 + ) + (func (export "load_data_2") (param $i i32) (result v128) + (v128.load align=1 (local.get $i)) ;; 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x10 0x11 0x12 0x13 0x14 0x15 + ) + (func (export "load_data_3") (param $i i32) (result v128) + (v128.load offset=1 align=1 (local.get $i)) ;; 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x10 0x11 0x12 0x13 0x14 0x15 0x00 + ) + (func (export "load_data_4") (param $i i32) (result v128) + (v128.load offset=2 align=1 (local.get $i)) ;; 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x10 0x11 0x12 0x13 0x14 0x15 0x00 0x00 + ) + (func (export "load_data_5") (param $i i32) (result v128) + (v128.load offset=15 align=1 (local.get $i)) ;; 0x15 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 + ) + + (func (export "store_data_0") (result v128) + (v128.store offset=0 (i32.const 0) (v128.const f32x4 0 1 2 3)) + (v128.load offset=0 (i32.const 0)) + ) + (func (export "store_data_1") (result v128) + (v128.store align=1 (i32.const 0) (v128.const i32x4 0 1 2 3)) + (v128.load align=1 (i32.const 0)) + ) + (func (export "store_data_2") (result v128) + (v128.store offset=1 align=1 (i32.const 0) (v128.const i16x8 0 1 2 3 4 5 6 7)) + (v128.load offset=1 align=1 (i32.const 0)) + ) + (func (export "store_data_3") (result v128) + (v128.store offset=2 align=1 (i32.const 0) (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)) + (v128.load offset=2 align=1 (i32.const 0)) + ) + (func (export "store_data_4") (result v128) + (v128.store offset=15 align=1 (i32.const 0) (v128.const i32x4 0 1 2 3)) + (v128.load offset=15 (i32.const 0)) + ) + (func (export "store_data_5") (result v128) + (v128.store offset=65520 align=1 (i32.const 0) (v128.const i32x4 0 1 2 3)) + (v128.load offset=65520 (i32.const 0)) + ) + (func (export "store_data_6") (param $i i32) + (v128.store offset=1 align=1 (local.get $i) (v128.const i32x4 0 1 2 3)) + ) +) + +(assert_return (invoke "load_data_1" (i32.const 0)) (v128.const i32x4 0x03020100 0x07060504 0x11100908 0x15141312)) +(assert_return (invoke "load_data_2" (i32.const 0)) (v128.const i32x4 0x03020100 0x07060504 0x11100908 0x15141312)) +(assert_return (invoke "load_data_3" (i32.const 0)) (v128.const i32x4 0x04030201 0x08070605 0x12111009 0x00151413)) +(assert_return (invoke "load_data_4" (i32.const 0)) (v128.const i32x4 0x05040302 0x09080706 0x13121110 0x00001514)) +(assert_return (invoke "load_data_5" (i32.const 0)) (v128.const i32x4 0x00000015 0x00000000 0x00000000 0x00000000)) + +(assert_return (invoke "load_data_1" (i32.const 0)) (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x1110 0x1312 0x1514)) +(assert_return (invoke "load_data_2" (i32.const 0)) (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x1110 0x1312 0x1514)) +(assert_return (invoke "load_data_3" (i32.const 0)) (v128.const i16x8 0x0201 0x0403 0x0605 0x0807 0x1009 0x1211 0x1413 0x0015)) +(assert_return (invoke "load_data_4" (i32.const 0)) (v128.const i16x8 0x0302 0x0504 0x0706 0x0908 0x1110 0x1312 0x1514 0x0000)) +(assert_return (invoke "load_data_5" (i32.const 0)) (v128.const i16x8 0x0015 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000)) + +(assert_return (invoke "load_data_1" (i32.const 0)) (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x10 0x11 0x12 0x13 0x14 0x15)) +(assert_return (invoke "load_data_2" (i32.const 0)) (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x10 0x11 0x12 0x13 0x14 0x15)) +(assert_return (invoke "load_data_3" (i32.const 0)) (v128.const i8x16 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x10 0x11 0x12 0x13 0x14 0x15 0x00)) +(assert_return (invoke "load_data_4" (i32.const 0)) (v128.const i8x16 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x10 0x11 0x12 0x13 0x14 0x15 0x00 0x00)) +(assert_return (invoke "load_data_5" (i32.const 0)) (v128.const i8x16 0x15 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00)) + +(assert_return (invoke "load_data_1" (i32.const 65505)) (v128.const i32x4 0x19181716 0x23222120 0x27262524 0x31302928)) +(assert_return (invoke "load_data_2" (i32.const 65505)) (v128.const i32x4 0x19181716 0x23222120 0x27262524 0x31302928)) +(assert_return (invoke "load_data_3" (i32.const 65505)) (v128.const i32x4 0x20191817 0x24232221 0x28272625 0x00313029)) +(assert_return (invoke "load_data_4" (i32.const 65505)) (v128.const i32x4 0x21201918 0x25242322 0x29282726 0x00003130)) +(assert_return (invoke "load_data_5" (i32.const 65505)) (v128.const i32x4 0x00000031 0x00000000 0x00000000 0x00000000)) + +(assert_return (invoke "load_data_1" (i32.const 65505)) (v128.const i16x8 0x1716 0x1918 0x2120 0x2322 0x2524 0x2726 0x2928 0x3130)) +(assert_return (invoke "load_data_2" (i32.const 65505)) (v128.const i16x8 0x1716 0x1918 0x2120 0x2322 0x2524 0x2726 0x2928 0x3130)) +(assert_return (invoke "load_data_3" (i32.const 65505)) (v128.const i16x8 0x1817 0x2019 0x2221 0x2423 0x2625 0x2827 0x3029 0x0031)) +(assert_return (invoke "load_data_4" (i32.const 65505)) (v128.const i16x8 0x1918 0x2120 0x2322 0x2524 0x2726 0x2928 0x3130 0x0000)) +(assert_return (invoke "load_data_5" (i32.const 65505)) (v128.const i16x8 0x0031 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000)) + +(assert_return (invoke "load_data_1" (i32.const 65505)) (v128.const i8x16 0x16 0x17 0x18 0x19 0x20 0x21 0x22 0x23 0x24 0x25 0x26 0x27 0x28 0x29 0x30 0x31)) +(assert_return (invoke "load_data_2" (i32.const 65505)) (v128.const i8x16 0x16 0x17 0x18 0x19 0x20 0x21 0x22 0x23 0x24 0x25 0x26 0x27 0x28 0x29 0x30 0x31)) +(assert_return (invoke "load_data_3" (i32.const 65505)) (v128.const i8x16 0x17 0x18 0x19 0x20 0x21 0x22 0x23 0x24 0x25 0x26 0x27 0x28 0x29 0x30 0x31 0x00)) +(assert_return (invoke "load_data_4" (i32.const 65505)) (v128.const i8x16 0x18 0x19 0x20 0x21 0x22 0x23 0x24 0x25 0x26 0x27 0x28 0x29 0x30 0x31 0x00 0x00)) +(assert_return (invoke "load_data_5" (i32.const 65505)) (v128.const i8x16 0x31 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00)) + +(assert_trap (invoke "load_data_3" (i32.const -1)) "out of bounds memory access") +(assert_trap (invoke "load_data_5" (i32.const 65506)) "out of bounds memory access") + +(assert_return (invoke "store_data_0") (v128.const f32x4 0 1 2 3)) +(assert_return (invoke "store_data_1") (v128.const i32x4 0 1 2 3)) +(assert_return (invoke "store_data_2") (v128.const i16x8 0 1 2 3 4 5 6 7)) +(assert_return (invoke "store_data_3") (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)) +(assert_return (invoke "store_data_4") (v128.const i32x4 0 1 2 3)) +(assert_return (invoke "store_data_5") (v128.const i32x4 0 1 2 3)) + +(assert_trap (invoke "store_data_6" (i32.const -1)) "out of bounds memory access") +(assert_trap (invoke "store_data_6" (i32.const 65535)) "out of bounds memory access") + +;; Load/Store v128 data with invalid offset + +(module + (memory 1) + (func (export "v128.load_offset_65521") + (drop (v128.load offset=65521 (i32.const 0))) + ) +) +(assert_trap (invoke "v128.load_offset_65521") "out of bounds memory access") + +(assert_malformed + (module quote + "(memory 1)" + "(func" + " (drop (v128.load offset=-1 (i32.const 0)))" + ")" + ) + "unknown operator" +) + +(module + (memory 1) + (func (export "v128.store_offset_65521") + (v128.store offset=65521 (i32.const 0) (v128.const i32x4 0 0 0 0)) + ) +) +(assert_trap (invoke "v128.store_offset_65521") "out of bounds memory access") + +(assert_malformed + (module quote + "(memory 1)" + "(func" + " (v128.store offset=-1 (i32.const 0) (v128.const i32x4 0 0 0 0))" + ")" + ) + "unknown operator" +) + + +;; Offset constant out of range + +(assert_malformed + (module quote + "(memory 1)" + "(func (drop (v128.load offset=4294967296 (i32.const 0))))" + ) + "i32 constant" +) + +(assert_malformed + (module quote + "(memory 1)" + "(func (v128.store offset=4294967296 (i32.const 0) (v128.const i32x4 0 0 0 0)))" + ) + "i32 constant" +) diff --git a/runtime/near-vm/tests/wast/spec/proposals/simd/simd_align.wast b/runtime/near-vm/tests/wast/spec/proposals/simd/simd_align.wast new file mode 100644 index 00000000000..ed91ed5c602 --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/proposals/simd/simd_align.wast @@ -0,0 +1,355 @@ +;; Valid alignment + +(module (memory 1) (func (drop (v128.load align=1 (i32.const 0))))) +(module (memory 1) (func (drop (v128.load align=2 (i32.const 0))))) +(module (memory 1) (func (drop (v128.load align=4 (i32.const 0))))) +(module (memory 1) (func (drop (v128.load align=8 (i32.const 0))))) +(module (memory 1) (func (drop (v128.load align=16 (i32.const 0))))) + +(module (memory 1) (func (v128.store align=1 (i32.const 0) (v128.const i32x4 0 1 2 3)))) +(module (memory 1) (func (v128.store align=2 (i32.const 0) (v128.const i32x4 0 1 2 3)))) +(module (memory 1) (func (v128.store align=4 (i32.const 0) (v128.const i32x4 0 1 2 3)))) +(module (memory 1) (func (v128.store align=8 (i32.const 0) (v128.const i32x4 0 1 2 3)))) +(module (memory 1) (func (v128.store align=16 (i32.const 0) (v128.const i32x4 0 1 2 3)))) + +(module (memory 1) (func (drop (v128.load8x8_s align=1 (i32.const 0))))) +(module (memory 1) (func (drop (v128.load8x8_s align=2 (i32.const 0))))) +(module (memory 1) (func (drop (v128.load8x8_s align=4 (i32.const 0))))) +(module (memory 1) (func (drop (v128.load8x8_s align=8 (i32.const 0))))) +(module (memory 1) (func (drop (v128.load8x8_u align=1 (i32.const 0))))) +(module (memory 1) (func (drop (v128.load8x8_u align=2 (i32.const 0))))) +(module (memory 1) (func (drop (v128.load8x8_u align=4 (i32.const 0))))) +(module (memory 1) (func (drop (v128.load8x8_u align=8 (i32.const 0))))) +(module (memory 1) (func (drop (v128.load16x4_s align=1 (i32.const 0))))) +(module (memory 1) (func (drop (v128.load16x4_s align=2 (i32.const 0))))) +(module (memory 1) (func (drop (v128.load16x4_s align=4 (i32.const 0))))) +(module (memory 1) (func (drop (v128.load16x4_s align=8 (i32.const 0))))) +(module (memory 1) (func (drop (v128.load16x4_u align=1 (i32.const 0))))) +(module (memory 1) (func (drop (v128.load16x4_u align=2 (i32.const 0))))) +(module (memory 1) (func (drop (v128.load16x4_u align=4 (i32.const 0))))) +(module (memory 1) (func (drop (v128.load16x4_u align=8 (i32.const 0))))) +(module (memory 1) (func (drop (v128.load32x2_s align=1 (i32.const 0))))) +(module (memory 1) (func (drop (v128.load32x2_s align=2 (i32.const 0))))) +(module (memory 1) (func (drop (v128.load32x2_s align=4 (i32.const 0))))) +(module (memory 1) (func (drop (v128.load32x2_s align=8 (i32.const 0))))) +(module (memory 1) (func (drop (v128.load32x2_u align=1 (i32.const 0))))) +(module (memory 1) (func (drop (v128.load32x2_u align=2 (i32.const 0))))) +(module (memory 1) (func (drop (v128.load32x2_u align=4 (i32.const 0))))) +(module (memory 1) (func (drop (v128.load32x2_u align=8 (i32.const 0))))) + +(module (memory 1) (func (drop (v128.load8_splat align=1 (i32.const 0))))) +(module (memory 1) (func (drop (v128.load16_splat align=1 (i32.const 0))))) +(module (memory 1) (func (drop (v128.load16_splat align=2 (i32.const 0))))) +(module (memory 1) (func (drop (v128.load32_splat align=1 (i32.const 0))))) +(module (memory 1) (func (drop (v128.load32_splat align=2 (i32.const 0))))) +(module (memory 1) (func (drop (v128.load32_splat align=4 (i32.const 0))))) +(module (memory 1) (func (drop (v128.load64_splat align=1 (i32.const 0))))) +(module (memory 1) (func (drop (v128.load64_splat align=2 (i32.const 0))))) +(module (memory 1) (func (drop (v128.load64_splat align=4 (i32.const 0))))) +(module (memory 1) (func (drop (v128.load64_splat align=8 (i32.const 0))))) + +;; Invalid alignment + +(assert_invalid + (module (memory 1) (func (drop (v128.load align=32 (i32.const 0))))) + "alignment must not be larger than natural" +) +(assert_invalid + (module (memory 0) (func(v128.store align=32 (i32.const 0) (v128.const i32x4 0 0 0 0)))) + "alignment must not be larger than natural" +) +(assert_invalid + (module (memory 1) (func (result v128) (v128.load8x8_s align=16 (i32.const 0)))) + "alignment must not be larger than natural" +) +(assert_invalid + (module (memory 1) (func (result v128) (v128.load8x8_u align=16 (i32.const 0)))) + "alignment must not be larger than natural" +) +(assert_invalid + (module (memory 1) (func (result v128) (v128.load16x4_s align=16 (i32.const 0)))) + "alignment must not be larger than natural" +) +(assert_invalid + (module (memory 1) (func (result v128) (v128.load16x4_u align=16 (i32.const 0)))) + "alignment must not be larger than natural" +) +(assert_invalid + (module (memory 1) (func (result v128) (v128.load32x2_s align=16 (i32.const 0)))) + "alignment must not be larger than natural" +) +(assert_invalid + (module (memory 1) (func (result v128) (v128.load32x2_u align=16 (i32.const 0)))) + "alignment must not be larger than natural" +) +(assert_invalid + (module (memory 1) (func (result v128) (v128.load8_splat align=2 (i32.const 0)))) + "alignment must not be larger than natural" +) +(assert_invalid + (module (memory 1) (func (result v128) (v128.load16_splat align=4 (i32.const 0)))) + "alignment must not be larger than natural" +) +(assert_invalid + (module (memory 1) (func (result v128) (v128.load32_splat align=8 (i32.const 0)))) + "alignment must not be larger than natural" +) +(assert_invalid + (module (memory 1) (func (result v128) (v128.load64_splat align=16 (i32.const 0)))) + "alignment must not be larger than natural" +) + +;; Malformed alignment + +(assert_malformed + (module quote + "(memory 1) (func (drop (v128.load align=-1 (i32.const 0))))" + ) + "unknown operator" +) +(assert_malformed + (module quote + "(memory 1) (func (drop (v128.load align=0 (i32.const 0))))" + ) + "alignment must be a power of two" +) +(assert_malformed + (module quote + "(memory 1) (func (drop (v128.load align=7 (i32.const 0))))" + ) + "alignment must be a power of two" +) +(assert_malformed + (module quote + "(memory 1) (func (v128.store align=-1 (i32.const 0) (v128.const i32x4 0 0 0 0)))" + ) + "unknown operator" +) +(assert_malformed + (module quote + "(memory 0) (func (v128.store align=0 (i32.const 0) (v128.const i32x4 0 0 0 0)))" + ) + "alignment must be a power of two" +) +(assert_malformed + (module quote + "(memory 0) (func (v128.store align=7 (i32.const 0) (v128.const i32x4 0 0 0 0)))" + ) + "alignment must be a power of two" +) +(assert_malformed + (module quote + "(memory 1) (func (result v128) (v128.load8x8_s align=-1 (i32.const 0)))" + ) + "unknown operator" +) +(assert_malformed + (module quote + "(memory 1) (func (result v128) (v128.load8x8_s align=0 (i32.const 0)))" + ) + "alignment must be a power of two" +) +(assert_malformed + (module quote + "(memory 1) (func (result v128) (v128.load8x8_s align=7 (i32.const 0)))" + ) + "alignment must be a power of two" +) +(assert_malformed + (module quote + "(memory 1) (func (result v128) (v128.load8x8_u align=-1 (i32.const 0)))" + ) + "unknown operator" +) +(assert_malformed + (module quote + "(memory 1) (func (result v128) (v128.load8x8_u align=0 (i32.const 0)))" + ) + "alignment must be a power of two" +) +(assert_malformed + (module quote + "(memory 1) (func (result v128) (v128.load8x8_u align=7 (i32.const 0)))" + ) + "alignment must be a power of two" +) +(assert_malformed + (module quote + "(memory 1) (func (result v128) (v128.load16x4_s align=-1 (i32.const 0)))" + ) + "unknown operator" +) +(assert_malformed + (module quote + "(memory 1) (func (result v128) (v128.load16x4_s align=0 (i32.const 0)))" + ) + "alignment must be a power of two" +) +(assert_malformed + (module quote + "(memory 1) (func (result v128) (v128.load16x4_s align=7 (i32.const 0)))" + ) + "alignment must be a power of two" +) +(assert_malformed + (module quote + "(memory 1) (func (result v128) (v128.load16x4_u align=-1 (i32.const 0)))" + ) + "unknown operator" +) +(assert_malformed + (module quote + "(memory 1) (func (result v128) (v128.load16x4_u align=0 (i32.const 0)))" + ) + "alignment must be a power of two" +) +(assert_malformed + (module quote + "(memory 1) (func (result v128) (v128.load16x4_u align=7 (i32.const 0)))" + ) + "alignment must be a power of two" +) +(assert_malformed + (module quote + "(memory 1) (func (result v128) (v128.load32x2_s align=-1 (i32.const 0)))" + ) + "unknown operator" +) +(assert_malformed + (module quote + "(memory 1) (func (result v128) (v128.load32x2_s align=0 (i32.const 0)))" + ) + "alignment must be a power of two" +) +(assert_malformed + (module quote + "(memory 1) (func (result v128) (v128.load32x2_s align=7 (i32.const 0)))" + ) + "alignment must be a power of two" +) +(assert_malformed + (module quote + "(memory 1) (func (result v128) (v128.load32x2_u align=-1 (i32.const 0)))" + ) + "unknown operator" +) +(assert_malformed + (module quote + "(memory 1) (func (result v128) (v128.load32x2_u align=0 (i32.const 0)))" + ) + "alignment must be a power of two" +) +(assert_malformed + (module quote + "(memory 1) (func (result v128) (v128.load32x2_u align=7 (i32.const 0)))" + ) + "alignment must be a power of two" +) +(assert_malformed + (module quote + "(memory 1) (func (result v128) (v128.load8_splat align=-1 (i32.const 0)))" + ) + "unknown operator" +) +(assert_malformed + (module quote + "(memory 1) (func (result v128) (v128.load8_splat align=0 (i32.const 0)))" + ) + "alignment must be a power of two" +) +(assert_malformed + (module quote + "(memory 1) (func (result v128) (v128.load16_splat align=-1 (i32.const 0)))" + ) + "unknown operator" +) +(assert_malformed + (module quote + "(memory 1) (func (result v128) (v128.load16_splat align=0 (i32.const 0)))" + ) + "alignment must be a power of two" +) +(assert_malformed + (module quote + "(memory 1) (func (result v128) (v128.load32_splat align=-1 (i32.const 0)))" + ) + "unknown operator" +) +(assert_malformed + (module quote + "(memory 1) (func (result v128) (v128.load32_splat align=0 (i32.const 0)))" + ) + "alignment must be a power of two" +) +(assert_malformed + (module quote + "(memory 1) (func (result v128) (v128.load32_splat align=3 (i32.const 0)))" + ) + "alignment must be a power of two" +) +(assert_malformed + (module quote + "(memory 1) (func (result v128) (v128.load64_splat align=-1 (i32.const 0)))" + ) + "unknown operator" +) +(assert_malformed + (module quote + "(memory 1) (func (result v128) (v128.load64_splat align=0 (i32.const 0)))" + ) + "alignment must be a power of two" +) +(assert_malformed + (module quote + "(memory 1) (func (result v128) (v128.load64_splat align=7 (i32.const 0)))" + ) + "alignment must be a power of two" +) + +;; Test that misaligned SIMD loads/stores don't trap + +(module + (memory 1 1) + (func (export "v128.load align=16") (param $address i32) (result v128) + (v128.load align=16 (local.get $address)) + ) + (func (export "v128.store align=16") (param $address i32) (param $value v128) + (v128.store align=16 (local.get $address) (local.get $value)) + ) +) + +(assert_return (invoke "v128.load align=16" (i32.const 0)) (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "v128.load align=16" (i32.const 1)) (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "v128.store align=16" (i32.const 1) (v128.const i8x16 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16))) +(assert_return (invoke "v128.load align=16" (i32.const 0)) (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)) + +;; Test aligned and unaligned read/write + +(module + (memory 1) + (func (export "v128_unaligned_read_and_write") (result v128) + (local v128) + (v128.store (i32.const 0) (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)) + (v128.load (i32.const 0)) + ) + (func (export "v128_aligned_read_and_write") (result v128) + (local v128) + (v128.store align=2 (i32.const 0) (v128.const i16x8 0 1 2 3 4 5 6 7)) + (v128.load align=2 (i32.const 0)) + ) + (func (export "v128_aligned_read_and_unaligned_write") (result v128) + (local v128) + (v128.store (i32.const 0) (v128.const i32x4 0 1 2 3)) + (v128.load align=2 (i32.const 0)) + ) + (func (export "v128_unaligned_read_and_aligned_write") (result v128) + (local v128) + (v128.store align=2 (i32.const 0) (v128.const i32x4 0 1 2 3)) + (v128.load (i32.const 0)) + ) +) + +(assert_return (invoke "v128_unaligned_read_and_write") (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)) +(assert_return (invoke "v128_aligned_read_and_write") (v128.const i16x8 0 1 2 3 4 5 6 7)) +(assert_return (invoke "v128_aligned_read_and_unaligned_write") (v128.const i32x4 0 1 2 3)) +(assert_return (invoke "v128_unaligned_read_and_aligned_write") (v128.const i32x4 0 1 2 3)) diff --git a/runtime/near-vm/tests/wast/spec/proposals/simd/simd_bit_shift.wast b/runtime/near-vm/tests/wast/spec/proposals/simd/simd_bit_shift.wast new file mode 100644 index 00000000000..98e155651e4 --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/proposals/simd/simd_bit_shift.wast @@ -0,0 +1,1104 @@ +;; Test all the bit shift operators on major boundary values and all special values. + +(module + (func (export "i8x16.shl") (param $0 v128) (param $1 i32) (result v128) (i8x16.shl (local.get $0) (local.get $1))) + (func (export "i8x16.shr_s") (param $0 v128) (param $1 i32) (result v128) (i8x16.shr_s (local.get $0) (local.get $1))) + (func (export "i8x16.shr_u") (param $0 v128) (param $1 i32) (result v128) (i8x16.shr_u (local.get $0) (local.get $1))) + + (func (export "i16x8.shl") (param $0 v128) (param $1 i32) (result v128) (i16x8.shl (local.get $0) (local.get $1))) + (func (export "i16x8.shr_s") (param $0 v128) (param $1 i32) (result v128) (i16x8.shr_s (local.get $0) (local.get $1))) + (func (export "i16x8.shr_u") (param $0 v128) (param $1 i32) (result v128) (i16x8.shr_u (local.get $0) (local.get $1))) + + (func (export "i32x4.shl") (param $0 v128) (param $1 i32) (result v128) (i32x4.shl (local.get $0) (local.get $1))) + (func (export "i32x4.shr_s") (param $0 v128) (param $1 i32) (result v128) (i32x4.shr_s (local.get $0) (local.get $1))) + (func (export "i32x4.shr_u") (param $0 v128) (param $1 i32) (result v128) (i32x4.shr_u (local.get $0) (local.get $1))) + + (func (export "i64x2.shl") (param $0 v128) (param $1 i32) (result v128) (i64x2.shl (local.get $0) (local.get $1))) + (func (export "i64x2.shr_s") (param $0 v128) (param $1 i32) (result v128) (i64x2.shr_s (local.get $0) (local.get $1))) + (func (export "i64x2.shr_u") (param $0 v128) (param $1 i32) (result v128) (i64x2.shr_u (local.get $0) (local.get $1))) + + ;; shifting by a constant amount + ;; i8x16 + (func (export "i8x16.shl_1") (param $0 v128) (result v128) (i8x16.shl (local.get $0) (i32.const 1))) + (func (export "i8x16.shr_u_8") (param $0 v128) (result v128) (i8x16.shr_u (local.get $0) (i32.const 8))) + (func (export "i8x16.shr_s_9") (param $0 v128) (result v128) (i8x16.shr_s (local.get $0) (i32.const 9))) + + ;; i16x8 + (func (export "i16x8.shl_1") (param $0 v128) (result v128) (i16x8.shl (local.get $0) (i32.const 1))) + (func (export "i16x8.shr_u_16") (param $0 v128) (result v128) (i16x8.shr_u (local.get $0) (i32.const 16))) + (func (export "i16x8.shr_s_17") (param $0 v128) (result v128) (i16x8.shr_s (local.get $0) (i32.const 17))) + + ;; i32x4 + (func (export "i32x4.shl_1") (param $0 v128) (result v128) (i32x4.shl (local.get $0) (i32.const 1))) + (func (export "i32x4.shr_u_32") (param $0 v128) (result v128) (i32x4.shr_u (local.get $0) (i32.const 32))) + (func (export "i32x4.shr_s_33") (param $0 v128) (result v128) (i32x4.shr_s (local.get $0) (i32.const 33))) + + ;; i64x2 + (func (export "i64x2.shl_1") (param $0 v128) (result v128) (i64x2.shl (local.get $0) (i32.const 1))) + (func (export "i64x2.shr_u_64") (param $0 v128) (result v128) (i64x2.shr_u (local.get $0) (i32.const 64))) + (func (export "i64x2.shr_s_65") (param $0 v128) (result v128) (i64x2.shr_s (local.get $0) (i32.const 65))) +) + +;; i8x16 shl +;; amount less than lane width +(assert_return (invoke "i8x16.shl" (v128.const i8x16 -128 -64 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D) + (i32.const 1)) + (v128.const i8x16 0 -128 0 2 4 6 8 10 12 14 16 18 0x14 0x16 0x18 0x1A)) +(assert_return (invoke "i8x16.shl" (v128.const i8x16 0xAA 0xBB 0xCC 0xDD 0xEE 0xFF 0xA0 0xB0 0xC0 0xD0 0xE0 0xF0 0x0A 0x0B 0x0C 0x0D) + (i32.const 4)) + (v128.const i8x16 0xA0 0xB0 0xC0 0xD0 0xE0 0xF0 0x00 0x00 0x00 0x00 0x00 0x00 0xA0 0xB0 0xC0 0xD0)) +;; amount is multiple of lane width +(assert_return (invoke "i8x16.shl" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F) + (i32.const 8)) + (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F)) +(assert_return (invoke "i8x16.shl" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F) + (i32.const 32)) + (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F)) +(assert_return (invoke "i8x16.shl" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F) + (i32.const 128)) + (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F)) +(assert_return (invoke "i8x16.shl" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F) + (i32.const 256)) + (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F)) +;; amount greater than but not a multiple of lane width +(assert_return (invoke "i8x16.shl" (v128.const i8x16 -128 -64 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D) + (i32.const 9)) + (v128.const i8x16 0 -128 0 2 4 6 8 10 12 14 16 18 0x14 0x16 0x18 0x1A)) +(assert_return (invoke "i8x16.shl" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F) + (i32.const 9)) + (v128.const i8x16 0 2 4 6 8 10 12 14 16 18 0x14 0x16 0x18 0x1A 0x1C 0x1E)) +(assert_return (invoke "i8x16.shl" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F) + (i32.const 17)) + (v128.const i8x16 0 2 4 6 8 10 12 14 16 18 0x14 0x16 0x18 0x1A 0x1C 0x1E)) +(assert_return (invoke "i8x16.shl" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F) + (i32.const 33)) + (v128.const i8x16 0 2 4 6 8 10 12 14 16 18 0x14 0x16 0x18 0x1A 0x1C 0x1E)) +(assert_return (invoke "i8x16.shl" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F) + (i32.const 129)) + (v128.const i8x16 0 2 4 6 8 10 12 14 16 18 0x14 0x16 0x18 0x1A 0x1C 0x1E)) +(assert_return (invoke "i8x16.shl" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F) + (i32.const 257)) + (v128.const i8x16 0 2 4 6 8 10 12 14 16 18 0x14 0x16 0x18 0x1A 0x1C 0x1E)) +(assert_return (invoke "i8x16.shl" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F) + (i32.const 513)) + (v128.const i8x16 0 2 4 6 8 10 12 14 16 18 0x14 0x16 0x18 0x1A 0x1C 0x1E)) +(assert_return (invoke "i8x16.shl" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F) + (i32.const 514)) + (v128.const i8x16 0 4 8 12 16 20 24 28 32 36 0x28 0x2C 0x30 0x34 0x38 0x3C)) +;; i8x16 shr_u +;; amount less than lane width +(assert_return (invoke "i8x16.shr_u" (v128.const i8x16 -128 -64 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D) + (i32.const 1)) + (v128.const i8x16 64 96 0 0 1 1 2 2 3 3 4 4 0x05 0x05 0x06 0x06)) +(assert_return (invoke "i8x16.shr_u" (v128.const i8x16 0xAA 0xBB 0xCC 0xDD 0xEE 0xFF 0xA0 0xB0 0xC0 0xD0 0xE0 0xF0 0x0A 0x0B 0x0C 0x0D) + (i32.const 4)) + (v128.const i8x16 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F 0x00 0x00 0x00 0x00)) +;; amount is multiple of lane width +(assert_return (invoke "i8x16.shr_u" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F) + (i32.const 8)) + (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F)) +(assert_return (invoke "i8x16.shr_u" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F) + (i32.const 32)) + (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F)) +(assert_return (invoke "i8x16.shr_u" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F) + (i32.const 128)) + (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F)) +(assert_return (invoke "i8x16.shr_u" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F) + (i32.const 256)) + (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F)) +;; amount greater than but not a multiple of lane width +(assert_return (invoke "i8x16.shr_u" (v128.const i8x16 -128 -64 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D) + (i32.const 9)) + (v128.const i8x16 64 96 0 0 1 1 2 2 3 3 4 4 0x05 0x05 0x06 0x06)) +(assert_return (invoke "i8x16.shr_u" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F) + (i32.const 9)) + (v128.const i8x16 0 0 1 1 2 2 3 3 4 4 0x05 0x05 0x06 0x06 0x07 0x07)) +(assert_return (invoke "i8x16.shr_u" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F) + (i32.const 17)) + (v128.const i8x16 0 0 1 1 2 2 3 3 4 4 0x05 0x05 0x06 0x06 0x07 0x07)) +(assert_return (invoke "i8x16.shr_u" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F) + (i32.const 33)) + (v128.const i8x16 0 0 1 1 2 2 3 3 4 4 0x05 0x05 0x06 0x06 0x07 0x07)) +(assert_return (invoke "i8x16.shr_u" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F) + (i32.const 129)) + (v128.const i8x16 0 0 1 1 2 2 3 3 4 4 0x05 0x05 0x06 0x06 0x07 0x07)) +(assert_return (invoke "i8x16.shr_u" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F) + (i32.const 257)) + (v128.const i8x16 0 0 1 1 2 2 3 3 4 4 0x05 0x05 0x06 0x06 0x07 0x07)) +(assert_return (invoke "i8x16.shr_u" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F) + (i32.const 513)) + (v128.const i8x16 0 0 1 1 2 2 3 3 4 4 0x05 0x05 0x06 0x06 0x07 0x07)) +(assert_return (invoke "i8x16.shr_u" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F) + (i32.const 514)) + (v128.const i8x16 0 0 0 0 1 1 1 1 2 2 0x02 0x02 0x03 0x03 0x03 0x03)) +;; i8x16 shr_s +;; amount less than lane width +(assert_return (invoke "i8x16.shr_s" (v128.const i8x16 -128 -64 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D) + (i32.const 1)) + (v128.const i8x16 192 224 0 0 1 1 2 2 3 3 4 4 0x05 0x05 0x06 0x06)) +(assert_return (invoke "i8x16.shr_s" (v128.const i8x16 0xAA 0xBB 0xCC 0xDD 0xEE 0xFF 0xA0 0xB0 0xC0 0xD0 0xE0 0xF0 0x0A 0x0B 0x0C 0x0D) + (i32.const 4)) + (v128.const i8x16 0xFA 0xFB 0xFC 0xFD 0xFE 0xFF 0xFA 0xFB 0xFC 0xFD 0xFE 0xFF 0x00 0x00 0x00 0x00)) +;; amount is multiple of lane width +(assert_return (invoke "i8x16.shr_s" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F) + (i32.const 8)) + (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F)) +(assert_return (invoke "i8x16.shr_s" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F) + (i32.const 32)) + (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F)) +(assert_return (invoke "i8x16.shr_s" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F) + (i32.const 128)) + (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F)) +(assert_return (invoke "i8x16.shr_s" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F) + (i32.const 256)) + (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F)) +;; amount greater than but not a multiple of lane width +(assert_return (invoke "i8x16.shr_s" (v128.const i8x16 -128 -64 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D) + (i32.const 9)) + (v128.const i8x16 192 224 0 0 1 1 2 2 3 3 4 4 0x05 0x05 0x06 0x06)) +(assert_return (invoke "i8x16.shr_s" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F) + (i32.const 9)) + (v128.const i8x16 0 0 1 1 2 2 3 3 4 4 0x05 0x05 0x06 0x06 0x07 0x07)) +(assert_return (invoke "i8x16.shr_s" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F) + (i32.const 17)) + (v128.const i8x16 0 0 1 1 2 2 3 3 4 4 0x05 0x05 0x06 0x06 0x07 0x07)) +(assert_return (invoke "i8x16.shr_s" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F) + (i32.const 33)) + (v128.const i8x16 0 0 1 1 2 2 3 3 4 4 0x05 0x05 0x06 0x06 0x07 0x07)) +(assert_return (invoke "i8x16.shr_s" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F) + (i32.const 129)) + (v128.const i8x16 0 0 1 1 2 2 3 3 4 4 0x05 0x05 0x06 0x06 0x07 0x07)) +(assert_return (invoke "i8x16.shr_s" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F) + (i32.const 257)) + (v128.const i8x16 0 0 1 1 2 2 3 3 4 4 0x05 0x05 0x06 0x06 0x07 0x07)) +(assert_return (invoke "i8x16.shr_s" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F) + (i32.const 513)) + (v128.const i8x16 0 0 1 1 2 2 3 3 4 4 0x05 0x05 0x06 0x06 0x07 0x07)) +(assert_return (invoke "i8x16.shr_s" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F) + (i32.const 514)) + (v128.const i8x16 0 0 0 0 1 1 1 1 2 2 0x02 0x02 0x03 0x03 0x03 0x03)) +;; shifting by a constant amount +(assert_return (invoke "i8x16.shl_1" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F)) + (v128.const i8x16 0 2 4 6 8 10 12 14 16 18 0x14 0x16 0x18 0x1A 0x1C 0x1E)) +(assert_return (invoke "i8x16.shr_u_8" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F)) + (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F)) +(assert_return (invoke "i8x16.shr_s_9" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F)) + (v128.const i8x16 0 0 1 1 2 2 3 3 4 4 0x05 0x05 0x06 0x06 0x07 0x07)) + +;; i16x8 shl +;; amount less than lane width +(assert_return (invoke "i16x8.shl" (v128.const i16x8 -128 -64 0 1 2 3 4 5) + (i32.const 1)) + (v128.const i16x8 65280 65408 0 2 4 6 8 10)) +(assert_return (invoke "i16x8.shl" (v128.const i16x8 012_345 012_345 012_345 012_345 012_345 012_345 012_345 012_345) + (i32.const 2)) + (v128.const i16x8 49380 49380 49380 49380 49380 49380 49380 49380)) +(assert_return (invoke "i16x8.shl" (v128.const i16x8 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234) + (i32.const 2)) + (v128.const i16x8 0x48d0 0x48d0 0x48d0 0x48d0 0x48d0 0x48d0 0x48d0 0x48d0)) +(assert_return (invoke "i16x8.shl" (v128.const i16x8 0xAABB 0xCCDD 0xEEFF 0xA0B0 0xC0D0 0xE0F0 0x0A0B 0x0C0D) + (i32.const 4)) + (v128.const i16x8 0xABB0 0xCDD0 0xEFF0 0xB00 0xD00 0xF00 0xA0B0 0xC0D0)) +(assert_return (invoke "i16x8.shl" (v128.const i16x8 0 1 2 3 4 5 6 7) + (i32.const 8)) + (v128.const i16x8 0 256 512 768 1024 1280 1536 1792)) +;; amount is multiple of lane width +(assert_return (invoke "i16x8.shl" (v128.const i16x8 0 1 2 3 4 5 6 7) + (i32.const 32)) + (v128.const i16x8 0 1 2 3 4 5 6 7)) +(assert_return (invoke "i16x8.shl" (v128.const i16x8 0 1 2 3 4 5 6 7) + (i32.const 128)) + (v128.const i16x8 0 1 2 3 4 5 6 7)) +(assert_return (invoke "i16x8.shl" (v128.const i16x8 0 1 2 3 4 5 6 7) + (i32.const 256)) + (v128.const i16x8 0 1 2 3 4 5 6 7)) +;; amount greater than but not a multiple of lane width +(assert_return (invoke "i16x8.shl" (v128.const i16x8 -128 -64 0 1 2 3 4 5) + (i32.const 17)) + (v128.const i16x8 65280 65408 0 2 4 6 8 10)) +(assert_return (invoke "i16x8.shl" (v128.const i16x8 0 1 2 3 4 5 6 7) + (i32.const 17)) + (v128.const i16x8 0 2 4 6 8 10 12 14)) +(assert_return (invoke "i16x8.shl" (v128.const i16x8 0 1 2 3 4 5 6 7) + (i32.const 33)) + (v128.const i16x8 0 2 4 6 8 10 12 14)) +(assert_return (invoke "i16x8.shl" (v128.const i16x8 0 1 2 3 4 5 6 7) + (i32.const 129)) + (v128.const i16x8 0 2 4 6 8 10 12 14)) +(assert_return (invoke "i16x8.shl" (v128.const i16x8 0 1 2 3 4 5 6 7) + (i32.const 257)) + (v128.const i16x8 0 2 4 6 8 10 12 14)) +(assert_return (invoke "i16x8.shl" (v128.const i16x8 0 1 2 3 4 5 6 7) + (i32.const 513)) + (v128.const i16x8 0 2 4 6 8 10 12 14)) +(assert_return (invoke "i16x8.shl" (v128.const i16x8 0 1 2 3 4 5 6 7) + (i32.const 514)) + (v128.const i16x8 0 4 8 12 16 20 24 28)) + +;; i16x8 shr_u +;; amount less than lane width +(assert_return (invoke "i16x8.shr_u" (v128.const i16x8 -128 -64 0 1 2 3 4 5) + (i32.const 1)) + (v128.const i16x8 32704 32736 0 0 1 1 2 2)) +(assert_return (invoke "i16x8.shr_u" (v128.const i16x8 012_345 012_345 012_345 012_345 012_345 012_345 012_345 012_345) + (i32.const 2)) + (v128.const i16x8 3086 3086 3086 3086 3086 3086 3086 3086)) +(assert_return (invoke "i16x8.shr_u" (v128.const i16x8 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB) + (i32.const 2)) + (v128.const i16x8 0x242a 0x242a 0x242a 0x242a 0x242a 0x242a 0x242a 0x242a)) +(assert_return (invoke "i16x8.shr_u" (v128.const i16x8 0xAABB 0xCCDD 0xEEFF 0xA0B0 0xC0D0 0xE0F0 0x0A0B 0x0C0D) + (i32.const 4)) + (v128.const i16x8 0xAAB 0xCCD 0xEEF 0xA0B 0xC0D 0xE0F 0x0A0 0x0C0)) +(assert_return (invoke "i16x8.shr_u" (v128.const i16x8 0 1 2 3 4 5 6 7) + (i32.const 8)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +;; amount is multiple of lane width +(assert_return (invoke "i16x8.shr_u" (v128.const i16x8 0 1 2 3 4 5 6 7) + (i32.const 32)) + (v128.const i16x8 0 1 2 3 4 5 6 7)) +(assert_return (invoke "i16x8.shr_u" (v128.const i16x8 0 1 2 3 4 5 6 7) + (i32.const 128)) + (v128.const i16x8 0 1 2 3 4 5 6 7)) +(assert_return (invoke "i16x8.shr_u" (v128.const i16x8 0 1 2 3 4 5 6 7) + (i32.const 256)) + (v128.const i16x8 0 1 2 3 4 5 6 7)) +;; amount greater than but not a multiple of lane width +(assert_return (invoke "i16x8.shr_u" (v128.const i16x8 -128 -64 0 1 2 3 4 5) + (i32.const 17)) + (v128.const i16x8 32704 32736 0 0 1 1 2 2)) +(assert_return (invoke "i16x8.shr_u" (v128.const i16x8 0 1 2 3 4 5 6 7) + (i32.const 17)) + (v128.const i16x8 0 0 1 1 2 2 3 3)) +(assert_return (invoke "i16x8.shr_u" (v128.const i16x8 0 1 2 3 4 5 6 7) + (i32.const 33)) + (v128.const i16x8 0 0 1 1 2 2 3 3)) +(assert_return (invoke "i16x8.shr_u" (v128.const i16x8 0 1 2 3 4 5 6 7) + (i32.const 129)) + (v128.const i16x8 0 0 1 1 2 2 3 3)) +(assert_return (invoke "i16x8.shr_u" (v128.const i16x8 0 1 2 3 4 5 6 7) + (i32.const 257)) + (v128.const i16x8 0 0 1 1 2 2 3 3)) +(assert_return (invoke "i16x8.shr_u" (v128.const i16x8 0 1 2 3 4 5 6 7) + (i32.const 513)) + (v128.const i16x8 0 0 1 1 2 2 3 3)) +(assert_return (invoke "i16x8.shr_u" (v128.const i16x8 0 1 2 3 4 5 6 7) + (i32.const 514)) + (v128.const i16x8 0 0 0 0 1 1 1 1)) + +;; i16x8 shr_s +;; amount less than lane width +(assert_return (invoke "i16x8.shr_s" (v128.const i16x8 -128 -64 0 1 2 3 4 5) + (i32.const 1)) + (v128.const i16x8 65472 65504 0 0 1 1 2 2)) +(assert_return (invoke "i16x8.shr_s" (v128.const i16x8 012_345 012_345 012_345 012_345 012_345 012_345 012_345 012_345) + (i32.const 2)) + (v128.const i16x8 3086 3086 3086 3086 3086 3086 3086 3086)) +(assert_return (invoke "i16x8.shr_s" (v128.const i16x8 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB) + (i32.const 2)) + (v128.const i16x8 0xe42a 0xe42a 0xe42a 0xe42a 0xe42a 0xe42a 0xe42a 0xe42a)) +(assert_return (invoke "i16x8.shr_s" (v128.const i16x8 0xAABB 0xCCDD 0xEEFF 0xA0B0 0xC0D0 0xE0F0 0x0A0B 0x0C0D) + (i32.const 4)) + (v128.const i16x8 0xFAAB 0xFCCD 0xFEEF 0xFA0B 0xFC0D 0xFE0F 0x00A0 0x00C0)) +(assert_return (invoke "i16x8.shr_s" (v128.const i16x8 0 1 2 3 4 5 6 7) + (i32.const 8)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +;; amount is multiple of lane width +(assert_return (invoke "i16x8.shr_s" (v128.const i16x8 0 1 2 3 4 5 6 7) + (i32.const 32)) + (v128.const i16x8 0 1 2 3 4 5 6 7)) +(assert_return (invoke "i16x8.shr_s" (v128.const i16x8 0 1 2 3 4 5 6 7) + (i32.const 128)) + (v128.const i16x8 0 1 2 3 4 5 6 7)) +(assert_return (invoke "i16x8.shr_s" (v128.const i16x8 0 1 2 3 4 5 6 7) + (i32.const 256)) + (v128.const i16x8 0 1 2 3 4 5 6 7)) +;; amount greater than but not a multiple of lane width +(assert_return (invoke "i16x8.shr_s" (v128.const i16x8 -128 -64 0 1 2 3 4 5) + (i32.const 17)) + (v128.const i16x8 65472 65504 0 0 1 1 2 2)) +(assert_return (invoke "i16x8.shr_s" (v128.const i16x8 0 1 2 3 4 5 6 7) + (i32.const 17)) + (v128.const i16x8 0 0 1 1 2 2 3 3)) +(assert_return (invoke "i16x8.shr_s" (v128.const i16x8 0 1 2 3 4 5 6 7) + (i32.const 33)) + (v128.const i16x8 0 0 1 1 2 2 3 3)) +(assert_return (invoke "i16x8.shr_s" (v128.const i16x8 0 1 2 3 4 5 6 7) + (i32.const 129)) + (v128.const i16x8 0 0 1 1 2 2 3 3)) +(assert_return (invoke "i16x8.shr_s" (v128.const i16x8 0 1 2 3 4 5 6 7) + (i32.const 257)) + (v128.const i16x8 0 0 1 1 2 2 3 3)) +(assert_return (invoke "i16x8.shr_s" (v128.const i16x8 0 1 2 3 4 5 6 7) + (i32.const 513)) + (v128.const i16x8 0 0 1 1 2 2 3 3)) +(assert_return (invoke "i16x8.shr_s" (v128.const i16x8 0 1 2 3 4 5 6 7) + (i32.const 514)) + (v128.const i16x8 0 0 0 0 1 1 1 1)) + +;; shifting by a constant amount +(assert_return (invoke "i16x8.shl_1" (v128.const i16x8 0 1 2 3 4 5 6 7)) + (v128.const i16x8 0 2 4 6 8 10 12 14)) +(assert_return (invoke "i16x8.shr_u_16" (v128.const i16x8 0 1 2 3 4 5 6 7)) + (v128.const i16x8 0 1 2 3 4 5 6 7)) +(assert_return (invoke "i16x8.shr_s_17" (v128.const i16x8 0 1 2 3 4 5 6 7)) + (v128.const i16x8 0 0 1 1 2 2 3 3)) + +;; i32x4 shl +;; amount less than lane width +(assert_return (invoke "i32x4.shl" (v128.const i32x4 -2147483648 -32768 0 0x0A0B0C0D) + (i32.const 1)) + (v128.const i32x4 0 4294901760 0 0x1416181A)) +(assert_return (invoke "i32x4.shl" (v128.const i32x4 01_234_567_890 01_234_567_890 01_234_567_890 01_234_567_890) + (i32.const 2)) + (v128.const i32x4 643304264 643304264 643304264 643304264)) +(assert_return (invoke "i32x4.shl" (v128.const i32x4 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678) + (i32.const 2)) + (v128.const i32x4 0x48d159e0 0x48d159e0 0x48d159e0 0x48d159e0)) +(assert_return (invoke "i32x4.shl" (v128.const i32x4 0xAABBCCDD 0xEEFFA0B0 0xC0D0E0F0 0x0A0B0C0D) + (i32.const 4)) + (v128.const i32x4 0xABBCCDD0 0xEFFA0B00 0x0D0E0F00 0xA0B0C0D0)) +(assert_return (invoke "i32x4.shl" (v128.const i32x4 0 1 0x0E 0x0F) + (i32.const 8)) + (v128.const i32x4 0 256 0x00000E00 0x00000F00)) +;; amount is multiple of lane width +(assert_return (invoke "i32x4.shl" (v128.const i32x4 0 1 0x0E 0x0F) + (i32.const 32)) + (v128.const i32x4 0 1 0x0E 0x0F)) +(assert_return (invoke "i32x4.shl" (v128.const i32x4 0 1 0x0E 0x0F) + (i32.const 128)) + (v128.const i32x4 0 1 0x0E 0x0F)) +(assert_return (invoke "i32x4.shl" (v128.const i32x4 0 1 0x0E 0x0F) + (i32.const 256)) + (v128.const i32x4 0 1 0x0E 0x0F)) +;; amount greater than but not a multiple of lane width +(assert_return (invoke "i32x4.shl" (v128.const i32x4 -2147483648 -32768 0 0x0A0B0C0D) + (i32.const 33)) + (v128.const i32x4 0 4294901760 0 0x1416181A)) +(assert_return (invoke "i32x4.shl" (v128.const i32x4 0 1 0x0E 0x0F) + (i32.const 33)) + (v128.const i32x4 0 2 0x1C 0x1E)) +(assert_return (invoke "i32x4.shl" (v128.const i32x4 0 1 0x0E 0x0F) + (i32.const 65)) + (v128.const i32x4 0 2 0x1C 0x1E)) +(assert_return (invoke "i32x4.shl" (v128.const i32x4 0 1 0x0E 0x0F) + (i32.const 129)) + (v128.const i32x4 0 2 0x1C 0x1E)) +(assert_return (invoke "i32x4.shl" (v128.const i32x4 0 1 0x0E 0x0F) + (i32.const 257)) + (v128.const i32x4 0 2 0x1C 0x1E)) +(assert_return (invoke "i32x4.shl" (v128.const i32x4 0 1 0x0E 0x0F) + (i32.const 513)) + (v128.const i32x4 0 2 0x1C 0x1E)) +(assert_return (invoke "i32x4.shl" (v128.const i32x4 0 1 0x0E 0x0F) + (i32.const 514)) + (v128.const i32x4 0 4 0x38 0x3C)) + +;; i32x4 shr_u +;; amount less than lane width +(assert_return (invoke "i32x4.shr_u" (v128.const i32x4 -2147483648 -32768 0x0000000C 0x0000000D) + (i32.const 1)) + (v128.const i32x4 1073741824 2147467264 0x00000006 0x00000006)) +(assert_return (invoke "i32x4.shr_u" (v128.const i32x4 01_234_567_890 01_234_567_890 01_234_567_890 01_234_567_890) + (i32.const 2)) + (v128.const i32x4 308641972 308641972 308641972 308641972)) +(assert_return (invoke "i32x4.shr_u" (v128.const i32x4 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef) + (i32.const 2)) + (v128.const i32x4 0x242af37b 0x242af37b 0x242af37b 0x242af37b)) +(assert_return (invoke "i32x4.shr_u" (v128.const i32x4 0xAABBCCDD 0xEEFFA0B0 0xC0D0E0F0 0x0A0B0C0D) + (i32.const 4)) + (v128.const i32x4 0x0AABBCCD 0x0EEFFA0B 0x0C0D0E0F 0x00A0B0C0)) +(assert_return (invoke "i32x4.shr_u" (v128.const i32x4 0 1 0x0E 0x0F) + (i32.const 8)) + (v128.const i32x4 0 0 0x00000000 0x00000000)) +;; amount is multiple of lane width +(assert_return (invoke "i32x4.shr_u" (v128.const i32x4 0 1 0x0E 0x0F) + (i32.const 32)) + (v128.const i32x4 0 1 0x0E 0x0F)) +(assert_return (invoke "i32x4.shr_u" (v128.const i32x4 0 1 0x0E 0x0F) + (i32.const 128)) + (v128.const i32x4 0 1 0x0E 0x0F)) +(assert_return (invoke "i32x4.shr_u" (v128.const i32x4 0 1 0x0E 0x0F) + (i32.const 256)) + (v128.const i32x4 0 1 0x0E 0x0F)) +;; amount greater than but not a multiple of lane width +(assert_return (invoke "i32x4.shr_u" (v128.const i32x4 -2147483648 -32768 0x0000000C 0x0000000D) + (i32.const 33)) + (v128.const i32x4 1073741824 2147467264 0x00000006 0x00000006)) +(assert_return (invoke "i32x4.shr_u" (v128.const i32x4 0 1 0x0E 0x0F) + (i32.const 33)) + (v128.const i32x4 0 0 0x07 0x07)) +(assert_return (invoke "i32x4.shr_u" (v128.const i32x4 0 1 0x0E 0x0F) + (i32.const 65)) + (v128.const i32x4 0 0 0x07 0x07)) +(assert_return (invoke "i32x4.shr_u" (v128.const i32x4 0 1 0x0E 0x0F) + (i32.const 129)) + (v128.const i32x4 0 0 0x07 0x07)) +(assert_return (invoke "i32x4.shr_u" (v128.const i32x4 0 1 0x0E 0x0F) + (i32.const 257)) + (v128.const i32x4 0 0 0x07 0x07)) +(assert_return (invoke "i32x4.shr_u" (v128.const i32x4 0 1 0x0E 0x0F) + (i32.const 513)) + (v128.const i32x4 0 0 0x07 0x07)) +(assert_return (invoke "i32x4.shr_u" (v128.const i32x4 0 1 0x0E 0x0F) + (i32.const 514)) + (v128.const i32x4 0 0 0x03 0x03)) + +;; i32x4 shr_s +;; amount less than lane width +(assert_return (invoke "i32x4.shr_s" (v128.const i32x4 -2147483648 -32768 0x0C 0x0D) + (i32.const 1)) + (v128.const i32x4 3221225472 4294950912 0x06 0x06)) +(assert_return (invoke "i32x4.shr_s" (v128.const i32x4 01_234_567_890 01_234_567_890 01_234_567_890 01_234_567_890) + (i32.const 2)) + (v128.const i32x4 308641972 308641972 308641972 308641972)) +(assert_return (invoke "i32x4.shr_s" (v128.const i32x4 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef) + (i32.const 2)) + (v128.const i32x4 0xe42af37b 0xe42af37b 0xe42af37b 0xe42af37b)) +(assert_return (invoke "i32x4.shr_s" (v128.const i32x4 0xAABBCCDD 0xEEFFA0B0 0xC0D0E0F0 0x0A0B0C0D) + (i32.const 4)) + (v128.const i32x4 0xfaabbccd 0xFEEFFA0B 0xFC0D0E0F 0x00A0B0C0)) +;; amount is multiple of lane width +(assert_return (invoke "i32x4.shr_s" (v128.const i32x4 0 1 0x0E 0x0F) + (i32.const 8)) + (v128.const i32x4 0 0 0x00000000 0x00000000)) +(assert_return (invoke "i32x4.shr_s" (v128.const i32x4 0 1 0x0E 0x0F) + (i32.const 32)) + (v128.const i32x4 0 1 0x0E 0x0F)) +(assert_return (invoke "i32x4.shr_s" (v128.const i32x4 0 1 0x0E 0x0F) + (i32.const 128)) + (v128.const i32x4 0 1 0x0E 0x0F)) +(assert_return (invoke "i32x4.shr_s" (v128.const i32x4 0 1 0x0E 0x0F) + (i32.const 256)) + (v128.const i32x4 0 1 0x0E 0x0F)) +;; amount greater than but not a multiple of lane width +(assert_return (invoke "i32x4.shr_s" (v128.const i32x4 -2147483648 -32768 0x0C 0x0D) + (i32.const 33)) + (v128.const i32x4 3221225472 4294950912 0x06 0x06)) +(assert_return (invoke "i32x4.shr_s" (v128.const i32x4 0 1 0x0E 0x0F) + (i32.const 33)) + (v128.const i32x4 0 0 0x07 0x07)) +(assert_return (invoke "i32x4.shr_s" (v128.const i32x4 0 1 0x0E 0x0F) + (i32.const 65)) + (v128.const i32x4 0 0 0x07 0x07)) +(assert_return (invoke "i32x4.shr_s" (v128.const i32x4 0 1 0x0E 0x0F) + (i32.const 129)) + (v128.const i32x4 0 0 0x07 0x07)) +(assert_return (invoke "i32x4.shr_s" (v128.const i32x4 0 1 0x0E 0x0F) + (i32.const 257)) + (v128.const i32x4 0 0 0x07 0x07)) +(assert_return (invoke "i32x4.shr_s" (v128.const i32x4 0 1 0x0E 0x0F) + (i32.const 513)) + (v128.const i32x4 0 0 0x07 0x07)) +(assert_return (invoke "i32x4.shr_s" (v128.const i32x4 0 1 0x0E 0x0F) + (i32.const 514)) + (v128.const i32x4 0 0 0x03 0x03)) + +;; shifting by a constant amount +(assert_return (invoke "i32x4.shl_1" (v128.const i32x4 0 1 0x0E 0x0F)) + (v128.const i32x4 0 2 28 30)) +(assert_return (invoke "i32x4.shr_u_32" (v128.const i32x4 0 1 0x0E 0x0F)) + (v128.const i32x4 0 1 0x0E 0x0F)) +(assert_return (invoke "i32x4.shr_s_33" (v128.const i32x4 0 1 0x0E 0x0F)) + (v128.const i32x4 0 0 7 7)) + +;; i64x2 shl +;; amount less than lane width +(assert_return (invoke "i64x2.shl" (v128.const i64x2 -9223372036854775808 -2147483648) + (i32.const 1)) + (v128.const i64x2 0 18446744069414584320)) +(assert_return (invoke "i64x2.shl" (v128.const i64x2 01_234_567_890_123_456_789 01_234_567_890_123_456_789) + (i32.const 2)) + (v128.const i64x2 4938271560493827156 4938271560493827156)) +(assert_return (invoke "i64x2.shl" (v128.const i64x2 0x0_1234_5678_90AB_cdef 0x0_1234_5678_90AB_cdef) + (i32.const 2)) + (v128.const i64x2 0x48d159e242af37bc 0x48d159e242af37bc)) +(assert_return (invoke "i64x2.shl" (v128.const i64x2 0xAABBCCDDEEFFA0B0 0xC0D0E0F00A0B0C0D) + (i32.const 4)) + (v128.const i64x2 0xABBCCDDEEFFA0B00 0xD0E0F00A0B0C0D0)) +(assert_return (invoke "i64x2.shl" (v128.const i64x2 0xAABBCCDDEEFFA0B0 0xC0D0E0F00A0B0C0D) + (i32.const 8)) + (v128.const i64x2 0xBBCCDDEEFFA0B000 0xD0E0F00A0B0C0D00)) +(assert_return (invoke "i64x2.shl" (v128.const i64x2 1 0x0F) + (i32.const 16)) + (v128.const i64x2 65536 0xF0000)) +(assert_return (invoke "i64x2.shl" (v128.const i64x2 1 0x0F) + (i32.const 32)) + (v128.const i64x2 4294967296 0xF00000000)) +;; amount is multiple of lane width +(assert_return (invoke "i64x2.shl" (v128.const i64x2 1 0x0F) + (i32.const 128)) + (v128.const i64x2 1 0x0F)) +(assert_return (invoke "i64x2.shl" (v128.const i64x2 1 0x0F) + (i32.const 256)) + (v128.const i64x2 1 0x0F)) +;; amount greater than but not a multiple of lane width +(assert_return (invoke "i64x2.shl" (v128.const i64x2 1 0x0F) + (i32.const 65)) + (v128.const i64x2 2 0x1E)) +(assert_return (invoke "i64x2.shl" (v128.const i64x2 1 0x0F) + (i32.const 129)) + (v128.const i64x2 2 0x1E)) +(assert_return (invoke "i64x2.shl" (v128.const i64x2 1 0x0F) + (i32.const 257)) + (v128.const i64x2 2 0x1E)) +(assert_return (invoke "i64x2.shl" (v128.const i64x2 1 0x0F) + (i32.const 513)) + (v128.const i64x2 2 0x1E)) +(assert_return (invoke "i64x2.shl" (v128.const i64x2 1 0x0F) + (i32.const 514)) + (v128.const i64x2 4 0x3C)) + +;; i64x2 shr_u +;; amount less than lane width +(assert_return (invoke "i64x2.shr_u" (v128.const i64x2 -9223372036854775808 -2147483648) + (i32.const 1)) + (v128.const i64x2 4611686018427387904 9223372035781033984)) +(assert_return (invoke "i64x2.shr_u" (v128.const i64x2 01_234_567_890_123_456_789 01_234_567_890_123_456_789) + (i32.const 2)) + (v128.const i64x2 308641972530864197 308641972530864197)) +(assert_return (invoke "i64x2.shr_u" (v128.const i64x2 0x0_90AB_cdef_8765_4321 0x0_90AB_cdef_8765_4321) + (i32.const 2)) + (v128.const i64x2 0x242af37be1d950c8 0x242af37be1d950c8)) +(assert_return (invoke "i64x2.shr_u" (v128.const i64x2 0xAABBCCDDEEFFA0B0 0xC0D0E0F00A0B0C0D) + (i32.const 4)) + (v128.const i64x2 0xAABBCCDDEEFFA0B 0xC0D0E0F00A0B0C0)) +(assert_return (invoke "i64x2.shr_u" (v128.const i64x2 0xAABBCCDDEEFFA0B0 0xC0D0E0F00A0B0C0D) + (i32.const 8)) + (v128.const i64x2 0xAABBCCDDEEFFA0 0xC0D0E0F00A0B0C)) +(assert_return (invoke "i64x2.shr_u" (v128.const i64x2 1 0x0F) + (i32.const 16)) + (v128.const i64x2 0 0x00)) +(assert_return (invoke "i64x2.shr_u" (v128.const i64x2 1 0x0F) + (i32.const 32)) + (v128.const i64x2 0 0x00)) +;; amount is multiple of lane width +(assert_return (invoke "i64x2.shr_u" (v128.const i64x2 1 0x0F) + (i32.const 128)) + (v128.const i64x2 1 0x0F)) +(assert_return (invoke "i64x2.shr_u" (v128.const i64x2 1 0x0F) + (i32.const 256)) + (v128.const i64x2 1 0x0F)) +;; amount greater than but not a multiple of lane width +(assert_return (invoke "i64x2.shr_u" (v128.const i64x2 1 0x0F) + (i32.const 65)) + (v128.const i64x2 0 0x07)) +(assert_return (invoke "i64x2.shr_u" (v128.const i64x2 1 0x0F) + (i32.const 129)) + (v128.const i64x2 0 0x07)) +(assert_return (invoke "i64x2.shr_u" (v128.const i64x2 1 0x0F) + (i32.const 257)) + (v128.const i64x2 0 0x07)) +(assert_return (invoke "i64x2.shr_u" (v128.const i64x2 1 0x0F) + (i32.const 513)) + (v128.const i64x2 0 0x07)) +(assert_return (invoke "i64x2.shr_u" (v128.const i64x2 0 0x0F) + (i32.const 514)) + (v128.const i64x2 0 0x03)) + +;; i64x2 shr_s +;; amount less than lane width +(assert_return (invoke "i64x2.shr_s" (v128.const i64x2 -9223372036854775808 -2147483648) + (i32.const 1)) + (v128.const i64x2 13835058055282163712 18446744072635809792)) +(assert_return (invoke "i64x2.shr_s" (v128.const i64x2 01_234_567_890_123_456_789 01_234_567_890_123_456_789) + (i32.const 2)) + (v128.const i64x2 308641972530864197 308641972530864197)) +(assert_return (invoke "i64x2.shr_s" (v128.const i64x2 0x0_90AB_cdef_8765_4321 0x0_90AB_cdef_8765_4321) + (i32.const 2)) + (v128.const i64x2 0xe42af37be1d950c8 0xe42af37be1d950c8)) +(assert_return (invoke "i64x2.shr_s" (v128.const i64x2 0xAABBCCDDEEFFA0B0 0xC0D0E0F00A0B0C0D) + (i32.const 4)) + (v128.const i64x2 0xFAABBCCDDEEFFA0B 0xFC0D0E0F00A0B0C0)) +(assert_return (invoke "i64x2.shr_s" (v128.const i64x2 0xFFAABBCCDDEEFFA0 0xC0D0E0F00A0B0C0D) + (i32.const 8)) + (v128.const i64x2 0xFFFFAABBCCDDEEFF 0xFFC0D0E0F00A0B0C)) +(assert_return (invoke "i64x2.shr_s" (v128.const i64x2 1 0x0F) + (i32.const 16)) + (v128.const i64x2 0 0x00)) +(assert_return (invoke "i64x2.shr_s" (v128.const i64x2 1 0x0F) + (i32.const 32)) + (v128.const i64x2 0 0x00)) +;; amount is multiple of lane width +(assert_return (invoke "i64x2.shr_s" (v128.const i64x2 1 0x0F) + (i32.const 128)) + (v128.const i64x2 1 0x0F)) +(assert_return (invoke "i64x2.shr_s" (v128.const i64x2 1 0x0F) + (i32.const 256)) + (v128.const i64x2 1 0x0F)) +;; amount greater than but not a multiple of lane width +(assert_return (invoke "i64x2.shr_s" (v128.const i64x2 -9223372036854775808 -2147483648) + (i32.const 65)) + (v128.const i64x2 13835058055282163712 18446744072635809792)) +(assert_return (invoke "i64x2.shr_s" (v128.const i64x2 0x0C 0x0D) + (i32.const 65)) + (v128.const i64x2 0x06 0x06)) +(assert_return (invoke "i64x2.shr_s" (v128.const i64x2 1 0x0F) + (i32.const 129)) + (v128.const i64x2 0 0x07)) +(assert_return (invoke "i64x2.shr_s" (v128.const i64x2 1 0x0F) + (i32.const 257)) + (v128.const i64x2 0 0x07)) +(assert_return (invoke "i64x2.shr_s" (v128.const i64x2 1 0x0F) + (i32.const 513)) + (v128.const i64x2 0 0x07)) +(assert_return (invoke "i64x2.shr_s" (v128.const i64x2 1 0x0F) + (i32.const 514)) + (v128.const i64x2 0 0x03)) + +;; shifting by a constant amount +(assert_return (invoke "i64x2.shl_1" (v128.const i64x2 1 0x0F)) + (v128.const i64x2 2 0x1E)) +(assert_return (invoke "i64x2.shr_u_64" (v128.const i64x2 1 0x0F)) + (v128.const i64x2 1 0x0F)) +(assert_return (invoke "i64x2.shr_s_65" (v128.const i64x2 1 0x0F)) + (v128.const i64x2 0 0x07)) + +;; Combination + +(module (memory 1) + (func (export "i8x16.shl-in-block") + (block + (drop + (block (result v128) + (i8x16.shl + (block (result v128) (v128.load (i32.const 0))) (i32.const 1) + ) + ) + ) + ) + ) + (func (export "i8x16.shr_s-in-block") + (block + (drop + (block (result v128) + (i8x16.shr_s + (block (result v128) (v128.load (i32.const 0))) (i32.const 1) + ) + ) + ) + ) + ) + (func (export "i8x16.shr_u-in-block") + (block + (drop + (block (result v128) + (i8x16.shr_u + (block (result v128) (v128.load (i32.const 0))) (i32.const 1) + ) + ) + ) + ) + ) + (func (export "i16x8.shl-in-block") + (block + (drop + (block (result v128) + (i16x8.shl + (block (result v128) (v128.load (i32.const 0))) (i32.const 1) + ) + ) + ) + ) + ) + (func (export "i16x8.shr_s-in-block") + (block + (drop + (block (result v128) + (i16x8.shr_s + (block (result v128) (v128.load (i32.const 0))) (i32.const 1) + ) + ) + ) + ) + ) + (func (export "i16x8.shr_u-in-block") + (block + (drop + (block (result v128) + (i16x8.shr_u + (block (result v128) (v128.load (i32.const 0))) (i32.const 1) + ) + ) + ) + ) + ) + (func (export "i32x4.shl-in-block") + (block + (drop + (block (result v128) + (i32x4.shl + (block (result v128) (v128.load (i32.const 0))) (i32.const 1) + ) + ) + ) + ) + ) + (func (export "i32x4.shr_s-in-block") + (block + (drop + (block (result v128) + (i32x4.shr_s + (block (result v128) (v128.load (i32.const 0))) (i32.const 1) + ) + ) + ) + ) + ) + (func (export "i32x4.shr_u-in-block") + (block + (drop + (block (result v128) + (i32x4.shr_u + (block (result v128) (v128.load (i32.const 0))) (i32.const 1) + ) + ) + ) + ) + ) + (func (export "i64x2.shl-in-block") + (block + (drop + (block (result v128) + (i64x2.shl + (block (result v128) (v128.load (i32.const 0))) (i32.const 1) + ) + ) + ) + ) + ) + (func (export "i64x2.shr_s-in-block") + (block + (drop + (block (result v128) + (i64x2.shr_s + (block (result v128) (v128.load (i32.const 0))) (i32.const 1) + ) + ) + ) + ) + ) + (func (export "i64x2.shr_u-in-block") + (block + (drop + (block (result v128) + (i64x2.shr_u + (block (result v128) (v128.load (i32.const 0))) (i32.const 1) + ) + ) + ) + ) + ) + (func (export "nested-i8x16.shl") + (drop + (i8x16.shl + (i8x16.shl + (i8x16.shl + (v128.load (i32.const 0)) (i32.const 1) + ) + (i32.const 1) + ) + (i32.const 1) + ) + ) + ) + (func (export "nested-i8x16.shr_s") + (drop + (i8x16.shr_s + (i8x16.shr_s + (i8x16.shr_s + (v128.load (i32.const 0)) (i32.const 1) + ) + (i32.const 1) + ) + (i32.const 1) + ) + ) + ) + (func (export "nested-i8x16.shr_u") + (drop + (i8x16.shr_u + (i8x16.shr_u + (i8x16.shr_u + (v128.load (i32.const 0)) (i32.const 1) + ) + (i32.const 1) + ) + (i32.const 1) + ) + ) + ) + (func (export "nested-i16x8.shl") + (drop + (i16x8.shl + (i16x8.shl + (i16x8.shl + (v128.load (i32.const 0)) (i32.const 1) + ) + (i32.const 1) + ) + (i32.const 1) + ) + ) + ) + (func (export "nested-i16x8.shr_s") + (drop + (i16x8.shr_s + (i16x8.shr_s + (i16x8.shr_s + (v128.load (i32.const 0)) (i32.const 1) + ) + (i32.const 1) + ) + (i32.const 1) + ) + ) + ) + (func (export "nested-i16x8.shr_u") + (drop + (i16x8.shr_u + (i16x8.shr_u + (i16x8.shr_u + (v128.load (i32.const 0)) (i32.const 1) + ) + (i32.const 1) + ) + (i32.const 1) + ) + ) + ) + (func (export "nested-i32x4.shl") + (drop + (i32x4.shl + (i32x4.shl + (i32x4.shl + (v128.load (i32.const 0)) (i32.const 1) + ) + (i32.const 1) + ) + (i32.const 1) + ) + ) + ) + (func (export "nested-i32x4.shr_s") + (drop + (i32x4.shr_s + (i32x4.shr_s + (i32x4.shr_s + (v128.load (i32.const 0)) (i32.const 1) + ) + (i32.const 1) + ) + (i32.const 1) + ) + ) + ) + (func (export "nested-i32x4.shr_u") + (drop + (i32x4.shr_u + (i32x4.shr_u + (i32x4.shr_u + (v128.load (i32.const 0)) (i32.const 1) + ) + (i32.const 1) + ) + (i32.const 1) + ) + ) + ) + (func (export "nested-i64x2.shl") + (drop + (i64x2.shl + (i64x2.shl + (i64x2.shl + (v128.load (i32.const 0)) (i32.const 1) + ) + (i32.const 1) + ) + (i32.const 1) + ) + ) + ) + (func (export "nested-i64x2.shr_s") + (drop + (i64x2.shr_s + (i64x2.shr_s + (i64x2.shr_s + (v128.load (i32.const 0)) (i32.const 1) + ) + (i32.const 1) + ) + (i32.const 1) + ) + ) + ) + (func (export "nested-i64x2.shr_u") + (drop + (i64x2.shr_u + (i64x2.shr_u + (i64x2.shr_u + (v128.load (i32.const 0)) (i32.const 1) + ) + (i32.const 1) + ) + (i32.const 1) + ) + ) + ) +) + +(assert_return (invoke "i8x16.shl-in-block")) +(assert_return (invoke "i8x16.shr_s-in-block")) +(assert_return (invoke "i8x16.shr_u-in-block")) +(assert_return (invoke "i16x8.shl-in-block")) +(assert_return (invoke "i16x8.shr_s-in-block")) +(assert_return (invoke "i16x8.shr_u-in-block")) +(assert_return (invoke "i32x4.shl-in-block")) +(assert_return (invoke "i32x4.shr_s-in-block")) +(assert_return (invoke "i32x4.shr_u-in-block")) +(assert_return (invoke "i64x2.shl-in-block")) +(assert_return (invoke "i64x2.shr_s-in-block")) +(assert_return (invoke "i64x2.shr_u-in-block")) +(assert_return (invoke "nested-i8x16.shl")) +(assert_return (invoke "nested-i8x16.shr_s")) +(assert_return (invoke "nested-i8x16.shr_u")) +(assert_return (invoke "nested-i16x8.shl")) +(assert_return (invoke "nested-i16x8.shr_s")) +(assert_return (invoke "nested-i16x8.shr_u")) +(assert_return (invoke "nested-i32x4.shl")) +(assert_return (invoke "nested-i32x4.shr_s")) +(assert_return (invoke "nested-i32x4.shr_u")) +(assert_return (invoke "nested-i64x2.shl")) +(assert_return (invoke "nested-i64x2.shr_s")) +(assert_return (invoke "nested-i64x2.shr_u")) + +;; Type check + +(assert_invalid (module (func (result v128) (i8x16.shl (i32.const 0) (i32.const 0)))) "type mismatch") +(assert_invalid (module (func (result v128) (i8x16.shr_s (i32.const 0) (i32.const 0)))) "type mismatch") +(assert_invalid (module (func (result v128) (i8x16.shr_u (i32.const 0) (i32.const 0)))) "type mismatch") +(assert_invalid (module (func (result v128) (i16x8.shl (i32.const 0) (i32.const 0)))) "type mismatch") +(assert_invalid (module (func (result v128) (i16x8.shr_s (i32.const 0) (i32.const 0)))) "type mismatch") +(assert_invalid (module (func (result v128) (i16x8.shr_u (i32.const 0) (i32.const 0)))) "type mismatch") +(assert_invalid (module (func (result v128) (i32x4.shl (i32.const 0) (i32.const 0)))) "type mismatch") +(assert_invalid (module (func (result v128) (i32x4.shr_s (i32.const 0) (i32.const 0)))) "type mismatch") +(assert_invalid (module (func (result v128) (i32x4.shr_u (i32.const 0) (i32.const 0)))) "type mismatch") +(assert_invalid (module (func (result v128) (i64x2.shl (i32.const 0) (i32.const 0)))) "type mismatch") +(assert_invalid (module (func (result v128) (i64x2.shr_s (i32.const 0) (i32.const 0)))) "type mismatch") +(assert_invalid (module (func (result v128) (i64x2.shr_u (i32.const 0) (i32.const 0)))) "type mismatch") + +;; Unknown operators + +(assert_malformed (module quote "(memory 1) (func (result v128) (i8x16.shl_s (v128.const i32x4 0 0 0 0)))") "unknown operator") +(assert_malformed (module quote "(memory 1) (func (result v128) (i8x16.shl_r (v128.const i32x4 0 0 0 0)))") "unknown operator") +(assert_malformed (module quote "(memory 1) (func (result v128) (i8x16.shr (v128.const i32x4 0 0 0 0)))") "unknown operator") +(assert_malformed (module quote "(memory 1) (func (result v128) (i16x8.shl_s (v128.const i32x4 0 0 0 0)))") "unknown operator") +(assert_malformed (module quote "(memory 1) (func (result v128) (i16x8.shl_r (v128.const i32x4 0 0 0 0)))") "unknown operator") +(assert_malformed (module quote "(memory 1) (func (result v128) (i16x8.shr (v128.const i32x4 0 0 0 0)))") "unknown operator") +(assert_malformed (module quote "(memory 1) (func (result v128) (i32x4.shl_s (v128.const i32x4 0 0 0 0)))") "unknown operator") +(assert_malformed (module quote "(memory 1) (func (result v128) (i32x4.shl_r (v128.const i32x4 0 0 0 0)))") "unknown operator") +(assert_malformed (module quote "(memory 1) (func (result v128) (i32x4.shr (v128.const i32x4 0 0 0 0)))") "unknown operator") +(assert_malformed (module quote "(memory 1) (func (result v128) (i64x2.shl_s (v128.const i32x4 0 0 0 0)))") "unknown operator") +(assert_malformed (module quote "(memory 1) (func (result v128) (i64x2.shl_r (v128.const i32x4 0 0 0 0)))") "unknown operator") +(assert_malformed (module quote "(memory 1) (func (result v128) (i64x2.shr (v128.const i32x4 0 0 0 0)))") "unknown operator") +(assert_malformed (module quote "(memory 1) (func (result v128) (f32x4.shl (v128.const i32x4 0 0 0 0)))") "unknown operator") +(assert_malformed (module quote "(memory 1) (func (result v128) (f32x4.shr_s (v128.const i32x4 0 0 0 0)))") "unknown operator") +(assert_malformed (module quote "(memory 1) (func (result v128) (f32x4.shr_u (v128.const i32x4 0 0 0 0)))") "unknown operator") + +;; Test operation with empty argument + +(assert_invalid + (module + (func $i8x16.shl-1st-arg-empty (result v128) + (i8x16.shl (i32.const 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i8x16.shl-last-arg-empty (result v128) + (i8x16.shl (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i8x16.shl-arg-empty (result v128) + (i8x16.shl) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i16x8.shr_u-1st-arg-empty (result v128) + (i16x8.shr_u (i32.const 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i16x8.shr_u-last-arg-empty (result v128) + (i16x8.shr_u (v128.const i16x8 0 0 0 0 0 0 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i16x8.shr_u-arg-empty (result v128) + (i16x8.shr_u) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i32x4.shr_s-1st-arg-empty (result v128) + (i32x4.shr_s (i32.const 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i32x4.shr_s-last-arg-empty (result v128) + (i32x4.shr_s (v128.const i32x4 0 0 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i32x4.shr_s-arg-empty (result v128) + (i32x4.shr_s) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i64x2.shl-1st-arg-empty (result v128) + (i64x2.shl (i32.const 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i64x2.shr_u-last-arg-empty (result v128) + (i64x2.shr_u (v128.const i64x2 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i64x2.shr_s-arg-empty (result v128) + (i64x2.shr_s) + ) + ) + "type mismatch" +) diff --git a/runtime/near-vm/tests/wast/spec/proposals/simd/simd_bitwise.wast b/runtime/near-vm/tests/wast/spec/proposals/simd/simd_bitwise.wast new file mode 100644 index 00000000000..f646bf61d46 --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/proposals/simd/simd_bitwise.wast @@ -0,0 +1,812 @@ +;; Test all the bitwise operators on major boundary values and all special values. + +(module + (func (export "not") (param $0 v128) (result v128) (v128.not (local.get $0))) + (func (export "and") (param $0 v128) (param $1 v128) (result v128) (v128.and (local.get $0) (local.get $1))) + (func (export "or") (param $0 v128) (param $1 v128) (result v128) (v128.or (local.get $0) (local.get $1))) + (func (export "xor") (param $0 v128) (param $1 v128) (result v128) (v128.xor (local.get $0) (local.get $1))) + (func (export "bitselect") (param $0 v128) (param $1 v128) (param $2 v128) (result v128) + (v128.bitselect (local.get $0) (local.get $1) (local.get $2)) + ) + (func (export "andnot") (param $0 v128) (param $1 v128) (result v128) (v128.andnot (local.get $0) (local.get $1))) +) + +;; i32x4 +(assert_return (invoke "not" (v128.const i32x4 0 0 0 0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "not" (v128.const i32x4 -1 -1 -1 -1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "not" (v128.const i32x4 -1 0 -1 0)) + (v128.const i32x4 0 -1 0 -1)) +(assert_return (invoke "not" (v128.const i32x4 0 -1 0 -1)) + (v128.const i32x4 -1 0 -1 0)) +(assert_return (invoke "not" (v128.const i32x4 0x55555555 0x55555555 0x55555555 0x55555555)) + (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA)) +(assert_return (invoke "not" (v128.const i32x4 3435973836 3435973836 3435973836 3435973836)) + (v128.const i32x4 858993459 858993459 858993459 858993459)) +(assert_return (invoke "not" (v128.const i32x4 01_234_567_890 01_234_567_890 01_234_567_890 01_234_567_890)) + (v128.const i32x4 3060399405 3060399405 3060399405 3060399405)) +(assert_return (invoke "not" (v128.const i32x4 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678)) + (v128.const i32x4 0xedcba987 0xedcba987 0xedcba987 0xedcba987)) +(assert_return (invoke "and" (v128.const i32x4 0 0 -1 -1) + (v128.const i32x4 0 -1 0 -1)) + (v128.const i32x4 0 0 0 -1)) +(assert_return (invoke "and" (v128.const i32x4 0 0 0 0) + (v128.const i32x4 0 0 0 0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "and" (v128.const i32x4 0 0 0 0) + (v128.const i32x4 -1 -1 -1 -1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "and" (v128.const i32x4 0 0 0 0) + (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "and" (v128.const i32x4 1 1 1 1) + (v128.const i32x4 1 1 1 1)) + (v128.const i32x4 1 1 1 1)) +(assert_return (invoke "and" (v128.const i32x4 255 255 255 255) + (v128.const i32x4 85 85 85 85)) + (v128.const i32x4 85 85 85 85)) +(assert_return (invoke "and" (v128.const i32x4 255 255 255 255) + (v128.const i32x4 128 128 128 128)) + (v128.const i32x4 128 128 128 128)) +(assert_return (invoke "and" (v128.const i32x4 2863311530 2863311530 2863311530 2863311530) + (v128.const i32x4 10 128 5 165)) + (v128.const i32x4 10 128 0 160)) +(assert_return (invoke "and" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF) + (v128.const i32x4 0x55555555 0x55555555 0x55555555 0x55555555)) + (v128.const i32x4 0x55555555 0x55555555 0x55555555 0x55555555)) +(assert_return (invoke "and" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF) + (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA)) + (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA)) +(assert_return (invoke "and" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF) + (v128.const i32x4 0x0 0x0 0x0 0x0)) + (v128.const i32x4 0x0 0x0 0x0 0x0)) +(assert_return (invoke "and" (v128.const i32x4 0x55555555 0x55555555 0x55555555 0x55555555) + (v128.const i32x4 0x5555 0xFFFF 0x55FF 0x5FFF)) + (v128.const i32x4 0x5555 0x5555 0x5555 0x5555)) +(assert_return (invoke "and" (v128.const i32x4 01_234_567_890 01_234_567_890 01_234_567_890 01_234_567_890) + (v128.const i32x4 01_234_567_890 01_234_567_890 01_234_567_890 01_234_567_890)) + (v128.const i32x4 1234567890 1234567890 1234567890 1234567890)) +(assert_return (invoke "and" (v128.const i32x4 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678) + (v128.const i32x4 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef)) + (v128.const i32x4 0x10204468 0x10204468 0x10204468 0x10204468)) +(assert_return (invoke "or" (v128.const i32x4 0 0 -1 -1) + (v128.const i32x4 0 -1 0 -1)) + (v128.const i32x4 0 -1 -1 -1)) +(assert_return (invoke "or" (v128.const i32x4 0 0 0 0) + (v128.const i32x4 0 0 0 0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "or" (v128.const i32x4 0 0 0 0) + (v128.const i32x4 -1 -1 -1 -1)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "or" (v128.const i32x4 0 0 0 0) + (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)) + (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)) +(assert_return (invoke "or" (v128.const i32x4 1 1 1 1) + (v128.const i32x4 1 1 1 1)) + (v128.const i32x4 1 1 1 1)) +(assert_return (invoke "or" (v128.const i32x4 255 255 255 255) + (v128.const i32x4 85 85 85 85)) + (v128.const i32x4 255 255 255 255)) +(assert_return (invoke "or" (v128.const i32x4 255 255 255 255) + (v128.const i32x4 128 128 128 128)) + (v128.const i32x4 255 255 255 255)) +(assert_return (invoke "or" (v128.const i32x4 2863311530 2863311530 2863311530 2863311530) + (v128.const i32x4 10 128 5 165)) + (v128.const i32x4 2863311530 2863311530 2863311535 2863311535)) +(assert_return (invoke "or" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF) + (v128.const i32x4 0x55555555 0x55555555 0x55555555 0x55555555)) + (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)) +(assert_return (invoke "or" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF) + (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA)) + (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)) +(assert_return (invoke "or" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF) + (v128.const i32x4 0x0 0x0 0x0 0x0)) + (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)) +(assert_return (invoke "or" (v128.const i32x4 0x55555555 0x55555555 0x55555555 0x55555555) + (v128.const i32x4 0x5555 0xFFFF 0x55FF 0x5FFF)) + (v128.const i32x4 0x55555555 0x5555ffff 0x555555ff 0x55555fff)) +(assert_return (invoke "or" (v128.const i32x4 01_234_567_890 01_234_567_890 01_234_567_890 01_234_567_890) + (v128.const i32x4 01_234_567_890 01_234_567_890 01_234_567_890 01_234_567_890)) + (v128.const i32x4 1234567890 1234567890 1234567890 1234567890)) +(assert_return (invoke "or" (v128.const i32x4 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678) + (v128.const i32x4 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef)) + (v128.const i32x4 0x92bfdfff 0x92bfdfff 0x92bfdfff 0x92bfdfff)) +(assert_return (invoke "xor" (v128.const i32x4 0 0 -1 -1) + (v128.const i32x4 0 -1 0 -1)) + (v128.const i32x4 0 -1 -1 0)) +(assert_return (invoke "xor" (v128.const i32x4 0 0 0 0) + (v128.const i32x4 0 0 0 0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "xor" (v128.const i32x4 0 0 0 0) + (v128.const i32x4 -1 -1 -1 -1)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "xor" (v128.const i32x4 0 0 0 0) + (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)) + (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)) +(assert_return (invoke "xor" (v128.const i32x4 1 1 1 1) + (v128.const i32x4 1 1 1 1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "xor" (v128.const i32x4 255 255 255 255) + (v128.const i32x4 85 85 85 85)) + (v128.const i32x4 170 170 170 170)) +(assert_return (invoke "xor" (v128.const i32x4 255 255 255 255) + (v128.const i32x4 128 128 128 128)) + (v128.const i32x4 127 127 127 127)) +(assert_return (invoke "xor" (v128.const i32x4 2863311530 2863311530 2863311530 2863311530) + (v128.const i32x4 10 128 5 165)) + (v128.const i32x4 2863311520 2863311402 2863311535 2863311375)) +(assert_return (invoke "xor" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF) + (v128.const i32x4 0x55555555 0x55555555 0x55555555 0x55555555)) + (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA)) +(assert_return (invoke "xor" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF) + (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA)) + (v128.const i32x4 0x55555555 0x55555555 0x55555555 0x55555555)) +(assert_return (invoke "xor" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF) + (v128.const i32x4 0x0 0x0 0x0 0x0)) + (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)) +(assert_return (invoke "xor" (v128.const i32x4 0x55555555 0x55555555 0x55555555 0x55555555) + (v128.const i32x4 0x5555 0xFFFF 0x55FF 0x5FFF)) + (v128.const i32x4 0x55550000 0x5555AAAA 0x555500AA 0x55550AAA)) +(assert_return (invoke "xor" (v128.const i32x4 01_234_567_890 01_234_567_890 01_234_567_890 01_234_567_890) + (v128.const i32x4 01_234_567_890 01_234_567_890 01_234_567_890 01_234_567_890)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "xor" (v128.const i32x4 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678) + (v128.const i32x4 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef)) + (v128.const i32x4 0x829f9b97 0x829f9b97 0x829f9b97 0x829f9b97)) +(assert_return (invoke "bitselect" (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA) + (v128.const i32x4 0xBBBBBBBB 0xBBBBBBBB 0xBBBBBBBB 0xBBBBBBBB) + (v128.const i32x4 0x00112345 0xF00FFFFF 0x10112021 0xBBAABBAA)) + (v128.const i32x4 0xBBAABABA 0xABBAAAAA 0xABAABBBA 0xAABBAABB)) +(assert_return (invoke "bitselect" (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA) + (v128.const i32x4 0xBBBBBBBB 0xBBBBBBBB 0xBBBBBBBB 0xBBBBBBBB) + (v128.const i32x4 0x00000000 0x00000000 0x00000000 0x00000000)) + (v128.const i32x4 0xBBBBBBBB 0xBBBBBBBB 0xBBBBBBBB 0xBBBBBBBB)) +(assert_return (invoke "bitselect" (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA) + (v128.const i32x4 0xBBBBBBBB 0xBBBBBBBB 0xBBBBBBBB 0xBBBBBBBB) + (v128.const i32x4 0x11111111 0x11111111 0x11111111 0x11111111)) + (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA)) +(assert_return (invoke "bitselect" (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA) + (v128.const i32x4 0xBBBBBBBB 0xBBBBBBBB 0xBBBBBBBB 0xBBBBBBBB) + (v128.const i32x4 0x01234567 0x89ABCDEF 0xFEDCBA98 0x76543210)) + (v128.const i32x4 0xBABABABA 0xBABABABA 0xABABABAB 0xABABABAB)) +(assert_return (invoke "bitselect" (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA) + (v128.const i32x4 0x55555555 0x55555555 0x55555555 0x55555555) + (v128.const i32x4 0x01234567 0x89ABCDEF 0xFEDCBA98 0x76543210)) + (v128.const i32x4 0x54761032 0xDCFE98BA 0xAB89EFCD 0x23016745)) +(assert_return (invoke "bitselect" (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA) + (v128.const i32x4 0x55555555 0x55555555 0x55555555 0x55555555) + (v128.const i32x4 0x55555555 0xAAAAAAAA 0x00000000 0xFFFFFFFF)) + (v128.const i32x4 0x00000000 0xFFFFFFFF 0x55555555 0xAAAAAAAA)) +(assert_return (invoke "bitselect" (v128.const i32x4 01_234_567_890 01_234_567_890 01_234_567_890 01_234_567_890) + (v128.const i32x4 03_060_399_406 03_060_399_406 03_060_399_406 03_060_399_406) + (v128.const i32x4 0xcdefcdef 0xcdefcdef 0xcdefcdef 0xcdefcdef)) + (v128.const i32x4 2072391874 2072391874 2072391874 2072391874)) +(assert_return (invoke "bitselect" (v128.const i32x4 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678) + (v128.const i32x4 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef) + (v128.const i32x4 0xcdefcdef 0xcdefcdef 0xcdefcdef 0xcdefcdef)) + (v128.const i32x4 0x10244468 0x10244468 0x10244468 0x10244468)) +(assert_return (invoke "andnot" (v128.const i32x4 0 0 -1 -1) + (v128.const i32x4 0 -1 0 -1)) + (v128.const i32x4 0 0 -1 0)) +(assert_return (invoke "andnot" (v128.const i32x4 0 0 0 0) + (v128.const i32x4 0 0 0 0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "andnot" (v128.const i32x4 0 0 0 0) + (v128.const i32x4 -1 -1 -1 -1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "andnot" (v128.const i32x4 0 0 0 0) + (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "andnot" (v128.const i32x4 1 1 1 1) + (v128.const i32x4 1 1 1 1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "andnot" (v128.const i32x4 255 255 255 255) + (v128.const i32x4 85 85 85 85)) + (v128.const i32x4 170 170 170 170)) +(assert_return (invoke "andnot" (v128.const i32x4 255 255 255 255) + (v128.const i32x4 128 128 128 128)) + (v128.const i32x4 127 127 127 127)) +(assert_return (invoke "andnot" (v128.const i32x4 2863311530 2863311530 2863311530 2863311530) + (v128.const i32x4 10 128 5 165)) + (v128.const i32x4 2863311520 2863311402 2863311530 2863311370)) +(assert_return (invoke "andnot" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF) + (v128.const i32x4 0x55555555 0x55555555 0x55555555 0x55555555)) + (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA)) +(assert_return (invoke "andnot" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF) + (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA)) + (v128.const i32x4 0x55555555 0x55555555 0x55555555 0x55555555)) +(assert_return (invoke "andnot" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF) + (v128.const i32x4 0x0 0x0 0x0 0x0)) + (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)) +(assert_return (invoke "andnot" (v128.const i32x4 0x55555555 0x55555555 0x55555555 0x55555555) + (v128.const i32x4 0x5555 0xFFFF 0x55FF 0x5FFF)) + (v128.const i32x4 0x55550000 0x55550000 0x55550000 0x55550000)) +(assert_return (invoke "andnot" (v128.const i32x4 01_234_567_890 01_234_567_890 01_234_567_890 01_234_567_890) + (v128.const i32x4 01_234_567_890 01_234_567_890 01_234_567_890 01_234_567_890)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "andnot" (v128.const i32x4 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678) + (v128.const i32x4 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef)) + (v128.const i32x4 0x02141210 0x02141210 0x02141210 0x02141210)) + +;; for float special data [e.g. -nan nan -inf inf] +(assert_return (invoke "not" (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 5.87747e-39 5.87747e-39 5.87747e-39 5.87747e-39)) +(assert_return (invoke "not" (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 -5.87747e-39 -5.87747e-39 -5.87747e-39 -5.87747e-39)) +(assert_return (invoke "not" (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const i32x4 0x007fffff 0x007fffff 0x007fffff 0x007fffff)) +(assert_return (invoke "not" (v128.const f32x4 inf inf inf inf)) + (v128.const i32x4 0x807fffff 0x807fffff 0x807fffff 0x807fffff)) +(assert_return (invoke "and" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const i32x4 0xffc00000 0xffc00000 0xffc00000 0xffc00000)) +(assert_return (invoke "and" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 nan nan nan nan)) +(assert_return (invoke "and" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "and" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "and" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 nan nan nan nan)) +(assert_return (invoke "and" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "and" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "and" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "and" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "and" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "or" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const i32x4 0xffc00000 0xffc00000 0xffc00000 0xffc00000)) +(assert_return (invoke "or" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 nan nan nan nan)) + (v128.const i32x4 0xffc00000 0xffc00000 0xffc00000 0xffc00000)) +(assert_return (invoke "or" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const i32x4 0xffc00000 0xffc00000 0xffc00000 0xffc00000)) +(assert_return (invoke "or" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 inf inf inf inf)) + (v128.const i32x4 0xffc00000 0xffc00000 0xffc00000 0xffc00000)) +(assert_return (invoke "or" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 nan nan nan nan)) +(assert_return (invoke "or" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const i32x4 0xffc00000 0xffc00000 0xffc00000 0xffc00000)) +(assert_return (invoke "or" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 nan nan nan nan)) +(assert_return (invoke "or" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "or" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "or" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "xor" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 0 0 0 0)) +(assert_return (invoke "xor" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 -0 -0 -0 -0)) +(assert_return (invoke "xor" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const i32x4 0x00400000 0x00400000 0x00400000 0x00400000)) +(assert_return (invoke "xor" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 inf inf inf inf)) + (v128.const i32x4 0x80400000 0x80400000 0x80400000 0x80400000)) +(assert_return (invoke "xor" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 0 0 0 0)) +(assert_return (invoke "xor" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const i32x4 0x80400000 0x80400000 0x80400000 0x80400000)) +(assert_return (invoke "xor" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 inf inf inf inf)) + (v128.const i32x4 0x00400000 0x00400000 0x00400000 0x00400000)) +(assert_return (invoke "xor" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 0 0 0 0)) +(assert_return (invoke "xor" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 inf inf inf inf)) + (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000)) +(assert_return (invoke "xor" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 0 0 0 0)) +(assert_return (invoke "bitselect" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 0xA5A5A5A5 0xA5A5A5A5 0xA5A5A5A5 0xA5A5A5A5)) + (v128.const i32x4 0xffc00000 0xffc00000 0xffc00000 0xffc00000)) +(assert_return (invoke "bitselect" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 0xA5A5A5A5 0xA5A5A5A5 0xA5A5A5A5 0xA5A5A5A5)) + (v128.const f32x4 nan nan nan nan)) +(assert_return (invoke "bitselect" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 0xA5A5A5A5 0xA5A5A5A5 0xA5A5A5A5 0xA5A5A5A5)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "bitselect" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 0xA5A5A5A5 0xA5A5A5A5 0xA5A5A5A5 0xA5A5A5A5)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "bitselect" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 0xA5A5A5A5 0xA5A5A5A5 0xA5A5A5A5 0xA5A5A5A5)) + (v128.const f32x4 nan nan nan nan)) +(assert_return (invoke "bitselect" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 0xA5A5A5A5 0xA5A5A5A5 0xA5A5A5A5 0xA5A5A5A5)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "bitselect" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 0xA5A5A5A5 0xA5A5A5A5 0xA5A5A5A5 0xA5A5A5A5)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "bitselect" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 0xA5A5A5A5 0xA5A5A5A5 0xA5A5A5A5 0xA5A5A5A5)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "bitselect" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 0xA5A5A5A5 0xA5A5A5A5 0xA5A5A5A5 0xA5A5A5A5)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "bitselect" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 0xA5A5A5A5 0xA5A5A5A5 0xA5A5A5A5 0xA5A5A5A5)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "andnot" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const i32x4 0x00000000 0x00000000 0x00000000 0x00000000)) +(assert_return (invoke "andnot" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 -0 -0 -0 -0)) +(assert_return (invoke "andnot" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const i32x4 0x00400000 0x00400000 0x00400000 0x00400000)) +(assert_return (invoke "andnot" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 inf inf inf inf)) + (v128.const i32x4 0x80400000 0x80400000 0x80400000 0x80400000)) +(assert_return (invoke "andnot" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 0x00000000 0x00000000 0x00000000 0x00000000)) +(assert_return (invoke "andnot" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const i32x4 0x00400000 0x00400000 0x00400000 0x00400000)) +(assert_return (invoke "andnot" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 inf inf inf inf)) + (v128.const i32x4 0x00400000 0x00400000 0x00400000 0x00400000)) +(assert_return (invoke "andnot" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 0x00000000 0x00000000 0x00000000 0x00000000)) +(assert_return (invoke "andnot" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 inf inf inf inf)) + (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000)) +(assert_return (invoke "andnot" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 inf inf inf inf)) + (v128.const i32x4 0x00000000 0x00000000 0x00000000 0x00000000)) + +;; Type check + +;; not +(assert_invalid (module (func (result v128) (v128.not (i32.const 0)))) "type mismatch") +;; and +(assert_invalid (module (func (result v128) (v128.and (i32.const 0) (v128.const i32x4 0 0 0 0)))) "type mismatch") +(assert_invalid (module (func (result v128) (v128.and (v128.const i32x4 0 0 0 0) (i32.const 0)))) "type mismatch") +(assert_invalid (module (func (result v128) (v128.and (i32.const 0) (i32.const 0)))) "type mismatch") +;; or +(assert_invalid (module (func (result v128) (v128.or (i32.const 0) (v128.const i32x4 0 0 0 0)))) "type mismatch") +(assert_invalid (module (func (result v128) (v128.or (v128.const i32x4 0 0 0 0) (i32.const 0)))) "type mismatch") +(assert_invalid (module (func (result v128) (v128.or (i32.const 0) (i32.const 0)))) "type mismatch") +;; xor +(assert_invalid (module (func (result v128) (v128.xor (i32.const 0) (v128.const i32x4 0 0 0 0)))) "type mismatch") +(assert_invalid (module (func (result v128) (v128.xor (v128.const i32x4 0 0 0 0) (i32.const 0)))) "type mismatch") +(assert_invalid (module (func (result v128) (v128.xor (i32.const 0) (i32.const 0)))) "type mismatch") +;; bitselect +(assert_invalid (module (func (result v128) (v128.bitselect (i32.const 0) (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0)))) "type mismatch") +(assert_invalid (module (func (result v128) (v128.bitselect (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0) (i32.const 0)))) "type mismatch") +(assert_invalid (module (func (result v128) (v128.bitselect (i32.const 0) (i32.const 0) (i32.const 0)))) "type mismatch") +;; andnot +(assert_invalid (module (func (result v128) (v128.andnot (i32.const 0) (v128.const i32x4 0 0 0 0)))) "type mismatch") +(assert_invalid (module (func (result v128) (v128.andnot (v128.const i32x4 0 0 0 0) (i32.const 0)))) "type mismatch") +(assert_invalid (module (func (result v128) (v128.andnot (i32.const 0) (i32.const 0)))) "type mismatch") + +;; Combination + +(module (memory 1) + (func (export "v128.not-in-block") + (block + (drop + (block (result v128) + (v128.not + (block (result v128) (v128.load (i32.const 0))) + ) + ) + ) + ) + ) + (func (export "v128.and-in-block") + (block + (drop + (block (result v128) + (v128.and + (block (result v128) (v128.load (i32.const 0))) + (block (result v128) (v128.load (i32.const 1))) + ) + ) + ) + ) + ) + (func (export "v128.or-in-block") + (block + (drop + (block (result v128) + (v128.or + (block (result v128) (v128.load (i32.const 0))) + (block (result v128) (v128.load (i32.const 1))) + ) + ) + ) + ) + ) + (func (export "v128.xor-in-block") + (block + (drop + (block (result v128) + (v128.xor + (block (result v128) (v128.load (i32.const 0))) + (block (result v128) (v128.load (i32.const 1))) + ) + ) + ) + ) + ) + (func (export "v128.bitselect-in-block") + (block + (drop + (block (result v128) + (v128.bitselect + (block (result v128) (v128.load (i32.const 0))) + (block (result v128) (v128.load (i32.const 1))) + (block (result v128) (v128.load (i32.const 2))) + ) + ) + ) + ) + ) + (func (export "v128.andnot-in-block") + (block + (drop + (block (result v128) + (v128.andnot + (block (result v128) (v128.load (i32.const 0))) + (block (result v128) (v128.load (i32.const 1))) + ) + ) + ) + ) + ) + (func (export "nested-v128.not") + (drop + (v128.not + (v128.not + (v128.not + (v128.load (i32.const 0)) + ) + ) + ) + ) + ) + (func (export "nested-v128.and") + (drop + (v128.and + (v128.and + (v128.and + (v128.load (i32.const 0)) + (v128.load (i32.const 1)) + ) + (v128.and + (v128.load (i32.const 0)) + (v128.load (i32.const 1)) + ) + ) + (v128.and + (v128.and + (v128.load (i32.const 0)) + (v128.load (i32.const 1)) + ) + (v128.and + (v128.load (i32.const 0)) + (v128.load (i32.const 1)) + ) + ) + ) + ) + ) + (func (export "nested-v128.or") + (drop + (v128.or + (v128.or + (v128.or + (v128.load (i32.const 0)) + (v128.load (i32.const 1)) + ) + (v128.or + (v128.load (i32.const 0)) + (v128.load (i32.const 1)) + ) + ) + (v128.or + (v128.or + (v128.load (i32.const 0)) + (v128.load (i32.const 1)) + ) + (v128.or + (v128.load (i32.const 0)) + (v128.load (i32.const 1)) + ) + ) + ) + ) + ) + (func (export "nested-v128.xor") + (drop + (v128.xor + (v128.xor + (v128.xor + (v128.load (i32.const 0)) + (v128.load (i32.const 1)) + ) + (v128.xor + (v128.load (i32.const 0)) + (v128.load (i32.const 1)) + ) + ) + (v128.xor + (v128.xor + (v128.load (i32.const 0)) + (v128.load (i32.const 1)) + ) + (v128.xor + (v128.load (i32.const 0)) + (v128.load (i32.const 1)) + ) + ) + ) + ) + ) + (func (export "nested-v128.bitselect") + (drop + (v128.bitselect + (v128.bitselect + (v128.bitselect + (v128.load (i32.const 0)) + (v128.load (i32.const 1)) + (v128.load (i32.const 2)) + ) + (v128.bitselect + (v128.load (i32.const 0)) + (v128.load (i32.const 1)) + (v128.load (i32.const 2)) + ) + (v128.bitselect + (v128.load (i32.const 0)) + (v128.load (i32.const 1)) + (v128.load (i32.const 2)) + ) + ) + (v128.bitselect + (v128.bitselect + (v128.load (i32.const 0)) + (v128.load (i32.const 1)) + (v128.load (i32.const 2)) + ) + (v128.bitselect + (v128.load (i32.const 0)) + (v128.load (i32.const 1)) + (v128.load (i32.const 2)) + ) + (v128.bitselect + (v128.load (i32.const 0)) + (v128.load (i32.const 1)) + (v128.load (i32.const 2)) + ) + ) + (v128.bitselect + (v128.bitselect + (v128.load (i32.const 0)) + (v128.load (i32.const 1)) + (v128.load (i32.const 2)) + ) + (v128.bitselect + (v128.load (i32.const 0)) + (v128.load (i32.const 1)) + (v128.load (i32.const 2)) + ) + (v128.bitselect + (v128.load (i32.const 0)) + (v128.load (i32.const 1)) + (v128.load (i32.const 2)) + ) + ) + ) + ) + ) + (func (export "nested-v128.andnot") + (drop + (v128.andnot + (v128.andnot + (v128.andnot + (v128.load (i32.const 0)) + (v128.load (i32.const 1)) + ) + (v128.andnot + (v128.load (i32.const 0)) + (v128.load (i32.const 1)) + ) + ) + (v128.andnot + (v128.andnot + (v128.load (i32.const 0)) + (v128.load (i32.const 1)) + ) + (v128.andnot + (v128.load (i32.const 0)) + (v128.load (i32.const 1)) + ) + ) + ) + ) + ) + (func (export "as-param") + (drop + (v128.or + (v128.and + (v128.not + (v128.load (i32.const 0)) + ) + (v128.not + (v128.load (i32.const 1)) + ) + ) + (v128.xor + (v128.bitselect + (v128.load (i32.const 0)) + (v128.load (i32.const 1)) + (v128.load (i32.const 2)) + ) + (v128.andnot + (v128.load (i32.const 0)) + (v128.load (i32.const 1)) + ) + ) + ) + ) + ) +) +(assert_return (invoke "v128.not-in-block")) +(assert_return (invoke "v128.and-in-block")) +(assert_return (invoke "v128.or-in-block")) +(assert_return (invoke "v128.xor-in-block")) +(assert_return (invoke "v128.bitselect-in-block")) +(assert_return (invoke "v128.andnot-in-block")) +(assert_return (invoke "nested-v128.not")) +(assert_return (invoke "nested-v128.and")) +(assert_return (invoke "nested-v128.or")) +(assert_return (invoke "nested-v128.xor")) +(assert_return (invoke "nested-v128.bitselect")) +(assert_return (invoke "nested-v128.andnot")) +(assert_return (invoke "as-param")) + + +;; Test operation with empty argument + +(assert_invalid + (module + (func $v128.not-arg-empty (result v128) + (v128.not) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $v128.and-1st-arg-empty (result v128) + (v128.and (v128.const i32x4 0 0 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $v128.and-arg-empty (result v128) + (v128.and) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $v128.or-1st-arg-empty (result v128) + (v128.or (v128.const i32x4 0 0 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $v128.or-arg-empty (result v128) + (v128.or) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $v128.xor-1st-arg-empty (result v128) + (v128.xor (v128.const i32x4 0 0 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $v128.xor-arg-empty (result v128) + (v128.xor) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $v128.andnot-1st-arg-empty (result v128) + (v128.andnot (v128.const i32x4 0 0 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $v128.andnot-arg-empty (result v128) + (v128.andnot) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $v128.bitselect-1st-arg-empty (result v128) + (v128.bitselect (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $v128.bitselect-two-args-empty (result v128) + (v128.bitselect (v128.const i32x4 0 0 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $v128.bitselect-arg-empty (result v128) + (v128.bitselect) + ) + ) + "type mismatch" +) diff --git a/runtime/near-vm/tests/wast/spec/proposals/simd/simd_boolean.wast b/runtime/near-vm/tests/wast/spec/proposals/simd/simd_boolean.wast new file mode 100644 index 00000000000..6ab330fe508 --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/proposals/simd/simd_boolean.wast @@ -0,0 +1,1058 @@ +;; Test all the boolean operators on major boundary values and all special values. + +(module + (func (export "i8x16.any_true") (param $0 v128) (result i32) (v128.any_true (local.get $0))) + (func (export "i8x16.all_true") (param $0 v128) (result i32) (i8x16.all_true (local.get $0))) + (func (export "i8x16.bitmask") (param $0 v128) (result i32) (i8x16.bitmask (local.get $0))) + + (func (export "i16x8.any_true") (param $0 v128) (result i32) (v128.any_true (local.get $0))) + (func (export "i16x8.all_true") (param $0 v128) (result i32) (i16x8.all_true (local.get $0))) + (func (export "i16x8.bitmask") (param $0 v128) (result i32) (i16x8.bitmask (local.get $0))) + + (func (export "i32x4.any_true") (param $0 v128) (result i32) (v128.any_true (local.get $0))) + (func (export "i32x4.all_true") (param $0 v128) (result i32) (i32x4.all_true (local.get $0))) + (func (export "i32x4.bitmask") (param $0 v128) (result i32) (i32x4.bitmask (local.get $0))) + + (func (export "i64x2.all_true") (param $0 v128) (result i32) (i64x2.all_true (local.get $0))) + (func (export "i64x2.bitmask") (param $0 v128) (result i32) (i64x2.bitmask (local.get $0))) +) + +;; i8x16 +(assert_return (invoke "i8x16.any_true" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + (i32.const 0)) +(assert_return (invoke "i8x16.any_true" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0)) + (i32.const 1)) +(assert_return (invoke "i8x16.any_true" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1)) + (i32.const 1)) +(assert_return (invoke "i8x16.any_true" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) + (i32.const 1)) +(assert_return (invoke "i8x16.any_true" (v128.const i8x16 -1 0 1 2 3 4 5 6 7 8 9 0xA 0xB 0xC 0xD 0xF)) + (i32.const 1)) +(assert_return (invoke "i8x16.any_true" (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00)) + (i32.const 0)) +(assert_return (invoke "i8x16.any_true" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)) + (i32.const 1)) +(assert_return (invoke "i8x16.any_true" (v128.const i8x16 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB)) + (i32.const 1)) +(assert_return (invoke "i8x16.any_true" (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55)) + (i32.const 1)) +(assert_return (invoke "i8x16.all_true" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + (i32.const 0)) +(assert_return (invoke "i8x16.all_true" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0)) + (i32.const 0)) +(assert_return (invoke "i8x16.all_true" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1)) + (i32.const 0)) +(assert_return (invoke "i8x16.all_true" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) + (i32.const 1)) +(assert_return (invoke "i8x16.all_true" (v128.const i8x16 -1 0 1 2 3 4 5 6 7 8 9 0xA 0xB 0xC 0xD 0xF)) + (i32.const 0)) +(assert_return (invoke "i8x16.all_true" (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00)) + (i32.const 0)) +(assert_return (invoke "i8x16.all_true" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)) + (i32.const 1)) +(assert_return (invoke "i8x16.all_true" (v128.const i8x16 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB)) + (i32.const 1)) +(assert_return (invoke "i8x16.all_true" (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55)) + (i32.const 1)) +(assert_return (invoke "i8x16.bitmask" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)) + (i32.const 0x0000FFFF)) +(assert_return (invoke "i8x16.bitmask" (v128.const i8x16 -1 0 1 2 3 4 5 6 7 8 9 0xA 0xB 0xC 0xD 0xF)) + (i32.const 0x00000001)) + +;; i16x8 +(assert_return (invoke "i16x8.any_true" (v128.const i16x8 0 0 0 0 0 0 0 0)) + (i32.const 0)) +(assert_return (invoke "i16x8.any_true" (v128.const i16x8 0 0 0 0 0 0 1 0)) + (i32.const 1)) +(assert_return (invoke "i16x8.any_true" (v128.const i16x8 1 1 1 1 1 1 0 1)) + (i32.const 1)) +(assert_return (invoke "i16x8.any_true" (v128.const i16x8 1 1 1 1 1 1 1 1)) + (i32.const 1)) +(assert_return (invoke "i16x8.any_true" (v128.const i16x8 -1 0 1 2 0xB 0xC 0xD 0xF)) + (i32.const 1)) +(assert_return (invoke "i16x8.any_true" (v128.const i16x8 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00)) + (i32.const 0)) +(assert_return (invoke "i16x8.any_true" (v128.const i16x8 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)) + (i32.const 1)) +(assert_return (invoke "i16x8.any_true" (v128.const i16x8 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB)) + (i32.const 1)) +(assert_return (invoke "i16x8.any_true" (v128.const i16x8 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55)) + (i32.const 1)) +(assert_return (invoke "i16x8.any_true" (v128.const i16x8 012_345 012_345 012_345 012_345 012_345 012_345 012_345 012_345)) + (i32.const 1)) +(assert_return (invoke "i16x8.any_true" (v128.const i16x8 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234)) + (i32.const 1)) +(assert_return (invoke "i16x8.all_true" (v128.const i16x8 0 0 0 0 0 0 0 0)) + (i32.const 0)) +(assert_return (invoke "i16x8.all_true" (v128.const i16x8 0 0 0 0 0 0 1 0)) + (i32.const 0)) +(assert_return (invoke "i16x8.all_true" (v128.const i16x8 1 1 1 1 1 1 0 1)) + (i32.const 0)) +(assert_return (invoke "i16x8.all_true" (v128.const i16x8 1 1 1 1 1 1 1 1)) + (i32.const 1)) +(assert_return (invoke "i16x8.all_true" (v128.const i16x8 -1 0 1 2 0xB 0xC 0xD 0xF)) + (i32.const 0)) +(assert_return (invoke "i16x8.all_true" (v128.const i16x8 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00)) + (i32.const 0)) +(assert_return (invoke "i16x8.all_true" (v128.const i16x8 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)) + (i32.const 1)) +(assert_return (invoke "i16x8.all_true" (v128.const i16x8 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB)) + (i32.const 1)) +(assert_return (invoke "i16x8.all_true" (v128.const i16x8 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55)) + (i32.const 1)) +(assert_return (invoke "i16x8.all_true" (v128.const i16x8 012_345 012_345 012_345 012_345 012_345 012_345 012_345 012_345)) + (i32.const 1)) +(assert_return (invoke "i16x8.all_true" (v128.const i16x8 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234)) + (i32.const 1)) +(assert_return (invoke "i16x8.bitmask" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)) + (i32.const 0x000000FF)) +(assert_return (invoke "i16x8.bitmask" (v128.const i16x8 -1 0 1 2 0xB 0xC 0xD 0xF)) + (i32.const 0x00000001)) + +;; i32x4 +(assert_return (invoke "i32x4.any_true" (v128.const i32x4 0 0 0 0)) + (i32.const 0)) +(assert_return (invoke "i32x4.any_true" (v128.const i32x4 0 0 1 0)) + (i32.const 1)) +(assert_return (invoke "i32x4.any_true" (v128.const i32x4 1 1 0 1)) + (i32.const 1)) +(assert_return (invoke "i32x4.any_true" (v128.const i32x4 1 1 1 1)) + (i32.const 1)) +(assert_return (invoke "i32x4.any_true" (v128.const i32x4 -1 0 1 0xF)) + (i32.const 1)) +(assert_return (invoke "i32x4.any_true" (v128.const i32x4 0x00 0x00 0x00 0x00)) + (i32.const 0)) +(assert_return (invoke "i32x4.any_true" (v128.const i32x4 0xFF 0xFF 0xFF 0xFF)) + (i32.const 1)) +(assert_return (invoke "i32x4.any_true" (v128.const i32x4 0xAB 0xAB 0xAB 0xAB)) + (i32.const 1)) +(assert_return (invoke "i32x4.any_true" (v128.const i32x4 0x55 0x55 0x55 0x55)) + (i32.const 1)) +(assert_return (invoke "i32x4.any_true" (v128.const i32x4 01_234_567_890 01_234_567_890 01_234_567_890 01_234_567_890)) + (i32.const 1)) +(assert_return (invoke "i32x4.any_true" (v128.const i32x4 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678)) + (i32.const 1)) +(assert_return (invoke "i32x4.all_true" (v128.const i32x4 0 0 0 0)) + (i32.const 0)) +(assert_return (invoke "i32x4.all_true" (v128.const i32x4 0 0 1 0)) + (i32.const 0)) +(assert_return (invoke "i32x4.all_true" (v128.const i32x4 1 1 0 1)) + (i32.const 0)) +(assert_return (invoke "i32x4.all_true" (v128.const i32x4 1 1 1 1)) + (i32.const 1)) +(assert_return (invoke "i32x4.all_true" (v128.const i32x4 -1 0 1 0xF)) + (i32.const 0)) +(assert_return (invoke "i32x4.all_true" (v128.const i32x4 0x00 0x00 0x00 0x00)) + (i32.const 0)) +(assert_return (invoke "i32x4.all_true" (v128.const i32x4 0xFF 0xFF 0xFF 0xFF)) + (i32.const 1)) +(assert_return (invoke "i32x4.all_true" (v128.const i32x4 0xAB 0xAB 0xAB 0xAB)) + (i32.const 1)) +(assert_return (invoke "i32x4.all_true" (v128.const i32x4 0x55 0x55 0x55 0x55)) + (i32.const 1)) +(assert_return (invoke "i32x4.all_true" (v128.const i32x4 01_234_567_890 01_234_567_890 01_234_567_890 01_234_567_890)) + (i32.const 1)) +(assert_return (invoke "i32x4.all_true" (v128.const i32x4 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678)) + (i32.const 1)) +(assert_return (invoke "i32x4.bitmask" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)) + (i32.const 0x0000000F)) +(assert_return (invoke "i32x4.bitmask" (v128.const i32x4 -1 0 1 0xF)) + (i32.const 0x00000001)) + +;; i64x2 +(assert_return (invoke "i64x2.all_true" (v128.const i64x2 0 0)) + (i32.const 0)) +(assert_return (invoke "i64x2.all_true" (v128.const i64x2 0 1)) + (i32.const 0)) +(assert_return (invoke "i64x2.all_true" (v128.const i64x2 1 0)) + (i32.const 0)) +(assert_return (invoke "i64x2.all_true" (v128.const i64x2 1 1)) + (i32.const 1)) +(assert_return (invoke "i64x2.all_true" (v128.const i64x2 -1 0)) + (i32.const 0)) +(assert_return (invoke "i64x2.all_true" (v128.const i64x2 0x00 0x00)) + (i32.const 0)) +(assert_return (invoke "i64x2.all_true" (v128.const i64x2 0xFF 0xFF)) + (i32.const 1)) +(assert_return (invoke "i64x2.all_true" (v128.const i64x2 0xAB 0xAB)) + (i32.const 1)) +(assert_return (invoke "i64x2.all_true" (v128.const i64x2 0x55 0x55)) + (i32.const 1)) +(assert_return (invoke "i64x2.bitmask" (v128.const i64x2 0xFFFFFFFF_FFFFFFFF 0xFFFFFFFF_FFFFFFFF)) + (i32.const 0x00000003)) +(assert_return (invoke "i64x2.bitmask" (v128.const i64x2 -1 0xF)) + (i32.const 0x00000001)) + +;; Combination + +(module (memory 1) + ;; as if condition + (func (export "i8x16_any_true_as_if_cond") (param v128) (result i32) + (if (result i32) (v128.any_true (local.get 0)) + (then (i32.const 1)) + (else (i32.const 0)) + ) + ) + (func (export "i16x8_any_true_as_if_cond") (param v128) (result i32) + (if (result i32) (v128.any_true (local.get 0)) + (then (i32.const 1)) + (else (i32.const 0)) + ) + ) + (func (export "i32x4_any_true_as_if_cond") (param v128) (result i32) + (if (result i32) (v128.any_true (local.get 0)) + (then (i32.const 1)) + (else (i32.const 0)) + ) + ) + (func (export "i8x16_all_true_as_if_cond") (param v128) (result i32) + (if (result i32) (i8x16.all_true (local.get 0)) + (then (i32.const 1)) + (else (i32.const 0)) + ) + ) + (func (export "i16x8_all_true_as_if_cond") (param v128) (result i32) + (if (result i32) (i16x8.all_true (local.get 0)) + (then (i32.const 1)) + (else (i32.const 0)) + ) + ) + (func (export "i32x4_all_true_as_if_cond") (param v128) (result i32) + (if (result i32) (i32x4.all_true (local.get 0)) + (then (i32.const 1)) + (else (i32.const 0)) + ) + ) + ;; any_true as select condition + (func (export "i8x16_any_true_as_select_cond") (param v128) (result i32) + (select (i32.const 1) (i32.const 0) (v128.any_true (local.get 0))) + ) + (func (export "i16x8_any_true_as_select_cond") (param v128) (result i32) + (select (i32.const 1) (i32.const 0) (v128.any_true (local.get 0))) + ) + (func (export "i32x4_any_true_as_select_cond") (param v128) (result i32) + (select (i32.const 1) (i32.const 0) (v128.any_true (local.get 0))) + ) + ;; all_true as select condition + (func (export "i8x16_all_true_as_select_cond") (param v128) (result i32) + (select (i32.const 1) (i32.const 0) (i8x16.all_true (local.get 0))) + ) + (func (export "i16x8_all_true_as_select_cond") (param v128) (result i32) + (select (i32.const 1) (i32.const 0) (i16x8.all_true (local.get 0))) + ) + (func (export "i32x4_all_true_as_select_cond") (param v128) (result i32) + (select (i32.const 1) (i32.const 0) (i32x4.all_true (local.get 0))) + ) + ;; any_true as br_if condition + (func (export "i8x16_any_true_as_br_if_cond") (param $0 v128) (result i32) + (local $1 i32) + (local.set $1 (i32.const 2)) + (block + (local.set $1 (i32.const 1)) + (br_if 0 (v128.any_true (local.get $0))) + (local.set $1 (i32.const 0)) + ) + (local.get $1) + ) + (func (export "i16x8_any_true_as_br_if_cond") (param $0 v128) (result i32) + (local $1 i32) + (local.set $1 (i32.const 2)) + (block + (local.set $1 (i32.const 1)) + (br_if 0 (v128.any_true (local.get $0))) + (local.set $1 (i32.const 0)) + ) + (local.get $1) + ) + (func (export "i32x4_any_true_as_br_if_cond") (param $0 v128) (result i32) + (local $1 i32) + (local.set $1 (i32.const 2)) + (block + (local.set $1 (i32.const 1)) + (br_if 0 (v128.any_true (local.get $0))) + (local.set $1 (i32.const 0)) + ) + (local.get $1) + ) + ;; all_true as br_if condition + (func (export "i8x16_all_true_as_br_if_cond") (param $0 v128) (result i32) + (local $1 i32) + (local.set $1 (i32.const 2)) + (block + (local.set $1 (i32.const 1)) + (br_if 0 (i8x16.all_true (local.get $0))) + (local.set $1 (i32.const 0)) + ) + (local.get $1) + ) + (func (export "i16x8_all_true_as_br_if_cond") (param $0 v128) (result i32) + (local $1 i32) + (local.set $1 (i32.const 2)) + (block + (local.set $1 (i32.const 1)) + (br_if 0 (i16x8.all_true (local.get $0))) + (local.set $1 (i32.const 0)) + ) + (local.get $1) + ) + (func (export "i32x4_all_true_as_br_if_cond") (param $0 v128) (result i32) + (local $1 i32) + (local.set $1 (i32.const 2)) + (block + (local.set $1 (i32.const 1)) + (br_if 0 (i32x4.all_true (local.get $0))) + (local.set $1 (i32.const 0)) + ) + (local.get $1) + ) + ;; any_true as i32.and operand + (func (export "i8x16_any_true_as_i32.and_operand") (param $0 v128) (param $1 v128) (result i32) + (i32.and (v128.any_true (local.get $0)) (v128.any_true (local.get $1))) + ) + (func (export "i16x8_any_true_as_i32.and_operand") (param $0 v128) (param $1 v128) (result i32) + (i32.and (v128.any_true (local.get $0)) (v128.any_true (local.get $1))) + ) + (func (export "i32x4_any_true_as_i32.and_operand") (param $0 v128) (param $1 v128) (result i32) + (i32.and (v128.any_true (local.get $0)) (v128.any_true (local.get $1))) + ) + ;; any_true as i32.or operand + (func (export "i8x16_any_true_as_i32.or_operand") (param $0 v128) (param $1 v128) (result i32) + (i32.or (v128.any_true (local.get $0)) (v128.any_true (local.get $1))) + ) + (func (export "i16x8_any_true_as_i32.or_operand") (param $0 v128) (param $1 v128) (result i32) + (i32.or (v128.any_true (local.get $0)) (v128.any_true (local.get $1))) + ) + (func (export "i32x4_any_true_as_i32.or_operand") (param $0 v128) (param $1 v128) (result i32) + (i32.or (v128.any_true (local.get $0)) (v128.any_true (local.get $1))) + ) + ;; any_true as i32.xor operand + (func (export "i8x16_any_true_as_i32.xor_operand") (param $0 v128) (param $1 v128) (result i32) + (i32.xor (v128.any_true (local.get $0)) (v128.any_true (local.get $1))) + ) + (func (export "i16x8_any_true_as_i32.xor_operand") (param $0 v128) (param $1 v128) (result i32) + (i32.xor (v128.any_true (local.get $0)) (v128.any_true (local.get $1))) + ) + (func (export "i32x4_any_true_as_i32.xor_operand") (param $0 v128) (param $1 v128) (result i32) + (i32.xor (v128.any_true (local.get $0)) (v128.any_true (local.get $1))) + ) + ;; all_true as i32.and operand + (func (export "i8x16_all_true_as_i32.and_operand") (param $0 v128) (param $1 v128) (result i32) + (i32.and (i8x16.all_true (local.get $0)) (i8x16.all_true (local.get $1))) + ) + (func (export "i16x8_all_true_as_i32.and_operand") (param $0 v128) (param $1 v128) (result i32) + (i32.and (i16x8.all_true (local.get $0)) (i16x8.all_true (local.get $1))) + ) + (func (export "i32x4_all_true_as_i32.and_operand") (param $0 v128) (param $1 v128) (result i32) + (i32.and (i32x4.all_true (local.get $0)) (i32x4.all_true (local.get $1))) + ) + ;; all_true as i32.or operand + (func (export "i8x16_all_true_as_i32.or_operand") (param $0 v128) (param $1 v128) (result i32) + (i32.or (i8x16.all_true (local.get $0)) (i8x16.all_true (local.get $1))) + ) + (func (export "i16x8_all_true_as_i32.or_operand") (param $0 v128) (param $1 v128) (result i32) + (i32.or (i16x8.all_true (local.get $0)) (i16x8.all_true (local.get $1))) + ) + (func (export "i32x4_all_true_as_i32.or_operand") (param $0 v128) (param $1 v128) (result i32) + (i32.or (i32x4.all_true (local.get $0)) (i32x4.all_true (local.get $1))) + ) + ;; all_true as i32.xor operand + (func (export "i8x16_all_true_as_i32.xor_operand") (param $0 v128) (param $1 v128) (result i32) + (i32.xor (i8x16.all_true (local.get $0)) (i8x16.all_true (local.get $1))) + ) + (func (export "i16x8_all_true_as_i32.xor_operand") (param $0 v128) (param $1 v128) (result i32) + (i32.xor (i16x8.all_true (local.get $0)) (i16x8.all_true (local.get $1))) + ) + (func (export "i32x4_all_true_as_i32.xor_operand") (param $0 v128) (param $1 v128) (result i32) + (i32.xor (i32x4.all_true (local.get $0)) (i32x4.all_true (local.get $1))) + ) + ;; any_true with v128.not + (func (export "i8x16_any_true_with_v128.not") (param $0 v128) (result i32) + (v128.any_true (v128.not (local.get $0))) + ) + (func (export "i16x8_any_true_with_v128.not") (param $0 v128) (result i32) + (v128.any_true (v128.not (local.get $0))) + ) + (func (export "i32x4_any_true_with_v128.not") (param $0 v128) (result i32) + (v128.any_true (v128.not (local.get $0))) + ) + ;; any_true with v128.and + (func (export "i8x16_any_true_with_v128.and") (param $0 v128) (param $1 v128) (result i32) + (v128.any_true (v128.and (local.get $0) (local.get $1))) + ) + (func (export "i16x8_any_true_with_v128.and") (param $0 v128) (param $1 v128) (result i32) + (v128.any_true (v128.and (local.get $0) (local.get $1))) + ) + (func (export "i32x4_any_true_with_v128.and") (param $0 v128) (param $1 v128) (result i32) + (v128.any_true (v128.and (local.get $0) (local.get $1))) + ) + ;; any_true with v128.or + (func (export "i8x16_any_true_with_v128.or") (param $0 v128) (param $1 v128) (result i32) + (v128.any_true (v128.or (local.get $0) (local.get $1))) + ) + (func (export "i16x8_any_true_with_v128.or") (param $0 v128) (param $1 v128) (result i32) + (v128.any_true (v128.or (local.get $0) (local.get $1))) + ) + (func (export "i32x4_any_true_with_v128.or") (param $0 v128) (param $1 v128) (result i32) + (v128.any_true (v128.or (local.get $0) (local.get $1))) + ) + ;; any_true with v128.xor + (func (export "i8x16_any_true_with_v128.xor") (param $0 v128) (param $1 v128) (result i32) + (v128.any_true (v128.xor (local.get $0) (local.get $1))) + ) + (func (export "i16x8_any_true_with_v128.xor") (param $0 v128) (param $1 v128) (result i32) + (v128.any_true (v128.xor (local.get $0) (local.get $1))) + ) + (func (export "i32x4_any_true_with_v128.xor") (param $0 v128) (param $1 v128) (result i32) + (v128.any_true (v128.xor (local.get $0) (local.get $1))) + ) + ;; any_true with v128.bitselect + (func (export "i8x16_any_true_with_v128.bitselect") (param $0 v128) (param $1 v128) (param $2 v128) (result i32) + (v128.any_true (v128.bitselect (local.get $0) (local.get $1) (local.get $2))) + ) + (func (export "i16x8_any_true_with_v128.bitselect") (param $0 v128) (param $1 v128) (param $2 v128) (result i32) + (v128.any_true (v128.bitselect (local.get $0) (local.get $1) (local.get $2))) + ) + (func (export "i32x4_any_true_with_v128.bitselect") (param $0 v128) (param $1 v128) (param $2 v128) (result i32) + (v128.any_true (v128.bitselect (local.get $0) (local.get $1) (local.get $2))) + ) + ;; all_true with v128.not + (func (export "i8x16_all_true_with_v128.not") (param $0 v128) (result i32) + (i8x16.all_true (v128.not (local.get $0))) + ) + (func (export "i16x8_all_true_with_v128.not") (param $0 v128) (result i32) + (i16x8.all_true (v128.not (local.get $0))) + ) + (func (export "i32x4_all_true_with_v128.not") (param $0 v128) (result i32) + (i32x4.all_true (v128.not (local.get $0))) + ) + ;; all_true with v128.and + (func (export "i8x16_all_true_with_v128.and") (param $0 v128) (param $1 v128) (result i32) + (i8x16.all_true (v128.and (local.get $0) (local.get $1))) + ) + (func (export "i16x8_all_true_with_v128.and") (param $0 v128) (param $1 v128) (result i32) + (i16x8.all_true (v128.and (local.get $0) (local.get $1))) + ) + (func (export "i32x4_all_true_with_v128.and") (param $0 v128) (param $1 v128) (result i32) + (i32x4.all_true (v128.and (local.get $0) (local.get $1))) + ) + ;; all_true with v128.or + (func (export "i8x16_all_true_with_v128.or") (param $0 v128) (param $1 v128) (result i32) + (i8x16.all_true (v128.or (local.get $0) (local.get $1))) + ) + (func (export "i16x8_all_true_with_v128.or") (param $0 v128) (param $1 v128) (result i32) + (i16x8.all_true (v128.or (local.get $0) (local.get $1))) + ) + (func (export "i32x4_all_true_with_v128.or") (param $0 v128) (param $1 v128) (result i32) + (i32x4.all_true (v128.or (local.get $0) (local.get $1))) + ) + ;; all_true with v128.xor + (func (export "i8x16_all_true_with_v128.xor") (param $0 v128) (param $1 v128) (result i32) + (i8x16.all_true (v128.xor (local.get $0) (local.get $1))) + ) + (func (export "i16x8_all_true_with_v128.xor") (param $0 v128) (param $1 v128) (result i32) + (i16x8.all_true (v128.xor (local.get $0) (local.get $1))) + ) + (func (export "i32x4_all_true_with_v128.xor") (param $0 v128) (param $1 v128) (result i32) + (i32x4.all_true (v128.xor (local.get $0) (local.get $1))) + ) + ;; all_true with v128.bitselect + (func (export "i8x16_all_true_with_v128.bitselect") (param $0 v128) (param $1 v128) (param $2 v128) (result i32) + (i8x16.all_true (v128.bitselect (local.get $0) (local.get $1) (local.get $2))) + ) + (func (export "i16x8_all_true_with_v128.bitselect") (param $0 v128) (param $1 v128) (param $2 v128) (result i32) + (i16x8.all_true (v128.bitselect (local.get $0) (local.get $1) (local.get $2))) + ) + (func (export "i32x4_all_true_with_v128.bitselect") (param $0 v128) (param $1 v128) (param $2 v128) (result i32) + (i32x4.all_true (v128.bitselect (local.get $0) (local.get $1) (local.get $2))) + ) +) + +;; 'any_true' as 'if' condition +;; i8x16 +(assert_return (invoke "i8x16_any_true_as_if_cond" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + (i32.const 0)) +(assert_return (invoke "i8x16_any_true_as_if_cond" (v128.const i8x16 0 0 1 0 0 0 1 0 0 0 1 0 0 0 1 0)) + (i32.const 1)) +(assert_return (invoke "i8x16_any_true_as_if_cond" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) + (i32.const 1)) +;; i16x8 +(assert_return (invoke "i16x8_any_true_as_if_cond" (v128.const i16x8 0 0 0 0 0 0 0 0)) + (i32.const 0)) +(assert_return (invoke "i16x8_any_true_as_if_cond" (v128.const i16x8 0 0 1 0 0 0 1 0)) + (i32.const 1)) +(assert_return (invoke "i16x8_any_true_as_if_cond" (v128.const i16x8 1 1 1 1 1 1 1 1)) + (i32.const 1)) +;; i32x4 +(assert_return (invoke "i32x4_any_true_as_if_cond" (v128.const i32x4 0 0 0 0)) + (i32.const 0)) +(assert_return (invoke "i32x4_any_true_as_if_cond" (v128.const i32x4 0 0 1 0)) + (i32.const 1)) +(assert_return (invoke "i32x4_any_true_as_if_cond" (v128.const i32x4 1 1 1 1)) + (i32.const 1)) + +;; 'all_true' as 'if' condition +;; i8x16 +(assert_return (invoke "i8x16_all_true_as_if_cond" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + (i32.const 0)) +(assert_return (invoke "i8x16_all_true_as_if_cond" (v128.const i8x16 1 1 1 0 1 1 1 0 1 1 1 0 1 1 1 0)) + (i32.const 0)) +(assert_return (invoke "i8x16_all_true_as_if_cond" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) + (i32.const 1)) +;; i16x8 +(assert_return (invoke "i16x8_all_true_as_if_cond" (v128.const i16x8 0 0 0 0 0 0 0 0)) + (i32.const 0)) +(assert_return (invoke "i16x8_all_true_as_if_cond" (v128.const i16x8 1 1 1 0 1 1 1 0)) + (i32.const 0)) +(assert_return (invoke "i16x8_all_true_as_if_cond" (v128.const i16x8 1 1 1 1 1 1 1 1)) + (i32.const 1)) +;; i32x4 +(assert_return (invoke "i32x4_all_true_as_if_cond" (v128.const i32x4 0 0 0 0)) + (i32.const 0)) +(assert_return (invoke "i32x4_all_true_as_if_cond" (v128.const i32x4 1 1 1 0)) + (i32.const 0)) +(assert_return (invoke "i32x4_all_true_as_if_cond" (v128.const i32x4 1 1 1 1)) + (i32.const 1)) + +;; any_true as select condition +(assert_return (invoke "i8x16_any_true_as_select_cond" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + (i32.const 0)) +(assert_return (invoke "i8x16_any_true_as_select_cond" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0)) + (i32.const 1)) +(assert_return (invoke "i16x8_any_true_as_select_cond" (v128.const i16x8 0 0 0 0 0 0 0 0)) + (i32.const 0)) +(assert_return (invoke "i16x8_any_true_as_select_cond" (v128.const i16x8 0 0 0 0 0 0 1 0)) + (i32.const 1)) +(assert_return (invoke "i32x4_any_true_as_select_cond" (v128.const i32x4 0 0 0 0)) + (i32.const 0)) +(assert_return (invoke "i32x4_any_true_as_select_cond" (v128.const i32x4 0 0 1 0)) + (i32.const 1)) +;; all_true as select condition +(assert_return (invoke "i8x16_all_true_as_select_cond" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) + (i32.const 1)) +(assert_return (invoke "i8x16_all_true_as_select_cond" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1)) + (i32.const 0)) +(assert_return (invoke "i16x8_all_true_as_select_cond" (v128.const i16x8 1 1 1 1 1 1 1 1)) + (i32.const 1)) +(assert_return (invoke "i16x8_all_true_as_select_cond" (v128.const i16x8 1 1 1 1 1 1 0 1)) + (i32.const 0)) +(assert_return (invoke "i32x4_all_true_as_select_cond" (v128.const i32x4 1 1 1 1)) + (i32.const 1)) +(assert_return (invoke "i32x4_all_true_as_select_cond" (v128.const i32x4 1 1 0 1)) + (i32.const 0)) +;; any_true as br_if condition +(assert_return (invoke "i8x16_any_true_as_br_if_cond" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + (i32.const 0)) +(assert_return (invoke "i8x16_any_true_as_br_if_cond" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0)) + (i32.const 1)) +(assert_return (invoke "i16x8_any_true_as_br_if_cond" (v128.const i16x8 0 0 0 0 0 0 0 0)) + (i32.const 0)) +(assert_return (invoke "i16x8_any_true_as_br_if_cond" (v128.const i16x8 0 0 0 0 0 0 1 0)) + (i32.const 1)) +(assert_return (invoke "i32x4_any_true_as_br_if_cond" (v128.const i32x4 0 0 0 0)) + (i32.const 0)) +(assert_return (invoke "i32x4_any_true_as_br_if_cond" (v128.const i32x4 0 0 1 0)) + (i32.const 1)) +;; all_true as br_if condition +(assert_return (invoke "i8x16_all_true_as_br_if_cond" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) + (i32.const 1)) +(assert_return (invoke "i8x16_all_true_as_br_if_cond" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1)) + (i32.const 0)) +(assert_return (invoke "i16x8_all_true_as_br_if_cond" (v128.const i16x8 1 1 1 1 1 1 1 1)) + (i32.const 1)) +(assert_return (invoke "i16x8_all_true_as_br_if_cond" (v128.const i16x8 1 1 1 1 1 1 0 1)) + (i32.const 0)) +(assert_return (invoke "i32x4_all_true_as_br_if_cond" (v128.const i32x4 1 1 1 1)) + (i32.const 1)) +(assert_return (invoke "i32x4_all_true_as_br_if_cond" (v128.const i32x4 1 1 0 1)) + (i32.const 0)) +;; any_true as and operand +(assert_return (invoke "i8x16_any_true_as_i32.and_operand" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + (i32.const 0)) +(assert_return (invoke "i8x16_any_true_as_i32.and_operand" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0)) + (i32.const 0)) +(assert_return (invoke "i8x16_any_true_as_i32.and_operand" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0)) + (i32.const 1)) +(assert_return (invoke "i16x8_any_true_as_i32.and_operand" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i16x8 0 0 0 0 0 0 0 0)) + (i32.const 0)) +(assert_return (invoke "i16x8_any_true_as_i32.and_operand" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i16x8 0 0 0 0 0 0 1 0)) + (i32.const 0)) +(assert_return (invoke "i16x8_any_true_as_i32.and_operand" (v128.const i16x8 0 0 0 0 0 0 1 0) + (v128.const i16x8 0 0 0 0 0 0 1 0)) + (i32.const 1)) +(assert_return (invoke "i32x4_any_true_as_i32.and_operand" (v128.const i32x4 0 0 0 0) + (v128.const i32x4 0 0 0 0)) + (i32.const 0)) +(assert_return (invoke "i32x4_any_true_as_i32.and_operand" (v128.const i32x4 0 0 0 0) + (v128.const i32x4 0 0 1 0)) + (i32.const 0)) +(assert_return (invoke "i32x4_any_true_as_i32.and_operand" (v128.const i32x4 0 0 1 0) + (v128.const i32x4 0 0 1 0)) + (i32.const 1)) +;; any_true as or operand +(assert_return (invoke "i8x16_any_true_as_i32.or_operand" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + (i32.const 0)) +(assert_return (invoke "i8x16_any_true_as_i32.or_operand" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0)) + (i32.const 1)) +(assert_return (invoke "i8x16_any_true_as_i32.or_operand" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0)) + (i32.const 1)) +(assert_return (invoke "i16x8_any_true_as_i32.or_operand" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i16x8 0 0 0 0 0 0 0 0)) + (i32.const 0)) +(assert_return (invoke "i16x8_any_true_as_i32.or_operand" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i16x8 0 0 0 0 0 0 1 0)) + (i32.const 1)) +(assert_return (invoke "i16x8_any_true_as_i32.or_operand" (v128.const i16x8 0 0 0 0 0 0 1 0) + (v128.const i16x8 0 0 0 0 0 0 1 0)) + (i32.const 1)) +(assert_return (invoke "i32x4_any_true_as_i32.or_operand" (v128.const i32x4 0 0 0 0) + (v128.const i32x4 0 0 0 0)) + (i32.const 0)) +(assert_return (invoke "i32x4_any_true_as_i32.or_operand" (v128.const i32x4 0 0 0 0) + (v128.const i32x4 0 0 1 0)) + (i32.const 1)) +(assert_return (invoke "i32x4_any_true_as_i32.or_operand" (v128.const i32x4 0 0 1 0) + (v128.const i32x4 0 0 1 0)) + (i32.const 1)) +;; any_true as xor operand +(assert_return (invoke "i8x16_any_true_as_i32.xor_operand" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + (i32.const 0)) +(assert_return (invoke "i8x16_any_true_as_i32.xor_operand" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0)) + (i32.const 1)) +(assert_return (invoke "i8x16_any_true_as_i32.xor_operand" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0)) + (i32.const 0)) +(assert_return (invoke "i16x8_any_true_as_i32.xor_operand" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i16x8 0 0 0 0 0 0 0 0)) + (i32.const 0)) +(assert_return (invoke "i16x8_any_true_as_i32.xor_operand" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i16x8 0 0 0 0 0 0 1 0)) + (i32.const 1)) +(assert_return (invoke "i16x8_any_true_as_i32.xor_operand" (v128.const i16x8 0 0 0 0 0 0 1 0) + (v128.const i16x8 0 0 0 0 0 0 1 0)) + (i32.const 0)) +(assert_return (invoke "i32x4_any_true_as_i32.xor_operand" (v128.const i32x4 0 0 0 0) + (v128.const i32x4 0 0 0 0)) + (i32.const 0)) +(assert_return (invoke "i32x4_any_true_as_i32.xor_operand" (v128.const i32x4 0 0 0 0) + (v128.const i32x4 0 0 1 0)) + (i32.const 1)) +(assert_return (invoke "i32x4_any_true_as_i32.xor_operand" (v128.const i32x4 0 0 1 0) + (v128.const i32x4 0 0 1 0)) + (i32.const 0)) +;; all_true as and operand +(assert_return (invoke "i8x16_all_true_as_i32.and_operand" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) + (i32.const 1)) +(assert_return (invoke "i8x16_all_true_as_i32.and_operand" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1)) + (i32.const 0)) +(assert_return (invoke "i8x16_all_true_as_i32.and_operand" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + (i32.const 0)) +(assert_return (invoke "i16x8_all_true_as_i32.and_operand" (v128.const i16x8 1 1 1 1 1 1 1 1) + (v128.const i16x8 1 1 1 1 1 1 1 1)) + (i32.const 1)) +(assert_return (invoke "i16x8_all_true_as_i32.and_operand" (v128.const i16x8 1 1 1 1 1 1 1 1) + (v128.const i16x8 1 1 1 1 1 1 0 1)) + (i32.const 0)) +(assert_return (invoke "i16x8_all_true_as_i32.and_operand" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i16x8 0 0 0 0 0 0 1 0)) + (i32.const 0)) +(assert_return (invoke "i32x4_all_true_as_i32.and_operand" (v128.const i32x4 1 1 1 1) + (v128.const i32x4 1 1 1 1)) + (i32.const 1)) +(assert_return (invoke "i32x4_all_true_as_i32.and_operand" (v128.const i32x4 1 1 1 1) + (v128.const i32x4 1 1 0 1)) + (i32.const 0)) +(assert_return (invoke "i32x4_all_true_as_i32.and_operand" (v128.const i32x4 0 0 0 0) + (v128.const i32x4 0 0 1 0)) + (i32.const 0)) +;; all_true as or operand +(assert_return (invoke "i8x16_all_true_as_i32.or_operand" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) + (i32.const 1)) +(assert_return (invoke "i8x16_all_true_as_i32.or_operand" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1)) + (i32.const 1)) +(assert_return (invoke "i8x16_all_true_as_i32.or_operand" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + (i32.const 0)) +(assert_return (invoke "i16x8_all_true_as_i32.or_operand" (v128.const i16x8 1 1 1 1 1 1 1 1) + (v128.const i16x8 1 1 1 1 1 1 1 1)) + (i32.const 1)) +(assert_return (invoke "i16x8_all_true_as_i32.or_operand" (v128.const i16x8 1 1 1 1 1 1 1 1) + (v128.const i16x8 1 1 1 1 1 1 0 1)) + (i32.const 1)) +(assert_return (invoke "i16x8_all_true_as_i32.or_operand" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i16x8 0 0 0 0 0 0 0 0)) + (i32.const 0)) +(assert_return (invoke "i32x4_all_true_as_i32.or_operand" (v128.const i32x4 1 1 1 1) + (v128.const i32x4 1 1 1 1)) + (i32.const 1)) +(assert_return (invoke "i32x4_all_true_as_i32.or_operand" (v128.const i32x4 1 1 1 1) + (v128.const i32x4 1 1 0 1)) + (i32.const 1)) +(assert_return (invoke "i32x4_all_true_as_i32.or_operand" (v128.const i32x4 0 0 0 0) + (v128.const i32x4 0 0 0 0)) + (i32.const 0)) +;; all_true as xor operand +(assert_return (invoke "i8x16_all_true_as_i32.xor_operand" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) + (i32.const 0)) +(assert_return (invoke "i8x16_all_true_as_i32.xor_operand" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1)) + (i32.const 1)) +(assert_return (invoke "i8x16_all_true_as_i32.xor_operand" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + (i32.const 0)) +(assert_return (invoke "i16x8_all_true_as_i32.xor_operand" (v128.const i16x8 1 1 1 1 1 1 1 1) + (v128.const i16x8 1 1 1 1 1 1 1 1)) + (i32.const 0)) +(assert_return (invoke "i16x8_all_true_as_i32.xor_operand" (v128.const i16x8 1 1 1 1 1 1 1 1) + (v128.const i16x8 1 1 1 1 1 1 0 1)) + (i32.const 1)) +(assert_return (invoke "i16x8_all_true_as_i32.xor_operand" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i16x8 0 0 0 0 0 0 0 0)) + (i32.const 0)) +(assert_return (invoke "i32x4_all_true_as_i32.xor_operand" (v128.const i32x4 1 1 1 1) + (v128.const i32x4 1 1 1 1)) + (i32.const 0)) +(assert_return (invoke "i32x4_all_true_as_i32.xor_operand" (v128.const i32x4 1 1 1 1) + (v128.const i32x4 1 1 0 1)) + (i32.const 1)) +(assert_return (invoke "i32x4_all_true_as_i32.xor_operand" (v128.const i32x4 0 0 0 0) + (v128.const i32x4 0 0 0 0)) + (i32.const 0)) +;; any_true with v128.not +(assert_return (invoke "i8x16_any_true_with_v128.not" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + (i32.const 1)) +(assert_return (invoke "i8x16_any_true_with_v128.not" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + (i32.const 0)) +(assert_return (invoke "i8x16_any_true_with_v128.not" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -1 0)) + (i32.const 1)) +(assert_return (invoke "i16x8_any_true_with_v128.not" (v128.const i16x8 0 0 0 0 0 0 0 0)) + (i32.const 1)) +(assert_return (invoke "i16x8_any_true_with_v128.not" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + (i32.const 0)) +(assert_return (invoke "i16x8_any_true_with_v128.not" (v128.const i16x8 0 0 0 0 0 0 -1 0)) + (i32.const 1)) +(assert_return (invoke "i32x4_any_true_with_v128.not" (v128.const i32x4 0 0 0 0)) + (i32.const 1)) +(assert_return (invoke "i32x4_any_true_with_v128.not" (v128.const i32x4 -1 -1 -1 -1)) + (i32.const 0)) +(assert_return (invoke "i32x4_any_true_with_v128.not" (v128.const i32x4 0 0 -1 0)) + (i32.const 1)) +;; any_true with v128.and +(assert_return (invoke "i8x16_any_true_with_v128.and" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + (i32.const 0)) +(assert_return (invoke "i8x16_any_true_with_v128.and" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + (i32.const 1)) +(assert_return (invoke "i8x16_any_true_with_v128.and" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -1 0) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -1 0)) + (i32.const 1)) +(assert_return (invoke "i16x8_any_true_with_v128.and" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i16x8 0 0 0 0 0 0 0 0)) + (i32.const 0)) +(assert_return (invoke "i16x8_any_true_with_v128.and" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + (i32.const 1)) +(assert_return (invoke "i16x8_any_true_with_v128.and" (v128.const i16x8 0 0 0 0 0 0 -1 0) + (v128.const i16x8 0 0 0 0 0 0 -1 0)) + (i32.const 1)) +(assert_return (invoke "i32x4_any_true_with_v128.and" (v128.const i32x4 0 0 0 0) + (v128.const i32x4 0 0 0 0)) + (i32.const 0)) +(assert_return (invoke "i32x4_any_true_with_v128.and" (v128.const i32x4 -1 -1 -1 -1) + (v128.const i32x4 -1 -1 -1 -1)) + (i32.const 1)) +(assert_return (invoke "i32x4_any_true_with_v128.and" (v128.const i32x4 0 0 -1 0) + (v128.const i32x4 0 0 -1 0)) + (i32.const 1)) +;; any_true with v128.or +(assert_return (invoke "i8x16_any_true_with_v128.or" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + (i32.const 0)) +(assert_return (invoke "i8x16_any_true_with_v128.or" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + (i32.const 1)) +(assert_return (invoke "i8x16_any_true_with_v128.or" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -1 0) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -1 0)) + (i32.const 1)) +(assert_return (invoke "i16x8_any_true_with_v128.or" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i16x8 0 0 0 0 0 0 0 0)) + (i32.const 0)) +(assert_return (invoke "i16x8_any_true_with_v128.or" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + (i32.const 1)) +(assert_return (invoke "i16x8_any_true_with_v128.or" (v128.const i16x8 0 0 0 0 0 0 -1 0) + (v128.const i16x8 0 0 0 0 0 0 -1 0)) + (i32.const 1)) +(assert_return (invoke "i32x4_any_true_with_v128.or" (v128.const i32x4 0 0 0 0) + (v128.const i32x4 0 0 0 0)) + (i32.const 0)) +(assert_return (invoke "i32x4_any_true_with_v128.or" (v128.const i32x4 -1 -1 -1 -1) + (v128.const i32x4 -1 -1 -1 -1)) + (i32.const 1)) +(assert_return (invoke "i32x4_any_true_with_v128.or" (v128.const i32x4 0 0 -1 0) + (v128.const i32x4 0 0 -1 0)) + (i32.const 1)) +;; any_true with v128.xor +(assert_return (invoke "i8x16_any_true_with_v128.xor" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + (i32.const 0)) +(assert_return (invoke "i8x16_any_true_with_v128.xor" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + (i32.const 0)) +(assert_return (invoke "i8x16_any_true_with_v128.xor" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -1 0)) + (i32.const 1)) +(assert_return (invoke "i16x8_any_true_with_v128.xor" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i16x8 0 0 0 0 0 0 0 0)) + (i32.const 0)) +(assert_return (invoke "i16x8_any_true_with_v128.xor" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + (i32.const 0)) +(assert_return (invoke "i16x8_any_true_with_v128.xor" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i16x8 0 0 0 0 0 0 -1 0)) + (i32.const 1)) +(assert_return (invoke "i32x4_any_true_with_v128.xor" (v128.const i32x4 0 0 0 0) + (v128.const i32x4 0 0 0 0)) + (i32.const 0)) +(assert_return (invoke "i32x4_any_true_with_v128.xor" (v128.const i32x4 -1 -1 -1 -1) + (v128.const i32x4 -1 -1 -1 -1)) + (i32.const 0)) +(assert_return (invoke "i32x4_any_true_with_v128.xor" (v128.const i32x4 0 0 0 0) + (v128.const i32x4 0 0 -1 0)) + (i32.const 1)) +;; any_true with v128.bitselect +(assert_return (invoke "i8x16_any_true_with_v128.bitselect" (v128.const i8x16 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA) + (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55) + (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55)) + (i32.const 0)) +(assert_return (invoke "i8x16_any_true_with_v128.bitselect" (v128.const i8x16 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA) + (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55) + (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0xFF 0x55)) + (i32.const 1)) +(assert_return (invoke "i16x8_any_true_with_v128.bitselect" (v128.const i16x8 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA) + (v128.const i16x8 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55) + (v128.const i16x8 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55)) + (i32.const 0)) +(assert_return (invoke "i16x8_any_true_with_v128.bitselect" (v128.const i16x8 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA) + (v128.const i16x8 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55) + (v128.const i16x8 0x55 0x55 0x55 0x55 0x55 0x55 0xFF 0x55)) + (i32.const 1)) +(assert_return (invoke "i32x4_any_true_with_v128.bitselect" (v128.const i32x4 0xAA 0xAA 0xAA 0xAA) + (v128.const i32x4 0x55 0x55 0x55 0x55) + (v128.const i32x4 0x55 0x55 0x55 0x55)) + (i32.const 0)) +(assert_return (invoke "i32x4_any_true_with_v128.bitselect" (v128.const i32x4 0xAA 0xAA 0xAA 0xAA) + (v128.const i32x4 0x55 0x55 0x55 0x55) + (v128.const i32x4 0x55 0x55 0xFF 0x55)) + (i32.const 1)) +;; all_true with v128.not +(assert_return (invoke "i8x16_all_true_with_v128.not" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + (i32.const 1)) +(assert_return (invoke "i8x16_all_true_with_v128.not" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + (i32.const 0)) +(assert_return (invoke "i8x16_all_true_with_v128.not" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -1 0)) + (i32.const 0)) +(assert_return (invoke "i16x8_all_true_with_v128.not" (v128.const i16x8 0 0 0 0 0 0 0 0)) + (i32.const 1)) +(assert_return (invoke "i16x8_all_true_with_v128.not" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + (i32.const 0)) +(assert_return (invoke "i16x8_all_true_with_v128.not" (v128.const i16x8 0 0 0 0 0 0 -1 0)) + (i32.const 0)) +(assert_return (invoke "i32x4_all_true_with_v128.not" (v128.const i32x4 0 0 0 0)) + (i32.const 1)) +(assert_return (invoke "i32x4_all_true_with_v128.not" (v128.const i32x4 -1 -1 -1 -1)) + (i32.const 0)) +(assert_return (invoke "i32x4_all_true_with_v128.not" (v128.const i32x4 0 0 -1 0)) + (i32.const 0)) +;; all_true with v128.and +(assert_return (invoke "i8x16_all_true_with_v128.and" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + (i32.const 0)) +(assert_return (invoke "i8x16_all_true_with_v128.and" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + (i32.const 1)) +(assert_return (invoke "i8x16_all_true_with_v128.and" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -1 0) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -1 0)) + (i32.const 0)) +(assert_return (invoke "i16x8_all_true_with_v128.and" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i16x8 0 0 0 0 0 0 0 0)) + (i32.const 0)) +(assert_return (invoke "i16x8_all_true_with_v128.and" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + (i32.const 1)) +(assert_return (invoke "i16x8_all_true_with_v128.and" (v128.const i16x8 0 0 0 0 0 0 -1 0) + (v128.const i16x8 0 0 0 0 0 0 -1 0)) + (i32.const 0)) +(assert_return (invoke "i32x4_all_true_with_v128.and" (v128.const i32x4 0 0 0 0) + (v128.const i32x4 0 0 0 0)) + (i32.const 0)) +(assert_return (invoke "i32x4_all_true_with_v128.and" (v128.const i32x4 -1 -1 -1 -1) + (v128.const i32x4 -1 -1 -1 -1)) + (i32.const 1)) +(assert_return (invoke "i32x4_all_true_with_v128.and" (v128.const i32x4 0 0 -1 0) + (v128.const i32x4 0 0 -1 0)) + (i32.const 0)) +;; all_true with v128.or +(assert_return (invoke "i8x16_all_true_with_v128.or" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + (i32.const 0)) +(assert_return (invoke "i8x16_all_true_with_v128.or" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + (i32.const 1)) +(assert_return (invoke "i8x16_all_true_with_v128.or" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -1 0) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -1 0)) + (i32.const 0)) +(assert_return (invoke "i16x8_all_true_with_v128.or" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i16x8 0 0 0 0 0 0 0 0)) + (i32.const 0)) +(assert_return (invoke "i16x8_all_true_with_v128.or" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + (i32.const 1)) +(assert_return (invoke "i16x8_all_true_with_v128.or" (v128.const i16x8 0 0 0 0 0 0 -1 0) + (v128.const i16x8 0 0 0 0 0 0 -1 0)) + (i32.const 0)) +(assert_return (invoke "i32x4_all_true_with_v128.or" (v128.const i32x4 0 0 0 0) + (v128.const i32x4 0 0 0 0)) + (i32.const 0)) +(assert_return (invoke "i32x4_all_true_with_v128.or" (v128.const i32x4 -1 -1 -1 -1) + (v128.const i32x4 -1 -1 -1 -1)) + (i32.const 1)) +(assert_return (invoke "i32x4_all_true_with_v128.or" (v128.const i32x4 0 0 -1 0) + (v128.const i32x4 0 0 -1 0)) + (i32.const 0)) +;; all_true with v128.xor +(assert_return (invoke "i8x16_all_true_with_v128.xor" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + (i32.const 0)) +(assert_return (invoke "i8x16_all_true_with_v128.xor" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + (i32.const 0)) +(assert_return (invoke "i8x16_all_true_with_v128.xor" (v128.const i8x16 0 -1 0 -1 0 -1 0 -1 0 -1 0 -1 0 -1 0 -1) + (v128.const i8x16 -1 0 -1 0 -1 0 -1 0 -1 0 -1 0 -1 0 -1 0)) + (i32.const 1)) +(assert_return (invoke "i16x8_all_true_with_v128.xor" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i16x8 0 0 0 0 0 0 0 0)) + (i32.const 0)) +(assert_return (invoke "i16x8_all_true_with_v128.xor" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + (i32.const 0)) +(assert_return (invoke "i16x8_all_true_with_v128.xor" (v128.const i16x8 0 -1 0 -1 0 -1 0 -1) + (v128.const i16x8 -1 0 -1 0 -1 0 -1 0)) + (i32.const 1)) +(assert_return (invoke "i32x4_all_true_with_v128.xor" (v128.const i32x4 0 0 0 0) + (v128.const i32x4 0 0 0 0)) + (i32.const 0)) +(assert_return (invoke "i32x4_all_true_with_v128.xor" (v128.const i32x4 -1 -1 -1 -1) + (v128.const i32x4 -1 -1 -1 -1)) + (i32.const 0)) +(assert_return (invoke "i32x4_all_true_with_v128.xor" (v128.const i32x4 0 -1 0 -1) + (v128.const i32x4 -1 0 -1 0)) + (i32.const 1)) +;; all_true with v128.bitselect +(assert_return (invoke "i8x16_all_true_with_v128.bitselect" (v128.const i8x16 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA) + (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55) + (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55)) + (i32.const 0)) +(assert_return (invoke "i8x16_all_true_with_v128.bitselect" (v128.const i8x16 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA) + (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55) + (v128.const i8x16 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA)) + (i32.const 1)) +(assert_return (invoke "i16x8_all_true_with_v128.bitselect" (v128.const i16x8 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA) + (v128.const i16x8 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55) + (v128.const i16x8 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55)) + (i32.const 0)) +(assert_return (invoke "i16x8_all_true_with_v128.bitselect" (v128.const i16x8 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA) + (v128.const i16x8 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55) + (v128.const i16x8 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA)) + (i32.const 1)) +(assert_return (invoke "i32x4_all_true_with_v128.bitselect" (v128.const i32x4 0xAA 0xAA 0xAA 0xAA) + (v128.const i32x4 0x55 0x55 0x55 0x55) + (v128.const i32x4 0x55 0x55 0x55 0x55)) + (i32.const 0)) +(assert_return (invoke "i32x4_all_true_with_v128.bitselect" (v128.const i32x4 0xAA 0xAA 0xAA 0xAA) + (v128.const i32x4 0x55 0x55 0x55 0x55) + (v128.const i32x4 0xAA 0xAA 0xAA 0xAA)) + (i32.const 1)) + +;; Type check + +(assert_invalid (module (func (result i32) (v128.any_true (i32.const 0)))) "type mismatch") +(assert_invalid (module (func (result i32) (i8x16.all_true (i32.const 0)))) "type mismatch") +(assert_invalid (module (func (result i32) (v128.any_true (i32.const 0)))) "type mismatch") +(assert_invalid (module (func (result i32) (i16x8.all_true (i32.const 0)))) "type mismatch") +(assert_invalid (module (func (result i32) (v128.any_true (i32.const 0)))) "type mismatch") +(assert_invalid (module (func (result i32) (i32x4.all_true (i32.const 0)))) "type mismatch") + +;; Unknown operators + +(assert_malformed (module quote "(memory 1) (func (result i32) (f32x4.any_true (v128.const i32x4 0 0 0 0)))") "unknown operator") +(assert_malformed (module quote "(memory 1) (func (result i32) (f32x4.all_true (v128.const i32x4 0 0 0 0)))") "unknown operator") +(assert_malformed (module quote "(memory 1) (func (result i32) (f64x2.any_true (v128.const i32x4 0 0 0 0)))") "unknown operator") +(assert_malformed (module quote "(memory 1) (func (result i32) (f64x2.all_true (v128.const i32x4 0 0 0 0)))") "unknown operator") + +;; Test operation with empty argument + +(assert_invalid + (module + (func $v128.any_true-arg-empty (result v128) + (v128.any_true) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i8x16.all_true-arg-empty (result v128) + (i8x16.all_true) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $v128.any_true-arg-empty (result v128) + (v128.any_true) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i16x8.all_true-arg-empty (result v128) + (i16x8.all_true) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $v128.any_true-arg-empty (result v128) + (v128.any_true) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i32x4.all_true-arg-empty (result v128) + (i32x4.all_true) + ) + ) + "type mismatch" +) diff --git a/runtime/near-vm/tests/wast/spec/proposals/simd/simd_const.wast b/runtime/near-vm/tests/wast/spec/proposals/simd/simd_const.wast new file mode 100644 index 00000000000..8080cfb0f9e --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/proposals/simd/simd_const.wast @@ -0,0 +1,1664 @@ +;; v128.const normal parameter (e.g. (i8x16, i16x8 i32x4, f32x4)) + +(module (func (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF) drop)) +(module (func (v128.const i8x16 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80) drop)) +(module (func (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255) drop)) +(module (func (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128) drop)) +(module (func (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF) drop)) +(module (func (v128.const i16x8 -0x8000 -0x8000 -0x8000 -0x8000 -0x8000 -0x8000 -0x8000 -0x8000) drop)) +(module (func (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535) drop)) +(module (func (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768) drop)) +(module (func (v128.const i16x8 65_535 65_535 65_535 65_535 65_535 65_535 65_535 65_535) drop)) +(module (func (v128.const i16x8 -32_768 -32_768 -32_768 -32_768 -32_768 -32_768 -32_768 -32_768) drop)) +(module (func (v128.const i16x8 0_123_45 0_123_45 0_123_45 0_123_45 0_123_45 0_123_45 0_123_45 0_123_45) drop)) +(module (func (v128.const i16x8 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234) drop)) +(module (func (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff) drop)) +(module (func (v128.const i32x4 -0x80000000 -0x80000000 -0x80000000 -0x80000000) drop)) +(module (func (v128.const i32x4 4294967295 4294967295 4294967295 4294967295) drop)) +(module (func (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648) drop)) +(module (func (v128.const i32x4 0xffff_ffff 0xffff_ffff 0xffff_ffff 0xffff_ffff) drop)) +(module (func (v128.const i32x4 -0x8000_0000 -0x8000_0000 -0x8000_0000 -0x8000_0000) drop)) +(module (func (v128.const i32x4 4_294_967_295 4_294_967_295 4_294_967_295 4_294_967_295) drop)) +(module (func (v128.const i32x4 -2_147_483_648 -2_147_483_648 -2_147_483_648 -2_147_483_648) drop)) +(module (func (v128.const i32x4 0_123_456_789 0_123_456_789 0_123_456_789 0_123_456_789) drop)) +(module (func (v128.const i32x4 0x0_9acf_fBDF 0x0_9acf_fBDF 0x0_9acf_fBDF 0x0_9acf_fBDF) drop)) +(module (func (v128.const i64x2 0xffffffffffffffff 0xffffffffffffffff) drop)) +(module (func (v128.const i64x2 -0x8000000000000000 -0x8000000000000000) drop)) +(module (func (v128.const i64x2 18446744073709551615 18446744073709551615) drop)) +(module (func (v128.const i64x2 -9223372036854775808 -9223372036854775808) drop)) +(module (func (v128.const i64x2 0xffff_ffff_ffff_ffff 0xffff_ffff_ffff_ffff) drop)) +(module (func (v128.const i64x2 -0x8000_0000_0000_0000 -0x8000_0000_0000_0000) drop)) +(module (func (v128.const i64x2 18_446_744_073_709_551_615 18_446_744_073_709_551_615) drop)) +(module (func (v128.const i64x2 -9_223_372_036_854_775_808 -9_223_372_036_854_775_808) drop)) +(module (func (v128.const i64x2 0_123_456_789 0_123_456_789) drop)) +(module (func (v128.const i64x2 0x0125_6789_ADEF_bcef 0x0125_6789_ADEF_bcef) drop)) +(module (func (v128.const f32x4 0x1p127 0x1p127 0x1p127 0x1p127) drop)) +(module (func (v128.const f32x4 -0x1p127 -0x1p127 -0x1p127 -0x1p127) drop)) +(module (func (v128.const f32x4 1e38 1e38 1e38 1e38) drop)) +(module (func (v128.const f32x4 -1e38 -1e38 -1e38 -1e38) drop)) +(module (func (v128.const f32x4 340282356779733623858607532500980858880 340282356779733623858607532500980858880 + 340282356779733623858607532500980858880 340282356779733623858607532500980858880) drop)) +(module (func (v128.const f32x4 -340282356779733623858607532500980858880 -340282356779733623858607532500980858880 + -340282356779733623858607532500980858880 -340282356779733623858607532500980858880) drop)) +(module (func (v128.const f32x4 nan:0x1 nan:0x1 nan:0x1 nan:0x1) drop)) +(module (func (v128.const f32x4 nan:0x7f_ffff nan:0x7f_ffff nan:0x7f_ffff nan:0x7f_ffff) drop)) +(module (func (v128.const f32x4 0123456789 0123456789 0123456789 0123456789) drop)) +(module (func (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019) drop)) +(module (func (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019) drop)) +(module (func (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019) drop)) +(module (func (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.) drop)) +(module (func (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019) drop)) +(module (func (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019) drop)) +(module (func (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019) drop)) +(module (func (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789) drop)) +(module (func (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019) drop)) +(module (func (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019) drop)) +(module (func (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019) drop)) +(module (func (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF) drop)) +(module (func (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019) drop)) +(module (func (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019) drop)) +(module (func (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019) drop)) +(module (func (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.) drop)) +(module (func (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019) drop)) +(module (func (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019) drop)) +(module (func (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019) drop)) +(module (func (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF) drop)) +(module (func (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019) drop)) +(module (func (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019) drop)) +(module (func (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019) drop)) +(module (func (v128.const f64x2 0x1p1023 0x1p1023) drop)) +(module (func (v128.const f64x2 -0x1p1023 -0x1p1023) drop)) +(module (func (v128.const f64x2 1e308 1e308) drop)) +(module (func (v128.const f64x2 -1e308 -1e308) drop)) +(module (func (v128.const f64x2 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368 + 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368) drop)) +(module (func (v128.const f64x2 -179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368 + -179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368) drop)) +(module (func (v128.const f64x2 nan:0x1 nan:0x1) drop)) +(module (func (v128.const f64x2 nan:0xf_ffff_ffff_ffff nan:0xf_ffff_ffff_ffff) drop)) +(module (func (v128.const f64x2 0123456789 0123456789) drop)) +(module (func (v128.const f64x2 0123456789e019 0123456789e019) drop)) +(module (func (v128.const f64x2 0123456789e+019 0123456789e+019) drop)) +(module (func (v128.const f64x2 0123456789e-019 0123456789e-019) drop)) +(module (func (v128.const f64x2 0123456789. 0123456789.) drop)) +(module (func (v128.const f64x2 0123456789.e019 0123456789.e019) drop)) +(module (func (v128.const f64x2 0123456789.e+019 0123456789.e+019) drop)) +(module (func (v128.const f64x2 0123456789.e-019 0123456789.e-019) drop)) +(module (func (v128.const f64x2 0123456789.0123456789 0123456789.0123456789) drop)) +(module (func (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019) drop)) +(module (func (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019) drop)) +(module (func (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019) drop)) +(module (func (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef) drop)) +(module (func (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019) drop)) +(module (func (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019) drop)) +(module (func (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019) drop)) +(module (func (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.) drop)) +(module (func (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019) drop)) +(module (func (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019) drop)) +(module (func (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019) drop)) +(module (func (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef) drop)) +(module (func (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019) drop)) +(module (func (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019) drop)) +(module (func (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019) drop)) + +;; Non-splat cases + +(module (func (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF + -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80) drop)) +(module (func (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 255 255 255 255 + -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80) drop)) +(module (func (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 255 255 255 255 + -0x80 -0x80 -0x80 -0x80 -128 -128 -128 -128) drop)) +(module (func (v128.const i16x8 0xFF 0xFF 0xFF 0xFF -0x8000 -0x8000 -0x8000 -0x8000) drop)) +(module (func (v128.const i16x8 0xFF 0xFF 65535 65535 -0x8000 -0x8000 -0x8000 -0x8000) drop)) +(module (func (v128.const i16x8 0xFF 0xFF 65535 65535 -0x8000 -0x8000 -32768 -32768) drop)) +(module (func (v128.const i32x4 0xffffffff 0xffffffff -0x80000000 -0x80000000) drop)) +(module (func (v128.const i32x4 0xffffffff 4294967295 -0x80000000 -0x80000000) drop)) +(module (func (v128.const i32x4 0xffffffff 4294967295 -0x80000000 -2147483648) drop)) +(module (func (v128.const f32x4 0x1p127 0x1p127 -0x1p127 -1e38) drop)) +(module (func (v128.const f32x4 0x1p127 340282356779733623858607532500980858880 -1e38 -340282356779733623858607532500980858880) drop)) +(module (func (v128.const f32x4 nan -nan inf -inf) drop)) +(module (func (v128.const i64x2 0xffffffffffffffff 0x8000000000000000) drop)) +(module (func (v128.const i64x2 0xffffffffffffffff -9223372036854775808) drop)) +(module (func (v128.const f64x2 0x1p1023 -1e308) drop)) +(module (func (v128.const f64x2 nan -inf) drop)) + +;; Constant out of range (int literal is too large) + +(module (memory 1)) +(assert_malformed + (module quote "(func (v128.const i8x16 0x100 0x100 0x100 0x100 0x100 0x100 0x100 0x100 0x100 0x100 0x100 0x100 0x100 0x100 0x100 0x100) drop)") + "constant out of range" +) +(assert_malformed + (module quote "(func (v128.const i8x16 -0x81 -0x81 -0x81 -0x81 -0x81 -0x81 -0x81 -0x81 -0x81 -0x81 -0x81 -0x81 -0x81 -0x81 -0x81 -0x81) drop)") + "constant out of range" +) +(assert_malformed + (module quote "(func (v128.const i8x16 256 256 256 256 256 256 256 256 256 256 256 256 256 256 256 256) drop)") + "constant out of range" +) +(assert_malformed + (module quote "(func (v128.const i8x16 -129 -129 -129 -129 -129 -129 -129 -129 -129 -129 -129 -129 -129 -129 -129 -129) drop)") + "constant out of range" +) +(assert_malformed + (module quote "(func (v128.const i16x8 0x10000 0x10000 0x10000 0x10000 0x10000 0x10000 0x10000 0x10000) drop)") + "constant out of range" +) +(assert_malformed + (module quote "(func (v128.const i16x8 -0x8001 -0x8001 -0x8001 -0x8001 -0x8001 -0x8001 -0x8001 -0x8001) drop)") + "constant out of range" +) +(assert_malformed + (module quote "(func (v128.const i16x8 65536 65536 65536 65536 65536 65536 65536 65536) drop)") + "constant out of range" +) +(assert_malformed + (module quote "(func (v128.const i16x8 -32769 -32769 -32769 -32769 -32769 -32769 -32769 -32769) drop)") + "constant out of range" +) +(assert_malformed + (module quote "(func (v128.const i32x4 0x100000000 0x100000000 0x100000000 0x100000000) drop)") + "constant out of range" +) +(assert_malformed + (module quote "(func (v128.const i32x4 -0x80000001 -0x80000001 -0x80000001 -0x80000001) drop)") + "constant out of range" +) +(assert_malformed + (module quote "(func (v128.const i32x4 4294967296 4294967296 4294967296 4294967296) drop)") + "constant out of range" +) +(assert_malformed + (module quote "(func (v128.const i32x4 -2147483649 -2147483649 -2147483649 -2147483649) drop)") + "constant out of range" +) +(assert_malformed + (module quote "(func (v128.const f32x4 0x1p128 0x1p128 0x1p128 0x1p128) drop)") + "constant out of range" +) +(assert_malformed + (module quote "(func (v128.const f32x4 -0x1p128 -0x1p128 -0x1p128 -0x1p128) drop)") + "constant out of range" +) +(assert_malformed + (module quote "(func (v128.const f32x4 1e39 1e39 1e39 1e39) drop)") + "constant out of range" +) +(assert_malformed + (module quote "(func (v128.const f32x4 -1e39 -1e39 -1e39 -1e39) drop)") + "constant out of range" +) +(assert_malformed + (module quote "(func (v128.const f32x4 340282356779733661637539395458142568448 340282356779733661637539395458142568448" + " 340282356779733661637539395458142568448 340282356779733661637539395458142568448) drop)") + "constant out of range" +) +(assert_malformed + (module quote "(func (v128.const f32x4 -340282356779733661637539395458142568448 -340282356779733661637539395458142568448" + " -340282356779733661637539395458142568448 -340282356779733661637539395458142568448) drop)") + "constant out of range" +) + +(assert_malformed + (module quote "(func (v128.const f32x4 nan:0x80_0000 nan:0x80_0000 nan:0x80_0000 nan:0x80_0000) drop)") + "constant out of range" +) + +(assert_malformed + (module quote "(func (v128.const f64x2 269653970229347356221791135597556535197105851288767494898376215204735891170042808140884337949150317257310688430271573696351481990334196274152701320055306275479074865864826923114368235135583993416113802762682700913456874855354834422248712838998185022412196739306217084753107265771378949821875606039276187287552" + " 269653970229347356221791135597556535197105851288767494898376215204735891170042808140884337949150317257310688430271573696351481990334196274152701320055306275479074865864826923114368235135583993416113802762682700913456874855354834422248712838998185022412196739306217084753107265771378949821875606039276187287552) drop)") + "constant out of range" +) +(assert_malformed + (module quote "(func (v128.const f64x2 -269653970229347356221791135597556535197105851288767494898376215204735891170042808140884337949150317257310688430271573696351481990334196274152701320055306275479074865864826923114368235135583993416113802762682700913456874855354834422248712838998185022412196739306217084753107265771378949821875606039276187287552" + " -269653970229347356221791135597556535197105851288767494898376215204735891170042808140884337949150317257310688430271573696351481990334196274152701320055306275479074865864826923114368235135583993416113802762682700913456874855354834422248712838998185022412196739306217084753107265771378949821875606039276187287552) drop)") + "constant out of range" +) + +(assert_malformed + (module quote "(func (v128.const f64x2 nan:0x10_0000_0000_0000 nan:0x10_0000_0000_0000) drop)") + "constant out of range" +) + +;; More malformed v128.const forms +(assert_malformed + (module quote "(func (v128.const) drop)") + "unexpected token" +) + +(assert_malformed + (module quote "(func (v128.const 0 0 0 0) drop)") + "unexpected token" +) +(assert_malformed + (module quote "(func (v128.const i8x16) drop)") + "wrong number of lane literals" +) +(assert_malformed + (module quote "(func (v128.const i8x16 0x 0x 0x 0x 0x 0x 0x 0x 0x 0x 0x 0x 0x 0x 0x 0x) drop)") + "unknown operator" +) +(assert_malformed + (module quote "(func (v128.const i8x16 1x 1x 1x 1x 1x 1x 1x 1x 1x 1x 1x 1x 1x 1x 1x 1x) drop)") + "unknown operator" +) +(assert_malformed + (module quote "(func (v128.const i8x16 0xg 0xg 0xg 0xg 0xg 0xg 0xg 0xg 0xg 0xg 0xg 0xg 0xg 0xg 0xg 0xg) drop)") + "unknown operator" +) + +(assert_malformed + (module quote "(func (v128.const i16x8) drop)") + "wrong number of lane literals" +) +(assert_malformed + (module quote "(func (v128.const i16x8 0x 0x 0x 0x 0x 0x 0x 0x) drop)") + "unknown operator" +) +(assert_malformed + (module quote "(func (v128.const i16x8 1x 1x 1x 1x 1x 1x 1x 1x) drop)") + "unknown operator" +) +(assert_malformed + (module quote "(func (v128.const i16x8 0xg 0xg 0xg 0xg 0xg 0xg 0xg 0xg) drop)") + "unknown operator" +) + +(assert_malformed + (module quote "(func (v128.const i32x4) drop)") + "wrong number of lane literals" +) +(assert_malformed + (module quote "(func (v128.const i32x4 0x 0x 0x 0x) drop)") + "unknown operator" +) +(assert_malformed + (module quote "(func (v128.const i32x4 1x 1x 1x 1x) drop)") + "unknown operator" +) +(assert_malformed + (module quote "(func (v128.const i32x4 0xg 0xg 0xg 0xg) drop)") + "unknown operator" +) + +(assert_malformed + (module quote "(func (v128.const i64x2) drop)") + "wrong number of lane literals" +) +(assert_malformed + (module quote "(func (v128.const i64x2 0x 0x) drop)") + "unknown operator" +) +(assert_malformed + (module quote "(func (v128.const f64x2 1x 1x) drop)") + "unknown operator" +) +(assert_malformed + (module quote "(func (v128.const f64x2 0xg 0xg) drop)") + "unknown operator" +) + +(assert_malformed + (module quote "(func (v128.const f32x4) drop)") + "wrong number of lane literals" +) +(assert_malformed + (module quote "(func (v128.const f32x4 .0 .0 .0 .0) drop)") + "unknown operator" +) +(assert_malformed + (module quote "(func (v128.const f32x4 .0e0 .0e0 .0e0 .0e0) drop)") + "unknown operator" +) +(assert_malformed + (module quote "(func (v128.const f32x4 0e 0e 0e 0e) drop)") + "unknown operator" +) +(assert_malformed + (module quote "(func (v128.const f32x4 0e+ 0e+ 0e+ 0e+) drop)") + "unknown operator" +) +(assert_malformed + (module quote "(func (v128.const f32x4 0.0e 0.0e 0.0e 0.0e) drop)") + "unknown operator" +) +(assert_malformed + (module quote "(func (v128.const f32x4 0.0e- 0.0e- 0.0e- 0.0e-) drop)") + "unknown operator" +) +(assert_malformed + (module quote "(func (v128.const f32x4 0x 0x 0x 0x) drop)") + "unknown operator" +) +(assert_malformed + (module quote "(func (v128.const f32x4 1x 1x 1x 1x) drop)") + "unknown operator" +) +(assert_malformed + (module quote "(func (v128.const f32x4 0xg 0xg 0xg 0xg) drop)") + "unknown operator" +) +(assert_malformed + (module quote "(func (v128.const f32x4 0x. 0x. 0x. 0x.) drop)") + "unknown operator" +) +(assert_malformed + (module quote "(func (v128.const f32x4 0x0.g 0x0.g 0x0.g 0x0.g) drop)") + "unknown operator" +) +(assert_malformed + (module quote "(func (v128.const f32x4 0x0p 0x0p 0x0p 0x0p) drop)") + "unknown operator" +) +(assert_malformed + (module quote "(func (v128.const f32x4 0x0p+ 0x0p+ 0x0p+ 0x0p+) drop)") + "unknown operator" +) +(assert_malformed + (module quote "(func (v128.const f32x4 0x0p- 0x0p- 0x0p- 0x0p-) drop)") + "unknown operator" +) +(assert_malformed + (module quote "(func (v128.const f32x4 0x0.0p 0x0.0p 0x0.0p 0x0.0p) drop)") + "unknown operator" +) +(assert_malformed + (module quote "(func (v128.const f32x4 0x0.0p+ 0x0.0p+ 0x0.0p+ 0x0.0p+) drop)") + "unknown operator" +) +(assert_malformed + (module quote "(func (v128.const f32x4 0x0.0p- 0x0.0p- 0x0.0p- 0x0.0p-) drop)") + "unknown operator" +) +(assert_malformed + (module quote "(func (v128.const f32x4 0x0pA 0x0pA 0x0pA 0x0pA) drop)") + "unknown operator" +) +(assert_malformed + (module quote "(func (v128.const f32x4 nan:1 nan:1 nan:1 nan:1) drop)") + "unknown operator" +) +(assert_malformed + (module quote "(func (v128.const f32x4 nan:0x0 nan:0x0 nan:0x0 nan:0x0) drop)") + "constant out of range" +) + +(assert_malformed + (module quote "(func (v128.const f64x2) drop)") + "wrong number of lane literals" +) +(assert_malformed + (module quote "(func (v128.const f64x2 .0 .0) drop)") + "unknown operator" +) +(assert_malformed + (module quote "(func (v128.const f64x2 .0e0 .0e0) drop)") + "unknown operator" +) +(assert_malformed + (module quote "(func (v128.const f64x2 0e 0e) drop)") + "unknown operator" +) +(assert_malformed + (module quote "(func (v128.const f64x2 0e+ 0e+) drop)") + "unknown operator" +) +(assert_malformed + (module quote "(func (v128.const f64x2 0.0e+ 0.0e+) drop)") + "unknown operator" +) +(assert_malformed + (module quote "(func (v128.const f64x2 0.0e- 0.0e-) drop)") + "unknown operator" +) +(assert_malformed + (module quote "(func (v128.const f64x2 0x 0x) drop)") + "unknown operator" +) +(assert_malformed + (module quote "(func (v128.const f64x2 1x 1x) drop)") + "unknown operator" +) +(assert_malformed + (module quote "(func (v128.const f64x2 0xg 0xg) drop)") + "unknown operator" +) +(assert_malformed + (module quote "(func (v128.const f64x2 0x. 0x.) drop)") + "unknown operator" +) +(assert_malformed + (module quote "(func (v128.const f64x2 0x0.g 0x0.g) drop)") + "unknown operator" +) +(assert_malformed + (module quote "(func (v128.const f64x2 0x0p 0x0p) drop)") + "unknown operator" +) +(assert_malformed + (module quote "(func (v128.const f64x2 0x0p+ 0x0p+) drop)") + "unknown operator" +) +(assert_malformed + (module quote "(func (v128.const f64x2 0x0p- 0x0p-) drop)") + "unknown operator" +) +(assert_malformed + (module quote "(func (v128.const f64x2 0x0.0p 0x0.0p) drop)") + "unknown operator" +) +(assert_malformed + (module quote "(func (v128.const f64x2 0x0.0p+ 0x0.0p+) drop)") + "unknown operator" +) +(assert_malformed + (module quote "(func (v128.const f64x2 0x0.0p- 0x0.0p-) drop)") + "unknown operator" +) +(assert_malformed + (module quote "(func (v128.const f64x2 0x0pA 0x0pA) drop)") + "unknown operator" +) +(assert_malformed + (module quote "(func (v128.const f64x2 nan:1 nan:1) drop)") + "unknown operator" +) +(assert_malformed + (module quote "(func (v128.const f64x2 nan:0x0 nan:0x0) drop)") + "constant out of range" +) + +;; too little arguments + +(assert_malformed + (module quote "(func (v128.const i32x4 0x10000000000000000 0x10000000000000000) drop)") + "wrong number of lane literals" +) + +;; too many arguments +(assert_malformed + (module quote "(func (v128.const i32x4 0x1 0x1 0x1 0x1 0x1) drop)") + "wrong number of lane literals" +) + +;; Rounding behaviour + +;; f32x4, small exponent +(module (func (export "f") (result v128) (v128.const f32x4 +0x1.00000100000000000p-50 +0x1.00000100000000000p-50 +0x1.00000100000000000p-50 +0x1.00000100000000000p-50))) +(assert_return (invoke "f") (v128.const f32x4 +0x1.000000p-50 +0x1.000000p-50 +0x1.000000p-50 +0x1.000000p-50)) +(module (func (export "f") (result v128) (v128.const f32x4 -0x1.00000100000000000p-50 -0x1.00000100000000000p-50 -0x1.00000100000000000p-50 -0x1.00000100000000000p-50))) +(assert_return (invoke "f") (v128.const f32x4 -0x1.000000p-50 -0x1.000000p-50 -0x1.000000p-50 -0x1.000000p-50)) +(module (func (export "f") (result v128) (v128.const f32x4 +0x1.00000500000000001p-50 +0x1.00000500000000001p-50 +0x1.00000500000000001p-50 +0x1.00000500000000001p-50))) +(assert_return (invoke "f") (v128.const f32x4 +0x1.000006p-50 +0x1.000006p-50 +0x1.000006p-50 +0x1.000006p-50)) +(module (func (export "f") (result v128) (v128.const f32x4 -0x1.00000500000000001p-50 -0x1.00000500000000001p-50 -0x1.00000500000000001p-50 -0x1.00000500000000001p-50))) +(assert_return (invoke "f") (v128.const f32x4 -0x1.000006p-50 -0x1.000006p-50 -0x1.000006p-50 -0x1.000006p-50)) + +(module (func (export "f") (result v128) (v128.const f32x4 +0x4000.004000000p-64 +0x4000.004000000p-64 +0x4000.004000000p-64 +0x4000.004000000p-64))) +(assert_return (invoke "f") (v128.const f32x4 +0x1.000000p-50 +0x1.000000p-50 +0x1.000000p-50 +0x1.000000p-50)) +(module (func (export "f") (result v128) (v128.const f32x4 -0x4000.004000000p-64 -0x4000.004000000p-64 -0x4000.004000000p-64 -0x4000.004000000p-64))) +(assert_return (invoke "f") (v128.const f32x4 -0x1.000000p-50 -0x1.000000p-50 -0x1.000000p-50 -0x1.000000p-50)) +(module (func (export "f") (result v128) (v128.const f32x4 +0x4000.014000001p-64 +0x4000.014000001p-64 +0x4000.014000001p-64 +0x4000.014000001p-64))) +(assert_return (invoke "f") (v128.const f32x4 +0x1.000006p-50 +0x1.000006p-50 +0x1.000006p-50 +0x1.000006p-50)) +(module (func (export "f") (result v128) (v128.const f32x4 -0x4000.014000001p-64 -0x4000.014000001p-64 -0x4000.014000001p-64 -0x4000.014000001p-64))) +(assert_return (invoke "f") (v128.const f32x4 -0x1.000006p-50 -0x1.000006p-50 -0x1.000006p-50 -0x1.000006p-50)) + +(module (func (export "f") (result v128) (v128.const f32x4 +8.8817847263968443573e-16 +8.8817847263968443573e-16 +8.8817847263968443573e-16 +8.8817847263968443573e-16))) +(assert_return (invoke "f") (v128.const f32x4 +0x1.000000p-50 +0x1.000000p-50 +0x1.000000p-50 +0x1.000000p-50)) +(module (func (export "f") (result v128) (v128.const f32x4 -8.8817847263968443573e-16 -8.8817847263968443573e-16 -8.8817847263968443573e-16 -8.8817847263968443573e-16))) +(assert_return (invoke "f") (v128.const f32x4 -0x1.000000p-50 -0x1.000000p-50 -0x1.000000p-50 -0x1.000000p-50)) +(module (func (export "f") (result v128) (v128.const f32x4 +8.8817857851880284253e-16 +8.8817857851880284253e-16 +8.8817857851880284253e-16 +8.8817857851880284253e-16))) +(assert_return (invoke "f") (v128.const f32x4 +0x1.000004p-50 +0x1.000004p-50 +0x1.000004p-50 +0x1.000004p-50)) +(module (func (export "f") (result v128) (v128.const f32x4 -8.8817857851880284253e-16 -8.8817857851880284253e-16 -8.8817857851880284253e-16 -8.8817857851880284253e-16))) +(assert_return (invoke "f") (v128.const f32x4 -0x1.000004p-50 -0x1.000004p-50 -0x1.000004p-50 -0x1.000004p-50)) + +;; f32x4, large exponent +(module (func (export "f") (result v128) (v128.const f32x4 +0x1.00000100000000000p+50 +0x1.00000100000000000p+50 +0x1.00000100000000000p+50 +0x1.00000100000000000p+50))) +(assert_return (invoke "f") (v128.const f32x4 +0x1.000000p+50 +0x1.000000p+50 +0x1.000000p+50 +0x1.000000p+50)) +(module (func (export "f") (result v128) (v128.const f32x4 -0x1.00000100000000000p+50 -0x1.00000100000000000p+50 -0x1.00000100000000000p+50 -0x1.00000100000000000p+50))) +(assert_return (invoke "f") (v128.const f32x4 -0x1.000000p+50 -0x1.000000p+50 -0x1.000000p+50 -0x1.000000p+50)) +(module (func (export "f") (result v128) (v128.const f32x4 +0x1.00000500000000001p+50 +0x1.00000500000000001p+50 +0x1.00000500000000001p+50 +0x1.00000500000000001p+50))) +(assert_return (invoke "f") (v128.const f32x4 +0x1.000006p+50 +0x1.000006p+50 +0x1.000006p+50 +0x1.000006p+50)) +(module (func (export "f") (result v128) (v128.const f32x4 -0x1.00000500000000001p+50 -0x1.00000500000000001p+50 -0x1.00000500000000001p+50 -0x1.00000500000000001p+50))) +(assert_return (invoke "f") (v128.const f32x4 -0x1.000006p+50 -0x1.000006p+50 -0x1.000006p+50 -0x1.000006p+50)) + +(module (func (export "f") (result v128) (v128.const f32x4 +0x4000004000000 +0x4000004000000 +0x4000004000000 +0x4000004000000))) +(assert_return (invoke "f") (v128.const f32x4 +0x1.000000p+50 +0x1.000000p+50 +0x1.000000p+50 +0x1.000000p+50)) +(module (func (export "f") (result v128) (v128.const f32x4 -0x4000004000000 -0x4000004000000 -0x4000004000000 -0x4000004000000))) +(assert_return (invoke "f") (v128.const f32x4 -0x1.000000p+50 -0x1.000000p+50 -0x1.000000p+50 -0x1.000000p+50)) +(module (func (export "f") (result v128) (v128.const f32x4 +0x400000c000000 +0x400000c000000 +0x400000c000000 +0x400000c000000))) +(assert_return (invoke "f") (v128.const f32x4 +0x1.000004p+50 +0x1.000004p+50 +0x1.000004p+50 +0x1.000004p+50)) +(module (func (export "f") (result v128) (v128.const f32x4 -0x400000c000000 -0x400000c000000 -0x400000c000000 -0x400000c000000))) +(assert_return (invoke "f") (v128.const f32x4 -0x1.000004p+50 -0x1.000004p+50 -0x1.000004p+50 -0x1.000004p+50)) + +(module (func (export "f") (result v128) (v128.const f32x4 +1125899973951488 +1125899973951488 +1125899973951488 +1125899973951488))) +(assert_return (invoke "f") (v128.const f32x4 +0x1.000000p+50 +0x1.000000p+50 +0x1.000000p+50 +0x1.000000p+50)) +(module (func (export "f") (result v128) (v128.const f32x4 -1125899973951488 -1125899973951488 -1125899973951488 -1125899973951488))) +(assert_return (invoke "f") (v128.const f32x4 -0x1.000000p+50 -0x1.000000p+50 -0x1.000000p+50 -0x1.000000p+50)) +(module (func (export "f") (result v128) (v128.const f32x4 +1125900108169216 +1125900108169216 +1125900108169216 +1125900108169216))) +(assert_return (invoke "f") (v128.const f32x4 +0x1.000004p+50 +0x1.000004p+50 +0x1.000004p+50 +0x1.000004p+50)) +(module (func (export "f") (result v128) (v128.const f32x4 -1125900108169216 -1125900108169216 -1125900108169216 -1125900108169216))) +(assert_return (invoke "f") (v128.const f32x4 -0x1.000004p+50 -0x1.000004p+50 -0x1.000004p+50 -0x1.000004p+50)) + +;; f32x4, subnormal +(module (func (export "f") (result v128) (v128.const f32x4 +0x0.00000100000000000p-126 +0x0.00000100000000000p-126 +0x0.00000100000000000p-126 +0x0.00000100000000000p-126))) +(assert_return (invoke "f") (v128.const f32x4 +0x0.000000p-126 +0x0.000000p-126 +0x0.000000p-126 +0x0.000000p-126)) +(module (func (export "f") (result v128) (v128.const f32x4 -0x0.00000100000000000p-126 -0x0.00000100000000000p-126 -0x0.00000100000000000p-126 -0x0.00000100000000000p-126))) +(assert_return (invoke "f") (v128.const f32x4 -0x0.000000p-126 -0x0.000000p-126 -0x0.000000p-126 -0x0.000000p-126)) +(module (func (export "f") (result v128) (v128.const f32x4 +0x0.00000500000000001p-126 +0x0.00000500000000001p-126 +0x0.00000500000000001p-126 +0x0.00000500000000001p-126))) +(assert_return (invoke "f") (v128.const f32x4 +0x0.000006p-126 +0x0.000006p-126 +0x0.000006p-126 +0x0.000006p-126)) +(module (func (export "f") (result v128) (v128.const f32x4 -0x0.00000500000000001p-126 -0x0.00000500000000001p-126 -0x0.00000500000000001p-126 -0x0.00000500000000001p-126))) +(assert_return (invoke "f") (v128.const f32x4 -0x0.000006p-126 -0x0.000006p-126 -0x0.000006p-126 -0x0.000006p-126)) + +;; f32x4, round down at limit to infinity +(module (func (export "f") (result v128) (v128.const f32x4 +0x1.fffffe8p127 +0x1.fffffe8p127 +0x1.fffffe8p127 +0x1.fffffe8p127))) +(assert_return (invoke "f") (v128.const f32x4 +0x1.fffffep127 +0x1.fffffep127 +0x1.fffffep127 +0x1.fffffep127)) +(module (func (export "f") (result v128) (v128.const f32x4 -0x1.fffffe8p127 -0x1.fffffe8p127 -0x1.fffffe8p127 -0x1.fffffe8p127))) +(assert_return (invoke "f") (v128.const f32x4 -0x1.fffffep127 -0x1.fffffep127 -0x1.fffffep127 -0x1.fffffep127)) +(module (func (export "f") (result v128) (v128.const f32x4 +0x1.fffffefffffffffffp127 +0x1.fffffefffffffffffp127 +0x1.fffffefffffffffffp127 +0x1.fffffefffffffffffp127))) +(assert_return (invoke "f") (v128.const f32x4 +0x1.fffffep127 +0x1.fffffep127 +0x1.fffffep127 +0x1.fffffep127)) +(module (func (export "f") (result v128) (v128.const f32x4 -0x1.fffffefffffffffffp127 -0x1.fffffefffffffffffp127 -0x1.fffffefffffffffffp127 -0x1.fffffefffffffffffp127))) +(assert_return (invoke "f") (v128.const f32x4 -0x1.fffffep127 -0x1.fffffep127 -0x1.fffffep127 -0x1.fffffep127)) + +;; f64x2, small exponent +(module (func (export "f") (result f64) (f64.const +0x1.000000000000080000000000p-600))) +(assert_return (invoke "f") (f64.const +0x1.0000000000000p-600)) +(module (func (export "f") (result f64) (f64.const -0x1.000000000000080000000000p-600))) +(assert_return (invoke "f") (f64.const -0x1.0000000000000p-600)) +(module (func (export "f") (result f64) (f64.const +0x1.000000000000080000000001p-600))) +(assert_return (invoke "f") (f64.const +0x1.0000000000001p-600)) +(module (func (export "f") (result f64) (f64.const -0x1.000000000000080000000001p-600))) +(assert_return (invoke "f") (f64.const -0x1.0000000000001p-600)) +(module (func (export "f") (result f64) (f64.const +0x1.0000000000000fffffffffffp-600))) +(assert_return (invoke "f") (f64.const +0x1.0000000000001p-600)) +(module (func (export "f") (result f64) (f64.const -0x1.0000000000000fffffffffffp-600))) +(assert_return (invoke "f") (f64.const -0x1.0000000000001p-600)) +(module (func (export "f") (result f64) (f64.const +0x1.000000000000100000000000p-600))) +(assert_return (invoke "f") (f64.const +0x1.0000000000001p-600)) +(module (func (export "f") (result f64) (f64.const -0x1.000000000000100000000000p-600))) +(assert_return (invoke "f") (f64.const -0x1.0000000000001p-600)) +(module (func (export "f") (result f64) (f64.const +0x1.000000000000100000000001p-600))) +(assert_return (invoke "f") (f64.const +0x1.0000000000001p-600)) +(module (func (export "f") (result f64) (f64.const -0x1.000000000000100000000001p-600))) +(assert_return (invoke "f") (f64.const -0x1.0000000000001p-600)) +(module (func (export "f") (result f64) (f64.const +0x1.00000000000017ffffffffffp-600))) +(assert_return (invoke "f") (f64.const +0x1.0000000000001p-600)) +(module (func (export "f") (result f64) (f64.const -0x1.00000000000017ffffffffffp-600))) +(assert_return (invoke "f") (f64.const -0x1.0000000000001p-600)) +(module (func (export "f") (result f64) (f64.const +0x1.000000000000180000000000p-600))) +(assert_return (invoke "f") (f64.const +0x1.0000000000002p-600)) +(module (func (export "f") (result f64) (f64.const -0x1.000000000000180000000000p-600))) +(assert_return (invoke "f") (f64.const -0x1.0000000000002p-600)) +(module (func (export "f") (result f64) (f64.const +0x1.000000000000180000000001p-600))) +(assert_return (invoke "f") (f64.const +0x1.0000000000002p-600)) +(module (func (export "f") (result f64) (f64.const -0x1.000000000000180000000001p-600))) +(assert_return (invoke "f") (f64.const -0x1.0000000000002p-600)) +(module (func (export "f") (result f64) (f64.const +0x1.0000000000001fffffffffffp-600))) +(assert_return (invoke "f") (f64.const +0x1.0000000000002p-600)) +(module (func (export "f") (result f64) (f64.const -0x1.0000000000001fffffffffffp-600))) +(assert_return (invoke "f") (f64.const -0x1.0000000000002p-600)) +(module (func (export "f") (result f64) (f64.const +0x1.000000000000200000000000p-600))) +(assert_return (invoke "f") (f64.const +0x1.0000000000002p-600)) +(module (func (export "f") (result f64) (f64.const -0x1.000000000000200000000000p-600))) +(assert_return (invoke "f") (f64.const -0x1.0000000000002p-600)) +(module (func (export "f") (result f64) (f64.const +0x1.000000000000200000000001p-600))) +(assert_return (invoke "f") (f64.const +0x1.0000000000002p-600)) +(module (func (export "f") (result f64) (f64.const -0x1.000000000000200000000001p-600))) +(assert_return (invoke "f") (f64.const -0x1.0000000000002p-600)) +(module (func (export "f") (result f64) (f64.const +0x1.00000000000027ffffffffffp-600))) +(assert_return (invoke "f") (f64.const +0x1.0000000000002p-600)) +(module (func (export "f") (result f64) (f64.const -0x1.00000000000027ffffffffffp-600))) +(assert_return (invoke "f") (f64.const -0x1.0000000000002p-600)) +(module (func (export "f") (result f64) (f64.const +0x1.000000000000280000000001p-600))) +(assert_return (invoke "f") (f64.const +0x1.0000000000003p-600)) +(module (func (export "f") (result f64) (f64.const -0x1.000000000000280000000001p-600))) +(assert_return (invoke "f") (f64.const -0x1.0000000000003p-600)) +(module (func (export "f") (result f64) (f64.const +0x8000000.000000400000000000p-627))) +(assert_return (invoke "f") (f64.const +0x1.0000000000000p-600)) +(module (func (export "f") (result f64) (f64.const -0x8000000.000000400000000000p-627))) +(assert_return (invoke "f") (f64.const -0x1.0000000000000p-600)) +(module (func (export "f") (result f64) (f64.const +0x8000000.000000400000000001p-627))) +(assert_return (invoke "f") (f64.const +0x1.0000000000001p-600)) +(module (func (export "f") (result f64) (f64.const -0x8000000.000000400000000001p-627))) +(assert_return (invoke "f") (f64.const -0x1.0000000000001p-600)) +(module (func (export "f") (result f64) (f64.const +0x8000000.0000007fffffffffffp-627))) +(assert_return (invoke "f") (f64.const +0x1.0000000000001p-600)) +(module (func (export "f") (result f64) (f64.const -0x8000000.0000007fffffffffffp-627))) +(assert_return (invoke "f") (f64.const -0x1.0000000000001p-600)) +(module (func (export "f") (result f64) (f64.const +0x8000000.000000800000000000p-627))) +(assert_return (invoke "f") (f64.const +0x1.0000000000001p-600)) +(module (func (export "f") (result f64) (f64.const -0x8000000.000000800000000000p-627))) +(assert_return (invoke "f") (f64.const -0x1.0000000000001p-600)) +(module (func (export "f") (result f64) (f64.const +0x8000000.000000800000000001p-627))) +(assert_return (invoke "f") (f64.const +0x1.0000000000001p-600)) +(module (func (export "f") (result f64) (f64.const -0x8000000.000000800000000001p-627))) +(assert_return (invoke "f") (f64.const -0x1.0000000000001p-600)) +(module (func (export "f") (result f64) (f64.const +0x8000000.000000bfffffffffffp-627))) +(assert_return (invoke "f") (f64.const +0x1.0000000000001p-600)) +(module (func (export "f") (result f64) (f64.const -0x8000000.000000bfffffffffffp-627))) +(assert_return (invoke "f") (f64.const -0x1.0000000000001p-600)) +(module (func (export "f") (result f64) (f64.const +0x8000000.000000c00000000000p-627))) +(assert_return (invoke "f") (f64.const +0x1.0000000000002p-600)) +(module (func (export "f") (result f64) (f64.const -0x8000000.000000c00000000000p-627))) +(assert_return (invoke "f") (f64.const -0x1.0000000000002p-600)) +(module (func (export "f") (result f64) (f64.const +0x8000000.000000c00000000001p-627))) +(assert_return (invoke "f") (f64.const +0x1.0000000000002p-600)) +(module (func (export "f") (result f64) (f64.const -0x8000000.000000c00000000001p-627))) +(assert_return (invoke "f") (f64.const -0x1.0000000000002p-600)) +(module (func (export "f") (result f64) (f64.const +0x8000000.000000ffffffffffffp-627))) +(assert_return (invoke "f") (f64.const +0x1.0000000000002p-600)) +(module (func (export "f") (result f64) (f64.const -0x8000000.000000ffffffffffffp-627))) +(assert_return (invoke "f") (f64.const -0x1.0000000000002p-600)) +(module (func (export "f") (result f64) (f64.const +0x8000000.000001000000000000p-627))) +(assert_return (invoke "f") (f64.const +0x1.0000000000002p-600)) +(module (func (export "f") (result f64) (f64.const -0x8000000.000001000000000000p-627))) +(assert_return (invoke "f") (f64.const -0x1.0000000000002p-600)) +(module (func (export "f") (result f64) (f64.const +0x8000000.000001000000000001p-627))) +(assert_return (invoke "f") (f64.const +0x1.0000000000002p-600)) +(module (func (export "f") (result f64) (f64.const -0x8000000.000001000000000001p-627))) +(assert_return (invoke "f") (f64.const -0x1.0000000000002p-600)) +(module (func (export "f") (result f64) (f64.const +0x8000000.0000013fffffffffffp-627))) +(assert_return (invoke "f") (f64.const +0x1.0000000000002p-600)) +(module (func (export "f") (result f64) (f64.const -0x8000000.0000013fffffffffffp-627))) +(assert_return (invoke "f") (f64.const -0x1.0000000000002p-600)) +(module (func (export "f") (result f64) (f64.const +0x8000000.000001400000000001p-627))) +(assert_return (invoke "f") (f64.const +0x1.0000000000003p-600)) +(module (func (export "f") (result f64) (f64.const -0x8000000.000001400000000001p-627))) +(assert_return (invoke "f") (f64.const -0x1.0000000000003p-600)) +(module (func (export "f") (result f64) (f64.const +5.3575430359313371995e+300))) +(assert_return (invoke "f") (f64.const +0x1.0000000000000p+999)) +(module (func (export "f") (result f64) (f64.const -5.3575430359313371995e+300))) +(assert_return (invoke "f") (f64.const -0x1.0000000000000p+999)) +(module (func (export "f") (result f64) (f64.const +5.3575430359313371996e+300))) +(assert_return (invoke "f") (f64.const +0x1.0000000000001p+999)) +(module (func (export "f") (result f64) (f64.const -5.3575430359313371996e+300))) +(assert_return (invoke "f") (f64.const -0x1.0000000000001p+999)) +(module (func (export "f") (result f64) (f64.const +5.3575430359313383891e+300))) +(assert_return (invoke "f") (f64.const +0x1.0000000000001p+999)) +(module (func (export "f") (result f64) (f64.const -5.3575430359313383891e+300))) +(assert_return (invoke "f") (f64.const -0x1.0000000000001p+999)) +(module (func (export "f") (result f64) (f64.const +5.3575430359313383892e+300))) +(assert_return (invoke "f") (f64.const +0x1.0000000000002p+999)) +(module (func (export "f") (result f64) (f64.const -5.3575430359313383892e+300))) +(assert_return (invoke "f") (f64.const -0x1.0000000000002p+999)) + +;; f64, large exponent +(module (func (export "f") (result v128) (v128.const f64x2 +0x1.000000000000080000000000p+600 +0x1.000000000000080000000000p+600))) +(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000000p+600 +0x1.0000000000000p+600)) +(module (func (export "f") (result v128) (v128.const f64x2 -0x1.000000000000080000000000p+600 -0x1.000000000000080000000000p+600))) +(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000000p+600 -0x1.0000000000000p+600)) +(module (func (export "f") (result v128) (v128.const f64x2 +0x1.000000000000080000000001p+600 +0x1.000000000000080000000001p+600))) +(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000001p+600 +0x1.0000000000001p+600)) +(module (func (export "f") (result v128) (v128.const f64x2 -0x1.000000000000080000000001p+600 -0x1.000000000000080000000001p+600))) +(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000001p+600 -0x1.0000000000001p+600)) +(module (func (export "f") (result v128) (v128.const f64x2 +0x1.0000000000000fffffffffffp+600 +0x1.0000000000000fffffffffffp+600))) +(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000001p+600 +0x1.0000000000001p+600)) +(module (func (export "f") (result v128) (v128.const f64x2 -0x1.0000000000000fffffffffffp+600 -0x1.0000000000000fffffffffffp+600))) +(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000001p+600 -0x1.0000000000001p+600)) +(module (func (export "f") (result v128) (v128.const f64x2 +0x1.000000000000100000000000p+600 +0x1.000000000000100000000000p+600))) +(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000001p+600 +0x1.0000000000001p+600)) +(module (func (export "f") (result v128) (v128.const f64x2 -0x1.000000000000100000000000p+600 -0x1.000000000000100000000000p+600))) +(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000001p+600 -0x1.0000000000001p+600)) +(module (func (export "f") (result v128) (v128.const f64x2 +0x1.000000000000100000000001p+600 +0x1.000000000000100000000001p+600))) +(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000001p+600 +0x1.0000000000001p+600)) +(module (func (export "f") (result v128) (v128.const f64x2 -0x1.000000000000100000000001p+600 -0x1.000000000000100000000001p+600))) +(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000001p+600 -0x1.0000000000001p+600)) +(module (func (export "f") (result v128) (v128.const f64x2 +0x1.00000000000017ffffffffffp+600 +0x1.00000000000017ffffffffffp+600))) +(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000001p+600 +0x1.0000000000001p+600)) +(module (func (export "f") (result v128) (v128.const f64x2 -0x1.00000000000017ffffffffffp+600 -0x1.00000000000017ffffffffffp+600))) +(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000001p+600 -0x1.0000000000001p+600)) +(module (func (export "f") (result v128) (v128.const f64x2 +0x1.000000000000180000000000p+600 +0x1.000000000000180000000000p+600))) +(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000002p+600 +0x1.0000000000002p+600)) +(module (func (export "f") (result v128) (v128.const f64x2 -0x1.000000000000180000000000p+600 -0x1.000000000000180000000000p+600))) +(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000002p+600 -0x1.0000000000002p+600)) +(module (func (export "f") (result v128) (v128.const f64x2 +0x1.000000000000180000000001p+600 +0x1.000000000000180000000001p+600))) +(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000002p+600 +0x1.0000000000002p+600)) +(module (func (export "f") (result v128) (v128.const f64x2 -0x1.000000000000180000000001p+600 -0x1.000000000000180000000001p+600))) +(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000002p+600 -0x1.0000000000002p+600)) +(module (func (export "f") (result v128) (v128.const f64x2 +0x1.0000000000001fffffffffffp+600 +0x1.0000000000001fffffffffffp+600))) +(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000002p+600 +0x1.0000000000002p+600)) +(module (func (export "f") (result v128) (v128.const f64x2 -0x1.0000000000001fffffffffffp+600 -0x1.0000000000001fffffffffffp+600))) +(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000002p+600 -0x1.0000000000002p+600)) +(module (func (export "f") (result v128) (v128.const f64x2 +0x1.000000000000200000000000p+600 +0x1.000000000000200000000000p+600))) +(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000002p+600 +0x1.0000000000002p+600)) +(module (func (export "f") (result v128) (v128.const f64x2 -0x1.000000000000200000000000p+600 -0x1.000000000000200000000000p+600))) +(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000002p+600 -0x1.0000000000002p+600)) +(module (func (export "f") (result v128) (v128.const f64x2 +0x1.000000000000200000000001p+600 +0x1.000000000000200000000001p+600))) +(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000002p+600 +0x1.0000000000002p+600)) +(module (func (export "f") (result v128) (v128.const f64x2 -0x1.000000000000200000000001p+600 -0x1.000000000000200000000001p+600))) +(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000002p+600 -0x1.0000000000002p+600)) +(module (func (export "f") (result v128) (v128.const f64x2 +0x1.00000000000027ffffffffffp+600 +0x1.00000000000027ffffffffffp+600))) +(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000002p+600 +0x1.0000000000002p+600)) +(module (func (export "f") (result v128) (v128.const f64x2 -0x1.00000000000027ffffffffffp+600 -0x1.00000000000027ffffffffffp+600))) +(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000002p+600 -0x1.0000000000002p+600)) +(module (func (export "f") (result v128) (v128.const f64x2 +0x1.000000000000280000000000p+600 +0x1.000000000000280000000000p+600))) +(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000002p+600 +0x1.0000000000002p+600)) +(module (func (export "f") (result v128) (v128.const f64x2 -0x1.000000000000280000000000p+600 -0x1.000000000000280000000000p+600))) +(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000002p+600 -0x1.0000000000002p+600)) +(module (func (export "f") (result v128) (v128.const f64x2 +0x1.000000000000280000000001p+600 +0x1.000000000000280000000001p+600))) +(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000003p+600 +0x1.0000000000003p+600)) +(module (func (export "f") (result v128) (v128.const f64x2 -0x1.000000000000280000000001p+600 -0x1.000000000000280000000001p+600))) +(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000003p+600 -0x1.0000000000003p+600)) +(module (func (export "f") (result v128) (v128.const f64x2 +0x2000000000000100000000000 +0x2000000000000100000000000))) +(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000000p+97 +0x1.0000000000000p+97)) +(module (func (export "f") (result v128) (v128.const f64x2 -0x2000000000000100000000000 -0x2000000000000100000000000))) +(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000000p+97 -0x1.0000000000000p+97)) +(module (func (export "f") (result v128) (v128.const f64x2 +0x2000000000000100000000001 +0x2000000000000100000000001))) +(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000001p+97 +0x1.0000000000001p+97)) +(module (func (export "f") (result v128) (v128.const f64x2 -0x2000000000000100000000001 -0x2000000000000100000000001))) +(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000001p+97 -0x1.0000000000001p+97)) +(module (func (export "f") (result v128) (v128.const f64x2 +0x20000000000001fffffffffff +0x20000000000001fffffffffff))) +(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000001p+97 +0x1.0000000000001p+97)) +(module (func (export "f") (result v128) (v128.const f64x2 -0x20000000000001fffffffffff -0x20000000000001fffffffffff))) +(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000001p+97 -0x1.0000000000001p+97)) +(module (func (export "f") (result v128) (v128.const f64x2 +0x2000000000000200000000000 +0x2000000000000200000000000))) +(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000001p+97 +0x1.0000000000001p+97)) +(module (func (export "f") (result v128) (v128.const f64x2 -0x2000000000000200000000000 -0x2000000000000200000000000))) +(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000001p+97 -0x1.0000000000001p+97)) +(module (func (export "f") (result v128) (v128.const f64x2 +0x2000000000000200000000001 +0x2000000000000200000000001))) +(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000001p+97 +0x1.0000000000001p+97)) +(module (func (export "f") (result v128) (v128.const f64x2 -0x2000000000000200000000001 -0x2000000000000200000000001))) +(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000001p+97 -0x1.0000000000001p+97)) +(module (func (export "f") (result v128) (v128.const f64x2 +0x20000000000002fffffffffff +0x20000000000002fffffffffff))) +(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000001p+97 +0x1.0000000000001p+97)) +(module (func (export "f") (result v128) (v128.const f64x2 -0x20000000000002fffffffffff -0x20000000000002fffffffffff))) +(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000001p+97 -0x1.0000000000001p+97)) +(module (func (export "f") (result v128) (v128.const f64x2 +0x2000000000000300000000000 +0x2000000000000300000000000))) +(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000002p+97 +0x1.0000000000002p+97)) +(module (func (export "f") (result v128) (v128.const f64x2 -0x2000000000000300000000000 -0x2000000000000300000000000))) +(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000002p+97 -0x1.0000000000002p+97)) +(module (func (export "f") (result v128) (v128.const f64x2 +0x2000000000000300000000001 +0x2000000000000300000000001))) +(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000002p+97 +0x1.0000000000002p+97)) +(module (func (export "f") (result v128) (v128.const f64x2 -0x2000000000000300000000001 -0x2000000000000300000000001))) +(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000002p+97 -0x1.0000000000002p+97)) +(module (func (export "f") (result v128) (v128.const f64x2 +0x20000000000003fffffffffff +0x20000000000003fffffffffff))) +(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000002p+97 +0x1.0000000000002p+97)) +(module (func (export "f") (result v128) (v128.const f64x2 -0x20000000000003fffffffffff -0x20000000000003fffffffffff))) +(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000002p+97 -0x1.0000000000002p+97)) +(module (func (export "f") (result v128) (v128.const f64x2 +0x2000000000000400000000000 +0x2000000000000400000000000))) +(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000002p+97 +0x1.0000000000002p+97)) +(module (func (export "f") (result v128) (v128.const f64x2 -0x2000000000000400000000000 -0x2000000000000400000000000))) +(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000002p+97 -0x1.0000000000002p+97)) +(module (func (export "f") (result v128) (v128.const f64x2 +0x2000000000000400000000001 +0x2000000000000400000000001))) +(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000002p+97 +0x1.0000000000002p+97)) +(module (func (export "f") (result v128) (v128.const f64x2 -0x2000000000000400000000001 -0x2000000000000400000000001))) +(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000002p+97 -0x1.0000000000002p+97)) +(module (func (export "f") (result v128) (v128.const f64x2 +0x20000000000004fffffffffff +0x20000000000004fffffffffff))) +(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000002p+97 +0x1.0000000000002p+97)) +(module (func (export "f") (result v128) (v128.const f64x2 -0x20000000000004fffffffffff -0x20000000000004fffffffffff))) +(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000002p+97 -0x1.0000000000002p+97)) +(module (func (export "f") (result v128) (v128.const f64x2 +0x2000000000000500000000000 +0x2000000000000500000000000))) +(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000002p+97 +0x1.0000000000002p+97)) +(module (func (export "f") (result v128) (v128.const f64x2 -0x2000000000000500000000000 -0x2000000000000500000000000))) +(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000002p+97 -0x1.0000000000002p+97)) +(module (func (export "f") (result v128) (v128.const f64x2 +0x2000000000000500000000001 +0x2000000000000500000000001))) +(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000003p+97 +0x1.0000000000003p+97)) +(module (func (export "f") (result v128) (v128.const f64x2 -0x2000000000000500000000001 -0x2000000000000500000000001))) +(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000003p+97 -0x1.0000000000003p+97)) +(module (func (export "f") (result v128) (v128.const f64x2 +1152921504606847104 +1152921504606847104))) +(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000000p+60 +0x1.0000000000000p+60)) +(module (func (export "f") (result v128) (v128.const f64x2 -1152921504606847104 -1152921504606847104))) +(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000000p+60 -0x1.0000000000000p+60)) +(module (func (export "f") (result v128) (v128.const f64x2 +1152921504606847105 +1152921504606847105))) +(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000001p+60 +0x1.0000000000001p+60)) +(module (func (export "f") (result v128) (v128.const f64x2 -1152921504606847105 -1152921504606847105))) +(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000001p+60 -0x1.0000000000001p+60)) +(module (func (export "f") (result v128) (v128.const f64x2 +1152921504606847359 +1152921504606847359))) +(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000001p+60 +0x1.0000000000001p+60)) +(module (func (export "f") (result v128) (v128.const f64x2 -1152921504606847359 -1152921504606847359))) +(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000001p+60 -0x1.0000000000001p+60)) +(module (func (export "f") (result v128) (v128.const f64x2 +1152921504606847360 +1152921504606847360))) +(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000002p+60 +0x1.0000000000002p+60)) +(module (func (export "f") (result v128) (v128.const f64x2 -1152921504606847360 -1152921504606847360))) +(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000002p+60 -0x1.0000000000002p+60)) + +;; f64x2, subnormal +(module (func (export "f") (result v128) (v128.const f64x2 +0x0.000000000000080000000000p-1022 +0x0.000000000000080000000000p-1022))) +(assert_return (invoke "f") (v128.const f64x2 +0x0.0000000000000p-1022 +0x0.0000000000000p-1022)) +(module (func (export "f") (result v128) (v128.const f64x2 -0x0.000000000000080000000000p-1022 -0x0.000000000000080000000000p-1022))) +(assert_return (invoke "f") (v128.const f64x2 -0x0.0000000000000p-1022 -0x0.0000000000000p-1022)) +(module (func (export "f") (result v128) (v128.const f64x2 +0x0.000000000000080000000001p-1022 +0x0.000000000000080000000001p-1022))) +(assert_return (invoke "f") (v128.const f64x2 +0x0.0000000000001p-1022 +0x0.0000000000001p-1022)) +(module (func (export "f") (result v128) (v128.const f64x2 -0x0.000000000000080000000001p-1022 -0x0.000000000000080000000001p-1022))) +(assert_return (invoke "f") (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022)) +(module (func (export "f") (result v128) (v128.const f64x2 +0x0.0000000000000fffffffffffp-1022 +0x0.0000000000000fffffffffffp-1022))) +(assert_return (invoke "f") (v128.const f64x2 +0x0.0000000000001p-1022 +0x0.0000000000001p-1022)) +(module (func (export "f") (result v128) (v128.const f64x2 -0x0.0000000000000fffffffffffp-1022 -0x0.0000000000000fffffffffffp-1022))) +(assert_return (invoke "f") (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022)) +(module (func (export "f") (result v128) (v128.const f64x2 +0x0.000000000000100000000000p-1022 +0x0.000000000000100000000000p-1022))) +(assert_return (invoke "f") (v128.const f64x2 +0x0.0000000000001p-1022 +0x0.0000000000001p-1022)) +(module (func (export "f") (result v128) (v128.const f64x2 -0x0.000000000000100000000000p-1022 -0x0.000000000000100000000000p-1022))) +(assert_return (invoke "f") (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022)) +(module (func (export "f") (result v128) (v128.const f64x2 +0x0.000000000000100000000001p-1022 +0x0.000000000000100000000001p-1022))) +(assert_return (invoke "f") (v128.const f64x2 +0x0.0000000000001p-1022 +0x0.0000000000001p-1022)) +(module (func (export "f") (result v128) (v128.const f64x2 -0x0.000000000000100000000001p-1022 -0x0.000000000000100000000001p-1022))) +(assert_return (invoke "f") (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022)) +(module (func (export "f") (result v128) (v128.const f64x2 +0x0.00000000000017ffffffffffp-1022 +0x0.00000000000017ffffffffffp-1022))) +(assert_return (invoke "f") (v128.const f64x2 +0x0.0000000000001p-1022 +0x0.0000000000001p-1022)) +(module (func (export "f") (result v128) (v128.const f64x2 -0x0.00000000000017ffffffffffp-1022 -0x0.00000000000017ffffffffffp-1022))) +(assert_return (invoke "f") (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022)) +(module (func (export "f") (result v128) (v128.const f64x2 +0x0.000000000000180000000000p-1022 +0x0.000000000000180000000000p-1022))) +(assert_return (invoke "f") (v128.const f64x2 +0x0.0000000000002p-1022 +0x0.0000000000002p-1022)) +(module (func (export "f") (result v128) (v128.const f64x2 -0x0.000000000000180000000000p-1022 -0x0.000000000000180000000000p-1022))) +(assert_return (invoke "f") (v128.const f64x2 -0x0.0000000000002p-1022 -0x0.0000000000002p-1022)) +(module (func (export "f") (result v128) (v128.const f64x2 +0x0.000000000000180000000001p-1022 +0x0.000000000000180000000001p-1022))) +(assert_return (invoke "f") (v128.const f64x2 +0x0.0000000000002p-1022 +0x0.0000000000002p-1022)) +(module (func (export "f") (result v128) (v128.const f64x2 -0x0.000000000000180000000001p-1022 -0x0.000000000000180000000001p-1022))) +(assert_return (invoke "f") (v128.const f64x2 -0x0.0000000000002p-1022 -0x0.0000000000002p-1022)) +(module (func (export "f") (result v128) (v128.const f64x2 +0x0.0000000000001fffffffffffp-1022 +0x0.0000000000001fffffffffffp-1022))) +(assert_return (invoke "f") (v128.const f64x2 +0x0.0000000000002p-1022 +0x0.0000000000002p-1022)) +(module (func (export "f") (result v128) (v128.const f64x2 -0x0.0000000000001fffffffffffp-1022 -0x0.0000000000001fffffffffffp-1022))) +(assert_return (invoke "f") (v128.const f64x2 -0x0.0000000000002p-1022 -0x0.0000000000002p-1022)) +(module (func (export "f") (result v128) (v128.const f64x2 +0x0.000000000000200000000000p-1022 +0x0.000000000000200000000000p-1022))) +(assert_return (invoke "f") (v128.const f64x2 +0x0.0000000000002p-1022 +0x0.0000000000002p-1022)) +(module (func (export "f") (result v128) (v128.const f64x2 -0x0.000000000000200000000000p-1022 -0x0.000000000000200000000000p-1022))) +(assert_return (invoke "f") (v128.const f64x2 -0x0.0000000000002p-1022 -0x0.0000000000002p-1022)) +(module (func (export "f") (result v128) (v128.const f64x2 +0x0.000000000000200000000001p-1022 +0x0.000000000000200000000001p-1022))) +(assert_return (invoke "f") (v128.const f64x2 +0x0.0000000000002p-1022 +0x0.0000000000002p-1022)) +(module (func (export "f") (result v128) (v128.const f64x2 -0x0.000000000000200000000001p-1022 -0x0.000000000000200000000001p-1022))) +(assert_return (invoke "f") (v128.const f64x2 -0x0.0000000000002p-1022 -0x0.0000000000002p-1022)) +(module (func (export "f") (result v128) (v128.const f64x2 +0x0.00000000000027ffffffffffp-1022 +0x0.00000000000027ffffffffffp-1022))) +(assert_return (invoke "f") (v128.const f64x2 +0x0.0000000000002p-1022 +0x0.0000000000002p-1022)) +(module (func (export "f") (result v128) (v128.const f64x2 -0x0.00000000000027ffffffffffp-1022 -0x0.00000000000027ffffffffffp-1022))) +(assert_return (invoke "f") (v128.const f64x2 -0x0.0000000000002p-1022 -0x0.0000000000002p-1022)) +(module (func (export "f") (result v128) (v128.const f64x2 +0x0.000000000000280000000000p-1022 +0x0.000000000000280000000000p-1022))) +(assert_return (invoke "f") (v128.const f64x2 +0x0.0000000000002p-1022 +0x0.0000000000002p-1022)) +(module (func (export "f") (result v128) (v128.const f64x2 -0x0.000000000000280000000000p-1022 -0x0.000000000000280000000000p-1022))) +(assert_return (invoke "f") (v128.const f64x2 -0x0.0000000000002p-1022 -0x0.0000000000002p-1022)) +(module (func (export "f") (result v128) (v128.const f64x2 +0x1.000000000000280000000001p-1022 +0x1.000000000000280000000001p-1022))) +(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000003p-1022 +0x1.0000000000003p-1022)) +(module (func (export "f") (result v128) (v128.const f64x2 -0x1.000000000000280000000001p-1022 -0x1.000000000000280000000001p-1022))) +(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000003p-1022 -0x1.0000000000003p-1022)) + +;; f64x2, round down at limit to infinity +(module (func (export "f") (result v128) (v128.const f64x2 +0x1.fffffffffffff4p1023 +0x1.fffffffffffff4p1023))) +(assert_return (invoke "f") (v128.const f64x2 +0x1.fffffffffffffp1023 +0x1.fffffffffffffp1023)) +(module (func (export "f") (result v128) (v128.const f64x2 -0x1.fffffffffffff4p1023 -0x1.fffffffffffff4p1023))) +(assert_return (invoke "f") (v128.const f64x2 -0x1.fffffffffffffp1023 -0x1.fffffffffffffp1023)) +(module (func (export "f") (result v128) (v128.const f64x2 +0x1.fffffffffffff7ffffffp1023 +0x1.fffffffffffff7ffffffp1023))) +(assert_return (invoke "f") (v128.const f64x2 +0x1.fffffffffffffp1023 +0x1.fffffffffffffp1023)) +(module (func (export "f") (result v128) (v128.const f64x2 -0x1.fffffffffffff7ffffffp1023 -0x1.fffffffffffff7ffffffp1023))) +(assert_return (invoke "f") (v128.const f64x2 -0x1.fffffffffffffp1023 -0x1.fffffffffffffp1023)) + +;; As parameters of control constructs + +(module (memory 1) + (func (export "as-br-retval") (result v128) + (block (result v128) (br 0 (v128.const i32x4 0x03020100 0x07060504 0x0b0a0908 0x0f0e0d0c))) + ) + (func (export "as-br_if-retval") (result v128) + (block (result v128) + (br_if 0 (v128.const i32x4 0 1 2 3) (i32.const 1)) + ) + ) + (func (export "as-return-retval") (result v128) + (return (v128.const i32x4 0 1 2 3)) + ) + (func (export "as-if-then-retval") (result v128) + (if (result v128) (i32.const 1) + (then (v128.const i32x4 0 1 2 3)) (else (v128.const i32x4 3 2 1 0)) + ) + ) + (func (export "as-if-else-retval") (result v128) + (if (result v128) (i32.const 0) + (then (v128.const i32x4 0 1 2 3)) (else (v128.const i32x4 3 2 1 0)) + ) + ) + (func $f (param v128 v128 v128) (result v128) (v128.const i32x4 0 1 2 3)) + (func (export "as-call-param") (result v128) + (call $f (v128.const i32x4 0 1 2 3) (v128.const i32x4 0 1 2 3) (v128.const i32x4 0 1 2 3)) + ) + (func (export "as-block-retval") (result v128) + (block (result v128) (v128.const i32x4 0 1 2 3)) + ) + (func (export "as-loop-retval") (result v128) + (loop (result v128) (v128.const i32x4 0 1 2 3)) + ) + (func (export "as-drop-operand") + (drop (v128.const i32x4 0 1 2 3)) + ) + + (func (export "as-br-retval2") (result v128) + (block (result v128) (br 0 (v128.const i64x2 0x0302010007060504 0x0b0a09080f0e0d0c))) + ) + (func (export "as-br_if-retval2") (result v128) + (block (result v128) + (br_if 0 (v128.const i64x2 0 1) (i32.const 1)) + ) + ) + (func (export "as-return-retval2") (result v128) + (return (v128.const i64x2 0 1)) + ) + (func (export "as-if-then-retval2") (result v128) + (if (result v128) (i32.const 1) + (then (v128.const i64x2 0 1)) (else (v128.const i64x2 1 0)) + ) + ) + (func (export "as-if-else-retval2") (result v128) + (if (result v128) (i32.const 0) + (then (v128.const i64x2 0 1)) (else (v128.const i64x2 1 0)) + ) + ) + (func $f2 (param v128 v128 v128) (result v128) (v128.const i64x2 0 1)) + (func (export "as-call-param2") (result v128) + (call $f2 (v128.const i64x2 0 1) (v128.const i64x2 0 1) (v128.const i64x2 0 1)) + ) + + (type $sig (func (param v128 v128 v128) (result v128))) + (table funcref (elem $f $f2)) + (func (export "as-call_indirect-param") (result v128) + (call_indirect (type $sig) + (v128.const i32x4 0 1 2 3) (v128.const i32x4 0 1 2 3) (v128.const i32x4 0 1 2 3) (i32.const 0) + ) + ) + (func (export "as-call_indirect-param2") (result v128) + (call_indirect (type $sig) + (v128.const i64x2 0 1) (v128.const i64x2 0 1) (v128.const i64x2 0 1) (i32.const 1) + ) + ) + (func (export "as-block-retval2") (result v128) + (block (result v128) (v128.const i64x2 0 1)) + ) + (func (export "as-loop-retval2") (result v128) + (loop (result v128) (v128.const i64x2 0 1)) + ) + (func (export "as-drop-operand2") + (drop (v128.const i64x2 0 1)) + ) +) + +(assert_return (invoke "as-br-retval") (v128.const i32x4 0x03020100 0x07060504 0x0b0a0908 0x0f0e0d0c)) +(assert_return (invoke "as-br_if-retval") (v128.const i32x4 0 1 2 3)) +(assert_return (invoke "as-return-retval") (v128.const i32x4 0 1 2 3)) +(assert_return (invoke "as-if-then-retval") (v128.const i32x4 0 1 2 3)) +(assert_return (invoke "as-if-else-retval") (v128.const i32x4 3 2 1 0)) +(assert_return (invoke "as-call-param") (v128.const i32x4 0 1 2 3)) +(assert_return (invoke "as-call_indirect-param") (v128.const i32x4 0 1 2 3)) +(assert_return (invoke "as-block-retval") (v128.const i32x4 0 1 2 3)) +(assert_return (invoke "as-loop-retval") (v128.const i32x4 0 1 2 3)) +(assert_return (invoke "as-drop-operand")) + +(assert_return (invoke "as-br-retval2") (v128.const i64x2 0x0302010007060504 0x0b0a09080f0e0d0c)) +(assert_return (invoke "as-br_if-retval2") (v128.const i64x2 0 1)) +(assert_return (invoke "as-return-retval2") (v128.const i64x2 0 1)) +(assert_return (invoke "as-if-then-retval2") (v128.const i64x2 0 1)) +(assert_return (invoke "as-if-else-retval2") (v128.const i64x2 1 0)) +(assert_return (invoke "as-call-param2") (v128.const i64x2 0 1)) +(assert_return (invoke "as-call_indirect-param2") (v128.const i64x2 0 1)) +(assert_return (invoke "as-block-retval2") (v128.const i64x2 0 1)) +(assert_return (invoke "as-loop-retval2") (v128.const i64x2 0 1)) +(assert_return (invoke "as-drop-operand2")) + +;; v128 locals + +(module (memory 1) + (func (export "as-local.set/get-value_0_0") (param $0 v128) (result v128) + (local v128 v128 v128 v128) + (local.set 0 (local.get $0)) + (local.get 0) + ) + (func (export "as-local.set/get-value_0_1") (param $0 v128) (result v128) + (local v128 v128 v128 v128) + (local.set 0 (local.get $0)) + (local.set 1 (local.get 0)) + (local.set 2 (local.get 1)) + (local.set 3 (local.get 2)) + (local.get 0) + ) + (func (export "as-local.set/get-value_3_0") (param $0 v128) (result v128) + (local v128 v128 v128 v128) + (local.set 0 (local.get $0)) + (local.set 1 (local.get 0)) + (local.set 2 (local.get 1)) + (local.set 3 (local.get 2)) + (local.get 3) + ) + (func (export "as-local.tee-value") (result v128) + (local v128) + (local.tee 0 (v128.const i32x4 0 1 2 3)) + ) +) + +(assert_return (invoke "as-local.set/get-value_0_0" (v128.const i32x4 0 0 0 0)) (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "as-local.set/get-value_0_1" (v128.const i32x4 1 1 1 1)) (v128.const i32x4 1 1 1 1)) +(assert_return (invoke "as-local.set/get-value_3_0" (v128.const i32x4 2 2 2 2)) (v128.const i32x4 2 2 2 2)) +(assert_return (invoke "as-local.tee-value") (v128.const i32x4 0 1 2 3)) + + +;; v128 globals + +(module (memory 1) + (global $g0 (mut v128) (v128.const i32x4 0 1 2 3)) + (global $g1 (mut v128) (v128.const i32x4 4 5 6 7)) + (global $g2 (mut v128) (v128.const i32x4 8 9 10 11)) + (global $g3 (mut v128) (v128.const i32x4 12 13 14 15)) + (global $g4 (mut v128) (v128.const i32x4 16 17 18 19)) + + (func $set_g0 (export "as-global.set_value_$g0") (param $0 v128) + (global.set $g0 (local.get $0)) + ) + (func $set_g1_g2 (export "as-global.set_value_$g1_$g2") (param $0 v128) (param $1 v128) + (global.set $g1 (local.get $0)) + (global.set $g2 (local.get $1)) + ) + (func $set_g0_g1_g2_g3 (export "as-global.set_value_$g0_$g1_$g2_$g3") (param $0 v128) (param $1 v128) (param $2 v128) (param $3 v128) + (call $set_g0 (local.get $0)) + (call $set_g1_g2 (local.get $1) (local.get $2)) + (global.set $g3 (local.get $3)) + ) + (func (export "global.get_g0") (result v128) + (global.get $g0) + ) + (func (export "global.get_g1") (result v128) + (global.get $g1) + ) + (func (export "global.get_g2") (result v128) + (global.get $g2) + ) + (func (export "global.get_g3") (result v128) + (global.get $g3) + ) +) + +(assert_return (invoke "as-global.set_value_$g0_$g1_$g2_$g3" (v128.const i32x4 1 1 1 1) + (v128.const i32x4 2 2 2 2) + (v128.const i32x4 3 3 3 3) + (v128.const i32x4 4 4 4 4))) +(assert_return (invoke "global.get_g0") (v128.const i32x4 1 1 1 1)) +(assert_return (invoke "global.get_g1") (v128.const i32x4 2 2 2 2)) +(assert_return (invoke "global.get_g2") (v128.const i32x4 3 3 3 3)) +(assert_return (invoke "global.get_g3") (v128.const i32x4 4 4 4 4)) + + +;; Test integer literal parsing. + +(module + (func (export "i32x4.test") (result v128) (return (v128.const i32x4 0x0bAdD00D 0x0bAdD00D 0x0bAdD00D 0x0bAdD00D))) + (func (export "i32x4.smax") (result v128) (return (v128.const i32x4 0x7fffffff 0x7fffffff 0x7fffffff 0x7fffffff))) + (func (export "i32x4.neg_smax") (result v128) (return (v128.const i32x4 -0x7fffffff -0x7fffffff -0x7fffffff -0x7fffffff))) + (func (export "i32x4.inc_smin") (result v128) (return (i32x4.add (v128.const i32x4 -0x80000000 -0x80000000 -0x80000000 -0x80000000) (v128.const i32x4 1 1 1 1)))) + (func (export "i32x4.neg_zero") (result v128) (return (v128.const i32x4 -0x0 -0x0 -0x0 -0x0))) + (func (export "i32x4.not_octal") (result v128) (return (v128.const i32x4 010 010 010 010))) + (func (export "i32x4.plus_sign") (result v128) (return (v128.const i32x4 +42 +42 +42 +42))) + + (func (export "i32x4-dec-sep1") (result v128) (v128.const i32x4 1_000_000 1_000_000 1_000_000 1_000_000)) + (func (export "i32x4-dec-sep2") (result v128) (v128.const i32x4 1_0_0_0 1_0_0_0 1_0_0_0 1_0_0_0)) + (func (export "i32x4-hex-sep1") (result v128) (v128.const i32x4 0xa_0f_00_99 0xa_0f_00_99 0xa_0f_00_99 0xa_0f_00_99)) + (func (export "i32x4-hex-sep2") (result v128) (v128.const i32x4 0x1_a_A_0_f 0x1_a_A_0_f 0x1_a_A_0_f 0x1_a_A_0_f)) + + (func (export "i64x2.test") (result v128) (return (v128.const i64x2 0x0bAdD00D0bAdD00D 0x0bAdD00D0bAdD00D))) + (func (export "i64x2.smax") (result v128) (return (v128.const i64x2 0x7fffffffffffffff 0x7fffffffffffffff))) + (func (export "i64x2.neg_smax") (result v128) (return (v128.const i64x2 -0x7fffffffffffffff -0x7fffffffffffffff))) + (func (export "i64x2.inc_smin") (result v128) (return (i64x2.add (v128.const i64x2 -0x8000000000000000 -0x8000000000000000) (v128.const i64x2 1 1)))) + (func (export "i64x2.neg_zero") (result v128) (return (v128.const i64x2 -0x0 -0x0))) + (func (export "i64x2.not_octal") (result v128) (return (v128.const i64x2 010010 010010))) + (func (export "i64x2.plus_sign") (result v128) (return (v128.const i64x2 +42 +42))) + + (func (export "i64x2-dec-sep1") (result v128) (v128.const i64x2 10_000_000_000_000 10_000_000_000_000)) + (func (export "i64x2-dec-sep2") (result v128) (v128.const i64x2 1_0_0_0_0_0_0_0 1_0_0_0_0_0_0_0)) + (func (export "i64x2-hex-sep1") (result v128) (v128.const i64x2 0xa_0f_00_99_0a_0f_00_99 0xa_0f_00_99_0a_0f_00_99)) + (func (export "i64x2-hex-sep2") (result v128) (v128.const i64x2 0x1_a_A_0_f_1_a_A_0_f 0x1_a_A_0_f_1_a_A_0_f)) +) + +(assert_return (invoke "i32x4.test") (v128.const i32x4 195940365 195940365 195940365 195940365)) +(assert_return (invoke "i32x4.smax") (v128.const i32x4 2147483647 2147483647 2147483647 2147483647)) +(assert_return (invoke "i32x4.neg_smax") (v128.const i32x4 -2147483647 -2147483647 -2147483647 -2147483647)) +(assert_return (invoke "i32x4.inc_smin") (v128.const i32x4 -2147483647 -2147483647 -2147483647 -2147483647)) +(assert_return (invoke "i32x4.neg_zero") (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.not_octal") (v128.const i32x4 10 10 10 10)) +(assert_return (invoke "i32x4.plus_sign") (v128.const i32x4 42 42 42 42)) + +(assert_return (invoke "i32x4-dec-sep1") (v128.const i32x4 1000000 1000000 1000000 1000000)) +(assert_return (invoke "i32x4-dec-sep2") (v128.const i32x4 1000 1000 1000 1000)) +(assert_return (invoke "i32x4-hex-sep1") (v128.const i32x4 0xa0f0099 0xa0f0099 0xa0f0099 0xa0f0099)) +(assert_return (invoke "i32x4-hex-sep2") (v128.const i32x4 0x1aa0f 0x1aa0f 0x1aa0f 0x1aa0f)) + +(assert_return (invoke "i64x2.test") (v128.const i64x2 841557459837243405 841557459837243405)) +(assert_return (invoke "i64x2.smax") (v128.const i64x2 9223372036854775807 9223372036854775807)) +(assert_return (invoke "i64x2.neg_smax") (v128.const i64x2 -9223372036854775807 -9223372036854775807)) +(assert_return (invoke "i64x2.inc_smin") (v128.const i64x2 -9223372036854775807 -9223372036854775807)) +(assert_return (invoke "i64x2.neg_zero") (v128.const i64x2 0 0)) +(assert_return (invoke "i64x2.not_octal") (v128.const i64x2 10010 10010)) +(assert_return (invoke "i64x2.plus_sign") (v128.const i64x2 42 42)) + +(assert_return (invoke "i64x2-dec-sep1") (v128.const i64x2 10000000000000 10000000000000)) +(assert_return (invoke "i64x2-dec-sep2") (v128.const i64x2 10000000 10000000)) +(assert_return (invoke "i64x2-hex-sep1") (v128.const i64x2 0xa0f00990a0f0099 0xa0f00990a0f0099)) +(assert_return (invoke "i64x2-hex-sep2") (v128.const i64x2 0x1aa0f1aa0f 0x1aa0f1aa0f)) + +(assert_malformed + (module quote "(global v128 (v128.const i32x4 _100 _100 _100 _100))") + "unknown operator" +) +(assert_malformed + (module quote "(global v128 (v128.const i32x4 +_100 +_100 +_100 +_100))") + "unknown operator" +) +(assert_malformed + (module quote "(global v128 (v128.const i32x4 -_100 -_100 -_100 -_100))") + "unknown operator" +) +(assert_malformed + (module quote "(global v128 (v128.const i32x4 99_ 99_ 99_ 99_))") + "unknown operator" +) +(assert_malformed + (module quote "(global v128 (v128.const i32x4 1__000 1__000 1__000 1__000))") + "unknown operator" +) +(assert_malformed + (module quote "(global v128 (v128.const i32x4 _0x100 _0x100 _0x100 _0x100))") + "unknown operator" +) +(assert_malformed + (module quote "(global v128 (v128.const i32x4 0_x100 0_x100 0_x100 0_x100))") + "unknown operator" +) +(assert_malformed + (module quote "(global v128 (v128.const i32x4 0x_100 0x_100 0x_100 0x_100))") + "unknown operator" +) +(assert_malformed + (module quote "(global v128 (v128.const i32x4 0x00_ 0x00_ 0x00_ 0x00_))") + "unknown operator" +) +(assert_malformed + (module quote "(global v128 (v128.const i32x4 0xff__ffff 0xff__ffff 0xff__ffff 0xff__ffff))") + "unknown operator" +) + +(assert_malformed + (module quote "(global v128 (v128.const i64x2 _100_100 _100_100))") + "unknown operator" +) +(assert_malformed + (module quote "(global v128 (v128.const i64x2 +_100_100 +_100_100))") + "unknown operator" +) +(assert_malformed + (module quote "(global v128 (v128.const i64x2 -_100_100 -_100_100))") + "unknown operator" +) +(assert_malformed + (module quote "(global v128 (v128.const i64x2 99_99_ 99_99_))") + "unknown operator" +) +(assert_malformed + (module quote "(global v128 (v128.const i64x2 1__000_000 1__000_000))") + "unknown operator" +) +(assert_malformed + (module quote "(global v128 (v128.const i64x2 _0x100000 _0x100000))") + "unknown operator" +) +(assert_malformed + (module quote "(global v128 (v128.const i64x2 0_x100000 0_x100000))") + "unknown operator" +) +(assert_malformed + (module quote "(global v128 (v128.const i64x2 0x_100000 0x_100000))") + "unknown operator" +) +(assert_malformed + (module quote "(global v128 (v128.const i64x2 0x00_ 0x00_))") + "unknown operator" +) +(assert_malformed + (module quote "(global v128 (v128.const i64x2 0xff__ffff_ffff_ffff 0xff__ffff_ffff_ffff))") + "unknown operator" +) + +;; Test floating-point literal parsing. + +(module + (func (export "f32-dec-sep1") (result v128) (v128.const f32x4 1_000_000 1_000_000 1_000_000 1_000_000)) + (func (export "f32-dec-sep2") (result v128) (v128.const f32x4 1_0_0_0 1_0_0_0 1_0_0_0 1_0_0_0)) + (func (export "f32-dec-sep3") (result v128) (v128.const f32x4 100_3.141_592 100_3.141_592 100_3.141_592 100_3.141_592)) + (func (export "f32-dec-sep4") (result v128) (v128.const f32x4 99e+1_3 99e+1_3 99e+1_3 99e+1_3)) + (func (export "f32-dec-sep5") (result v128) (v128.const f32x4 122_000.11_3_54E0_2_3 122_000.11_3_54E0_2_3 122_000.11_3_54E0_2_3 122_000.11_3_54E0_2_3)) + (func (export "f32-hex-sep1") (result v128) (v128.const f32x4 0xa_0f_00_99 0xa_0f_00_99 0xa_0f_00_99 0xa_0f_00_99)) + (func (export "f32-hex-sep2") (result v128) (v128.const f32x4 0x1_a_A_0_f 0x1_a_A_0_f 0x1_a_A_0_f 0x1_a_A_0_f)) + (func (export "f32-hex-sep3") (result v128) (v128.const f32x4 0xa0_ff.f141_a59a 0xa0_ff.f141_a59a 0xa0_ff.f141_a59a 0xa0_ff.f141_a59a)) + (func (export "f32-hex-sep4") (result v128) (v128.const f32x4 0xf0P+1_3 0xf0P+1_3 0xf0P+1_3 0xf0P+1_3)) + (func (export "f32-hex-sep5") (result v128) (v128.const f32x4 0x2a_f00a.1f_3_eep2_3 0x2a_f00a.1f_3_eep2_3 0x2a_f00a.1f_3_eep2_3 0x2a_f00a.1f_3_eep2_3)) + (func (export "f64-dec-sep1") (result v128) (v128.const f64x2 1_000_000 1_000_000)) + (func (export "f64-dec-sep2") (result v128) (v128.const f64x2 1_0_0_0 1_0_0_0)) + (func (export "f64-dec-sep3") (result v128) (v128.const f64x2 100_3.141_592 100_3.141_592)) + (func (export "f64-dec-sep4") (result v128) (v128.const f64x2 99e+1_3 99e+1_3)) + (func (export "f64-dec-sep5") (result v128) (v128.const f64x2 122_000.11_3_54E0_2_3 122_000.11_3_54E0_2_3)) + (func (export "f64-hex-sep1") (result v128) (v128.const f64x2 0xa_0f_00_99 0xa_0f_00_99)) + (func (export "f64-hex-sep2") (result v128) (v128.const f64x2 0x1_a_A_0_f 0x1_a_A_0_f)) + (func (export "f64-hex-sep3") (result v128) (v128.const f64x2 0xa0_ff.f141_a59a 0xa0_ff.f141_a59a)) + (func (export "f64-hex-sep4") (result v128) (v128.const f64x2 0xf0P+1_3 0xf0P+1_3)) + (func (export "f64-hex-sep5") (result v128) (v128.const f64x2 0x2a_f00a.1f_3_eep2_3 0x2a_f00a.1f_3_eep2_3)) +) + +(assert_return (invoke "f32-dec-sep1") (v128.const f32x4 1000000 1000000 1000000 1000000)) +(assert_return (invoke "f32-dec-sep2") (v128.const f32x4 1000 1000 1000 1000)) +(assert_return (invoke "f32-dec-sep3") (v128.const f32x4 1003.141592 1003.141592 1003.141592 1003.141592)) +(assert_return (invoke "f32-dec-sep4") (v128.const f32x4 99e+13 99e+13 99e+13 99e+13)) +(assert_return (invoke "f32-dec-sep5") (v128.const f32x4 122000.11354e23 122000.11354e23 122000.11354e23 122000.11354e23)) +(assert_return (invoke "f32-hex-sep1") (v128.const f32x4 0xa0f0099 0xa0f0099 0xa0f0099 0xa0f0099)) +(assert_return (invoke "f32-hex-sep2") (v128.const f32x4 0x1aa0f 0x1aa0f 0x1aa0f 0x1aa0f)) +(assert_return (invoke "f32-hex-sep3") (v128.const f32x4 0xa0ff.f141a59a 0xa0ff.f141a59a 0xa0ff.f141a59a 0xa0ff.f141a59a)) +(assert_return (invoke "f32-hex-sep4") (v128.const f32x4 0xf0P+13 0xf0P+13 0xf0P+13 0xf0P+13)) +(assert_return (invoke "f32-hex-sep5") (v128.const f32x4 0x2af00a.1f3eep23 0x2af00a.1f3eep23 0x2af00a.1f3eep23 0x2af00a.1f3eep23)) +(assert_return (invoke "f64-dec-sep1") (v128.const f64x2 1000000 1000000)) +(assert_return (invoke "f64-dec-sep2") (v128.const f64x2 1000 1000)) +(assert_return (invoke "f64-dec-sep3") (v128.const f64x2 1003.141592 1003.141592)) +(assert_return (invoke "f64-dec-sep4") (v128.const f64x2 99e+13 99e+13)) +(assert_return (invoke "f64-dec-sep5") (v128.const f64x2 122000.11354e23 122000.11354e23)) +(assert_return (invoke "f64-hex-sep1") (v128.const f64x2 0xa0f0099 0xa0f0099)) +(assert_return (invoke "f64-hex-sep2") (v128.const f64x2 0x1aa0f 0x1aa0f)) +(assert_return (invoke "f64-hex-sep3") (v128.const f64x2 0xa0ff.f141a59a 0xa0ff.f141a59a)) +(assert_return (invoke "f64-hex-sep4") (v128.const f64x2 0xf0P+13 0xf0P+13)) +(assert_return (invoke "f64-hex-sep5") (v128.const f64x2 0x2af00a.1f3eep23 0x2af00a.1f3eep23)) + +(assert_malformed + (module quote "(global v128 (v128.const f32x4 _100 _100 _100 _100))") + "unknown operator" +) +(assert_malformed + (module quote "(global v128 (v128.const f32x4 +_100 +_100 +_100 +_100))") + "unknown operator" +) +(assert_malformed + (module quote "(global v128 (v128.const f32x4 -_100 -_100 -_100 -_100))") + "unknown operator" +) +(assert_malformed + (module quote "(global v128 (v128.const f32x4 99_ 99_ 99_ 99_))") + "unknown operator" +) +(assert_malformed + (module quote "(global v128 (v128.const f32x4 1__000 1__000 1__000 1__000))") + "unknown operator" +) +(assert_malformed + (module quote "(global v128 (v128.const f32x4 _1.0 _1.0 _1.0 _1.0))") + "unknown operator" +) +(assert_malformed + (module quote "(global v128 (v128.const f32x4 1.0_ 1.0_ 1.0_ 1.0_))") + "unknown operator" +) +(assert_malformed + (module quote "(global v128 (v128.const f32x4 1_.0 1_.0 1_.0 1_.0))") + "unknown operator" +) +(assert_malformed + (module quote "(global v128 (v128.const f32x4 1._0 1._0 1._0 1._0))") + "unknown operator" +) +(assert_malformed + (module quote "(global v128 (v128.const f32x4 _1e1 _1e1 _1e1 _1e1))") + "unknown operator" +) +(assert_malformed + (module quote "(global v128 (v128.const f32x4 1e1_ 1e1_ 1e1_ 1e1_))") + "unknown operator" +) +(assert_malformed + (module quote "(global v128 (v128.const f32x4 1_e1 1_e1 1_e1 1_e1))") + "unknown operator" +) +(assert_malformed + (module quote "(global v128 (v128.const f32x4 1e_1 1e_1 1e_1 1e_1))") + "unknown operator" +) +(assert_malformed + (module quote "(global v128 (v128.const f32x4 _1.0e1 _1.0e1 _1.0e1 _1.0e1))") + "unknown operator" +) +(assert_malformed + (module quote "(global v128 (v128.const f32x4 1.0e1_ 1.0e1_ 1.0e1_ 1.0e1_))") + "unknown operator" +) +(assert_malformed + (module quote "(global v128 (v128.const f32x4 1.0_e1 1.0_e1 1.0_e1 1.0_e1))") + "unknown operator" +) +(assert_malformed + (module quote "(global v128 (v128.const f32x4 1.0e_1 1.0e_1 1.0e_1 1.0e_1))") + "unknown operator" +) +(assert_malformed + (module quote "(global v128 (v128.const f32x4 1.0e+_1 1.0e+_1 1.0e+_1 1.0e+_1))") + "unknown operator" +) +(assert_malformed + (module quote "(global v128 (v128.const f32x4 1.0e_+1 1.0e_+1 1.0e_+1 1.0e_+1))") + "unknown operator" +) +(assert_malformed + (module quote "(global v128 (v128.const f32x4 _0x100 _0x100 _0x100 _0x100))") + "unknown operator" +) +(assert_malformed + (module quote "(global v128 (v128.const f32x4 0_x100 0_x100 0_x100 0_x100))") + "unknown operator" +) +(assert_malformed + (module quote "(global v128 (v128.const f32x4 0x_100 0x_100 0x_100 0x_100))") + "unknown operator" +) +(assert_malformed + (module quote "(global v128 (v128.const f32x4 0x00_ 0x00_ 0x00_ 0x00_))") + "unknown operator" +) +(assert_malformed + (module quote "(global v128 (v128.const f32x4 0xff__ffff 0xff__ffff 0xff__ffff 0xff__ffff))") + "unknown operator" +) +(assert_malformed + (module quote "(global v128 (v128.const f32x4 0x_1.0 0x_1.0 0x_1.0 0x_1.0))") + "unknown operator" +) +(assert_malformed + (module quote "(global v128 (v128.const f32x4 0x1.0_ 0x1.0_ 0x1.0_ 0x1.0_))") + "unknown operator" +) +(assert_malformed + (module quote "(global v128 (v128.const f32x4 0x1_.0 0x1_.0 0x1_.0 0x1_.0))") + "unknown operator" +) +(assert_malformed + (module quote "(global v128 (v128.const f32x4 0x1._0 0x1._0 0x1._0 0x1._0))") + "unknown operator" +) +(assert_malformed + (module quote "(global v128 (v128.const f32x4 0x_1p1 0x_1p1 0x_1p1 0x_1p1))") + "unknown operator" +) +(assert_malformed + (module quote "(global v128 (v128.const f32x4 0x1p1_ 0x1p1_ 0x1p1_ 0x1p1_))") + "unknown operator" +) +(assert_malformed + (module quote "(global v128 (v128.const f32x4 0x1_p1 0x1_p1 0x1_p1 0x1_p1))") + "unknown operator" +) +(assert_malformed + (module quote "(global v128 (v128.const f32x4 0x1p_1 0x1p_1 0x1p_1 0x1p_1))") + "unknown operator" +) +(assert_malformed + (module quote "(global v128 (v128.const f32x4 0x_1.0p1 0x_1.0p1 0x_1.0p1 0x_1.0p1))") + "unknown operator" +) +(assert_malformed + (module quote "(global v128 (v128.const f32x4 0x1.0p1_ 0x1.0p1_ 0x1.0p1_ 0x1.0p1_))") + "unknown operator" +) +(assert_malformed + (module quote "(global v128 (v128.const f32x4 0x1.0_p1 0x1.0_p1 0x1.0_p1 0x1.0_p1))") + "unknown operator" +) +(assert_malformed + (module quote "(global v128 (v128.const f32x4 0x1.0p_1 0x1.0p_1 0x1.0p_1 0x1.0p_1))") + "unknown operator" +) +(assert_malformed + (module quote "(global v128 (v128.const f32x4 0x1.0p+_1 0x1.0p+_1 0x1.0p+_1 0x1.0p+_1))") + "unknown operator" +) +(assert_malformed + (module quote "(global v128 (v128.const f32x4 0x1.0p_+1 0x1.0p_+1 0x1.0p_+1 0x1.0p_+1))") + "unknown operator" +) + +(assert_malformed + (module quote "(global v128 (v128.const f64x2 _100 _100))") + "unknown operator" +) +(assert_malformed + (module quote "(global v128 (v128.const f64x2 +_100 +_100))") + "unknown operator" +) +(assert_malformed + (module quote "(global v128 (v128.const f64x2 -_100 -_100))") + "unknown operator" +) +(assert_malformed + (module quote "(global v128 (v128.const f64x2 99_ 99_))") + "unknown operator" +) +(assert_malformed + (module quote "(global v128 (v128.const f64x2 1__000 1__000))") + "unknown operator" +) +(assert_malformed + (module quote "(global v128 (v128.const f64x2 _1.0 _1.0))") + "unknown operator" +) +(assert_malformed + (module quote "(global v128 (v128.const f64x2 1.0_ 1.0_))") + "unknown operator" +) +(assert_malformed + (module quote "(global v128 (v128.const f64x2 1_.0 1_.0))") + "unknown operator" +) +(assert_malformed + (module quote "(global v128 (v128.const f64x2 1._0 1._0))") + "unknown operator" +) +(assert_malformed + (module quote "(global v128 (v128.const f64x2 _1e1 _1e1))") + "unknown operator" +) +(assert_malformed + (module quote "(global v128 (v128.const f64x2 1e1_ 1e1_))") + "unknown operator" +) +(assert_malformed + (module quote "(global v128 (v128.const f64x2 1_e1 1_e1))") + "unknown operator" +) +(assert_malformed + (module quote "(global v128 (v128.const f64x2 1e_1 1e_1))") + "unknown operator" +) +(assert_malformed + (module quote "(global v128 (v128.const f64x2 _1.0e1 _1.0e1))") + "unknown operator" +) +(assert_malformed + (module quote "(global v128 (v128.const f64x2 1.0e1_ 1.0e1_))") + "unknown operator" +) +(assert_malformed + (module quote "(global v128 (v128.const f64x2 1.0_e1 1.0_e1))") + "unknown operator" +) +(assert_malformed + (module quote "(global v128 (v128.const f64x2 1.0e_1 1.0e_1))") + "unknown operator" +) +(assert_malformed + (module quote "(global v128 (v128.const f64x2 1.0e+_1 1.0e+_1))") + "unknown operator" +) +(assert_malformed + (module quote "(global v128 (v128.const f64x2 1.0e_+1 1.0e_+1))") + "unknown operator" +) +(assert_malformed + (module quote "(global v128 (v128.const f64x2 _0x100 _0x100))") + "unknown operator" +) +(assert_malformed + (module quote "(global v128 (v128.const f64x2 0_x100 0_x100))") + "unknown operator" +) +(assert_malformed + (module quote "(global v128 (v128.const f64x2 0x_100 0x_100))") + "unknown operator" +) +(assert_malformed + (module quote "(global v128 (v128.const f64x2 0x00_ 0x00_))") + "unknown operator" +) +(assert_malformed + (module quote "(global v128 (v128.const f64x2 0xff__ffff 0xff__ffff))") + "unknown operator" +) +(assert_malformed + (module quote "(global v128 (v128.const f64x2 0x_1.0 0x_1.0))") + "unknown operator" +) +(assert_malformed + (module quote "(global v128 (v128.const f64x2 0x1.0_ 0x1.0_))") + "unknown operator" +) +(assert_malformed + (module quote "(global v128 (v128.const f64x2 0x1_.0 0x1_.0))") + "unknown operator" +) +(assert_malformed + (module quote "(global v128 (v128.const f64x2 0x1._0 0x1._0))") + "unknown operator" +) +(assert_malformed + (module quote "(global v128 (v128.const f64x2 0x_1p1 0x_1p1))") + "unknown operator" +) +(assert_malformed + (module quote "(global v128 (v128.const f64x2 0x1p1_ 0x1p1_))") + "unknown operator" +) +(assert_malformed + (module quote "(global v128 (v128.const f64x2 0x1_p1 0x1_p1))") + "unknown operator" +) +(assert_malformed + (module quote "(global v128 (v128.const f64x2 0x1p_1 0x1p_1))") + "unknown operator" +) +(assert_malformed + (module quote "(global v128 (v128.const f64x2 0x_1.0p1 0x_1.0p1))") + "unknown operator" +) +(assert_malformed + (module quote "(global v128 (v128.const f64x2 0x1.0p1_ 0x1.0p1_))") + "unknown operator" +) +(assert_malformed + (module quote "(global v128 (v128.const f64x2 0x1.0_p1 0x1.0_p1))") + "unknown operator" +) +(assert_malformed + (module quote "(global v128 (v128.const f64x2 0x1.0p_1 0x1.0p_1))") + "unknown operator" +) +(assert_malformed + (module quote "(global v128 (v128.const f64x2 0x1.0p+_1 0x1.0p+_1))") + "unknown operator" +) +(assert_malformed + (module quote "(global v128 (v128.const f64x2 0x1.0p_+1 0x1.0p_+1))") + "unknown operator" +) + +;; Test parsing an integer from binary + +(module binary + "\00asm" "\01\00\00\00" + "\01\05\01" ;; type section + "\60\00\01\7b" ;; type 0 (func) + "\03\02\01\00" ;; func section + "\07\0f\01\0b" ;; export section + "\70\61\72\73\65\5f\69\38\78\31\36\00\00" ;; export name (parse_i8x16) + "\0a\16\01" ;; code section + "\14\00\fd\0c" ;; func body + "\00\00\00\00" ;; data lane 0~3 (0, 0, 0, 0) + "\80\80\80\80" ;; data lane 4~7 (-128, -128, -128, -128) + "\ff\ff\ff\ff" ;; data lane 8~11 (0xff, 0xff, 0xff, 0xff) + "\ff\ff\ff\ff" ;; data lane 12~15 (255, 255, 255, 255) + "\0b" ;; end +) +(assert_return (invoke "parse_i8x16") (v128.const i8x16 0 0 0 0 -128 -128 -128 -128 0xff 0xff 0xff 0xff 255 255 255 255)) + +(module binary + "\00asm" "\01\00\00\00" + "\01\05\01" ;; type section + "\60\00\01\7b" ;; type 0 (func) + "\03\02\01\00" ;; func section + "\07\0f\01\0b" ;; export section + "\70\61\72\73\65\5f\69\31\36\78\38\00\00" ;; export name (parse_i16x8) + "\0a\16\01" ;; code section + "\14\00\fd\0c" ;; func body + "\00\00\00\00" ;; data lane 0, 1 (0, 0) + "\00\80\00\80" ;; data lane 2, 3 (-32768, -32768) + "\ff\ff\ff\ff" ;; data lane 4, 5 (65535, 65535) + "\ff\ff\ff\ff" ;; data lane 6, 7 (0xffff, 0xffff) + "\0b" ;; end +) +(assert_return (invoke "parse_i16x8") (v128.const i16x8 0 0 -32768 -32768 65535 65535 0xffff 0xffff)) + +(module binary + "\00asm" "\01\00\00\00" + "\01\05\01" ;; type section + "\60\00\01\7b" ;; type 0 (func) + "\03\02\01\00" ;; func section + "\07\0f\01\0b" ;; export section + "\70\61\72\73\65\5f\69\33\32\78\34\00\00" ;; export name (parse_i32x4) + "\0a\16\01" ;; code section + "\14\00\fd\0c" ;; func body + "\d1\ff\ff\ff" ;; data lane 0 (4294967249) + "\d1\ff\ff\ff" ;; data lane 1 (4294967249) + "\d1\ff\ff\ff" ;; data lane 2 (4294967249) + "\d1\ff\ff\ff" ;; data lane 3 (4294967249) + "\0b" ;; end +) +(assert_return (invoke "parse_i32x4") (v128.const i32x4 4294967249 4294967249 4294967249 4294967249)) + +(module binary + "\00asm" "\01\00\00\00" + "\01\05\01" ;; type section + "\60\00\01\7b" ;; type 0 (func) + "\03\02\01\00" ;; func section + "\07\0f\01\0b" ;; export section + "\70\61\72\73\65\5f\69\36\34\78\32\00\00" ;; export name (parse_i64x2) + "\0a\16\01" ;; code section + "\14\00\fd\0c" ;; func body + "\ff\ff\ff\ff\ff\ff\ff\7f" ;; data lane 0 (9223372036854775807) + "\ff\ff\ff\ff\ff\ff\ff\7f" ;; data lane 1 (9223372036854775807) + "\0b" ;; end +) +(assert_return (invoke "parse_i64x2") (v128.const i64x2 9223372036854775807 9223372036854775807)) + +;; Test parsing a float from binary + +(module binary + "\00asm" "\01\00\00\00" + "\01\05\01" ;; type section + "\60\00\01\7b" ;; type 0 (func) + "\03\02\01\00" ;; func section + "\07\0f\01\0b" ;; export section + "\70\61\72\73\65\5f\66\33\32\78\34\00\00" ;; export name (parse_f32x4) + "\0a\16\01" ;; code section + "\14\00\fd\0c" ;; func body + "\00\00\80\4f" ;; data lane 0 (4294967249) + "\00\00\80\4f" ;; data lane 1 (4294967249) + "\00\00\80\4f" ;; data lane 2 (4294967249) + "\00\00\80\4f" ;; data lane 3 (4294967249) + "\0b" ;; end +) +(assert_return (invoke "parse_f32x4") (v128.const f32x4 4294967249 4294967249 4294967249 4294967249)) + +(module binary + "\00asm" "\01\00\00\00" + "\01\05\01" ;; type section + "\60\00\01\7b" ;; type 0 (func) + "\03\02\01\00" ;; func section + "\07\0f\01\0b" ;; export section + "\70\61\72\73\65\5f\66\36\34\78\32\00\00" ;; export name (parse_f64x2) + "\0a\16\01" ;; code section + "\14\00\fd\0c" ;; func body + "\ff\ff\ff\ff\ff\ff\ef\7f" ;; data lane 0 (0x1.fffffffffffffp+1023) + "\ff\ff\ff\ff\ff\ff\ef\7f" ;; data lane 1 (0x1.fffffffffffffp+1023) + "\0b" ;; end +) +(assert_return (invoke "parse_f64x2") (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) diff --git a/runtime/near-vm/tests/wast/spec/proposals/simd/simd_conversions.wast b/runtime/near-vm/tests/wast/spec/proposals/simd/simd_conversions.wast new file mode 100644 index 00000000000..552e9436123 --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/proposals/simd/simd_conversions.wast @@ -0,0 +1,899 @@ +;; Web Assembly SIMD-related type conversion tests + +(module + ;; Integer to floating point + (func (export "f32x4.convert_i32x4_s") (param v128) (result v128) + (f32x4.convert_i32x4_s (local.get 0))) + (func (export "f32x4.convert_i32x4_u") (param v128) (result v128) + (f32x4.convert_i32x4_u (local.get 0))) + + (func (export "f64x2.convert_low_i32x4_s") (param v128) (result v128) + (f64x2.convert_low_i32x4_s (local.get 0))) + (func (export "f64x2.convert_low_i32x4_u") (param v128) (result v128) + (f64x2.convert_low_i32x4_u (local.get 0))) + + ;; Integer to integer narrowing + (func (export "i8x16.narrow_i16x8_s") (param v128 v128) (result v128) + (i8x16.narrow_i16x8_s (local.get 0) (local.get 1))) + (func (export "i8x16.narrow_i16x8_u") (param v128 v128) (result v128) + (i8x16.narrow_i16x8_u (local.get 0) (local.get 1))) + (func (export "i16x8.narrow_i32x4_s") (param v128 v128) (result v128) + (i16x8.narrow_i32x4_s (local.get 0) (local.get 1))) + (func (export "i16x8.narrow_i32x4_u") (param v128 v128) (result v128) + (i16x8.narrow_i32x4_u (local.get 0)(local.get 1))) + + ;; Float to float promote/demote + (func (export "f64x2.promote_low_f32x4") (param v128) (result v128) + (f64x2.promote_low_f32x4 (local.get 0))) + (func (export "f32x4.demote_f64x2_zero") (param v128) (result v128) + (f32x4.demote_f64x2_zero (local.get 0))) +) + +;; f64x2.promote_low_f32x4 +;; Float constants copied from test/core/conversions.wast. + +(assert_return (invoke "f64x2.promote_low_f32x4" (v128.const f32x4 0.0 0.0 0.0 0.0)) + (v128.const f64x2 0.0 0.0)) +(assert_return (invoke "f64x2.promote_low_f32x4" (v128.const f32x4 -0.0 -0.0 -0.0 -0.0)) + (v128.const f64x2 -0.0 -0.0)) +(assert_return (invoke "f64x2.promote_low_f32x4" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f64x2 0x1p-149 0x1p-149)) +(assert_return (invoke "f64x2.promote_low_f32x4" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f64x2 -0x1p-149 -0x1p-149)) +(assert_return (invoke "f64x2.promote_low_f32x4" (v128.const f32x4 1.0 1.0 1.0 1.0)) + (v128.const f64x2 1.0 1.0)) +(assert_return (invoke "f64x2.promote_low_f32x4" (v128.const f32x4 -1.0 -1.0 -1.0 -1.0)) + (v128.const f64x2 -1.0 -1.0)) +(assert_return (invoke "f64x2.promote_low_f32x4" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f64x2 -0x1.fffffep+127 -0x1.fffffep+127)) +(assert_return (invoke "f64x2.promote_low_f32x4" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f64x2 0x1.fffffep+127 0x1.fffffep+127)) +;; Generated randomly by picking a random int and reinterpret it to float. +(assert_return (invoke "f64x2.promote_low_f32x4" (v128.const f32x4 0x1p-119 0x1p-119 0x1p-119 0x1p-119)) + (v128.const f64x2 0x1p-119 0x1p-119)) +;; Generated randomly by picking a random float. +(assert_return (invoke "f64x2.promote_low_f32x4" (v128.const f32x4 0x1.8f867ep+125 0x1.8f867ep+125 0x1.8f867ep+125 0x1.8f867ep+125)) + (v128.const f64x2 6.6382536710104395e+37 6.6382536710104395e+37)) +(assert_return (invoke "f64x2.promote_low_f32x4" (v128.const f32x4 inf inf inf inf)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.promote_low_f32x4" (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.promote_low_f32x4" (v128.const f32x4 nan nan nan nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.promote_low_f32x4" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.promote_low_f32x4" (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.promote_low_f32x4" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) + +;; f32x4.demote_f64x2_zero +;; Float constants copied from test/core/conversions.wast. + +(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 0.0 0.0)) + (v128.const f32x4 0.0 0.0 0 0)) +(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 -0.0 -0.0)) + (v128.const f32x4 -0.0 -0.0 0 0)) +(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f32x4 0.0 0.0 0 0)) +(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022)) + (v128.const f32x4 -0.0 -0.0 0 0)) +(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 1.0 1.0)) + (v128.const f32x4 1.0 1.0 0 0)) +(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 -1.0 -1.0)) + (v128.const f32x4 -1.0 -1.0 0 0)) +(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 0x1.fffffe0000000p-127 0x1.fffffe0000000p-127)) + (v128.const f32x4 0x1p-126 0x1p-126 0 0)) +(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 -0x1.fffffe0000000p-127 -0x1.fffffe0000000p-127)) + (v128.const f32x4 -0x1p-126 -0x1p-126 0 0)) +(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 0x1.fffffdfffffffp-127 0x1.fffffdfffffffp-127)) + (v128.const f32x4 0x1.fffffcp-127 0x1.fffffcp-127 0 0)) +(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 -0x1.fffffdfffffffp-127 -0x1.fffffdfffffffp-127)) + (v128.const f32x4 -0x1.fffffcp-127 -0x1.fffffcp-127 0 0)) +(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 0x1p-149 0x1p-149)) + (v128.const f32x4 0x1p-149 0x1p-149 0 0)) +(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 -0x1p-149 -0x1p-149)) + (v128.const f32x4 -0x1p-149 -0x1p-149 0 0)) +(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 0x1.fffffd0000000p+127 0x1.fffffd0000000p+127)) + (v128.const f32x4 0x1.fffffcp+127 0x1.fffffcp+127 0 0)) +(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 -0x1.fffffd0000000p+127 -0x1.fffffd0000000p+127)) + (v128.const f32x4 -0x1.fffffcp+127 -0x1.fffffcp+127 0 0)) +(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 0x1.fffffd0000001p+127 0x1.fffffd0000001p+127)) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0 0)) +(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 -0x1.fffffd0000001p+127 -0x1.fffffd0000001p+127)) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 0 0)) +(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0 0)) +(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 0 0)) +(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 0x1.fffffefffffffp+127 0x1.fffffefffffffp+127)) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0 0)) +(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 -0x1.fffffefffffffp+127 -0x1.fffffefffffffp+127)) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 0 0)) +(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 0x1.ffffffp+127 0x1.ffffffp+127)) + (v128.const f32x4 inf inf 0 0)) +(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 -0x1.ffffffp+127 -0x1.ffffffp+127)) + (v128.const f32x4 -inf -inf 0 0)) +(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 0x1p-119 0x1p-119)) + (v128.const f32x4 0x1p-119 0x1p-119 0 0)) +(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 0x1.8f867ep+125 0x1.8f867ep+125)) + (v128.const f32x4 0x1.8f867ep+125 0x1.8f867ep+125 0 0)) +(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 inf inf)) + (v128.const f32x4 inf inf 0 0)) +(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 -inf -inf)) + (v128.const f32x4 -inf -inf 0 0)) +(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 0x1.0000000000001p+0 0x1.0000000000001p+0)) + (v128.const f32x4 1.0 1.0 0 0)) +(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 0x1.fffffffffffffp-1 0x1.fffffffffffffp-1)) + (v128.const f32x4 1.0 1.0 0 0)) +(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 0x1.0000010000000p+0 0x1.0000010000000p+0)) + (v128.const f32x4 0x1.000000p+0 0x1.000000p+0 0 0)) +(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 0x1.0000010000001p+0 0x1.0000010000001p+0)) + (v128.const f32x4 0x1.000002p+0 0x1.000002p+0 0 0)) +(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 0x1.000002fffffffp+0 0x1.000002fffffffp+0)) + (v128.const f32x4 0x1.000002p+0 0x1.000002p+0 0 0)) +(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 0x1.0000030000000p+0 0x1.0000030000000p+0)) + (v128.const f32x4 0x1.000004p+0 0x1.000004p+0 0 0)) +(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 0x1.0000050000000p+0 0x1.0000050000000p+0)) + (v128.const f32x4 0x1.000004p+0 0x1.000004p+0 0 0)) +(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 0x1.0000010000000p+24 0x1.0000010000000p+24)) + (v128.const f32x4 0x1.0p+24 0x1.0p+24 0 0)) +(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 0x1.0000010000001p+24 0x1.0000010000001p+24)) + (v128.const f32x4 0x1.000002p+24 0x1.000002p+24 0 0)) +(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 0x1.000002fffffffp+24 0x1.000002fffffffp+24)) + (v128.const f32x4 0x1.000002p+24 0x1.000002p+24 0 0)) +(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 0x1.0000030000000p+24 0x1.0000030000000p+24)) + (v128.const f32x4 0x1.000004p+24 0x1.000004p+24 0 0)) +(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 0x1.4eae4f7024c7p+108 0x1.4eae4f7024c7p+108)) + (v128.const f32x4 0x1.4eae5p+108 0x1.4eae5p+108 0 0)) +(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 0x1.a12e71e358685p-113 0x1.a12e71e358685p-113)) + (v128.const f32x4 0x1.a12e72p-113 0x1.a12e72p-113 0 0)) +(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 0x1.cb98354d521ffp-127 0x1.cb98354d521ffp-127)) + (v128.const f32x4 0x1.cb9834p-127 0x1.cb9834p-127 0 0)) +(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 -0x1.6972b30cfb562p+1 -0x1.6972b30cfb562p+1)) + (v128.const f32x4 -0x1.6972b4p+1 -0x1.6972b4p+1 0 0)) +(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 -0x1.bedbe4819d4c4p+112 -0x1.bedbe4819d4c4p+112)) + (v128.const f32x4 -0x1.bedbe4p+112 -0x1.bedbe4p+112 0 0)) +(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 nan nan)) + (v128.const f32x4 nan:canonical nan:canonical 0 0)) +(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic 0 0)) +(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 -nan -nan)) + (v128.const f32x4 nan:canonical nan:canonical 0 0)) +(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic 0 0)) +(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f32x4 0.0 0.0 0 0)) +(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f32x4 -0.0 -0.0 0 0)) +(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 0x1.0p-150 0x1.0p-150)) + (v128.const f32x4 0.0 0.0 0 0)) +(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 -0x1.0p-150 -0x1.0p-150)) + (v128.const f32x4 -0.0 -0.0 0 0)) +(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 0x1.0000000000001p-150 0x1.0000000000001p-150)) + (v128.const f32x4 0x1p-149 0x1p-149 0 0)) +(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 -0x1.0000000000001p-150 -0x1.0000000000001p-150)) + (v128.const f32x4 -0x1p-149 -0x1p-149 0 0)) + + +;; Integer to floating point +;; f32x4.convert_i32x4_s + +(assert_return (invoke "f32x4.convert_i32x4_s" (v128.const i32x4 0 0 0 0)) + (v128.const f32x4 0.0 0.0 0.0 0.0)) +(assert_return (invoke "f32x4.convert_i32x4_s" (v128.const i32x4 1 1 1 1)) + (v128.const f32x4 1.0 1.0 1.0 1.0)) +(assert_return (invoke "f32x4.convert_i32x4_s" (v128.const i32x4 -1 -1 -1 -1)) + (v128.const f32x4 -1.0 -1.0 -1.0 -1.0)) +(assert_return (invoke "f32x4.convert_i32x4_s" (v128.const i32x4 2147483647 2147483647 2147483647 2147483647)) + (v128.const f32x4 2147483647.0 2147483647.0 2147483647.0 2147483647.0)) +(assert_return (invoke "f32x4.convert_i32x4_s" (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648)) + (v128.const f32x4 -2147483648.0 -2147483648.0 -2147483648.0 -2147483648.0)) +(assert_return (invoke "f32x4.convert_i32x4_s" (v128.const i32x4 1234567890 1234567890 1234567890 1234567890)) + (v128.const f32x4 0x1.26580cp+30 0x1.26580cp+30 0x1.26580cp+30 0x1.26580cp+30)) +(assert_return (invoke "f32x4.convert_i32x4_s" (v128.const i32x4 0_123_456_792 0_123_456_792 0_123_456_792 0_123_456_792)) + (v128.const f32x4 123456792.0 123456792.0 123456792.0 123456792.0)) +(assert_return (invoke "f32x4.convert_i32x4_s" (v128.const i32x4 0x0_1234_5680 0x0_1234_5680 0x0_1234_5680 0x0_1234_5680)) + (v128.const f32x4 305419904.0 305419904.0 305419904.0 305419904.0)) +;; Test rounding directions. + +(assert_return (invoke "f32x4.convert_i32x4_s" (v128.const i32x4 16777217 16777217 16777217 16777217)) + (v128.const f32x4 16777216.0 16777216.0 16777216.0 16777216.0)) +(assert_return (invoke "f32x4.convert_i32x4_s" (v128.const i32x4 -16777217 -16777217 -16777217 -16777217)) + (v128.const f32x4 -16777216.0 -16777216.0 -16777216.0 -16777216.0)) +(assert_return (invoke "f32x4.convert_i32x4_s" (v128.const i32x4 16777219 16777219 16777219 16777219)) + (v128.const f32x4 16777220.0 16777220.0 16777220.0 16777220.0)) +(assert_return (invoke "f32x4.convert_i32x4_s" (v128.const i32x4 -16777219 -16777219 -16777219 -16777219)) + (v128.const f32x4 -16777220.0 -16777220.0 -16777220.0 -16777220.0)) +(assert_return (invoke "f32x4.convert_i32x4_s" (v128.const i32x4 0 -1 0x7fffffff 0x80000000)) + (v128.const f32x4 0.0 -1.0 2147483647.0 -2147483648.0)) + +;; f32x4.convert_i32x4_u + +(assert_return (invoke "f32x4.convert_i32x4_u" (v128.const i32x4 0 0 0 0)) + (v128.const f32x4 0.0 0.0 0.0 0.0)) +(assert_return (invoke "f32x4.convert_i32x4_u" (v128.const i32x4 1 1 1 1)) + (v128.const f32x4 1.0 1.0 1.0 1.0)) +(assert_return (invoke "f32x4.convert_i32x4_u" (v128.const i32x4 -1 -1 -1 -1)) + (v128.const f32x4 4294967295.0 4294967295.0 4294967295.0 4294967295.0)) +(assert_return (invoke "f32x4.convert_i32x4_u" (v128.const i32x4 2147483647 2147483647 2147483647 2147483647)) + (v128.const f32x4 2147483648.0 2147483648.0 2147483648.0 2147483648.0)) +(assert_return (invoke "f32x4.convert_i32x4_u" (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648)) + (v128.const f32x4 2147483648.0 2147483648.0 2147483648.0 2147483648.0)) +(assert_return (invoke "f32x4.convert_i32x4_u" (v128.const i32x4 0x12345678 0x12345678 0x12345678 0x12345678)) + (v128.const f32x4 0x1.234568p+28 0x1.234568p+28 0x1.234568p+28 0x1.234568p+28)) +(assert_return (invoke "f32x4.convert_i32x4_u" (v128.const i32x4 0x80000080 0x80000080 0x80000080 0x80000080)) + (v128.const f32x4 0x1.000000p+31 0x1.000000p+31 0x1.000000p+31 0x1.000000p+31)) +(assert_return (invoke "f32x4.convert_i32x4_u" (v128.const i32x4 0x80000081 0x80000081 0x80000081 0x80000081)) + (v128.const f32x4 0x1.000002p+31 0x1.000002p+31 0x1.000002p+31 0x1.000002p+31)) +(assert_return (invoke "f32x4.convert_i32x4_u" (v128.const i32x4 0x80000082 0x80000082 0x80000082 0x80000082)) + (v128.const f32x4 0x1.000002p+31 0x1.000002p+31 0x1.000002p+31 0x1.000002p+31)) +(assert_return (invoke "f32x4.convert_i32x4_u" (v128.const i32x4 0xfffffe80 0xfffffe80 0xfffffe80 0xfffffe80)) + (v128.const f32x4 0x1.fffffcp+31 0x1.fffffcp+31 0x1.fffffcp+31 0x1.fffffcp+31)) +(assert_return (invoke "f32x4.convert_i32x4_u" (v128.const i32x4 0xfffffe81 0xfffffe81 0xfffffe81 0xfffffe81)) + (v128.const f32x4 0x1.fffffep+31 0x1.fffffep+31 0x1.fffffep+31 0x1.fffffep+31)) +(assert_return (invoke "f32x4.convert_i32x4_u" (v128.const i32x4 0xfffffe82 0xfffffe82 0xfffffe82 0xfffffe82)) + (v128.const f32x4 0x1.fffffep+31 0x1.fffffep+31 0x1.fffffep+31 0x1.fffffep+31)) +(assert_return (invoke "f32x4.convert_i32x4_u" (v128.const i32x4 0_123_456_792 0_123_456_792 0_123_456_792 0_123_456_792)) + (v128.const f32x4 123456792.0 123456792.0 123456792.0 123456792.0)) +(assert_return (invoke "f32x4.convert_i32x4_u" (v128.const i32x4 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef)) + (v128.const f32x4 2427178496.0 2427178496.0 2427178496.0 2427178496.0)) +;; Test rounding directions. + +(assert_return (invoke "f32x4.convert_i32x4_u" (v128.const i32x4 16777217 16777217 16777217 16777217)) + (v128.const f32x4 16777216.0 16777216.0 16777216.0 16777216.0)) +(assert_return (invoke "f32x4.convert_i32x4_u" (v128.const i32x4 16777219 16777219 16777219 16777219)) + (v128.const f32x4 16777220.0 16777220.0 16777220.0 16777220.0)) +(assert_return (invoke "f32x4.convert_i32x4_u" (v128.const i32x4 0 -1 0x7fffffff 0x80000000)) + (v128.const f32x4 0.0 4294967295.0 2147483647.0 2147483648.0)) + +;; f64x2.convert_i32x4_s +;; constants copied from test/core/conversions.wast. + +(assert_return (invoke "f64x2.convert_low_i32x4_s" (v128.const i32x4 1 1 0 0)) + (v128.const f64x2 1.0 1.0)) +(assert_return (invoke "f64x2.convert_low_i32x4_s" (v128.const i32x4 -1 -1 0 0)) + (v128.const f64x2 -1.0 -1.0)) +(assert_return (invoke "f64x2.convert_low_i32x4_s" (v128.const i32x4 0 0 0 0)) + (v128.const f64x2 0.0 0.0)) +(assert_return (invoke "f64x2.convert_low_i32x4_s" (v128.const i32x4 2147483647 2147483647 0 0)) + (v128.const f64x2 2147483647 2147483647)) +(assert_return (invoke "f64x2.convert_low_i32x4_s" (v128.const i32x4 -2147483648 -2147483648 0 0)) + (v128.const f64x2 -2147483648 -2147483648)) +(assert_return (invoke "f64x2.convert_low_i32x4_s" (v128.const i32x4 987654321 987654321 0 0)) + (v128.const f64x2 987654321 987654321)) + +;; f64x2.convert_i32x4_u +;; constants copied from test/core/conversions.wast. + +(assert_return (invoke "f64x2.convert_low_i32x4_u" (v128.const i32x4 1 1 0 0)) + (v128.const f64x2 1.0 1.0)) +(assert_return (invoke "f64x2.convert_low_i32x4_u" (v128.const i32x4 0 0 0 0)) + (v128.const f64x2 0.0 0.0)) +(assert_return (invoke "f64x2.convert_low_i32x4_u" (v128.const i32x4 2147483647 2147483647 0 0)) + (v128.const f64x2 2147483647 2147483647)) +(assert_return (invoke "f64x2.convert_low_i32x4_u" (v128.const i32x4 -2147483648 -2147483648 0 0)) + (v128.const f64x2 2147483648 2147483648)) +(assert_return (invoke "f64x2.convert_low_i32x4_u" (v128.const i32x4 0xffffffff 0xffffffff 0 0)) + (v128.const f64x2 4294967295.0 4294967295.0)) + +;; Integer to integer narrowing +;; i8x16.narrow_i16x8_s + +(assert_return (invoke "i8x16.narrow_i16x8_s" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i16x8 0 0 0 0 0 0 0 0)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i8x16.narrow_i16x8_s" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i16x8 1 1 1 1 1 1 1 1)) + (v128.const i8x16 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1)) +(assert_return (invoke "i8x16.narrow_i16x8_s" (v128.const i16x8 1 1 1 1 1 1 1 1) + (v128.const i16x8 0 0 0 0 0 0 0 0)) + (v128.const i8x16 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i8x16.narrow_i16x8_s" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i8x16 0 0 0 0 0 0 0 0 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "i8x16.narrow_i16x8_s" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1) + (v128.const i16x8 0 0 0 0 0 0 0 0)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i8x16.narrow_i16x8_s" (v128.const i16x8 1 1 1 1 1 1 1 1) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i8x16 1 1 1 1 1 1 1 1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "i8x16.narrow_i16x8_s" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1) + (v128.const i16x8 1 1 1 1 1 1 1 1)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 1 1 1 1 1 1 1 1)) +(assert_return (invoke "i8x16.narrow_i16x8_s" (v128.const i16x8 0x7e 0x7e 0x7e 0x7e 0x7e 0x7e 0x7e 0x7e) + (v128.const i16x8 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f)) + (v128.const i8x16 0x7e 0x7e 0x7e 0x7e 0x7e 0x7e 0x7e 0x7e 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f)) +(assert_return (invoke "i8x16.narrow_i16x8_s" (v128.const i16x8 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f) + (v128.const i16x8 0x7e 0x7e 0x7e 0x7e 0x7e 0x7e 0x7e 0x7e)) + (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7e 0x7e 0x7e 0x7e 0x7e 0x7e 0x7e 0x7e)) +(assert_return (invoke "i8x16.narrow_i16x8_s" (v128.const i16x8 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f) + (v128.const i16x8 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f)) + (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f)) +(assert_return (invoke "i8x16.narrow_i16x8_s" (v128.const i16x8 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80) + (v128.const i16x8 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)) + (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f)) +(assert_return (invoke "i8x16.narrow_i16x8_s" (v128.const i16x8 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f) + (v128.const i16x8 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)) + (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f)) +(assert_return (invoke "i8x16.narrow_i16x8_s" (v128.const i16x8 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80) + (v128.const i16x8 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f)) + (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f)) +(assert_return (invoke "i8x16.narrow_i16x8_s" (v128.const i16x8 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f) + (v128.const i16x8 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff)) + (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f)) +(assert_return (invoke "i8x16.narrow_i16x8_s" (v128.const i16x8 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff) + (v128.const i16x8 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f)) + (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f)) +(assert_return (invoke "i8x16.narrow_i16x8_s" (v128.const i16x8 -0x7f -0x7f -0x7f -0x7f -0x7f -0x7f -0x7f -0x7f) + (v128.const i16x8 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80)) + (v128.const i8x16 0x81 0x81 0x81 0x81 0x81 0x81 0x81 0x81 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80)) +(assert_return (invoke "i8x16.narrow_i16x8_s" (v128.const i16x8 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80) + (v128.const i16x8 -0x7f -0x7f -0x7f -0x7f -0x7f -0x7f -0x7f -0x7f)) + (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x81 0x81 0x81 0x81 0x81 0x81 0x81 0x81)) +(assert_return (invoke "i8x16.narrow_i16x8_s" (v128.const i16x8 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80) + (v128.const i16x8 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80)) + (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)) +(assert_return (invoke "i8x16.narrow_i16x8_s" (v128.const i16x8 -0x81 -0x81 -0x81 -0x81 -0x81 -0x81 -0x81 -0x81) + (v128.const i16x8 -0x81 -0x81 -0x81 -0x81 -0x81 -0x81 -0x81 -0x81)) + (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)) +(assert_return (invoke "i8x16.narrow_i16x8_s" (v128.const i16x8 -0x81 -0x81 -0x81 -0x81 -0x81 -0x81 -0x81 -0x81) + (v128.const i16x8 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80)) + (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)) +(assert_return (invoke "i8x16.narrow_i16x8_s" (v128.const i16x8 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80) + (v128.const i16x8 -0x81 -0x81 -0x81 -0x81 -0x81 -0x81 -0x81 -0x81)) + (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)) +(assert_return (invoke "i8x16.narrow_i16x8_s" (v128.const i16x8 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80) + (v128.const i16x8 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f)) + (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f)) +(assert_return (invoke "i8x16.narrow_i16x8_s" (v128.const i16x8 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80) + (v128.const i16x8 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)) + (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f)) +(assert_return (invoke "i8x16.narrow_i16x8_s" (v128.const i16x8 -0x81 -0x81 -0x81 -0x81 -0x81 -0x81 -0x81 -0x81) + (v128.const i16x8 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f)) + (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f)) +(assert_return (invoke "i8x16.narrow_i16x8_s" (v128.const i16x8 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80) + (v128.const i16x8 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff)) + (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f)) +(assert_return (invoke "i8x16.narrow_i16x8_s" (v128.const i16x8 -0x81 -0x81 -0x81 -0x81 -0x81 -0x81 -0x81 -0x81) + (v128.const i16x8 0x100 0x100 0x100 0x100 0x100 0x100 0x100 0x100)) + (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f)) +(assert_return (invoke "i8x16.narrow_i16x8_s" (v128.const i16x8 -0x8000 -0x8000 -0x8000 -0x8000 -0x8000 -0x8000 -0x8000 -0x8000) + (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff)) + (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff)) +(assert_return (invoke "i8x16.narrow_i16x8_s" (v128.const i16x8 012_345 012_345 012_345 012_345 012_345 012_345 012_345 012_345) + (v128.const i16x8 056_789 056_789 056_789 056_789 056_789 056_789 056_789 056_789)) + (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)) +(assert_return (invoke "i8x16.narrow_i16x8_s" (v128.const i16x8 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234) + (v128.const i16x8 0x0_5678 0x0_5678 0x0_5678 0x0_5678 0x0_5678 0x0_5678 0x0_5678 0x0_5678)) + (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f)) +;; i8x16.narrow_i16x8_u + +(assert_return (invoke "i8x16.narrow_i16x8_u" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i16x8 0 0 0 0 0 0 0 0)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i8x16.narrow_i16x8_u" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i16x8 1 1 1 1 1 1 1 1)) + (v128.const i8x16 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1)) +(assert_return (invoke "i8x16.narrow_i16x8_u" (v128.const i16x8 1 1 1 1 1 1 1 1) + (v128.const i16x8 0 0 0 0 0 0 0 0)) + (v128.const i8x16 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i8x16.narrow_i16x8_u" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i8x16.narrow_i16x8_u" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1) + (v128.const i16x8 0 0 0 0 0 0 0 0)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i8x16.narrow_i16x8_u" (v128.const i16x8 1 1 1 1 1 1 1 1) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i8x16 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i8x16.narrow_i16x8_u" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1) + (v128.const i16x8 1 1 1 1 1 1 1 1)) + (v128.const i8x16 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1)) +(assert_return (invoke "i8x16.narrow_i16x8_u" (v128.const i16x8 0x7e 0x7e 0x7e 0x7e 0x7e 0x7e 0x7e 0x7e) + (v128.const i16x8 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f)) + (v128.const i8x16 0x7e 0x7e 0x7e 0x7e 0x7e 0x7e 0x7e 0x7e 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f)) +(assert_return (invoke "i8x16.narrow_i16x8_u" (v128.const i16x8 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f) + (v128.const i16x8 0x7e 0x7e 0x7e 0x7e 0x7e 0x7e 0x7e 0x7e)) + (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7e 0x7e 0x7e 0x7e 0x7e 0x7e 0x7e 0x7e)) +(assert_return (invoke "i8x16.narrow_i16x8_u" (v128.const i16x8 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f) + (v128.const i16x8 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f)) + (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f)) +(assert_return (invoke "i8x16.narrow_i16x8_u" (v128.const i16x8 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80) + (v128.const i16x8 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)) + (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)) +(assert_return (invoke "i8x16.narrow_i16x8_u" (v128.const i16x8 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f) + (v128.const i16x8 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)) + (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)) +(assert_return (invoke "i8x16.narrow_i16x8_u" (v128.const i16x8 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80) + (v128.const i16x8 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f)) + (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f)) +(assert_return (invoke "i8x16.narrow_i16x8_u" (v128.const i16x8 0xfe 0xfe 0xfe 0xfe 0xfe 0xfe 0xfe 0xfe) + (v128.const i16x8 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff)) + (v128.const i8x16 0xfe 0xfe 0xfe 0xfe 0xfe 0xfe 0xfe 0xfe 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff)) +(assert_return (invoke "i8x16.narrow_i16x8_u" (v128.const i16x8 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff) + (v128.const i16x8 0xfe 0xfe 0xfe 0xfe 0xfe 0xfe 0xfe 0xfe)) + (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xfe 0xfe 0xfe 0xfe 0xfe 0xfe 0xfe 0xfe)) +(assert_return (invoke "i8x16.narrow_i16x8_u" (v128.const i16x8 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff) + (v128.const i16x8 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff)) + (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff)) +(assert_return (invoke "i8x16.narrow_i16x8_u" (v128.const i16x8 0x100 0x100 0x100 0x100 0x100 0x100 0x100 0x100) + (v128.const i16x8 0x100 0x100 0x100 0x100 0x100 0x100 0x100 0x100)) + (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff)) +(assert_return (invoke "i8x16.narrow_i16x8_u" (v128.const i16x8 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff) + (v128.const i16x8 0x100 0x100 0x100 0x100 0x100 0x100 0x100 0x100)) + (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff)) +(assert_return (invoke "i8x16.narrow_i16x8_u" (v128.const i16x8 0x100 0x100 0x100 0x100 0x100 0x100 0x100 0x100) + (v128.const i16x8 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff)) + (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff)) +(assert_return (invoke "i8x16.narrow_i16x8_u" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i16x8 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff)) +(assert_return (invoke "i8x16.narrow_i16x8_u" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i16x8 0x100 0x100 0x100 0x100 0x100 0x100 0x100 0x100)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff)) +(assert_return (invoke "i8x16.narrow_i16x8_u" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1) + (v128.const i16x8 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff)) +(assert_return (invoke "i8x16.narrow_i16x8_u" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1) + (v128.const i16x8 0x100 0x100 0x100 0x100 0x100 0x100 0x100 0x100)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff)) +(assert_return (invoke "i8x16.narrow_i16x8_u" (v128.const i16x8 -0x8000 -0x8000 -0x8000 -0x8000 -0x8000 -0x8000 -0x8000 -0x8000) + (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i8x16.narrow_i16x8_u" (v128.const i16x8 056_789 056_789 056_789 056_789 056_789 056_789 056_789 056_789) + (v128.const i16x8 012_345 012_345 012_345 012_345 012_345 012_345 012_345 012_345)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff)) +(assert_return (invoke "i8x16.narrow_i16x8_u" (v128.const i16x8 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB) + (v128.const i16x8 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff)) +;; i16x8.narrow_i32x4_s + +(assert_return (invoke "i16x8.narrow_i32x4_s" (v128.const i32x4 0 0 0 0) + (v128.const i32x4 0 0 0 0)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.narrow_i32x4_s" (v128.const i32x4 0 0 0 0) + (v128.const i32x4 1 1 1 1)) + (v128.const i16x8 0 0 0 0 1 1 1 1)) +(assert_return (invoke "i16x8.narrow_i32x4_s" (v128.const i32x4 1 1 1 1) + (v128.const i32x4 0 0 0 0)) + (v128.const i16x8 1 1 1 1 0 0 0 0)) +(assert_return (invoke "i16x8.narrow_i32x4_s" (v128.const i32x4 0 0 0 0) + (v128.const i32x4 -1 -1 -1 -1)) + (v128.const i16x8 0 0 0 0 -1 -1 -1 -1)) +(assert_return (invoke "i16x8.narrow_i32x4_s" (v128.const i32x4 -1 -1 -1 -1) + (v128.const i32x4 0 0 0 0)) + (v128.const i16x8 -1 -1 -1 -1 0 0 0 0)) +(assert_return (invoke "i16x8.narrow_i32x4_s" (v128.const i32x4 1 1 1 1) + (v128.const i32x4 -1 -1 -1 -1)) + (v128.const i16x8 1 1 1 1 -1 -1 -1 -1)) +(assert_return (invoke "i16x8.narrow_i32x4_s" (v128.const i32x4 -1 -1 -1 -1) + (v128.const i32x4 1 1 1 1)) + (v128.const i16x8 -1 -1 -1 -1 1 1 1 1)) +(assert_return (invoke "i16x8.narrow_i32x4_s" (v128.const i32x4 0x7ffe 0x7ffe 0x7ffe 0x7ffe) + (v128.const i32x4 0x7fff 0x7fff 0x7fff 0x7fff)) + (v128.const i16x8 0x7ffe 0x7ffe 0x7ffe 0x7ffe 0x7fff 0x7fff 0x7fff 0x7fff)) +(assert_return (invoke "i16x8.narrow_i32x4_s" (v128.const i32x4 0x7fff 0x7fff 0x7fff 0x7fff) + (v128.const i32x4 0x7ffe 0x7ffe 0x7ffe 0x7ffe)) + (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7ffe 0x7ffe 0x7ffe 0x7ffe)) +(assert_return (invoke "i16x8.narrow_i32x4_s" (v128.const i32x4 0x7fff 0x7fff 0x7fff 0x7fff) + (v128.const i32x4 0x7fff 0x7fff 0x7fff 0x7fff)) + (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff)) +(assert_return (invoke "i16x8.narrow_i32x4_s" (v128.const i32x4 0x8000 0x8000 0x8000 0x8000) + (v128.const i32x4 0x8000 0x8000 0x8000 0x8000)) + (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff)) +(assert_return (invoke "i16x8.narrow_i32x4_s" (v128.const i32x4 0x7fff 0x7fff 0x7fff 0x7fff) + (v128.const i32x4 0x8000 0x8000 0x8000 0x8000)) + (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff)) +(assert_return (invoke "i16x8.narrow_i32x4_s" (v128.const i32x4 0x8000 0x8000 0x8000 0x8000) + (v128.const i32x4 0x7fff 0x7fff 0x7fff 0x7fff)) + (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff)) +(assert_return (invoke "i16x8.narrow_i32x4_s" (v128.const i32x4 0x7fff 0x7fff 0x7fff 0x7fff) + (v128.const i32x4 0xffff 0xffff 0xffff 0xffff)) + (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff)) +(assert_return (invoke "i16x8.narrow_i32x4_s" (v128.const i32x4 0xffff 0xffff 0xffff 0xffff) + (v128.const i32x4 0x7fff 0x7fff 0x7fff 0x7fff)) + (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff)) +(assert_return (invoke "i16x8.narrow_i32x4_s" (v128.const i32x4 -0x7fff -0x7fff -0x7fff -0x7fff) + (v128.const i32x4 -0x8000 -0x8000 -0x8000 -0x8000)) + (v128.const i16x8 0x8001 0x8001 0x8001 0x8001 0x8000 0x8000 0x8000 0x8000)) +(assert_return (invoke "i16x8.narrow_i32x4_s" (v128.const i32x4 -0x8000 -0x8000 -0x8000 -0x8000) + (v128.const i32x4 -0x7fff -0x7fff -0x7fff -0x7fff)) + (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8001 0x8001 0x8001 0x8001)) +(assert_return (invoke "i16x8.narrow_i32x4_s" (v128.const i32x4 -0x8000 -0x8000 -0x8000 -0x8000) + (v128.const i32x4 -0x8000 -0x8000 -0x8000 -0x8000)) + (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)) +(assert_return (invoke "i16x8.narrow_i32x4_s" (v128.const i32x4 -0x8001 -0x8001 -0x8001 -0x8001) + (v128.const i32x4 -0x8001 -0x8001 -0x8001 -0x8001)) + (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)) +(assert_return (invoke "i16x8.narrow_i32x4_s" (v128.const i32x4 -0x8001 -0x8001 -0x8001 -0x8001) + (v128.const i32x4 -0x8000 -0x8000 -0x8000 -0x8000)) + (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)) +(assert_return (invoke "i16x8.narrow_i32x4_s" (v128.const i32x4 -0x8000 -0x8000 -0x8000 -0x8000) + (v128.const i32x4 -0x8001 -0x8001 -0x8001 -0x8001)) + (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)) +(assert_return (invoke "i16x8.narrow_i32x4_s" (v128.const i32x4 -0x8000 -0x8000 -0x8000 -0x8000) + (v128.const i32x4 0x7fff 0x7fff 0x7fff 0x7fff)) + (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x7fff 0x7fff 0x7fff 0x7fff)) +(assert_return (invoke "i16x8.narrow_i32x4_s" (v128.const i32x4 -0x8000 -0x8000 -0x8000 -0x8000) + (v128.const i32x4 0x8000 0x8000 0x8000 0x8000)) + (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x7fff 0x7fff 0x7fff 0x7fff)) +(assert_return (invoke "i16x8.narrow_i32x4_s" (v128.const i32x4 -0x8001 -0x8001 -0x8001 -0x8001) + (v128.const i32x4 0x7fff 0x7fff 0x7fff 0x7fff)) + (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x7fff 0x7fff 0x7fff 0x7fff)) +(assert_return (invoke "i16x8.narrow_i32x4_s" (v128.const i32x4 -0x8000 -0x8000 -0x8000 -0x8000) + (v128.const i32x4 0xffff 0xffff 0xffff 0xffff)) + (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x7fff 0x7fff 0x7fff 0x7fff)) +(assert_return (invoke "i16x8.narrow_i32x4_s" (v128.const i32x4 -0x8001 -0x8001 -0x8001 -0x8001) + (v128.const i32x4 0x10000 0x10000 0x10000 0x10000)) + (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x7fff 0x7fff 0x7fff 0x7fff)) +(assert_return (invoke "i16x8.narrow_i32x4_s" (v128.const i32x4 -0x8000000 -0x8000000 -0x8000000 -0x8000000) + (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff)) + (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0xffff 0xffff 0xffff 0xffff)) +(assert_return (invoke "i16x8.narrow_i32x4_s" (v128.const i32x4 0_123_456_789 0_123_456_789 0_123_456_789 0_123_456_789) + (v128.const i32x4 01_234_567_890 01_234_567_890 01_234_567_890 01_234_567_890)) + (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff)) +(assert_return (invoke "i16x8.narrow_i32x4_s" (v128.const i32x4 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef) + (v128.const i32x4 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678)) + (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x7fff 0x7fff 0x7fff 0x7fff)) +;; i16x8.narrow_i32x4_u + +(assert_return (invoke "i16x8.narrow_i32x4_u" (v128.const i32x4 0 0 0 0) + (v128.const i32x4 0 0 0 0)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.narrow_i32x4_u" (v128.const i32x4 0 0 0 0) + (v128.const i32x4 1 1 1 1)) + (v128.const i16x8 0 0 0 0 1 1 1 1)) +(assert_return (invoke "i16x8.narrow_i32x4_u" (v128.const i32x4 1 1 1 1) + (v128.const i32x4 0 0 0 0)) + (v128.const i16x8 1 1 1 1 0 0 0 0)) +(assert_return (invoke "i16x8.narrow_i32x4_u" (v128.const i32x4 0 0 0 0) + (v128.const i32x4 -1 -1 -1 -1)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.narrow_i32x4_u" (v128.const i32x4 -1 -1 -1 -1) + (v128.const i32x4 0 0 0 0)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.narrow_i32x4_u" (v128.const i32x4 1 1 1 1) + (v128.const i32x4 -1 -1 -1 -1)) + (v128.const i16x8 1 1 1 1 0 0 0 0)) +(assert_return (invoke "i16x8.narrow_i32x4_u" (v128.const i32x4 -1 -1 -1 -1) + (v128.const i32x4 1 1 1 1)) + (v128.const i16x8 0 0 0 0 1 1 1 1)) +(assert_return (invoke "i16x8.narrow_i32x4_u" (v128.const i32x4 0xfffe 0xfffe 0xfffe 0xfffe) + (v128.const i32x4 0xffff 0xffff 0xffff 0xffff)) + (v128.const i16x8 0xfffe 0xfffe 0xfffe 0xfffe 0xffff 0xffff 0xffff 0xffff)) +(assert_return (invoke "i16x8.narrow_i32x4_u" (v128.const i32x4 0xffff 0xffff 0xffff 0xffff) + (v128.const i32x4 0xfffe 0xfffe 0xfffe 0xfffe)) + (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xfffe 0xfffe 0xfffe 0xfffe)) +(assert_return (invoke "i16x8.narrow_i32x4_u" (v128.const i32x4 0xffff 0xffff 0xffff 0xffff) + (v128.const i32x4 0xffff 0xffff 0xffff 0xffff)) + (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff)) +(assert_return (invoke "i16x8.narrow_i32x4_u" (v128.const i32x4 0x10000 0x10000 0x10000 0x10000) + (v128.const i32x4 0x10000 0x10000 0x10000 0x10000)) + (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff)) +(assert_return (invoke "i16x8.narrow_i32x4_u" (v128.const i32x4 0xffff 0xffff 0xffff 0xffff) + (v128.const i32x4 0x10000 0x10000 0x10000 0x10000)) + (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff)) +(assert_return (invoke "i16x8.narrow_i32x4_u" (v128.const i32x4 0x10000 0x10000 0x10000 0x10000) + (v128.const i32x4 0xffff 0xffff 0xffff 0xffff)) + (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff)) +(assert_return (invoke "i16x8.narrow_i32x4_u" (v128.const i32x4 0 0 0 0) + (v128.const i32x4 0xffff 0xffff 0xffff 0xffff)) + (v128.const i16x8 0 0 0 0 0xffff 0xffff 0xffff 0xffff)) +(assert_return (invoke "i16x8.narrow_i32x4_u" (v128.const i32x4 0 0 0 0) + (v128.const i32x4 0x10000 0x10000 0x10000 0x10000)) + (v128.const i16x8 0 0 0 0 0xffff 0xffff 0xffff 0xffff)) +(assert_return (invoke "i16x8.narrow_i32x4_u" (v128.const i32x4 -1 -1 -1 -1) + (v128.const i32x4 0xffff 0xffff 0xffff 0xffff)) + (v128.const i16x8 0 0 0 0 0xffff 0xffff 0xffff 0xffff)) +(assert_return (invoke "i16x8.narrow_i32x4_u" (v128.const i32x4 -1 -1 -1 -1) + (v128.const i32x4 0x10000 0x10000 0x10000 0x10000)) + (v128.const i16x8 0 0 0 0 0xffff 0xffff 0xffff 0xffff)) +(assert_return (invoke "i16x8.narrow_i32x4_u" (v128.const i32x4 -0x80000000 -0x80000000 -0x80000000 -0x80000000) + (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.narrow_i32x4_u" (v128.const i32x4 0_123_456_789 0_123_456_789 0_123_456_789 0_123_456_789) + (v128.const i32x4 01_234_567_890 01_234_567_890 01_234_567_890 01_234_567_890)) + (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff)) +(assert_return (invoke "i16x8.narrow_i32x4_u" (v128.const i32x4 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef) + (v128.const i32x4 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678)) + (v128.const i16x8 0 0 0 0 0xffff 0xffff 0xffff 0xffff)) + + +;; Unknown operator + +(assert_malformed (module quote + "(func (result v128) (i32x4.trunc_sat_f32x4 (v128.const f32x4 0.0 0.0 0.0 0.0)))") + "unknown operator") +(assert_malformed (module quote + "(func (result v128) (i32x4.trunc_s_sat_f32x4 (v128.const f32x4 -2.0 -1.0 1.0 2.0)))") + "unknown operator") +(assert_malformed (module quote + "(func (result v128) (i32x4.trunc_u_sat_f32x4 (v128.const f32x4 -2.0 -1.0 1.0 2.0)))") + "unknown operator") +(assert_malformed (module quote + "(func (result v128) (i32x4.convert_f32x4 (v128.const f32x4 -1 0 1 2)))") + "unknown operator") +(assert_malformed (module quote + "(func (result v128) (i32x4.convert_s_f32x4 (v128.const f32x4 -1 0 1 2)))") + "unknown operator") +(assert_malformed (module quote + "(func (result v128) (i32x4.convert_u_f32x4 (v128.const f32x4 -1 0 1 2)))") + "unknown operator") + +(assert_malformed (module quote + "(func (result v128) (i64x2.trunc_sat_f64x2_s (v128.const f64x2 0.0 0.0)))") + "unknown operator") +(assert_malformed (module quote + "(func (result v128) (i64x2.trunc_sat_f64x2_u (v128.const f64x2 -2.0 -1.0)))") + "unknown operator") +(assert_malformed (module quote + "(func (result v128) (f64x2.convert_i64x2_s (v128.const i64x2 1 2)))") + "unknown operator") +(assert_malformed (module quote + "(func (result v128) (f64x2.convert_i64x2_u (v128.const i64x2 1 2)))") + "unknown operator") + +(assert_malformed (module quote + "(func (result v128) (i8x16.narrow_i16x8 (v128.const i16x8 0 0 0 0 0 0 0 0) (v128.const i16x8 0 0 0 0 0 0 0 0)))") + "unknown operator") +(assert_malformed (module quote + "(func (result v128) (i16x8.narrow_i8x16 (v128.const i16x8 0 0 0 0 0 0 0 0) (v128.const i16x8 0 0 0 0 0 0 0 0)))") + "unknown operator") +(assert_malformed (module quote + "(func (result v128) (i16x8.narrow_i8x16_s (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)))") + "unknown operator") +(assert_malformed (module quote + "(func (result v128) (i16x8.narrow_i8x16_u (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)))") + "unknown operator") +(assert_malformed (module quote + "(func (result v128) (i16x8.narrow_i32x4 (v128.const i16x8 0 0 0 0 0 0 0 0) (v128.const i16x8 0 0 0 0 0 0 0 0)))") + "unknown operator") +(assert_malformed (module quote + "(func (result v128) (i32x4.narrow_i16x8 (v128.const i16x8 0 0 0 0 0 0 0 0) (v128.const i16x8 0 0 0 0 0 0 0 0)))") + "unknown operator") +(assert_malformed (module quote + "(func (result v128) (i32x4.narrow_i16x8_s (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)))") + "unknown operator") +(assert_malformed (module quote + "(func (result v128) (i32x4.narrow_i16x8_u (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)))") + "unknown operator") + +(assert_malformed (module quote + "(func (result v128) (i16x8.extend_low_i8x16 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)))") + "unknown operator") +(assert_malformed (module quote + "(func (result v128) (i8x16.extend_low_i16x8_s (v128.const i16x8 0 0 0 0 0 0 0 0)))") + "unknown operator") +(assert_malformed (module quote + "(func (result v128) (i8x16.extend_low_i16x8_u (v128.const i16x8 0 0 0 0 0 0 0 0)))") + "unknown operator") +(assert_malformed (module quote + "(func (result v128) (i16x8.extend_high_i8x16 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)))") + "unknown operator") +(assert_malformed (module quote + "(func (result v128) (i8x16.extend_high_i16x8_s (v128.const i16x8 0 0 0 0 0 0 0 0)))") + "unknown operator") +(assert_malformed (module quote + "(func (result v128) (i8x16.extend_high_i16x8_u (v128.const i16x8 0 0 0 0 0 0 0 0)))") + "unknown operator") +(assert_malformed (module quote + "(func (result v128) (i32x4.extend_low_i16x8 (v128.const i16x8 0 0 0 0 0 0 0 0)))") + "unknown operator") +(assert_malformed (module quote + "(func (result v128) (i16x8.extend_low_i32x4_s (v128.const i32x4 0 0 0 0)))") + "unknown operator") +(assert_malformed (module quote + "(func (result v128) (i16x8.extend_low_i32x4_u (v128.const i32x4 0 0 0 0)))") + "unknown operator") +(assert_malformed (module quote + "(func (result v128) (i32x4.extend_high_i16x8 (v128.const i16x8 0 0 0 0 0 0 0 0)))") + "unknown operator") +(assert_malformed (module quote + "(func (result v128) (i16x8.extend_high_i32x4_s (v128.const i32x4 0 0 0 0)))") + "unknown operator") +(assert_malformed (module quote + "(func (result v128) (i16x8.extend_high_i32x4_u (v128.const i32x4 0 0 0 0)))") + "unknown operator") + + +;; Type mismatch + +(assert_invalid (module (func (result v128) (f32x4.convert_i32x4_s (i32.const 0)))) "type mismatch") +(assert_invalid (module (func (result v128) (f32x4.convert_i32x4_s (i64.const 0)))) "type mismatch") +(assert_invalid (module (func (result v128) (f32x4.convert_i32x4_u (i32.const 0)))) "type mismatch") +(assert_invalid (module (func (result v128) (f32x4.convert_i32x4_u (i64.const 0)))) "type mismatch") + +(assert_invalid (module (func (result v128) (i8x16.narrow_i16x8_s (i32.const 0) (i64.const 0)))) "type mismatch") +(assert_invalid (module (func (result v128) (i8x16.narrow_i16x8_u (i32.const 0) (i64.const 0)))) "type mismatch") +(assert_invalid (module (func (result v128) (i16x8.narrow_i32x4_s (f32.const 0.0) (f64.const 0.0)))) "type mismatch") +(assert_invalid (module (func (result v128) (i16x8.narrow_i32x4_s (f32.const 0.0) (f64.const 0.0)))) "type mismatch") + + +;; Combinations + +(module + (func (export "f32x4_convert_i32x4_s_add") (param v128 v128) (result v128) + (f32x4.convert_i32x4_s (i32x4.add (local.get 0) (local.get 1)))) + (func (export "f32x4_convert_i32x4_s_sub") (param v128 v128) (result v128) + (f32x4.convert_i32x4_s (i32x4.sub (local.get 0) (local.get 1)))) + (func (export "f32x4_convert_i32x4_u_mul") (param v128 v128) (result v128) + (f32x4.convert_i32x4_u (i32x4.mul (local.get 0) (local.get 1)))) + + (func (export "i16x8_low_extend_narrow_ss") (param v128 v128) (result v128) + (i16x8.extend_low_i8x16_s (i8x16.narrow_i16x8_s (local.get 0) (local.get 1)))) + (func (export "i16x8_low_extend_narrow_su") (param v128 v128) (result v128) + (i16x8.extend_low_i8x16_s (i8x16.narrow_i16x8_u (local.get 0) (local.get 1)))) + (func (export "i16x8_high_extend_narrow_ss") (param v128 v128) (result v128) + (i16x8.extend_low_i8x16_s (i8x16.narrow_i16x8_s (local.get 0) (local.get 1)))) + (func (export "i16x8_high_extend_narrow_su") (param v128 v128) (result v128) + (i16x8.extend_low_i8x16_s (i8x16.narrow_i16x8_u (local.get 0) (local.get 1)))) + (func (export "i16x8_low_extend_narrow_uu") (param v128 v128) (result v128) + (i16x8.extend_low_i8x16_u (i8x16.narrow_i16x8_u (local.get 0) (local.get 1)))) + (func (export "i16x8_low_extend_narrow_us") (param v128 v128) (result v128) + (i16x8.extend_low_i8x16_u (i8x16.narrow_i16x8_s (local.get 0) (local.get 1)))) + (func (export "i16x8_high_extend_narrow_uu") (param v128 v128) (result v128) + (i16x8.extend_low_i8x16_u (i8x16.narrow_i16x8_u (local.get 0) (local.get 1)))) + (func (export "i16x8_high_extend_narrow_us") (param v128 v128) (result v128) + (i16x8.extend_low_i8x16_u (i8x16.narrow_i16x8_s (local.get 0) (local.get 1)))) + + (func (export "i32x4_low_extend_narrow_ss") (param v128 v128) (result v128) + (i32x4.extend_low_i16x8_s (i16x8.narrow_i32x4_s (local.get 0) (local.get 1)))) + (func (export "i32x4_low_extend_narrow_su") (param v128 v128) (result v128) + (i32x4.extend_low_i16x8_s (i16x8.narrow_i32x4_u (local.get 0) (local.get 1)))) + (func (export "i32x4_high_extend_narrow_ss") (param v128 v128) (result v128) + (i32x4.extend_low_i16x8_s (i16x8.narrow_i32x4_s (local.get 0) (local.get 1)))) + (func (export "i32x4_high_extend_narrow_su") (param v128 v128) (result v128) + (i32x4.extend_low_i16x8_s (i16x8.narrow_i32x4_u (local.get 0) (local.get 1)))) + (func (export "i32x4_low_extend_narrow_uu") (param v128 v128) (result v128) + (i32x4.extend_low_i16x8_u (i16x8.narrow_i32x4_u (local.get 0) (local.get 1)))) + (func (export "i32x4_low_extend_narrow_us") (param v128 v128) (result v128) + (i32x4.extend_low_i16x8_u (i16x8.narrow_i32x4_s (local.get 0) (local.get 1)))) + (func (export "i32x4_high_extend_narrow_uu") (param v128 v128) (result v128) + (i32x4.extend_low_i16x8_u (i16x8.narrow_i32x4_u (local.get 0) (local.get 1)))) + (func (export "i32x4_high_extend_narrow_us") (param v128 v128) (result v128) + (i32x4.extend_low_i16x8_u (i16x8.narrow_i32x4_s (local.get 0) (local.get 1)))) +) + +(assert_return (invoke "f32x4_convert_i32x4_s_add" (v128.const i32x4 1 2 3 4) + (v128.const i32x4 2 3 4 5)) + (v128.const f32x4 3.0 5.0 7.0 9.0)) +(assert_return (invoke "f32x4_convert_i32x4_s_sub" (v128.const i32x4 0 1 2 3) + (v128.const i32x4 1 1 1 1)) + (v128.const f32x4 -1.0 0.0 1.0 2.0)) +(assert_return (invoke "f32x4_convert_i32x4_u_mul" (v128.const i32x4 1 2 3 4) + (v128.const i32x4 1 2 3 4)) + (v128.const f32x4 1.0 4.0 9.0 16.0)) + +(assert_return (invoke "i16x8_low_extend_narrow_ss" (v128.const i16x8 -0x8000 -0x7fff 0x7fff 0x8000 -0x8000 -0x7fff 0x7fff 0x8000) + (v128.const i16x8 -0x8000 -0x7fff 0x7fff 0x8000 -0x8000 -0x7fff 0x7fff 0x8000)) + (v128.const i16x8 0xff80 0xff80 0x7f 0xff80 0xff80 0xff80 0x7f 0xff80)) +(assert_return (invoke "i16x8_low_extend_narrow_su" (v128.const i16x8 -0x8000 -0x7fff 0x7fff 0xffff -0x8000 -0x7fff 0x7fff 0xffff) + (v128.const i16x8 -0x8000 -0x7fff 0x7fff 0xffff -0x8000 -0x7fff 0x7fff 0xffff)) + (v128.const i16x8 0 0 0xffff 0 0 0 0xffff 0)) +(assert_return (invoke "i16x8_high_extend_narrow_ss" (v128.const i16x8 -0x8000 -0x7fff 0x7fff 0x8000 -0x8000 -0x7fff 0x7fff 0x8000) + (v128.const i16x8 -0x8000 -0x7fff 0x7fff 0x8000 -0x8000 -0x7fff 0x7fff 0x8000)) + (v128.const i16x8 0xff80 0xff80 0x7f 0xff80 0xff80 0xff80 0x7f 0xff80)) +(assert_return (invoke "i16x8_high_extend_narrow_su" (v128.const i16x8 -0x8000 -0x7fff 0x7fff 0xffff -0x8000 -0x7fff 0x7fff 0xffff) + (v128.const i16x8 -0x8000 -0x7fff 0x7fff 0xffff -0x8000 -0x7fff 0x7fff 0xffff)) + (v128.const i16x8 0 0 0xffff 0 0 0 0xffff 0)) +(assert_return (invoke "i16x8_low_extend_narrow_uu" (v128.const i16x8 -0x8000 -0x7fff 0x8000 0xffff -0x8000 -0x7fff 0x8000 0xffff) + (v128.const i16x8 -0x8000 -0x7fff 0x8000 0xffff -0x8000 -0x7fff 0x8000 0xffff)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8_low_extend_narrow_us" (v128.const i16x8 -0x8000 -0x7fff 0x7fff 0x8000 -0x8000 -0x7fff 0x7fff 0x8000) + (v128.const i16x8 -0x8000 -0x7fff 0x7fff 0x8000 -0x8000 -0x7fff 0x7fff 0x8000)) + (v128.const i16x8 0x80 0x80 0x7f 0x80 0x80 0x80 0x7f 0x80)) +(assert_return (invoke "i16x8_high_extend_narrow_uu" (v128.const i16x8 -0x8000 -0x7fff 0x7fff 0xffff -0x8000 -0x7fff 0x7fff 0xffff) + (v128.const i16x8 -0x8000 -0x7fff 0x7fff 0xffff -0x8000 -0x7fff 0x7fff 0xffff)) + (v128.const i16x8 0 0 0xff 0 0 0 0xff 0)) +(assert_return (invoke "i16x8_high_extend_narrow_us" (v128.const i16x8 -0x8000 -0x7fff 0x7fff 0x8000 -0x8000 -0x7fff 0x7fff 0x8000) + (v128.const i16x8 -0x8000 -0x7fff 0x7fff 0x8000 -0x8000 -0x7fff 0x7fff 0x8000)) + (v128.const i16x8 0x80 0x80 0x7f 0x80 0x80 0x80 0x7f 0x80)) + +(assert_return (invoke "i32x4_low_extend_narrow_ss" (v128.const i32x4 -0x80000000 -0x7fffffff 0x7fffffff 0x8000000) + (v128.const i32x4 -0x80000000 -0x7fffffff 0x7fffffff 0x8000000)) + (v128.const i32x4 0xffff8000 0xffff8000 0x7fff 0x7fff)) +(assert_return (invoke "i32x4_low_extend_narrow_su" (v128.const i32x4 -0x80000000 -0x7fffffff 0x7fffffff 0xffffffff) + (v128.const i32x4 -0x80000000 -0x7fffffff 0x7fffffff 0xffffffff)) + (v128.const i32x4 0 0 0xffffffff 0)) +(assert_return (invoke "i32x4_high_extend_narrow_ss" (v128.const i32x4 -0x80000000 -0x7fffffff 0x7fffffff 0x8000000) + (v128.const i32x4 -0x80000000 -0x7fffffff 0x7fffffff 0x8000000)) + (v128.const i32x4 0xffff8000 0xffff8000 0x7fff 0x7fff)) +(assert_return (invoke "i32x4_high_extend_narrow_su" (v128.const i32x4 -0x80000000 -0x7fffffff 0x7fffffff 0xffffffff) + (v128.const i32x4 -0x80000000 -0x7fffffff 0x7fffffff 0xffffffff)) + (v128.const i32x4 0 0 0xffffffff 0)) +(assert_return (invoke "i32x4_low_extend_narrow_uu" (v128.const i32x4 -0x80000000 -0x7fffffff 0x7fffffff 0xffffffff) + (v128.const i32x4 -0x80000000 -0x7fffffff 0x7fffffff 0xffffffff)) + (v128.const i32x4 0 0 0xffff 0)) +(assert_return (invoke "i32x4_low_extend_narrow_us" (v128.const i32x4 -0x80000000 -0x7fffffff 0x7fffffff 0x8000000) + (v128.const i32x4 -0x80000000 -0x7fffffff 0x7fffffff 0x8000000)) + (v128.const i32x4 0x8000 0x8000 0x7fff 0x7fff)) +(assert_return (invoke "i32x4_high_extend_narrow_uu" (v128.const i32x4 -0x80000000 -0x7fffffff 0x7fffffff 0xffffffff) + (v128.const i32x4 -0x80000000 -0x7fffffff 0x7fffffff 0xffffffff)) + (v128.const i32x4 0 0 0xffff 0)) +(assert_return (invoke "i32x4_high_extend_narrow_us" (v128.const i32x4 -0x80000000 -0x7fffffff 0x7fffffff 0x8000000) + (v128.const i32x4 -0x80000000 -0x7fffffff 0x7fffffff 0x8000000)) + (v128.const i32x4 0x8000 0x8000 0x7fff 0x7fff)) + +;; Test operation with empty argument + +(assert_invalid + (module + (func $f32x4.convert_i32x4_s-arg-empty (result v128) + (f32x4.convert_i32x4_s) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $f32x4.convert_i32x4_u-arg-empty (result v128) + (f32x4.convert_i32x4_u) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i8x16.narrow_i16x8_s-1st-arg-empty (result v128) + (i8x16.narrow_i16x8_s (v128.const i16x8 0 0 0 0 0 0 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i8x16.narrow_i16x8_s-arg-empty (result v128) + (i8x16.narrow_i16x8_s) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i8x16.narrow_i16x8_u-1st-arg-empty (result v128) + (i8x16.narrow_i16x8_u (v128.const i16x8 0 0 0 0 0 0 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i8x16.narrow_i16x8_u-arg-empty (result v128) + (i8x16.narrow_i16x8_u) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i16x8.narrow_i32x4_s-1st-arg-empty (result v128) + (i16x8.narrow_i32x4_s (v128.const i32x4 0 0 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i16x8.narrow_i32x4_s-arg-empty (result v128) + (i16x8.narrow_i32x4_s) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i16x8.narrow_i32x4_u-1st-arg-empty (result v128) + (i16x8.narrow_i32x4_u (v128.const i32x4 0 0 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i16x8.narrow_i32x4_u-arg-empty (result v128) + (i16x8.narrow_i32x4_u) + ) + ) + "type mismatch" +) diff --git a/runtime/near-vm/tests/wast/spec/proposals/simd/simd_f32x4.wast b/runtime/near-vm/tests/wast/spec/proposals/simd/simd_f32x4.wast new file mode 100644 index 00000000000..819db8cfd18 --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/proposals/simd/simd_f32x4.wast @@ -0,0 +1,2407 @@ +;; Tests for f32x4 [abs, min, max] operations on major boundary values and all special values. + + +(module + (func (export "f32x4.min") (param v128 v128) (result v128) (f32x4.min (local.get 0) (local.get 1))) + (func (export "f32x4.max") (param v128 v128) (result v128) (f32x4.max (local.get 0) (local.get 1))) + (func (export "f32x4.abs") (param v128) (result v128) (f32x4.abs (local.get 0))) + ;; f32x4.min const vs const + (func (export "f32x4.min_with_const_0") (result v128) (f32x4.min (v128.const f32x4 0 1 2 -3) (v128.const f32x4 0 2 1 3))) + (func (export "f32x4.min_with_const_1") (result v128) (f32x4.min (v128.const f32x4 0 1 2 3) (v128.const f32x4 0 1 2 3))) + (func (export "f32x4.min_with_const_2") (result v128) (f32x4.min (v128.const f32x4 0x00 0x01 0x02 0x80000000) (v128.const f32x4 0x00 0x02 0x01 2147483648))) + (func (export "f32x4.min_with_const_3") (result v128) (f32x4.min (v128.const f32x4 0x00 0x01 0x02 0x80000000) (v128.const f32x4 0x00 0x01 0x02 0x80000000))) + ;; f32x4.min param vs const + (func (export "f32x4.min_with_const_5")(param v128) (result v128) (f32x4.min (local.get 0) (v128.const f32x4 0 1 2 -3))) + (func (export "f32x4.min_with_const_6")(param v128) (result v128) (f32x4.min (v128.const f32x4 0 1 2 3) (local.get 0))) + (func (export "f32x4.min_with_const_7")(param v128) (result v128) (f32x4.min (v128.const f32x4 0x00 0x01 0x02 0x80000000) (local.get 0))) + (func (export "f32x4.min_with_const_8")(param v128) (result v128) (f32x4.min (local.get 0) (v128.const f32x4 0x00 0x01 0x02 0x80000000))) + ;; f32x4.max const vs const + (func (export "f32x4.max_with_const_10") (result v128) (f32x4.max (v128.const f32x4 0 1 2 -3) (v128.const f32x4 0 2 1 3))) + (func (export "f32x4.max_with_const_11") (result v128) (f32x4.max (v128.const f32x4 0 1 2 3) (v128.const f32x4 0 1 2 3))) + (func (export "f32x4.max_with_const_12") (result v128) (f32x4.max (v128.const f32x4 0x00 0x01 0x02 0x80000000) (v128.const f32x4 0x00 0x02 0x01 2147483648))) + (func (export "f32x4.max_with_const_13") (result v128) (f32x4.max (v128.const f32x4 0x00 0x01 0x02 0x80000000) (v128.const f32x4 0x00 0x01 0x02 0x80000000))) + ;; f32x4.max param vs const + (func (export "f32x4.max_with_const_15")(param v128) (result v128) (f32x4.max (local.get 0) (v128.const f32x4 0 1 2 -3))) + (func (export "f32x4.max_with_const_16")(param v128) (result v128) (f32x4.max (v128.const f32x4 0 1 2 3) (local.get 0))) + (func (export "f32x4.max_with_const_17")(param v128) (result v128) (f32x4.max (v128.const f32x4 0x00 0x01 0x02 0x80000000) (local.get 0))) + (func (export "f32x4.max_with_const_18")(param v128) (result v128) (f32x4.max (local.get 0) (v128.const f32x4 0x00 0x01 0x02 0x80000000))) + + (func (export "f32x4.abs_with_const") (result v128) (f32x4.abs (v128.const f32x4 -0 -1 -2 -3))) +) + +;; f32x4.min const vs const +(assert_return (invoke "f32x4.min_with_const_0") (v128.const f32x4 0 1 1 -3)) +(assert_return (invoke "f32x4.min_with_const_1") (v128.const f32x4 0 1 2 3)) +(assert_return (invoke "f32x4.min_with_const_2") (v128.const f32x4 0x00 0x01 0x01 0x80000000)) +(assert_return (invoke "f32x4.min_with_const_3") (v128.const f32x4 0x00 0x01 0x02 0x80000000)) +;; f32x4.min param vs const +(assert_return (invoke "f32x4.min_with_const_5" (v128.const f32x4 0 2 1 3)) + (v128.const f32x4 0 1 1 -3)) +(assert_return (invoke "f32x4.min_with_const_6" (v128.const f32x4 0 1 2 3)) + (v128.const f32x4 0 1 2 3)) +(assert_return (invoke "f32x4.min_with_const_7" (v128.const f32x4 0x00 0x02 0x01 2147483648)) + (v128.const f32x4 0x00 0x01 0x01 0x80000000)) +(assert_return (invoke "f32x4.min_with_const_8" (v128.const f32x4 0x00 0x01 0x02 0x80000000)) + (v128.const f32x4 0x00 0x01 0x02 0x80000000)) +;; f32x4.max const vs const +(assert_return (invoke "f32x4.max_with_const_10") (v128.const f32x4 0 2 2 3)) +(assert_return (invoke "f32x4.max_with_const_11") (v128.const f32x4 0 1 2 3)) +(assert_return (invoke "f32x4.max_with_const_12") (v128.const f32x4 0x00 0x02 0x02 2147483648)) +(assert_return (invoke "f32x4.max_with_const_13") (v128.const f32x4 0x00 0x01 0x02 0x80000000)) +;; f32x4.max param vs const +(assert_return (invoke "f32x4.max_with_const_15" (v128.const f32x4 0 2 1 3)) + (v128.const f32x4 0 2 2 3)) +(assert_return (invoke "f32x4.max_with_const_16" (v128.const f32x4 0 1 2 3)) + (v128.const f32x4 0 1 2 3)) +(assert_return (invoke "f32x4.max_with_const_17" (v128.const f32x4 0x00 0x02 0x01 2147483648)) + (v128.const f32x4 0x00 0x02 0x02 2147483648)) +(assert_return (invoke "f32x4.max_with_const_18" (v128.const f32x4 0x00 0x01 0x02 0x80000000)) + (v128.const f32x4 0x00 0x01 0x02 0x80000000)) + +(assert_return (invoke "f32x4.abs_with_const") (v128.const f32x4 0 1 2 3)) + +;; Test different lanes go through different if-then clauses +;; f32x4.min +(assert_return + (invoke "f32x4.min" + (v128.const f32x4 nan 0 0 1) + (v128.const f32x4 0 -nan 1 0) + ) + (v128.const f32x4 nan:canonical nan:canonical 0 0) +) +;; f32x4.min +(assert_return + (invoke "f32x4.min" + (v128.const f32x4 nan 0 0 0) + (v128.const f32x4 0 -nan 1 0) + ) + (v128.const f32x4 nan:canonical nan:canonical 0 0) +) +;; f32x4.max +(assert_return + (invoke "f32x4.max" + (v128.const f32x4 nan 0 0 1) + (v128.const f32x4 0 -nan 1 0) + ) + (v128.const f32x4 nan:canonical nan:canonical 1 1) +) +;; f32x4.max +(assert_return + (invoke "f32x4.max" + (v128.const f32x4 nan 0 0 0) + (v128.const f32x4 0 -nan 1 0) + ) + (v128.const f32x4 nan:canonical nan:canonical 1 0) +) + +(assert_return (invoke "f32x4.min" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019) + (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)) + (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019) + (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)) + (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019) + (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)) + (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019) + (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)) + (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019) + (v128.const f32x4 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789)) + (v128.const f32x4 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019) + (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)) + (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019) + (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)) + (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019) + (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)) + (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019) + (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)) + (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019) + (v128.const f32x4 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789)) + (v128.const f32x4 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019) + (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)) + (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019) + (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)) + (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019) + (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)) + (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019) + (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)) + (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019) + (v128.const f32x4 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789)) + (v128.const f32x4 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019) + (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)) + (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019) + (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)) + (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019) + (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)) + (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019) + (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)) + (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019) + (v128.const f32x4 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789)) + (v128.const f32x4 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789) + (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)) + (v128.const f32x4 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789) + (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)) + (v128.const f32x4 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789) + (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)) + (v128.const f32x4 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789) + (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)) + (v128.const f32x4 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789) + (v128.const f32x4 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789)) + (v128.const f32x4 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019) + (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)) + (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019) + (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)) + (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019) + (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)) + (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019) + (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)) + (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019) + (v128.const f32x4 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789)) + (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019) + (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)) + (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019) + (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)) + (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019) + (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)) + (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019) + (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)) + (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019) + (v128.const f32x4 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789)) + (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019) + (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)) + (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019) + (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)) + (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019) + (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)) + (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019) + (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)) + (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019) + (v128.const f32x4 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789)) + (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019) + (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)) + (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019) + (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)) + (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019) + (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)) + (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019) + (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)) + (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019) + (v128.const f32x4 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789)) + (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789) + (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)) + (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789) + (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)) + (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789) + (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)) + (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789) + (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)) + (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789) + (v128.const f32x4 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789)) + (v128.const f32x4 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) + +;; Test opposite signs of zero +(assert_return (invoke "f32x4.min" (v128.const f32x4 0 0 -0 +0) + (v128.const f32x4 +0 -0 +0 -0)) + (v128.const f32x4 0 -0 -0 -0)) +(assert_return (invoke "f32x4.min" (v128.const f32x4 -0 -0 -0 -0) + (v128.const f32x4 +0 +0 +0 +0)) + (v128.const f32x4 -0 -0 -0 -0)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 0 0 -0 +0) + (v128.const f32x4 +0 -0 +0 -0)) + (v128.const f32x4 0 0 0 0)) +(assert_return (invoke "f32x4.max" (v128.const f32x4 -0 -0 -0 -0) + (v128.const f32x4 +0 +0 +0 +0)) + (v128.const f32x4 +0 +0 +0 +0)) + + +(assert_return (invoke "f32x4.abs" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.abs" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.abs" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.abs" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.abs" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.abs" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.abs" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.abs" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.abs" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.abs" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.abs" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.abs" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.abs" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.abs" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.abs" (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.abs" (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.abs" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)) + (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)) +(assert_return (invoke "f32x4.abs" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)) + (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)) +(assert_return (invoke "f32x4.abs" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)) + (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)) +(assert_return (invoke "f32x4.abs" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)) + (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)) +(assert_return (invoke "f32x4.abs" (v128.const f32x4 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789)) + (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)) + + +;; Unknown operators + +(assert_malformed (module quote "(memory 1) (func (result v128) (i8x16.min (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0)))") "unknown operator") +(assert_malformed (module quote "(memory 1) (func (result v128) (i8x16.max (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0)))") "unknown operator") +(assert_malformed (module quote "(memory 1) (func (result v128) (i16x8.min (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0)))") "unknown operator") +(assert_malformed (module quote "(memory 1) (func (result v128) (i16x8.max (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0)))") "unknown operator") +(assert_malformed (module quote "(memory 1) (func (result v128) (i32x4.min (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0)))") "unknown operator") +(assert_malformed (module quote "(memory 1) (func (result v128) (i32x4.max (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0)))") "unknown operator") +(assert_malformed (module quote "(memory 1) (func (result v128) (i64x2.min (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0)))") "unknown operator") +(assert_malformed (module quote "(memory 1) (func (result v128) (i64x2.max (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0)))") "unknown operator") + +;; type check +(assert_invalid (module (func (result v128) (f32x4.abs (i32.const 0)))) "type mismatch") +(assert_invalid (module (func (result v128) (f32x4.min (i32.const 0) (f32.const 0.0)))) "type mismatch") +(assert_invalid (module (func (result v128) (f32x4.max (i32.const 0) (f32.const 0.0)))) "type mismatch") + +;; Test operation with empty argument + +(assert_invalid + (module + (func $f32x4.abs-arg-empty (result v128) + (f32x4.abs) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $f32x4.min-1st-arg-empty (result v128) + (f32x4.min (v128.const f32x4 0 0 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $f32x4.min-arg-empty (result v128) + (f32x4.min) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $f32x4.max-1st-arg-empty (result v128) + (f32x4.max (v128.const f32x4 0 0 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $f32x4.max-arg-empty (result v128) + (f32x4.max) + ) + ) + "type mismatch" +) + +;; combination +(module + (func (export "max-min") (param v128 v128 v128) (result v128) + (f32x4.max (f32x4.min (local.get 0) (local.get 1))(local.get 2))) + (func (export "min-max") (param v128 v128 v128) (result v128) + (f32x4.min (f32x4.max (local.get 0) (local.get 1))(local.get 2))) + (func (export "max-abs") (param v128 v128) (result v128) + (f32x4.max (f32x4.abs (local.get 0)) (local.get 1))) + (func (export "min-abs") (param v128 v128) (result v128) + (f32x4.min (f32x4.abs (local.get 0)) (local.get 1))) +) + +(assert_return (invoke "max-min" (v128.const f32x4 1.125 1.125 1.125 1.125) + (v128.const f32x4 0.25 0.25 0.25 0.25) + (v128.const f32x4 0.125 0.125 0.125 0.125)) + (v128.const f32x4 0.25 0.25 0.25 0.25)) +(assert_return (invoke "min-max" (v128.const f32x4 1.125 1.125 1.125 1.125) + (v128.const f32x4 0.25 0.25 0.25 0.25) + (v128.const f32x4 0.125 0.125 0.125 0.125)) + (v128.const f32x4 0.125 0.125 0.125 0.125)) +(assert_return (invoke "max-abs" (v128.const f32x4 -1.125 -1.125 -1.125 -1.125) + (v128.const f32x4 0.125 0.125 0.125 0.125)) + (v128.const f32x4 1.125 1.125 1.125 1.125)) +(assert_return (invoke "min-abs" (v128.const f32x4 -1.125 -1.125 -1.125 -1.125) + (v128.const f32x4 0.125 0.125 0.125 0.125)) + (v128.const f32x4 0.125 0.125 0.125 0.125)) \ No newline at end of file diff --git a/runtime/near-vm/tests/wast/spec/proposals/simd/simd_f32x4_arith.wast b/runtime/near-vm/tests/wast/spec/proposals/simd/simd_f32x4_arith.wast new file mode 100644 index 00000000000..56f80f547bf --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/proposals/simd/simd_f32x4_arith.wast @@ -0,0 +1,5476 @@ +;; Tests for f32x4 arithmetic operations on major boundary values and all special values. + + +(module + (func (export "f32x4.add") (param v128 v128) (result v128) (f32x4.add (local.get 0) (local.get 1))) + (func (export "f32x4.sub") (param v128 v128) (result v128) (f32x4.sub (local.get 0) (local.get 1))) + (func (export "f32x4.mul") (param v128 v128) (result v128) (f32x4.mul (local.get 0) (local.get 1))) + (func (export "f32x4.div") (param v128 v128) (result v128) (f32x4.div (local.get 0) (local.get 1))) + (func (export "f32x4.neg") (param v128) (result v128) (f32x4.neg (local.get 0))) + (func (export "f32x4.sqrt") (param v128) (result v128) (f32x4.sqrt (local.get 0))) +) + +(assert_return (invoke "f32x4.add" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 0x1.0000000000000p-148 0x1.0000000000000p-148 0x1.0000000000000p-148 0x1.0000000000000p-148)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 0x1.0000020000000p-126 0x1.0000020000000p-126 0x1.0000020000000p-126 0x1.0000020000000p-126)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 -0x1.fffffc0000000p-127 -0x1.fffffc0000000p-127 -0x1.fffffc0000000p-127 -0x1.fffffc0000000p-127)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 -0x1.0000000000000p-148 -0x1.0000000000000p-148 -0x1.0000000000000p-148 -0x1.0000000000000p-148)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 0x1.fffffc0000000p-127 0x1.fffffc0000000p-127 0x1.fffffc0000000p-127 0x1.fffffc0000000p-127)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 -0x1.0000020000000p-126 -0x1.0000020000000p-126 -0x1.0000020000000p-126 -0x1.0000020000000p-126)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 0x1.0000020000000p-126 0x1.0000020000000p-126 0x1.0000020000000p-126 0x1.0000020000000p-126)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 0x1.fffffc0000000p-127 0x1.fffffc0000000p-127 0x1.fffffc0000000p-127 0x1.fffffc0000000p-127)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 0x1.0000000000000p-125 0x1.0000000000000p-125 0x1.0000000000000p-125 0x1.0000000000000p-125)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 -0x1.fffffc0000000p-127 -0x1.fffffc0000000p-127 -0x1.fffffc0000000p-127 -0x1.fffffc0000000p-127)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 -0x1.0000020000000p-126 -0x1.0000020000000p-126 -0x1.0000020000000p-126 -0x1.0000020000000p-126)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 -0x1.0000000000000p-125 -0x1.0000000000000p-125 -0x1.0000000000000p-125 -0x1.0000000000000p-125)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 0x1.8000000000000p+0 0x1.8000000000000p+0 0x1.8000000000000p+0 0x1.8000000000000p+0)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 0x1.b21fb60000000p+2 0x1.b21fb60000000p+2 0x1.b21fb60000000p+2 0x1.b21fb60000000p+2)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 -0x1.721fb60000000p+2 -0x1.721fb60000000p+2 -0x1.721fb60000000p+2 -0x1.721fb60000000p+2)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 -0x1.8000000000000p+0 -0x1.8000000000000p+0 -0x1.8000000000000p+0 -0x1.8000000000000p+0)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 0x1.721fb60000000p+2 0x1.721fb60000000p+2 0x1.721fb60000000p+2 0x1.721fb60000000p+2)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 -0x1.b21fb60000000p+2 -0x1.b21fb60000000p+2 -0x1.b21fb60000000p+2 -0x1.b21fb60000000p+2)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 0x1.8000000000000p+0 0x1.8000000000000p+0 0x1.8000000000000p+0 0x1.8000000000000p+0)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 0x1.0000000000000p+1 0x1.0000000000000p+1 0x1.0000000000000p+1 0x1.0000000000000p+1)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 0x1.d21fb60000000p+2 0x1.d21fb60000000p+2 0x1.d21fb60000000p+2 0x1.d21fb60000000p+2)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 -0x1.521fb60000000p+2 -0x1.521fb60000000p+2 -0x1.521fb60000000p+2 -0x1.521fb60000000p+2)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 -0x1.8000000000000p+0 -0x1.8000000000000p+0 -0x1.8000000000000p+0 -0x1.8000000000000p+0)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 -0x1.0000000000000p+1 -0x1.0000000000000p+1 -0x1.0000000000000p+1 -0x1.0000000000000p+1)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 0x1.521fb60000000p+2 0x1.521fb60000000p+2 0x1.521fb60000000p+2 0x1.521fb60000000p+2)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 -0x1.d21fb60000000p+2 -0x1.d21fb60000000p+2 -0x1.d21fb60000000p+2 -0x1.d21fb60000000p+2)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 0x1.b21fb60000000p+2 0x1.b21fb60000000p+2 0x1.b21fb60000000p+2 0x1.b21fb60000000p+2)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 0x1.721fb60000000p+2 0x1.721fb60000000p+2 0x1.721fb60000000p+2 0x1.721fb60000000p+2)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 0x1.d21fb60000000p+2 0x1.d21fb60000000p+2 0x1.d21fb60000000p+2 0x1.d21fb60000000p+2)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 0x1.521fb60000000p+2 0x1.521fb60000000p+2 0x1.521fb60000000p+2 0x1.521fb60000000p+2)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 0x1.921fb60000000p+3 0x1.921fb60000000p+3 0x1.921fb60000000p+3 0x1.921fb60000000p+3)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 -0x1.721fb60000000p+2 -0x1.721fb60000000p+2 -0x1.721fb60000000p+2 -0x1.721fb60000000p+2)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 -0x1.b21fb60000000p+2 -0x1.b21fb60000000p+2 -0x1.b21fb60000000p+2 -0x1.b21fb60000000p+2)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 -0x1.521fb60000000p+2 -0x1.521fb60000000p+2 -0x1.521fb60000000p+2 -0x1.521fb60000000p+2)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 -0x1.d21fb60000000p+2 -0x1.d21fb60000000p+2 -0x1.d21fb60000000p+2 -0x1.d21fb60000000p+2)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 -0x1.921fb60000000p+3 -0x1.921fb60000000p+3 -0x1.921fb60000000p+3 -0x1.921fb60000000p+3)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789) + (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)) + (v128.const f32x4 246913578.0 246913578.0 246913578.0 246913578.0)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019) + (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)) + (v128.const f32x4 2.46913578e+27 2.46913578e+27 2.46913578e+27 2.46913578e+27)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019) + (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)) + (v128.const f32x4 2.46913578e+27 2.46913578e+27 2.46913578e+27 2.46913578e+27)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019) + (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)) + (v128.const f32x4 2.46913578e-11 2.46913578e-11 2.46913578e-11 2.46913578e-11)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.) + (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)) + (v128.const f32x4 246913578.0 246913578.0 246913578.0 246913578.0)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019) + (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)) + (v128.const f32x4 2.46913578e+27 2.46913578e+27 2.46913578e+27 2.46913578e+27)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019) + (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)) + (v128.const f32x4 2.46913578e+27 2.46913578e+27 2.46913578e+27 2.46913578e+27)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019) + (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)) + (v128.const f32x4 2.46913578e-11 2.46913578e-11 2.46913578e-11 2.46913578e-11)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789) + (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)) + (v128.const f32x4 246913578.02469134 246913578.02469134 246913578.02469134 246913578.02469134)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f32x4 2.4691357802469137e+27 2.4691357802469137e+27 2.4691357802469137e+27 2.4691357802469137e+27)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f32x4 2.4691357802469137e+27 2.4691357802469137e+27 2.4691357802469137e+27 2.4691357802469137e+27)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f32x4 2.4691357802469137e-11 2.4691357802469137e-11 2.4691357802469137e-11 2.4691357802469137e-11)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF) + (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)) + (v128.const f32x4 0x1.23456789abcdfp+57 0x1.23456789abcdfp+57 0x1.23456789abcdfp+57 0x1.23456789abcdfp+57)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019) + (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)) + (v128.const f32x4 0x1.23456789abcdfp+76 0x1.23456789abcdfp+76 0x1.23456789abcdfp+76 0x1.23456789abcdfp+76)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019) + (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)) + (v128.const f32x4 0x1.23456789abcdfp+76 0x1.23456789abcdfp+76 0x1.23456789abcdfp+76 0x1.23456789abcdfp+76)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019) + (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)) + (v128.const f32x4 0x1.23456789abcdfp+38 0x1.23456789abcdfp+38 0x1.23456789abcdfp+38 0x1.23456789abcdfp+38)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.) + (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)) + (v128.const f32x4 0x1.23456789abcdfp+57 0x1.23456789abcdfp+57 0x1.23456789abcdfp+57 0x1.23456789abcdfp+57)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019) + (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)) + (v128.const f32x4 0x1.23456789abcdfp+76 0x1.23456789abcdfp+76 0x1.23456789abcdfp+76 0x1.23456789abcdfp+76)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019) + (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)) + (v128.const f32x4 0x1.23456789abcdfp+76 0x1.23456789abcdfp+76 0x1.23456789abcdfp+76 0x1.23456789abcdfp+76)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019) + (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)) + (v128.const f32x4 0x1.23456789abcdfp+38 0x1.23456789abcdfp+38 0x1.23456789abcdfp+38 0x1.23456789abcdfp+38)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF) + (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)) + (v128.const f32x4 0x1.23456789abcdfp+57 0x1.23456789abcdfp+57 0x1.23456789abcdfp+57 0x1.23456789abcdfp+57)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019) + (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)) + (v128.const f32x4 0x1.23456789abcdfp+76 0x1.23456789abcdfp+76 0x1.23456789abcdfp+76 0x1.23456789abcdfp+76)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019) + (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)) + (v128.const f32x4 0x1.23456789abcdfp+76 0x1.23456789abcdfp+76 0x1.23456789abcdfp+76 0x1.23456789abcdfp+76)) +(assert_return (invoke "f32x4.add" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019) + (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)) + (v128.const f32x4 0x1.23456789abcdfp+38 0x1.23456789abcdfp+38 0x1.23456789abcdfp+38 0x1.23456789abcdfp+38)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 0x1.0000000000000p-148 0x1.0000000000000p-148 0x1.0000000000000p-148 0x1.0000000000000p-148)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 -0x1.fffffc0000000p-127 -0x1.fffffc0000000p-127 -0x1.fffffc0000000p-127 -0x1.fffffc0000000p-127)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 0x1.0000020000000p-126 0x1.0000020000000p-126 0x1.0000020000000p-126 0x1.0000020000000p-126)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 -0x1.0000000000000p-148 -0x1.0000000000000p-148 -0x1.0000000000000p-148 -0x1.0000000000000p-148)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 -0x1.0000020000000p-126 -0x1.0000020000000p-126 -0x1.0000020000000p-126 -0x1.0000020000000p-126)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 0x1.fffffc0000000p-127 0x1.fffffc0000000p-127 0x1.fffffc0000000p-127 0x1.fffffc0000000p-127)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 0x1.fffffc0000000p-127 0x1.fffffc0000000p-127 0x1.fffffc0000000p-127 0x1.fffffc0000000p-127)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 0x1.0000020000000p-126 0x1.0000020000000p-126 0x1.0000020000000p-126 0x1.0000020000000p-126)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 0x1.0000000000000p-125 0x1.0000000000000p-125 0x1.0000000000000p-125 0x1.0000000000000p-125)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 -0x1.0000020000000p-126 -0x1.0000020000000p-126 -0x1.0000020000000p-126 -0x1.0000020000000p-126)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 -0x1.fffffc0000000p-127 -0x1.fffffc0000000p-127 -0x1.fffffc0000000p-127 -0x1.fffffc0000000p-127)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 -0x1.0000000000000p-125 -0x1.0000000000000p-125 -0x1.0000000000000p-125 -0x1.0000000000000p-125)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 0x1.8000000000000p+0 0x1.8000000000000p+0 0x1.8000000000000p+0 0x1.8000000000000p+0)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 -0x1.721fb60000000p+2 -0x1.721fb60000000p+2 -0x1.721fb60000000p+2 -0x1.721fb60000000p+2)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 0x1.b21fb60000000p+2 0x1.b21fb60000000p+2 0x1.b21fb60000000p+2 0x1.b21fb60000000p+2)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 -0x1.8000000000000p+0 -0x1.8000000000000p+0 -0x1.8000000000000p+0 -0x1.8000000000000p+0)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 -0x1.b21fb60000000p+2 -0x1.b21fb60000000p+2 -0x1.b21fb60000000p+2 -0x1.b21fb60000000p+2)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 0x1.721fb60000000p+2 0x1.721fb60000000p+2 0x1.721fb60000000p+2 0x1.721fb60000000p+2)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 0x1.8000000000000p+0 0x1.8000000000000p+0 0x1.8000000000000p+0 0x1.8000000000000p+0)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 0x1.0000000000000p+1 0x1.0000000000000p+1 0x1.0000000000000p+1 0x1.0000000000000p+1)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 -0x1.521fb60000000p+2 -0x1.521fb60000000p+2 -0x1.521fb60000000p+2 -0x1.521fb60000000p+2)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 0x1.d21fb60000000p+2 0x1.d21fb60000000p+2 0x1.d21fb60000000p+2 0x1.d21fb60000000p+2)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 -0x1.8000000000000p+0 -0x1.8000000000000p+0 -0x1.8000000000000p+0 -0x1.8000000000000p+0)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 -0x1.0000000000000p+1 -0x1.0000000000000p+1 -0x1.0000000000000p+1 -0x1.0000000000000p+1)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 -0x1.d21fb60000000p+2 -0x1.d21fb60000000p+2 -0x1.d21fb60000000p+2 -0x1.d21fb60000000p+2)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 0x1.521fb60000000p+2 0x1.521fb60000000p+2 0x1.521fb60000000p+2 0x1.521fb60000000p+2)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 0x1.721fb60000000p+2 0x1.721fb60000000p+2 0x1.721fb60000000p+2 0x1.721fb60000000p+2)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 0x1.b21fb60000000p+2 0x1.b21fb60000000p+2 0x1.b21fb60000000p+2 0x1.b21fb60000000p+2)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 0x1.521fb60000000p+2 0x1.521fb60000000p+2 0x1.521fb60000000p+2 0x1.521fb60000000p+2)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 0x1.d21fb60000000p+2 0x1.d21fb60000000p+2 0x1.d21fb60000000p+2 0x1.d21fb60000000p+2)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 0x1.921fb60000000p+3 0x1.921fb60000000p+3 0x1.921fb60000000p+3 0x1.921fb60000000p+3)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 -0x1.b21fb60000000p+2 -0x1.b21fb60000000p+2 -0x1.b21fb60000000p+2 -0x1.b21fb60000000p+2)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 -0x1.721fb60000000p+2 -0x1.721fb60000000p+2 -0x1.721fb60000000p+2 -0x1.721fb60000000p+2)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 -0x1.d21fb60000000p+2 -0x1.d21fb60000000p+2 -0x1.d21fb60000000p+2 -0x1.d21fb60000000p+2)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 -0x1.521fb60000000p+2 -0x1.521fb60000000p+2 -0x1.521fb60000000p+2 -0x1.521fb60000000p+2)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 -0x1.921fb60000000p+3 -0x1.921fb60000000p+3 -0x1.921fb60000000p+3 -0x1.921fb60000000p+3)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789) + (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)) + (v128.const f32x4 0.0 0.0 0.0 0.0)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019) + (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)) + (v128.const f32x4 0.0 0.0 0.0 0.0)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019) + (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)) + (v128.const f32x4 0.0 0.0 0.0 0.0)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019) + (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)) + (v128.const f32x4 0.0 0.0 0.0 0.0)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.) + (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)) + (v128.const f32x4 0.0 0.0 0.0 0.0)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019) + (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)) + (v128.const f32x4 0.0 0.0 0.0 0.0)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019) + (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)) + (v128.const f32x4 0.0 0.0 0.0 0.0)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019) + (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)) + (v128.const f32x4 0.0 0.0 0.0 0.0)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789) + (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)) + (v128.const f32x4 0.0 0.0 0.0 0.0)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f32x4 0.0 0.0 0.0 0.0)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f32x4 0.0 0.0 0.0 0.0)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f32x4 0.0 0.0 0.0 0.0)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF) + (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019) + (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019) + (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019) + (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.) + (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019) + (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019) + (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019) + (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF) + (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019) + (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019) + (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019) + (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 0x1.0000000000000p-298 0x1.0000000000000p-298 0x1.0000000000000p-298 0x1.0000000000000p-298)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 -0x1.0000000000000p-298 -0x1.0000000000000p-298 -0x1.0000000000000p-298 -0x1.0000000000000p-298)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 0x1.0000000000000p-275 0x1.0000000000000p-275 0x1.0000000000000p-275 0x1.0000000000000p-275)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 -0x1.0000000000000p-275 -0x1.0000000000000p-275 -0x1.0000000000000p-275 -0x1.0000000000000p-275)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 0x1.0000000000000p-150 0x1.0000000000000p-150 0x1.0000000000000p-150 0x1.0000000000000p-150)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 -0x1.0000000000000p-150 -0x1.0000000000000p-150 -0x1.0000000000000p-150 -0x1.0000000000000p-150)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 0x1.921fb60000000p-147 0x1.921fb60000000p-147 0x1.921fb60000000p-147 0x1.921fb60000000p-147)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 -0x1.921fb60000000p-147 -0x1.921fb60000000p-147 -0x1.921fb60000000p-147 -0x1.921fb60000000p-147)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 0x1.fffffe0000000p-22 0x1.fffffe0000000p-22 0x1.fffffe0000000p-22 0x1.fffffe0000000p-22)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 -0x1.fffffe0000000p-22 -0x1.fffffe0000000p-22 -0x1.fffffe0000000p-22 -0x1.fffffe0000000p-22)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 -0x1.0000000000000p-298 -0x1.0000000000000p-298 -0x1.0000000000000p-298 -0x1.0000000000000p-298)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 0x1.0000000000000p-298 0x1.0000000000000p-298 0x1.0000000000000p-298 0x1.0000000000000p-298)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 -0x1.0000000000000p-275 -0x1.0000000000000p-275 -0x1.0000000000000p-275 -0x1.0000000000000p-275)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 0x1.0000000000000p-275 0x1.0000000000000p-275 0x1.0000000000000p-275 0x1.0000000000000p-275)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 -0x1.0000000000000p-150 -0x1.0000000000000p-150 -0x1.0000000000000p-150 -0x1.0000000000000p-150)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 0x1.0000000000000p-150 0x1.0000000000000p-150 0x1.0000000000000p-150 0x1.0000000000000p-150)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 -0x1.921fb60000000p-147 -0x1.921fb60000000p-147 -0x1.921fb60000000p-147 -0x1.921fb60000000p-147)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 0x1.921fb60000000p-147 0x1.921fb60000000p-147 0x1.921fb60000000p-147 0x1.921fb60000000p-147)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 -0x1.fffffe0000000p-22 -0x1.fffffe0000000p-22 -0x1.fffffe0000000p-22 -0x1.fffffe0000000p-22)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 0x1.fffffe0000000p-22 0x1.fffffe0000000p-22 0x1.fffffe0000000p-22 0x1.fffffe0000000p-22)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 0x1.0000000000000p-275 0x1.0000000000000p-275 0x1.0000000000000p-275 0x1.0000000000000p-275)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 -0x1.0000000000000p-275 -0x1.0000000000000p-275 -0x1.0000000000000p-275 -0x1.0000000000000p-275)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 0x1.0000000000000p-252 0x1.0000000000000p-252 0x1.0000000000000p-252 0x1.0000000000000p-252)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 -0x1.0000000000000p-252 -0x1.0000000000000p-252 -0x1.0000000000000p-252 -0x1.0000000000000p-252)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 0x1.0000000000000p-127 0x1.0000000000000p-127 0x1.0000000000000p-127 0x1.0000000000000p-127)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 -0x1.0000000000000p-127 -0x1.0000000000000p-127 -0x1.0000000000000p-127 -0x1.0000000000000p-127)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 0x1.921fb60000000p-124 0x1.921fb60000000p-124 0x1.921fb60000000p-124 0x1.921fb60000000p-124)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 -0x1.921fb60000000p-124 -0x1.921fb60000000p-124 -0x1.921fb60000000p-124 -0x1.921fb60000000p-124)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 0x1.fffffe0000000p+1 0x1.fffffe0000000p+1 0x1.fffffe0000000p+1 0x1.fffffe0000000p+1)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 -0x1.fffffe0000000p+1 -0x1.fffffe0000000p+1 -0x1.fffffe0000000p+1 -0x1.fffffe0000000p+1)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 -0x1.0000000000000p-275 -0x1.0000000000000p-275 -0x1.0000000000000p-275 -0x1.0000000000000p-275)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 0x1.0000000000000p-275 0x1.0000000000000p-275 0x1.0000000000000p-275 0x1.0000000000000p-275)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 -0x1.0000000000000p-252 -0x1.0000000000000p-252 -0x1.0000000000000p-252 -0x1.0000000000000p-252)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 0x1.0000000000000p-252 0x1.0000000000000p-252 0x1.0000000000000p-252 0x1.0000000000000p-252)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 -0x1.0000000000000p-127 -0x1.0000000000000p-127 -0x1.0000000000000p-127 -0x1.0000000000000p-127)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 0x1.0000000000000p-127 0x1.0000000000000p-127 0x1.0000000000000p-127 0x1.0000000000000p-127)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 -0x1.921fb60000000p-124 -0x1.921fb60000000p-124 -0x1.921fb60000000p-124 -0x1.921fb60000000p-124)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 0x1.921fb60000000p-124 0x1.921fb60000000p-124 0x1.921fb60000000p-124 0x1.921fb60000000p-124)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 -0x1.fffffe0000000p+1 -0x1.fffffe0000000p+1 -0x1.fffffe0000000p+1 -0x1.fffffe0000000p+1)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 0x1.fffffe0000000p+1 0x1.fffffe0000000p+1 0x1.fffffe0000000p+1 0x1.fffffe0000000p+1)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 0x1.0000000000000p-150 0x1.0000000000000p-150 0x1.0000000000000p-150 0x1.0000000000000p-150)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 -0x1.0000000000000p-150 -0x1.0000000000000p-150 -0x1.0000000000000p-150 -0x1.0000000000000p-150)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 0x1.0000000000000p-127 0x1.0000000000000p-127 0x1.0000000000000p-127 0x1.0000000000000p-127)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 -0x1.0000000000000p-127 -0x1.0000000000000p-127 -0x1.0000000000000p-127 -0x1.0000000000000p-127)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 0x1.0000000000000p-2 0x1.0000000000000p-2 0x1.0000000000000p-2 0x1.0000000000000p-2)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 -0x1.0000000000000p-2 -0x1.0000000000000p-2 -0x1.0000000000000p-2 -0x1.0000000000000p-2)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 0x1.921fb60000000p+1 0x1.921fb60000000p+1 0x1.921fb60000000p+1 0x1.921fb60000000p+1)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 -0x1.921fb60000000p+1 -0x1.921fb60000000p+1 -0x1.921fb60000000p+1 -0x1.921fb60000000p+1)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 0x1.fffffe0000000p+126 0x1.fffffe0000000p+126 0x1.fffffe0000000p+126 0x1.fffffe0000000p+126)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 -0x1.fffffe0000000p+126 -0x1.fffffe0000000p+126 -0x1.fffffe0000000p+126 -0x1.fffffe0000000p+126)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 -0x1.0000000000000p-150 -0x1.0000000000000p-150 -0x1.0000000000000p-150 -0x1.0000000000000p-150)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 0x1.0000000000000p-150 0x1.0000000000000p-150 0x1.0000000000000p-150 0x1.0000000000000p-150)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 -0x1.0000000000000p-127 -0x1.0000000000000p-127 -0x1.0000000000000p-127 -0x1.0000000000000p-127)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 0x1.0000000000000p-127 0x1.0000000000000p-127 0x1.0000000000000p-127 0x1.0000000000000p-127)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 -0x1.0000000000000p-2 -0x1.0000000000000p-2 -0x1.0000000000000p-2 -0x1.0000000000000p-2)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 0x1.0000000000000p-2 0x1.0000000000000p-2 0x1.0000000000000p-2 0x1.0000000000000p-2)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 -0x1.921fb60000000p+1 -0x1.921fb60000000p+1 -0x1.921fb60000000p+1 -0x1.921fb60000000p+1)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 0x1.921fb60000000p+1 0x1.921fb60000000p+1 0x1.921fb60000000p+1 0x1.921fb60000000p+1)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 -0x1.fffffe0000000p+126 -0x1.fffffe0000000p+126 -0x1.fffffe0000000p+126 -0x1.fffffe0000000p+126)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 0x1.fffffe0000000p+126 0x1.fffffe0000000p+126 0x1.fffffe0000000p+126 0x1.fffffe0000000p+126)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 0x1.921fb60000000p-147 0x1.921fb60000000p-147 0x1.921fb60000000p-147 0x1.921fb60000000p-147)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 -0x1.921fb60000000p-147 -0x1.921fb60000000p-147 -0x1.921fb60000000p-147 -0x1.921fb60000000p-147)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 0x1.921fb60000000p-124 0x1.921fb60000000p-124 0x1.921fb60000000p-124 0x1.921fb60000000p-124)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 -0x1.921fb60000000p-124 -0x1.921fb60000000p-124 -0x1.921fb60000000p-124 -0x1.921fb60000000p-124)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 0x1.921fb60000000p+1 0x1.921fb60000000p+1 0x1.921fb60000000p+1 0x1.921fb60000000p+1)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 -0x1.921fb60000000p+1 -0x1.921fb60000000p+1 -0x1.921fb60000000p+1 -0x1.921fb60000000p+1)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 0x1.3bd3cdc2cab20p+5 0x1.3bd3cdc2cab20p+5 0x1.3bd3cdc2cab20p+5 0x1.3bd3cdc2cab20p+5)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 -0x1.3bd3cdc2cab20p+5 -0x1.3bd3cdc2cab20p+5 -0x1.3bd3cdc2cab20p+5 -0x1.3bd3cdc2cab20p+5)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 -0x1.921fb60000000p-147 -0x1.921fb60000000p-147 -0x1.921fb60000000p-147 -0x1.921fb60000000p-147)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 0x1.921fb60000000p-147 0x1.921fb60000000p-147 0x1.921fb60000000p-147 0x1.921fb60000000p-147)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 -0x1.921fb60000000p-124 -0x1.921fb60000000p-124 -0x1.921fb60000000p-124 -0x1.921fb60000000p-124)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 0x1.921fb60000000p-124 0x1.921fb60000000p-124 0x1.921fb60000000p-124 0x1.921fb60000000p-124)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 -0x1.921fb60000000p+1 -0x1.921fb60000000p+1 -0x1.921fb60000000p+1 -0x1.921fb60000000p+1)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 0x1.921fb60000000p+1 0x1.921fb60000000p+1 0x1.921fb60000000p+1 0x1.921fb60000000p+1)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 -0x1.3bd3cdc2cab20p+5 -0x1.3bd3cdc2cab20p+5 -0x1.3bd3cdc2cab20p+5 -0x1.3bd3cdc2cab20p+5)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 0x1.3bd3cdc2cab20p+5 0x1.3bd3cdc2cab20p+5 0x1.3bd3cdc2cab20p+5 0x1.3bd3cdc2cab20p+5)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 0x1.fffffe0000000p-22 0x1.fffffe0000000p-22 0x1.fffffe0000000p-22 0x1.fffffe0000000p-22)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 -0x1.fffffe0000000p-22 -0x1.fffffe0000000p-22 -0x1.fffffe0000000p-22 -0x1.fffffe0000000p-22)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 0x1.fffffe0000000p+1 0x1.fffffe0000000p+1 0x1.fffffe0000000p+1 0x1.fffffe0000000p+1)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 -0x1.fffffe0000000p+1 -0x1.fffffe0000000p+1 -0x1.fffffe0000000p+1 -0x1.fffffe0000000p+1)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 0x1.fffffe0000000p+126 0x1.fffffe0000000p+126 0x1.fffffe0000000p+126 0x1.fffffe0000000p+126)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 -0x1.fffffe0000000p+126 -0x1.fffffe0000000p+126 -0x1.fffffe0000000p+126 -0x1.fffffe0000000p+126)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 -0x1.fffffe0000000p-22 -0x1.fffffe0000000p-22 -0x1.fffffe0000000p-22 -0x1.fffffe0000000p-22)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 0x1.fffffe0000000p-22 0x1.fffffe0000000p-22 0x1.fffffe0000000p-22 0x1.fffffe0000000p-22)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 -0x1.fffffe0000000p+1 -0x1.fffffe0000000p+1 -0x1.fffffe0000000p+1 -0x1.fffffe0000000p+1)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 0x1.fffffe0000000p+1 0x1.fffffe0000000p+1 0x1.fffffe0000000p+1 0x1.fffffe0000000p+1)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 -0x1.fffffe0000000p+126 -0x1.fffffe0000000p+126 -0x1.fffffe0000000p+126 -0x1.fffffe0000000p+126)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 0x1.fffffe0000000p+126 0x1.fffffe0000000p+126 0x1.fffffe0000000p+126 0x1.fffffe0000000p+126)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789) + (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)) + (v128.const f32x4 1.5241579434344448e+16 1.5241579434344448e+16 1.5241579434344448e+16 1.5241579434344448e+16)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019) + (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019) + (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019) + (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)) + (v128.const f32x4 1.5241579025420272e-22 1.5241579025420272e-22 1.5241579025420272e-22 1.5241579025420272e-22)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.) + (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)) + (v128.const f32x4 1.5241579434344448e+16 1.5241579434344448e+16 1.5241579434344448e+16 1.5241579434344448e+16)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019) + (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019) + (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019) + (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)) + (v128.const f32x4 1.5241579025420272e-22 1.5241579025420272e-22 1.5241579025420272e-22 1.5241579025420272e-22)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789) + (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)) + (v128.const f32x4 1.5241579434344448e+16 1.5241579434344448e+16 1.5241579434344448e+16 1.5241579434344448e+16)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f32x4 1.5241579025420272e-22 1.5241579025420272e-22 1.5241579025420272e-22 1.5241579025420272e-22)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF) + (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)) + (v128.const f32x4 0x1.4b66de0000000p+112 0x1.4b66de0000000p+112 0x1.4b66de0000000p+112 0x1.4b66de0000000p+112)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019) + (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019) + (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019) + (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)) + (v128.const f32x4 0x1.4b66de0000000p+74 0x1.4b66de0000000p+74 0x1.4b66de0000000p+74 0x1.4b66de0000000p+74)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.) + (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)) + (v128.const f32x4 0x1.4b66de0000000p+112 0x1.4b66de0000000p+112 0x1.4b66de0000000p+112 0x1.4b66de0000000p+112)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019) + (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019) + (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019) + (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)) + (v128.const f32x4 0x1.4b66de0000000p+74 0x1.4b66de0000000p+74 0x1.4b66de0000000p+74 0x1.4b66de0000000p+74)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF) + (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)) + (v128.const f32x4 0x1.4b66de0000000p+112 0x1.4b66de0000000p+112 0x1.4b66de0000000p+112 0x1.4b66de0000000p+112)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019) + (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019) + (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019) + (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)) + (v128.const f32x4 0x1.4b66de0000000p+74 0x1.4b66de0000000p+74 0x1.4b66de0000000p+74 0x1.4b66de0000000p+74)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 0x1.0000000000000p-23 0x1.0000000000000p-23 0x1.0000000000000p-23 0x1.0000000000000p-23)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 -0x1.0000000000000p-23 -0x1.0000000000000p-23 -0x1.0000000000000p-23 -0x1.0000000000000p-23)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 0x1.0000000000000p-148 0x1.0000000000000p-148 0x1.0000000000000p-148 0x1.0000000000000p-148)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 -0x1.0000000000000p-148 -0x1.0000000000000p-148 -0x1.0000000000000p-148 -0x1.0000000000000p-148)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 0x1.45f306446f9b4p-152 0x1.45f306446f9b4p-152 0x1.45f306446f9b4p-152 0x1.45f306446f9b4p-152)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 -0x1.45f306446f9b4p-152 -0x1.45f306446f9b4p-152 -0x1.45f306446f9b4p-152 -0x1.45f306446f9b4p-152)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 0x1.0000010000010p-277 0x1.0000010000010p-277 0x1.0000010000010p-277 0x1.0000010000010p-277)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 -0x1.0000010000010p-277 -0x1.0000010000010p-277 -0x1.0000010000010p-277 -0x1.0000010000010p-277)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 -0x1.0000000000000p-23 -0x1.0000000000000p-23 -0x1.0000000000000p-23 -0x1.0000000000000p-23)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 0x1.0000000000000p-23 0x1.0000000000000p-23 0x1.0000000000000p-23 0x1.0000000000000p-23)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 -0x1.0000000000000p-148 -0x1.0000000000000p-148 -0x1.0000000000000p-148 -0x1.0000000000000p-148)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 0x1.0000000000000p-148 0x1.0000000000000p-148 0x1.0000000000000p-148 0x1.0000000000000p-148)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 -0x1.45f306446f9b4p-152 -0x1.45f306446f9b4p-152 -0x1.45f306446f9b4p-152 -0x1.45f306446f9b4p-152)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 0x1.45f306446f9b4p-152 0x1.45f306446f9b4p-152 0x1.45f306446f9b4p-152 0x1.45f306446f9b4p-152)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 -0x1.0000010000010p-277 -0x1.0000010000010p-277 -0x1.0000010000010p-277 -0x1.0000010000010p-277)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 0x1.0000010000010p-277 0x1.0000010000010p-277 0x1.0000010000010p-277 0x1.0000010000010p-277)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 0x1.0000000000000p+23 0x1.0000000000000p+23 0x1.0000000000000p+23 0x1.0000000000000p+23)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 -0x1.0000000000000p+23 -0x1.0000000000000p+23 -0x1.0000000000000p+23 -0x1.0000000000000p+23)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 0x1.0000000000000p-125 0x1.0000000000000p-125 0x1.0000000000000p-125 0x1.0000000000000p-125)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 -0x1.0000000000000p-125 -0x1.0000000000000p-125 -0x1.0000000000000p-125 -0x1.0000000000000p-125)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 0x1.45f306446f9b4p-129 0x1.45f306446f9b4p-129 0x1.45f306446f9b4p-129 0x1.45f306446f9b4p-129)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 -0x1.45f306446f9b4p-129 -0x1.45f306446f9b4p-129 -0x1.45f306446f9b4p-129 -0x1.45f306446f9b4p-129)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 0x1.0000010000010p-254 0x1.0000010000010p-254 0x1.0000010000010p-254 0x1.0000010000010p-254)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 -0x1.0000010000010p-254 -0x1.0000010000010p-254 -0x1.0000010000010p-254 -0x1.0000010000010p-254)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 -0x1.0000000000000p+23 -0x1.0000000000000p+23 -0x1.0000000000000p+23 -0x1.0000000000000p+23)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 0x1.0000000000000p+23 0x1.0000000000000p+23 0x1.0000000000000p+23 0x1.0000000000000p+23)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 -0x1.0000000000000p-125 -0x1.0000000000000p-125 -0x1.0000000000000p-125 -0x1.0000000000000p-125)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 0x1.0000000000000p-125 0x1.0000000000000p-125 0x1.0000000000000p-125 0x1.0000000000000p-125)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 -0x1.45f306446f9b4p-129 -0x1.45f306446f9b4p-129 -0x1.45f306446f9b4p-129 -0x1.45f306446f9b4p-129)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 0x1.45f306446f9b4p-129 0x1.45f306446f9b4p-129 0x1.45f306446f9b4p-129 0x1.45f306446f9b4p-129)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 -0x1.0000010000010p-254 -0x1.0000010000010p-254 -0x1.0000010000010p-254 -0x1.0000010000010p-254)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 0x1.0000010000010p-254 0x1.0000010000010p-254 0x1.0000010000010p-254 0x1.0000010000010p-254)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 0x1.0000000000000p+125 0x1.0000000000000p+125 0x1.0000000000000p+125 0x1.0000000000000p+125)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 -0x1.0000000000000p+125 -0x1.0000000000000p+125 -0x1.0000000000000p+125 -0x1.0000000000000p+125)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 0x1.45f306446f9b4p-4 0x1.45f306446f9b4p-4 0x1.45f306446f9b4p-4 0x1.45f306446f9b4p-4)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 -0x1.45f306446f9b4p-4 -0x1.45f306446f9b4p-4 -0x1.45f306446f9b4p-4 -0x1.45f306446f9b4p-4)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 0x1.0000010000010p-129 0x1.0000010000010p-129 0x1.0000010000010p-129 0x1.0000010000010p-129)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 -0x1.0000010000010p-129 -0x1.0000010000010p-129 -0x1.0000010000010p-129 -0x1.0000010000010p-129)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 -0x1.0000000000000p+125 -0x1.0000000000000p+125 -0x1.0000000000000p+125 -0x1.0000000000000p+125)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 0x1.0000000000000p+125 0x1.0000000000000p+125 0x1.0000000000000p+125 0x1.0000000000000p+125)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 -0x1.45f306446f9b4p-4 -0x1.45f306446f9b4p-4 -0x1.45f306446f9b4p-4 -0x1.45f306446f9b4p-4)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 0x1.45f306446f9b4p-4 0x1.45f306446f9b4p-4 0x1.45f306446f9b4p-4 0x1.45f306446f9b4p-4)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 -0x1.0000010000010p-129 -0x1.0000010000010p-129 -0x1.0000010000010p-129 -0x1.0000010000010p-129)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 0x1.0000010000010p-129 0x1.0000010000010p-129 0x1.0000010000010p-129 0x1.0000010000010p-129)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 0x1.0000000000000p+126 0x1.0000000000000p+126 0x1.0000000000000p+126 0x1.0000000000000p+126)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 -0x1.0000000000000p+126 -0x1.0000000000000p+126 -0x1.0000000000000p+126 -0x1.0000000000000p+126)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 0x1.0000000000000p+1 0x1.0000000000000p+1 0x1.0000000000000p+1 0x1.0000000000000p+1)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 -0x1.0000000000000p+1 -0x1.0000000000000p+1 -0x1.0000000000000p+1 -0x1.0000000000000p+1)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 0x1.45f306446f9b4p-3 0x1.45f306446f9b4p-3 0x1.45f306446f9b4p-3 0x1.45f306446f9b4p-3)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 -0x1.45f306446f9b4p-3 -0x1.45f306446f9b4p-3 -0x1.45f306446f9b4p-3 -0x1.45f306446f9b4p-3)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 0x1.0000010000010p-128 0x1.0000010000010p-128 0x1.0000010000010p-128 0x1.0000010000010p-128)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 -0x1.0000010000010p-128 -0x1.0000010000010p-128 -0x1.0000010000010p-128 -0x1.0000010000010p-128)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 -0x1.0000000000000p+126 -0x1.0000000000000p+126 -0x1.0000000000000p+126 -0x1.0000000000000p+126)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 0x1.0000000000000p+126 0x1.0000000000000p+126 0x1.0000000000000p+126 0x1.0000000000000p+126)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 -0x1.0000000000000p+1 -0x1.0000000000000p+1 -0x1.0000000000000p+1 -0x1.0000000000000p+1)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 0x1.0000000000000p+1 0x1.0000000000000p+1 0x1.0000000000000p+1 0x1.0000000000000p+1)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 -0x1.45f306446f9b4p-3 -0x1.45f306446f9b4p-3 -0x1.45f306446f9b4p-3 -0x1.45f306446f9b4p-3)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 0x1.45f306446f9b4p-3 0x1.45f306446f9b4p-3 0x1.45f306446f9b4p-3 0x1.45f306446f9b4p-3)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 -0x1.0000010000010p-128 -0x1.0000010000010p-128 -0x1.0000010000010p-128 -0x1.0000010000010p-128)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 0x1.0000010000010p-128 0x1.0000010000010p-128 0x1.0000010000010p-128 0x1.0000010000010p-128)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 0x1.921fb60000000p+3 0x1.921fb60000000p+3 0x1.921fb60000000p+3 0x1.921fb60000000p+3)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 -0x1.921fb60000000p+3 -0x1.921fb60000000p+3 -0x1.921fb60000000p+3 -0x1.921fb60000000p+3)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 0x1.921fb7921fb79p-126 0x1.921fb7921fb79p-126 0x1.921fb7921fb79p-126 0x1.921fb7921fb79p-126)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 -0x1.921fb7921fb79p-126 -0x1.921fb7921fb79p-126 -0x1.921fb7921fb79p-126 -0x1.921fb7921fb79p-126)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 -0x1.921fb60000000p+3 -0x1.921fb60000000p+3 -0x1.921fb60000000p+3 -0x1.921fb60000000p+3)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 0x1.921fb60000000p+3 0x1.921fb60000000p+3 0x1.921fb60000000p+3 0x1.921fb60000000p+3)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 -0x1.921fb7921fb79p-126 -0x1.921fb7921fb79p-126 -0x1.921fb7921fb79p-126 -0x1.921fb7921fb79p-126)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 0x1.921fb7921fb79p-126 0x1.921fb7921fb79p-126 0x1.921fb7921fb79p-126 0x1.921fb7921fb79p-126)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 0x1.45f304fe7c950p+125 0x1.45f304fe7c950p+125 0x1.45f304fe7c950p+125 0x1.45f304fe7c950p+125)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 -0x1.45f304fe7c950p+125 -0x1.45f304fe7c950p+125 -0x1.45f304fe7c950p+125 -0x1.45f304fe7c950p+125)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 -0x1.45f304fe7c950p+125 -0x1.45f304fe7c950p+125 -0x1.45f304fe7c950p+125 -0x1.45f304fe7c950p+125)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 0x1.45f304fe7c950p+125 0x1.45f304fe7c950p+125 0x1.45f304fe7c950p+125 0x1.45f304fe7c950p+125)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789) + (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)) + (v128.const f32x4 1.0 1.0 1.0 1.0)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019) + (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)) + (v128.const f32x4 1.0 1.0 1.0 1.0)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019) + (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)) + (v128.const f32x4 1.0 1.0 1.0 1.0)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019) + (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)) + (v128.const f32x4 1.0 1.0 1.0 1.0)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.) + (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)) + (v128.const f32x4 1.0 1.0 1.0 1.0)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019) + (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)) + (v128.const f32x4 1.0 1.0 1.0 1.0)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019) + (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)) + (v128.const f32x4 1.0 1.0 1.0 1.0)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019) + (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)) + (v128.const f32x4 1.0 1.0 1.0 1.0)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789) + (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)) + (v128.const f32x4 1.0 1.0 1.0 1.0)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f32x4 1.0 1.0 1.0 1.0)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f32x4 1.0 1.0 1.0 1.0)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f32x4 1.0 1.0 1.0 1.0)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF) + (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019) + (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019) + (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019) + (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.) + (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019) + (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019) + (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019) + (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF) + (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019) + (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019) + (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.div" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019) + (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) +(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 0x1.6a09e667f3bcdp-75 0x1.6a09e667f3bcdp-75 0x1.6a09e667f3bcdp-75 0x1.6a09e667f3bcdp-75)) +(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 0x1.0000000000000p-63 0x1.0000000000000p-63 0x1.0000000000000p-63 0x1.0000000000000p-63)) +(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 0x1.6a09e667f3bcdp-1 0x1.6a09e667f3bcdp-1 0x1.6a09e667f3bcdp-1 0x1.6a09e667f3bcdp-1)) +(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 0x1.40d9324a48138p+1 0x1.40d9324a48138p+1 0x1.40d9324a48138p+1 0x1.40d9324a48138p+1)) +(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 0x1.fffffeffffffcp+63 0x1.fffffeffffffcp+63 0x1.fffffeffffffcp+63 0x1.fffffeffffffcp+63)) +(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)) + (v128.const f32x4 11111.111060555555 11111.111060555555 11111.111060555555 11111.111060555555)) +(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)) + (v128.const f32x4 35136418286444.62 35136418286444.62 35136418286444.62 35136418286444.62)) +(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)) + (v128.const f32x4 35136418286444.62 35136418286444.62 35136418286444.62 35136418286444.62)) +(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)) + (v128.const f32x4 3.5136418286444623e-06 3.5136418286444623e-06 3.5136418286444623e-06 3.5136418286444623e-06)) +(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)) + (v128.const f32x4 11111.111060555555 11111.111060555555 11111.111060555555 11111.111060555555)) +(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)) + (v128.const f32x4 35136418286444.62 35136418286444.62 35136418286444.62 35136418286444.62)) +(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)) + (v128.const f32x4 35136418286444.62 35136418286444.62 35136418286444.62 35136418286444.62)) +(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)) + (v128.const f32x4 3.5136418286444623e-06 3.5136418286444623e-06 3.5136418286444623e-06 3.5136418286444623e-06)) +(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)) + (v128.const f32x4 11111.11106111111 11111.11106111111 11111.11106111111 11111.11106111111)) +(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f32x4 35136418288201.445 35136418288201.445 35136418288201.445 35136418288201.445)) +(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f32x4 35136418288201.445 35136418288201.445 35136418288201.445 35136418288201.445)) +(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f32x4 3.513641828820144e-06 3.513641828820144e-06 3.513641828820144e-06 3.513641828820144e-06)) +(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)) + (v128.const f32x4 0x1.1111111111111p+28 0x1.1111111111111p+28 0x1.1111111111111p+28 0x1.1111111111111p+28)) +(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)) + (v128.const f32x4 0x1.822cb17ff2eb8p+37 0x1.822cb17ff2eb8p+37 0x1.822cb17ff2eb8p+37 0x1.822cb17ff2eb8p+37)) +(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)) + (v128.const f32x4 0x1.822cb17ff2eb8p+37 0x1.822cb17ff2eb8p+37 0x1.822cb17ff2eb8p+37 0x1.822cb17ff2eb8p+37)) +(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)) + (v128.const f32x4 0x1.822cb17ff2eb8p+18 0x1.822cb17ff2eb8p+18 0x1.822cb17ff2eb8p+18 0x1.822cb17ff2eb8p+18)) +(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)) + (v128.const f32x4 0x1.1111111111111p+28 0x1.1111111111111p+28 0x1.1111111111111p+28 0x1.1111111111111p+28)) +(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)) + (v128.const f32x4 0x1.822cb17ff2eb8p+37 0x1.822cb17ff2eb8p+37 0x1.822cb17ff2eb8p+37 0x1.822cb17ff2eb8p+37)) +(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)) + (v128.const f32x4 0x1.822cb17ff2eb8p+37 0x1.822cb17ff2eb8p+37 0x1.822cb17ff2eb8p+37 0x1.822cb17ff2eb8p+37)) +(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)) + (v128.const f32x4 0x1.822cb17ff2eb8p+18 0x1.822cb17ff2eb8p+18 0x1.822cb17ff2eb8p+18 0x1.822cb17ff2eb8p+18)) +(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)) + (v128.const f32x4 0x1.1111111111111p+28 0x1.1111111111111p+28 0x1.1111111111111p+28 0x1.1111111111111p+28)) +(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)) + (v128.const f32x4 0x1.822cb17ff2eb8p+37 0x1.822cb17ff2eb8p+37 0x1.822cb17ff2eb8p+37 0x1.822cb17ff2eb8p+37)) +(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)) + (v128.const f32x4 0x1.822cb17ff2eb8p+37 0x1.822cb17ff2eb8p+37 0x1.822cb17ff2eb8p+37 0x1.822cb17ff2eb8p+37)) +(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)) + (v128.const f32x4 0x1.822cb17ff2eb8p+18 0x1.822cb17ff2eb8p+18 0x1.822cb17ff2eb8p+18 0x1.822cb17ff2eb8p+18)) +(assert_return (invoke "f32x4.neg" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.neg" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.neg" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.neg" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.neg" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.neg" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.neg" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.neg" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.neg" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.neg" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.neg" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.neg" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.neg" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.neg" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.neg" (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.neg" (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.neg" (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 -nan -nan -nan -nan)) +(assert_return (invoke "f32x4.neg" (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 nan nan nan nan)) +(assert_return (invoke "f32x4.neg" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) +(assert_return (invoke "f32x4.neg" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) +(assert_return (invoke "f32x4.neg" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)) + (v128.const f32x4 -123456789.0 -123456789.0 -123456789.0 -123456789.0)) +(assert_return (invoke "f32x4.neg" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)) + (v128.const f32x4 -1.23456789e+27 -1.23456789e+27 -1.23456789e+27 -1.23456789e+27)) +(assert_return (invoke "f32x4.neg" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)) + (v128.const f32x4 -1.23456789e+27 -1.23456789e+27 -1.23456789e+27 -1.23456789e+27)) +(assert_return (invoke "f32x4.neg" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)) + (v128.const f32x4 -1.23456789e-11 -1.23456789e-11 -1.23456789e-11 -1.23456789e-11)) +(assert_return (invoke "f32x4.neg" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)) + (v128.const f32x4 -123456789.0 -123456789.0 -123456789.0 -123456789.0)) +(assert_return (invoke "f32x4.neg" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)) + (v128.const f32x4 -1.23456789e+27 -1.23456789e+27 -1.23456789e+27 -1.23456789e+27)) +(assert_return (invoke "f32x4.neg" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)) + (v128.const f32x4 -1.23456789e+27 -1.23456789e+27 -1.23456789e+27 -1.23456789e+27)) +(assert_return (invoke "f32x4.neg" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)) + (v128.const f32x4 -1.23456789e-11 -1.23456789e-11 -1.23456789e-11 -1.23456789e-11)) +(assert_return (invoke "f32x4.neg" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)) + (v128.const f32x4 -123456789.01234567 -123456789.01234567 -123456789.01234567 -123456789.01234567)) +(assert_return (invoke "f32x4.neg" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f32x4 -1.2345678901234569e+27 -1.2345678901234569e+27 -1.2345678901234569e+27 -1.2345678901234569e+27)) +(assert_return (invoke "f32x4.neg" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f32x4 -1.2345678901234569e+27 -1.2345678901234569e+27 -1.2345678901234569e+27 -1.2345678901234569e+27)) +(assert_return (invoke "f32x4.neg" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f32x4 -1.2345678901234568e-11 -1.2345678901234568e-11 -1.2345678901234568e-11 -1.2345678901234568e-11)) +(assert_return (invoke "f32x4.neg" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)) + (v128.const f32x4 -0x1.23456789abcdfp+56 -0x1.23456789abcdfp+56 -0x1.23456789abcdfp+56 -0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.neg" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)) + (v128.const f32x4 -0x1.23456789abcdfp+75 -0x1.23456789abcdfp+75 -0x1.23456789abcdfp+75 -0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.neg" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)) + (v128.const f32x4 -0x1.23456789abcdfp+75 -0x1.23456789abcdfp+75 -0x1.23456789abcdfp+75 -0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.neg" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)) + (v128.const f32x4 -0x1.23456789abcdfp+37 -0x1.23456789abcdfp+37 -0x1.23456789abcdfp+37 -0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.neg" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)) + (v128.const f32x4 -0x1.23456789abcdfp+56 -0x1.23456789abcdfp+56 -0x1.23456789abcdfp+56 -0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.neg" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)) + (v128.const f32x4 -0x1.23456789abcdfp+75 -0x1.23456789abcdfp+75 -0x1.23456789abcdfp+75 -0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.neg" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)) + (v128.const f32x4 -0x1.23456789abcdfp+75 -0x1.23456789abcdfp+75 -0x1.23456789abcdfp+75 -0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.neg" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)) + (v128.const f32x4 -0x1.23456789abcdfp+37 -0x1.23456789abcdfp+37 -0x1.23456789abcdfp+37 -0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.neg" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)) + (v128.const f32x4 -0x1.23456789abcdfp+56 -0x1.23456789abcdfp+56 -0x1.23456789abcdfp+56 -0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.neg" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)) + (v128.const f32x4 -0x1.23456789abcdfp+75 -0x1.23456789abcdfp+75 -0x1.23456789abcdfp+75 -0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.neg" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)) + (v128.const f32x4 -0x1.23456789abcdfp+75 -0x1.23456789abcdfp+75 -0x1.23456789abcdfp+75 -0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.neg" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)) + (v128.const f32x4 -0x1.23456789abcdfp+37 -0x1.23456789abcdfp+37 -0x1.23456789abcdfp+37 -0x1.23456789abcdfp+37)) + + +;; Mixed f32x4 tests when some lanes are NaNs +(module + + (func (export "f32x4_sqrt_arith") (result v128) + (f32x4.sqrt (v128.const f32x4 nan:0x200000 -nan:0x200000 16.0 25.0))) + (func (export "f32x4_sqrt_canon") (result v128) + (f32x4.sqrt (v128.const f32x4 -1.0 nan 4.0 9.0))) + (func (export "f32x4_sqrt_mixed") (result v128) + (f32x4.sqrt (v128.const f32x4 -inf nan:0x200000 36.0 49.0))) +) + +(assert_return (invoke "f32x4_sqrt_arith") (v128.const f32x4 nan:arithmetic nan:arithmetic 4.0 5.0)) +(assert_return (invoke "f32x4_sqrt_canon") (v128.const f32x4 nan:canonical nan:canonical 2.0 3.0)) +(assert_return (invoke "f32x4_sqrt_mixed") (v128.const f32x4 nan:canonical nan:arithmetic 6.0 7.0)) + +;; type check +(assert_invalid (module (func (result v128) (f32x4.neg (i32.const 0)))) "type mismatch") +(assert_invalid (module (func (result v128) (f32x4.sqrt (i32.const 0)))) "type mismatch") +(assert_invalid (module (func (result v128) (f32x4.add (i32.const 0) (f32.const 0.0)))) "type mismatch") +(assert_invalid (module (func (result v128) (f32x4.sub (i32.const 0) (f32.const 0.0)))) "type mismatch") +(assert_invalid (module (func (result v128) (f32x4.mul (i32.const 0) (f32.const 0.0)))) "type mismatch") +(assert_invalid (module (func (result v128) (f32x4.div (i32.const 0) (f32.const 0.0)))) "type mismatch") + +;; Test operation with empty argument + +(assert_invalid + (module + (func $f32x4.neg-arg-empty (result v128) + (f32x4.neg) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $f32x4.sqrt-arg-empty (result v128) + (f32x4.sqrt) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $f32x4.add-1st-arg-empty (result v128) + (f32x4.add (v128.const f32x4 0 0 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $f32x4.add-arg-empty (result v128) + (f32x4.add) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $f32x4.sub-1st-arg-empty (result v128) + (f32x4.sub (v128.const f32x4 0 0 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $f32x4.sub-arg-empty (result v128) + (f32x4.sub) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $f32x4.mul-1st-arg-empty (result v128) + (f32x4.mul (v128.const f32x4 0 0 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $f32x4.mul-arg-empty (result v128) + (f32x4.mul) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $f32x4.div-1st-arg-empty (result v128) + (f32x4.div (v128.const f32x4 0 0 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $f32x4.div-arg-empty (result v128) + (f32x4.div) + ) + ) + "type mismatch" +) + +;; combination +(module + (func (export "add-sub") (param v128 v128 v128) (result v128) + (f32x4.add (f32x4.sub (local.get 0) (local.get 1))(local.get 2))) + (func (export "div-add") (param v128 v128 v128) (result v128) + (f32x4.div (f32x4.add (local.get 0) (local.get 1))(local.get 2))) + (func (export "div-mul") (param v128 v128 v128) (result v128) + (f32x4.div (f32x4.mul (local.get 0) (local.get 1))(local.get 2))) + (func (export "div-sub") (param v128 v128 v128) (result v128) + (f32x4.div (f32x4.sub (local.get 0) (local.get 1))(local.get 2))) + (func (export "mul-add") (param v128 v128 v128) (result v128) + (f32x4.mul (f32x4.add (local.get 0) (local.get 1))(local.get 2))) + (func (export "mul-div") (param v128 v128 v128) (result v128) + (f32x4.mul (f32x4.div (local.get 0) (local.get 1))(local.get 2))) + (func (export "mul-sub") (param v128 v128 v128) (result v128) + (f32x4.mul (f32x4.sub (local.get 0) (local.get 1))(local.get 2))) + (func (export "sub-add") (param v128 v128 v128) (result v128) + (f32x4.sub (f32x4.add (local.get 0) (local.get 1))(local.get 2))) + (func (export "add-neg") (param v128 v128) (result v128) + (f32x4.add (f32x4.neg (local.get 0)) (local.get 1))) + (func (export "add-sqrt") (param v128 v128) (result v128) + (f32x4.add (f32x4.sqrt (local.get 0)) (local.get 1))) + (func (export "div-neg") (param v128 v128) (result v128) + (f32x4.div (f32x4.neg (local.get 0)) (local.get 1))) + (func (export "div-sqrt") (param v128 v128) (result v128) + (f32x4.div (f32x4.sqrt (local.get 0)) (local.get 1))) + (func (export "mul-neg") (param v128 v128) (result v128) + (f32x4.mul (f32x4.neg (local.get 0)) (local.get 1))) + (func (export "mul-sqrt") (param v128 v128) (result v128) + (f32x4.mul (f32x4.sqrt (local.get 0)) (local.get 1))) + (func (export "sub-neg") (param v128 v128) (result v128) + (f32x4.sub (f32x4.neg (local.get 0)) (local.get 1))) + (func (export "sub-sqrt") (param v128 v128) (result v128) + (f32x4.sub (f32x4.sqrt (local.get 0)) (local.get 1))) +) + +(assert_return (invoke "add-sub" (v128.const f32x4 1.125 1.125 1.125 1.125) + (v128.const f32x4 0.25 0.25 0.25 0.25) + (v128.const f32x4 0.125 0.125 0.125 0.125)) + (v128.const f32x4 1.0 1.0 1.0 1.0)) +(assert_return (invoke "div-add" (v128.const f32x4 1.125 1.125 1.125 1.125) + (v128.const f32x4 0.125 0.125 0.125 0.125) + (v128.const f32x4 0.25 0.25 0.25 0.25)) + (v128.const f32x4 5.0 5.0 5.0 5.0)) +(assert_return (invoke "div-mul" (v128.const f32x4 1.125 1.125 1.125 1.125) + (v128.const f32x4 4 4 4 4) + (v128.const f32x4 0.25 0.25 0.25 0.25)) + (v128.const f32x4 18.0 18.0 18.0 18.0)) +(assert_return (invoke "div-sub" (v128.const f32x4 1.125 1.125 1.125 1.125) + (v128.const f32x4 0.125 0.125 0.125 0.125) + (v128.const f32x4 0.25 0.25 0.25 0.25)) + (v128.const f32x4 4.0 4.0 4.0 4.0)) +(assert_return (invoke "mul-add" (v128.const f32x4 1.25 1.25 1.25 1.25) + (v128.const f32x4 0.25 0.25 0.25 0.25) + (v128.const f32x4 0.25 0.25 0.25 0.25)) + (v128.const f32x4 0.375 0.375 0.375 0.375)) +(assert_return (invoke "mul-div" (v128.const f32x4 1.125 1.125 1.125 1.125) + (v128.const f32x4 0.125 0.125 0.125 0.125) + (v128.const f32x4 0.25 0.25 0.25 0.25)) + (v128.const f32x4 2.25 2.25 2.25 2.25)) +(assert_return (invoke "mul-sub" (v128.const f32x4 1.125 1.125 1.125 1.125) + (v128.const f32x4 0.125 0.125 0.125 0.125) + (v128.const f32x4 0.25 0.25 0.25 0.25)) + (v128.const f32x4 0.25 0.25 0.25 0.25)) +(assert_return (invoke "sub-add" (v128.const f32x4 1.125 1.125 1.125 1.125) + (v128.const f32x4 0.25 0.25 0.25 0.25) + (v128.const f32x4 0.125 0.125 0.125 0.125)) + (v128.const f32x4 1.25 1.25 1.25 1.25)) +(assert_return (invoke "add-neg" (v128.const f32x4 1.125 1.125 1.125 1.125) + (v128.const f32x4 0.125 0.125 0.125 0.125)) + (v128.const f32x4 -1.0 -1.0 -1.0 -1.0)) +(assert_return (invoke "add-sqrt" (v128.const f32x4 2.25 2.25 2.25 2.25) + (v128.const f32x4 0.25 0.25 0.25 0.25)) + (v128.const f32x4 1.75 1.75 1.75 1.75)) +(assert_return (invoke "div-neg" (v128.const f32x4 1.5 1.5 1.5 1.5) + (v128.const f32x4 0.25 0.25 0.25 0.25)) + (v128.const f32x4 -6 -6 -6 -6)) +(assert_return (invoke "div-sqrt" (v128.const f32x4 2.25 2.25 2.25 2.25) + (v128.const f32x4 0.25 0.25 0.25 0.25)) + (v128.const f32x4 6 6 6 6)) +(assert_return (invoke "mul-neg" (v128.const f32x4 1.5 1.5 1.5 1.5) + (v128.const f32x4 0.25 0.25 0.25 0.25)) + (v128.const f32x4 -0.375 -0.375 -0.375 -0.375)) +(assert_return (invoke "mul-sqrt" (v128.const f32x4 2.25 2.25 2.25 2.25) + (v128.const f32x4 0.25 0.25 0.25 0.25)) + (v128.const f32x4 0.375 0.375 0.375 0.375)) +(assert_return (invoke "sub-neg" (v128.const f32x4 1.125 1.125 1.125 1.125) + (v128.const f32x4 0.125 0.125 0.125 0.125)) + (v128.const f32x4 -1.25 -1.25 -1.25 -1.25)) +(assert_return (invoke "sub-sqrt" (v128.const f32x4 2.25 2.25 2.25 2.25) + (v128.const f32x4 0.25 0.25 0.25 0.25)) + (v128.const f32x4 1.25 1.25 1.25 1.25)) \ No newline at end of file diff --git a/runtime/near-vm/tests/wast/spec/proposals/simd/simd_f32x4_cmp.wast b/runtime/near-vm/tests/wast/spec/proposals/simd/simd_f32x4_cmp.wast new file mode 100644 index 00000000000..9e9a8735bfc --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/proposals/simd/simd_f32x4_cmp.wast @@ -0,0 +1,8167 @@ +;; Test all the f32x4 comparison operators on major boundary values and all special values. + +(module + (func (export "eq") (param $x v128) (param $y v128) (result v128) (f32x4.eq (local.get $x) (local.get $y))) + (func (export "ne") (param $x v128) (param $y v128) (result v128) (f32x4.ne (local.get $x) (local.get $y))) + (func (export "lt") (param $x v128) (param $y v128) (result v128) (f32x4.lt (local.get $x) (local.get $y))) + (func (export "le") (param $x v128) (param $y v128) (result v128) (f32x4.le (local.get $x) (local.get $y))) + (func (export "gt") (param $x v128) (param $y v128) (result v128) (f32x4.gt (local.get $x) (local.get $y))) + (func (export "ge") (param $x v128) (param $y v128) (result v128) (f32x4.ge (local.get $x) (local.get $y))) +) + +;; eq +(assert_return (invoke "eq" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 nan nan nan nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 inf inf inf inf)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 nan nan nan nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "eq" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 inf inf inf inf)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 nan nan nan nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 inf inf inf inf)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 nan nan nan nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "eq" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 inf inf inf inf)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 nan nan nan nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "eq" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 inf inf inf inf)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 nan nan nan nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "eq" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 inf inf inf inf)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 nan nan nan nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "eq" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 inf inf inf inf)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 nan nan nan nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "eq" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "eq" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 inf inf inf inf)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 nan nan nan nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "eq" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 inf inf inf inf)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 nan nan nan nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "eq" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 inf inf inf inf)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 nan nan nan nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 inf inf inf inf)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 nan nan nan nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "eq" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 inf inf inf inf)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 nan nan nan nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "eq" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 inf inf inf inf)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 nan nan nan nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "eq" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 inf inf inf inf)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 nan nan nan nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "eq" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 inf inf inf inf)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 nan nan nan nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 inf inf inf inf)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 nan nan nan nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "eq" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "eq" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 inf inf inf inf)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 nan nan nan nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 inf inf inf inf)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "eq" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 nan nan nan nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 inf inf inf inf)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "eq" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 nan nan nan nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 inf inf inf inf)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "eq" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019) + (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "eq" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019) + (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019) + (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "eq" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019) + (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "eq" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019) + (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019) + (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019) + (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "eq" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019) + (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019) + (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019) + (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019) + (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "eq" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019) + (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019) + (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "eq" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019) + (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "eq" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019) + (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019) + (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "eq" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019) + (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019) + (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "eq" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019) + (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "eq" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019) + (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789) + (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789) + (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789) + (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789) + (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789) + (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)) + (v128.const i32x4 -1 -1 -1 -1)) + +;; ne +(assert_return (invoke "ne" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 nan nan nan nan)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 inf inf inf inf)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 nan nan nan nan)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ne" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 inf inf inf inf)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 nan nan nan nan)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 inf inf inf inf)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 nan nan nan nan)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ne" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 inf inf inf inf)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 nan nan nan nan)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ne" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 inf inf inf inf)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 nan nan nan nan)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ne" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 inf inf inf inf)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 nan nan nan nan)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ne" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 inf inf inf inf)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 nan nan nan nan)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ne" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ne" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 inf inf inf inf)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 nan nan nan nan)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ne" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 inf inf inf inf)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 nan nan nan nan)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ne" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 inf inf inf inf)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 nan nan nan nan)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 inf inf inf inf)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 nan nan nan nan)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ne" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 inf inf inf inf)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 nan nan nan nan)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ne" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 inf inf inf inf)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 nan nan nan nan)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ne" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 inf inf inf inf)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 nan nan nan nan)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ne" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 inf inf inf inf)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 nan nan nan nan)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 inf inf inf inf)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 nan nan nan nan)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ne" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ne" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 inf inf inf inf)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 nan nan nan nan)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 inf inf inf inf)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ne" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 nan nan nan nan)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 inf inf inf inf)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ne" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 nan nan nan nan)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 inf inf inf inf)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ne" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019) + (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ne" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019) + (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019) + (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ne" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019) + (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ne" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019) + (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019) + (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019) + (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ne" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019) + (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019) + (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019) + (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019) + (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ne" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019) + (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019) + (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ne" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019) + (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ne" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019) + (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019) + (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ne" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019) + (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019) + (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ne" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019) + (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ne" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019) + (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789) + (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789) + (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789) + (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789) + (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789) + (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)) + (v128.const i32x4 0 0 0 0)) + +;; lt +(assert_return (invoke "lt" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 nan nan nan nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 inf inf inf inf)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 nan nan nan nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "lt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "lt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "lt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "lt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 inf inf inf inf)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "lt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "lt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 nan nan nan nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 inf inf inf inf)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 nan nan nan nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "lt" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "lt" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "lt" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "lt" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "lt" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "lt" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "lt" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "lt" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "lt" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "lt" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "lt" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "lt" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 inf inf inf inf)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "lt" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "lt" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "lt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 nan nan nan nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "lt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 inf inf inf inf)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "lt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 nan nan nan nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "lt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "lt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 inf inf inf inf)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "lt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 nan nan nan nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "lt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "lt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "lt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "lt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "lt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "lt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "lt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "lt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "lt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "lt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "lt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 inf inf inf inf)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "lt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "lt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "lt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 nan nan nan nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "lt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "lt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "lt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "lt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "lt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 inf inf inf inf)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "lt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "lt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 nan nan nan nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "lt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "lt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "lt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "lt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "lt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "lt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "lt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "lt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "lt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 inf inf inf inf)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "lt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "lt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 nan nan nan nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 inf inf inf inf)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "lt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 nan nan nan nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 inf inf inf inf)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 nan nan nan nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "lt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "lt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "lt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "lt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "lt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "lt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "lt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 inf inf inf inf)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "lt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "lt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 nan nan nan nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "lt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "lt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "lt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "lt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "lt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "lt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "lt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "lt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 inf inf inf inf)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "lt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "lt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 nan nan nan nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "lt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "lt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "lt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 inf inf inf inf)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "lt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 nan nan nan nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "lt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "lt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "lt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "lt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "lt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "lt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "lt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "lt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "lt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "lt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 inf inf inf inf)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "lt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "lt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "lt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 nan nan nan nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 inf inf inf inf)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 nan nan nan nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "lt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "lt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "lt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "lt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "lt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 inf inf inf inf)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "lt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "lt" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 nan nan nan nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 inf inf inf inf)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 nan nan nan nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "lt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "lt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "lt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "lt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "lt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "lt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "lt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "lt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "lt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "lt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 inf inf inf inf)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "lt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "lt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 nan nan nan nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "lt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "lt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "lt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "lt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 inf inf inf inf)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "lt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019) + (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019) + (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019) + (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019) + (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019) + (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019) + (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "lt" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019) + (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019) + (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "lt" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019) + (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "lt" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019) + (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "lt" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019) + (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019) + (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019) + (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019) + (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019) + (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019) + (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019) + (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019) + (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019) + (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019) + (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789) + (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "lt" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789) + (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789) + (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "lt" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789) + (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "lt" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789) + (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)) + (v128.const i32x4 0 0 0 0)) + +;; le +(assert_return (invoke "le" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 nan nan nan nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 inf inf inf inf)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 nan nan nan nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 inf inf inf inf)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 nan nan nan nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 inf inf inf inf)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 nan nan nan nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 inf inf inf inf)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 nan nan nan nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 inf inf inf inf)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 nan nan nan nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 inf inf inf inf)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 nan nan nan nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 inf inf inf inf)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 nan nan nan nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 inf inf inf inf)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 nan nan nan nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 inf inf inf inf)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 nan nan nan nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 inf inf inf inf)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 nan nan nan nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 inf inf inf inf)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 nan nan nan nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 inf inf inf inf)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 nan nan nan nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 inf inf inf inf)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 nan nan nan nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 inf inf inf inf)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 nan nan nan nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 inf inf inf inf)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 nan nan nan nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 inf inf inf inf)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 nan nan nan nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 inf inf inf inf)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 nan nan nan nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 inf inf inf inf)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 nan nan nan nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 inf inf inf inf)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 nan nan nan nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 inf inf inf inf)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019) + (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019) + (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019) + (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019) + (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019) + (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019) + (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019) + (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019) + (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019) + (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019) + (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019) + (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019) + (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019) + (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019) + (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019) + (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019) + (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019) + (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019) + (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019) + (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019) + (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789) + (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789) + (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789) + (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789) + (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789) + (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)) + (v128.const i32x4 -1 -1 -1 -1)) + +;; gt +(assert_return (invoke "gt" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 nan nan nan nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 inf inf inf inf)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 nan nan nan nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "gt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "gt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "gt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "gt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "gt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "gt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "gt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "gt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 inf inf inf inf)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "gt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 nan nan nan nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 inf inf inf inf)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 nan nan nan nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 inf inf inf inf)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 nan nan nan nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "gt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "gt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "gt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "gt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "gt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "gt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "gt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "gt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "gt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "gt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "gt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 inf inf inf inf)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "gt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "gt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 nan nan nan nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "gt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "gt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "gt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "gt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "gt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "gt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "gt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "gt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "gt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "gt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 inf inf inf inf)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "gt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "gt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 nan nan nan nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "gt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 inf inf inf inf)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 nan nan nan nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "gt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "gt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "gt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "gt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "gt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "gt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 inf inf inf inf)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "gt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 nan nan nan nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "gt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "gt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "gt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 inf inf inf inf)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "gt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 nan nan nan nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "gt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "gt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "gt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "gt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "gt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "gt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "gt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "gt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "gt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "gt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "gt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "gt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 inf inf inf inf)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "gt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "gt" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 nan nan nan nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 inf inf inf inf)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 nan nan nan nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "gt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "gt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "gt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "gt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "gt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 inf inf inf inf)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "gt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 nan nan nan nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "gt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "gt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "gt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "gt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 inf inf inf inf)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "gt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 nan nan nan nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "gt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "gt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "gt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "gt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "gt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "gt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "gt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "gt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "gt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 inf inf inf inf)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "gt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "gt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 nan nan nan nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "gt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "gt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 inf inf inf inf)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 nan nan nan nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 inf inf inf inf)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 nan nan nan nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "gt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "gt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "gt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "gt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "gt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "gt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 inf inf inf inf)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "gt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 nan nan nan nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "gt" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "gt" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "gt" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "gt" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "gt" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "gt" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "gt" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "gt" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "gt" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "gt" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "gt" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "gt" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "gt" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 inf inf inf inf)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "gt" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "gt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 nan nan nan nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "gt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "gt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "gt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 inf inf inf inf)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 nan nan nan nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "gt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "gt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "gt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "gt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "gt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "gt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "gt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "gt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "gt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 inf inf inf inf)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "gt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019) + (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019) + (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "gt" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019) + (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019) + (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019) + (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "gt" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019) + (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019) + (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019) + (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019) + (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019) + (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019) + (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019) + (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "gt" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019) + (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019) + (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019) + (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "gt" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019) + (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019) + (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "gt" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019) + (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019) + (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019) + (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "gt" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789) + (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789) + (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "gt" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789) + (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789) + (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789) + (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)) + (v128.const i32x4 0 0 0 0)) + +;; ge +(assert_return (invoke "ge" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 nan nan nan nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 inf inf inf inf)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 nan nan nan nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 inf inf inf inf)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 nan nan nan nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 inf inf inf inf)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 nan nan nan nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 inf inf inf inf)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 nan nan nan nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 inf inf inf inf)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 nan nan nan nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 inf inf inf inf)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 nan nan nan nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 inf inf inf inf)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 nan nan nan nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 inf inf inf inf)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 nan nan nan nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 inf inf inf inf)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 nan nan nan nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 inf inf inf inf)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 nan nan nan nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 inf inf inf inf)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 nan nan nan nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 inf inf inf inf)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 nan nan nan nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 inf inf inf inf)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 nan nan nan nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 inf inf inf inf)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 nan nan nan nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 inf inf inf inf)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 nan nan nan nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 inf inf inf inf)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 nan nan nan nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 inf inf inf inf)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 nan nan nan nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 inf inf inf inf)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 nan nan nan nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 inf inf inf inf)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 nan nan nan nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 inf inf inf inf)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019) + (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019) + (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019) + (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019) + (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019) + (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019) + (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019) + (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019) + (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019) + (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019) + (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019) + (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019) + (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019) + (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019) + (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019) + (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019) + (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019) + (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019) + (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019) + (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019) + (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789) + (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789) + (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789) + (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789) + (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789) + (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)) + (v128.const i32x4 -1 -1 -1 -1)) + +;; eq + +;; f32x4.eq (f32x4) (i8x16) +(assert_return (invoke "eq" (v128.const f32x4 -1 0 1 2.0) + (v128.const i8x16 -1 -1 -1 -1 0 0 0 0 1 1 1 1 2 2 2 2)) + (v128.const i32x4 0 -1 0 0)) + +;; f32x4.eq (f32x4) (i16x8) +(assert_return (invoke "eq" (v128.const f32x4 -1 0 1 2.0) + (v128.const i16x8 -1 -1 0 0 1 1 2 2)) + (v128.const i32x4 0 -1 0 0)) + +;; f32x4.eq (f32x4) (i32x4) +(assert_return (invoke "eq" (v128.const f32x4 -1 0 1 2.0) + (v128.const i32x4 3212836864 0 1 2)) + (v128.const i32x4 -1 -1 0 0 )) + +;; ne + +;; f32x4.ne (f32x4) (i8x16) +(assert_return (invoke "ne" (v128.const f32x4 -1 0 1 2.0) + (v128.const i8x16 -1 -1 -1 -1 0 0 0 0 1 1 1 1 2 2 2 2)) + (v128.const i32x4 -1 0 -1 -1)) + +;; f32x4.ne (f32x4) (i16x8) +(assert_return (invoke "ne" (v128.const f32x4 -1 0 1 2.0) + (v128.const i16x8 -1 -1 0 0 1 1 2 2)) + (v128.const i32x4 -1 0 -1 -1)) + +;; f32x4.ne (f32x4) (i32x4) +(assert_return (invoke "ne" (v128.const f32x4 -1 0 1 2.0) + (v128.const i32x4 3212836864 0 1 2)) + (v128.const i32x4 0 0 -1 -1)) + +;; lt + +;; f32x4.lt (f32x4) (i8x16) +(assert_return (invoke "lt" (v128.const f32x4 -1 0 1 2.0) + (v128.const i8x16 -1 -1 -1 -1 0 0 0 0 1 1 1 1 2 2 2 2)) + (v128.const i32x4 0 0 0 0)) + +;; f32x4.lt (f32x4) (i16x8) +(assert_return (invoke "lt" (v128.const f32x4 -1 0 1 2.0) + (v128.const i16x8 -1 -1 0 0 1 1 2 2)) + (v128.const i32x4 0 0 0 0)) + +;; f32x4.lt (f32x4) (i32x4) +(assert_return (invoke "lt" (v128.const f32x4 -1 0 1 2.0) + (v128.const i32x4 3212836864 0 1 2)) + (v128.const i32x4 0 0 0 0)) + +;; le + +;; f32x4.le (f32x4) (i8x16) +(assert_return (invoke "le" (v128.const f32x4 -1 0 1 2.0) + (v128.const i8x16 -1 -1 -1 -1 0 0 0 0 1 1 1 1 2 2 2 2)) + (v128.const i32x4 0 -1 0 0)) + +;; f32x4.le (f32x4) (i16x8) +(assert_return (invoke "le" (v128.const f32x4 -1 0 1 2.0) + (v128.const i16x8 -1 -1 0 0 1 1 2 2)) + (v128.const i32x4 0 -1 0 0)) + +;; f32x4.le (f32x4) (i32x4) +(assert_return (invoke "le" (v128.const f32x4 -1 0 1 2.0) + (v128.const i32x4 3212836864 0 1 2)) + (v128.const i32x4 -1 -1 0 0)) + +;; gt + +;; f32x4.gt (f32x4) (i8x16) +(assert_return (invoke "gt" (v128.const f32x4 -1 0 1 2.0) + (v128.const i8x16 -1 -1 -1 -1 0 0 0 0 1 1 1 1 2 2 2 2)) + (v128.const i32x4 0 0 -1 -1)) + +;; f32x4.gt (f32x4) (i16x8) +(assert_return (invoke "gt" (v128.const f32x4 -1 0 1 2.0) + (v128.const i16x8 -1 -1 0 0 1 1 2 2)) + (v128.const i32x4 0 0 -1 -1)) + +;; f32x4.gt (f32x4) (i32x4) +(assert_return (invoke "gt" (v128.const f32x4 -1 0 1 2.0) + (v128.const i32x4 3212836864 0 1 2)) + (v128.const i32x4 0 0 -1 -1)) + +;; ge + +;; f32x4.ge (f32x4) (i8x16) +(assert_return (invoke "ge" (v128.const f32x4 -1 0 1 2.0) + (v128.const i8x16 -1 -1 -1 -1 0 0 0 0 1 1 1 1 2 2 2 2)) + (v128.const i32x4 0 -1 -1 -1)) + +;; f32x4.ge (f32x4) (i16x8) +(assert_return (invoke "ge" (v128.const f32x4 -1 0 1 2.0) + (v128.const i16x8 -1 -1 0 0 1 1 2 2)) + (v128.const i32x4 0 -1 -1 -1)) + +;; f32x4.ge (f32x4) (i32x4) +(assert_return (invoke "ge" (v128.const f32x4 -1 0 1 2.0) + (v128.const i32x4 3212836864 0 1 2)) + (v128.const i32x4 -1 -1 -1 -1)) + + +;; Type check + +(assert_invalid (module (func (result v128) (f32x4.eq (i64.const 0) (f64.const 0)))) "type mismatch") +(assert_invalid (module (func (result v128) (f32x4.ge (i64.const 0) (f64.const 0)))) "type mismatch") +(assert_invalid (module (func (result v128) (f32x4.gt (i64.const 0) (f64.const 0)))) "type mismatch") +(assert_invalid (module (func (result v128) (f32x4.le (i64.const 0) (f64.const 0)))) "type mismatch") +(assert_invalid (module (func (result v128) (f32x4.lt (i64.const 0) (f64.const 0)))) "type mismatch") +(assert_invalid (module (func (result v128) (f32x4.ne (i64.const 0) (f64.const 0)))) "type mismatch") + + +;; Unknown operators + +(assert_malformed (module quote "(memory 1) (func (param $x v128) (param $y v128) (result v128) (f4x32.eq (local.get $x) (local.get $y)))") "unknown operator") +(assert_malformed (module quote "(memory 1) (func (param $x v128) (param $y v128) (result v128) (f4x32.ge (local.get $x) (local.get $y)))") "unknown operator") +(assert_malformed (module quote "(memory 1) (func (param $x v128) (param $y v128) (result v128) (f4x32.gt (local.get $x) (local.get $y)))") "unknown operator") +(assert_malformed (module quote "(memory 1) (func (param $x v128) (param $y v128) (result v128) (f4x32.le (local.get $x) (local.get $y)))") "unknown operator") +(assert_malformed (module quote "(memory 1) (func (param $x v128) (param $y v128) (result v128) (f4x32.lt (local.get $x) (local.get $y)))") "unknown operator") +(assert_malformed (module quote "(memory 1) (func (param $x v128) (param $y v128) (result v128) (f4x32.ne (local.get $x) (local.get $y)))") "unknown operator") + + +;; Combination + +(module (memory 1) + (func (export "eq-in-block") + (block + (drop + (block (result v128) + (f32x4.eq + (block (result v128) (v128.load (i32.const 0))) + (block (result v128) (v128.load (i32.const 1))) + ) + ) + ) + ) + ) + (func (export "ne-in-block") + (block + (drop + (block (result v128) + (f32x4.ne + (block (result v128) (v128.load (i32.const 0))) + (block (result v128) (v128.load (i32.const 1))) + ) + ) + ) + ) + ) + (func (export "lt-in-block") + (block + (drop + (block (result v128) + (f32x4.lt + (block (result v128) (v128.load (i32.const 0))) + (block (result v128) (v128.load (i32.const 1))) + ) + ) + ) + ) + ) + (func (export "le-in-block") + (block + (drop + (block (result v128) + (f32x4.le + (block (result v128) (v128.load (i32.const 0))) + (block (result v128) (v128.load (i32.const 1))) + ) + ) + ) + ) + ) + (func (export "gt-in-block") + (block + (drop + (block (result v128) + (f32x4.gt + (block (result v128) (v128.load (i32.const 0))) + (block (result v128) (v128.load (i32.const 1))) + ) + ) + ) + ) + ) + (func (export "ge-in-block") + (block + (drop + (block (result v128) + (f32x4.ge + (block (result v128) (v128.load (i32.const 0))) + (block (result v128) (v128.load (i32.const 1))) + ) + ) + ) + ) + ) + (func (export "nested-eq") + (drop + (f32x4.eq + (f32x4.eq + (f32x4.eq + (v128.load (i32.const 0)) + (v128.load (i32.const 1)) + ) + (f32x4.eq + (v128.load (i32.const 2)) + (v128.load (i32.const 3)) + ) + ) + (f32x4.eq + (f32x4.eq + (v128.load (i32.const 0)) + (v128.load (i32.const 1)) + ) + (f32x4.eq + (v128.load (i32.const 2)) + (v128.load (i32.const 3)) + ) + ) + ) + ) + ) + (func (export "nested-ne") + (drop + (f32x4.ne + (f32x4.ne + (f32x4.ne + (v128.load (i32.const 0)) + (v128.load (i32.const 1)) + ) + (f32x4.ne + (v128.load (i32.const 2)) + (v128.load (i32.const 3)) + ) + ) + (f32x4.ne + (f32x4.ne + (v128.load (i32.const 0)) + (v128.load (i32.const 1)) + ) + (f32x4.ne + (v128.load (i32.const 2)) + (v128.load (i32.const 3)) + ) + ) + ) + ) + ) + (func (export "nested-lt") + (drop + (f32x4.lt + (f32x4.lt + (f32x4.lt + (v128.load (i32.const 0)) + (v128.load (i32.const 1)) + ) + (f32x4.lt + (v128.load (i32.const 2)) + (v128.load (i32.const 3)) + ) + ) + (f32x4.lt + (f32x4.lt + (v128.load (i32.const 0)) + (v128.load (i32.const 1)) + ) + (f32x4.lt + (v128.load (i32.const 2)) + (v128.load (i32.const 3)) + ) + ) + ) + ) + ) + (func (export "nested-le") + (drop + (f32x4.le + (f32x4.le + (f32x4.le + (v128.load (i32.const 0)) + (v128.load (i32.const 1)) + ) + (f32x4.le + (v128.load (i32.const 2)) + (v128.load (i32.const 3)) + ) + ) + (f32x4.le + (f32x4.le + (v128.load (i32.const 0)) + (v128.load (i32.const 1)) + ) + (f32x4.le + (v128.load (i32.const 2)) + (v128.load (i32.const 3)) + ) + ) + ) + ) + ) + (func (export "nested-gt") + (drop + (f32x4.gt + (f32x4.gt + (f32x4.gt + (v128.load (i32.const 0)) + (v128.load (i32.const 1)) + ) + (f32x4.gt + (v128.load (i32.const 2)) + (v128.load (i32.const 3)) + ) + ) + (f32x4.gt + (f32x4.gt + (v128.load (i32.const 0)) + (v128.load (i32.const 1)) + ) + (f32x4.gt + (v128.load (i32.const 2)) + (v128.load (i32.const 3)) + ) + ) + ) + ) + ) + (func (export "nested-ge") + (drop + (f32x4.ge + (f32x4.ge + (f32x4.ge + (v128.load (i32.const 0)) + (v128.load (i32.const 1)) + ) + (f32x4.ge + (v128.load (i32.const 2)) + (v128.load (i32.const 3)) + ) + ) + (f32x4.ge + (f32x4.ge + (v128.load (i32.const 0)) + (v128.load (i32.const 1)) + ) + (f32x4.ge + (v128.load (i32.const 2)) + (v128.load (i32.const 3)) + ) + ) + ) + ) + ) + (func (export "as-param") + (drop + (f32x4.ge + (f32x4.eq + (f32x4.lt + (v128.load (i32.const 0)) + (v128.load (i32.const 1)) + ) + (f32x4.le + (v128.load (i32.const 2)) + (v128.load (i32.const 3)) + ) + ) + (f32x4.ne + (f32x4.gt + (v128.load (i32.const 0)) + (v128.load (i32.const 1)) + ) + (f32x4.lt + (v128.load (i32.const 2)) + (v128.load (i32.const 3)) + ) + ) + ) + ) + ) +) + +(assert_return (invoke "eq-in-block")) +(assert_return (invoke "ne-in-block")) +(assert_return (invoke "lt-in-block")) +(assert_return (invoke "le-in-block")) +(assert_return (invoke "gt-in-block")) +(assert_return (invoke "ge-in-block")) +(assert_return (invoke "nested-eq")) +(assert_return (invoke "nested-ne")) +(assert_return (invoke "nested-lt")) +(assert_return (invoke "nested-le")) +(assert_return (invoke "nested-gt")) +(assert_return (invoke "nested-ge")) +(assert_return (invoke "as-param")) + +;; Test operation with empty argument + +(assert_invalid + (module + (func $f32x4.eq-1st-arg-empty (result v128) + (f32x4.eq (v128.const f32x4 0 0 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $f32x4.eq-arg-empty (result v128) + (f32x4.eq) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $f32x4.ne-1st-arg-empty (result v128) + (f32x4.ne (v128.const f32x4 0 0 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $f32x4.ne-arg-empty (result v128) + (f32x4.ne) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $f32x4.lt-1st-arg-empty (result v128) + (f32x4.lt (v128.const f32x4 0 0 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $f32x4.lt-arg-empty (result v128) + (f32x4.lt) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $f32x4.le-1st-arg-empty (result v128) + (f32x4.le (v128.const f32x4 0 0 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $f32x4.le-arg-empty (result v128) + (f32x4.le) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $f32x4.gt-1st-arg-empty (result v128) + (f32x4.gt (v128.const f32x4 0 0 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $f32x4.gt-arg-empty (result v128) + (f32x4.gt) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $f32x4.ge-1st-arg-empty (result v128) + (f32x4.ge (v128.const f32x4 0 0 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $f32x4.ge-arg-empty (result v128) + (f32x4.ge) + ) + ) + "type mismatch" +) \ No newline at end of file diff --git a/runtime/near-vm/tests/wast/spec/proposals/simd/simd_f32x4_pmin_pmax.wast b/runtime/near-vm/tests/wast/spec/proposals/simd/simd_f32x4_pmin_pmax.wast new file mode 100644 index 00000000000..b0f47b380c9 --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/proposals/simd/simd_f32x4_pmin_pmax.wast @@ -0,0 +1,11676 @@ +;; Tests for f32x4 [pmin, pmax] operations on major boundary values and all special values. + + +(module + (func (export "f32x4.pmin") (param v128 v128) (result v128) (f32x4.pmin (local.get 0) (local.get 1))) + (func (export "f32x4.pmax") (param v128 v128) (result v128) (f32x4.pmax (local.get 0) (local.get 1))) +) + +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)) + (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)) + (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)) + (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)) + (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)) + (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)) + (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)) + (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)) + (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)) + (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)) + (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)) + (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)) + (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)) + (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)) + (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)) + (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)) + (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)) + (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)) + (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)) + (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)) + (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)) + (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)) + (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)) + (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)) + (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)) + (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)) + (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)) + (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)) + (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)) + (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)) + (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)) + (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)) + (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)) + (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)) + (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)) + (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)) + (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)) + (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)) + (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)) + (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)) + (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)) + (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)) + (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)) + (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)) + (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)) + (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)) + (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)) + (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)) + (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)) + (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)) + (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)) + (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)) + (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)) + (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)) + (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)) + (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)) + (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)) + (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)) + (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)) + (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)) + (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)) + (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)) + (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)) + (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)) + (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)) + (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)) + (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)) + (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)) + (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)) + (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)) + (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)) + (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)) + (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)) + (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)) + (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)) + (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)) + (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)) + (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)) + (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)) + (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)) + (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)) + (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)) + (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)) + (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)) + (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)) + (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)) + (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)) + (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)) + (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)) + (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)) + (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)) + (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)) + (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)) + (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)) + (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)) + (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)) + (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)) + (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)) + (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)) + (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)) + (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)) + (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)) + (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)) + (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)) + (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)) + (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)) + (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)) + (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)) + (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)) + (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)) + (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)) + (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)) + (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)) + (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)) + (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)) + (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)) + (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)) + (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)) + (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)) + (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)) + (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)) + (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)) + (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)) + (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)) + (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)) + (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)) + (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)) + (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)) + (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)) + (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)) + (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)) + (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)) + (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)) + (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)) + (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)) + (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)) + (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)) + (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)) + (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)) + (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)) + (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)) + (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)) + (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)) + (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)) + (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)) + (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)) + (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)) + (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)) + (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)) + (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)) + (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)) + (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)) + (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)) + (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)) + (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)) + (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)) + (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)) + (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)) + (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)) + (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)) + (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)) + (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)) + (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)) + (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)) + (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)) + (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)) + (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)) + (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)) + (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)) + (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)) + (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)) + (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)) + (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)) + (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)) + (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)) + (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)) + (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)) + (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)) + (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)) + (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)) + (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)) + (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)) + (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)) + (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)) + (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)) + (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)) + (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)) + (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)) + (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)) + (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)) + (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)) + (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)) + (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)) + (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)) + (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)) + (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)) + (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)) + (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)) + (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)) + (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)) + (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)) + (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789) + (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)) + (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789) + (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)) + (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789) + (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)) + (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789) + (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)) + (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789) + (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)) + (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789) + (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)) + (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789) + (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)) + (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789) + (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)) + (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789) + (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)) + (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789) + (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789) + (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789) + (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789) + (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)) + (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789) + (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)) + (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789) + (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)) + (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789) + (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)) + (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789) + (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)) + (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789) + (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)) + (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789) + (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)) + (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789) + (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)) + (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789) + (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)) + (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789) + (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)) + (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789) + (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)) + (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789) + (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)) + (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019) + (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)) + (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019) + (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019) + (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019) + (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)) + (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019) + (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)) + (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019) + (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019) + (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019) + (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)) + (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019) + (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)) + (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019) + (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019) + (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019) + (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019) + (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019) + (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019) + (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019) + (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019) + (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019) + (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019) + (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019) + (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019) + (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019) + (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019) + (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019) + (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019) + (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)) + (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019) + (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019) + (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019) + (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)) + (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019) + (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)) + (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019) + (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019) + (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019) + (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)) + (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019) + (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)) + (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019) + (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019) + (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019) + (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019) + (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019) + (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019) + (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019) + (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019) + (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019) + (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019) + (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019) + (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019) + (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019) + (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019) + (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019) + (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019) + (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)) + (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019) + (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)) + (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019) + (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)) + (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019) + (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)) + (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019) + (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)) + (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019) + (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)) + (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019) + (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)) + (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019) + (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)) + (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019) + (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)) + (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019) + (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019) + (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019) + (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019) + (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)) + (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019) + (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)) + (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019) + (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)) + (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019) + (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)) + (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019) + (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)) + (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019) + (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)) + (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019) + (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)) + (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019) + (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)) + (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019) + (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)) + (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019) + (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)) + (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019) + (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)) + (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019) + (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)) + (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.) + (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)) + (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.) + (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)) + (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.) + (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)) + (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.) + (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)) + (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.) + (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)) + (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.) + (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)) + (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.) + (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)) + (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.) + (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)) + (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.) + (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)) + (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.) + (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.) + (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.) + (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.) + (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)) + (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.) + (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)) + (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.) + (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)) + (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.) + (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)) + (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.) + (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)) + (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.) + (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)) + (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.) + (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)) + (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.) + (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)) + (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.) + (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)) + (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.) + (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)) + (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.) + (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)) + (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.) + (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)) + (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019) + (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)) + (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019) + (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019) + (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019) + (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)) + (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019) + (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)) + (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019) + (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019) + (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019) + (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)) + (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019) + (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)) + (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019) + (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019) + (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019) + (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019) + (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019) + (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019) + (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019) + (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019) + (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019) + (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019) + (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019) + (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019) + (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019) + (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019) + (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019) + (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019) + (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)) + (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019) + (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019) + (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019) + (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)) + (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019) + (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)) + (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019) + (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019) + (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019) + (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)) + (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019) + (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)) + (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019) + (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019) + (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019) + (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019) + (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019) + (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019) + (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019) + (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019) + (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019) + (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019) + (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019) + (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019) + (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019) + (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019) + (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019) + (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019) + (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)) + (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019) + (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)) + (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019) + (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)) + (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019) + (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)) + (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019) + (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)) + (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019) + (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)) + (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019) + (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)) + (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019) + (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)) + (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019) + (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)) + (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019) + (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019) + (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019) + (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019) + (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)) + (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019) + (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)) + (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019) + (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)) + (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019) + (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)) + (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019) + (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)) + (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019) + (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)) + (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019) + (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)) + (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019) + (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)) + (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019) + (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)) + (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019) + (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)) + (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019) + (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)) + (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019) + (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)) + (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789) + (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)) + (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789) + (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)) + (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789) + (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)) + (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789) + (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)) + (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789) + (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)) + (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789) + (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)) + (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789) + (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)) + (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789) + (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)) + (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789) + (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)) + (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789) + (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789) + (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789) + (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789) + (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)) + (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789) + (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)) + (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789) + (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)) + (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789) + (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)) + (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789) + (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)) + (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789) + (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)) + (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789) + (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)) + (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789) + (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)) + (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789) + (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)) + (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789) + (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)) + (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789) + (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)) + (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789) + (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)) + (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)) + (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)) + (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)) + (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)) + (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)) + (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)) + (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)) + (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)) + (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)) + (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)) + (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)) + (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)) + (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)) + (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)) + (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)) + (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)) + (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)) + (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)) + (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)) + (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)) + (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)) + (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)) + (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)) + (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)) + (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)) + (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)) + (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)) + (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)) + (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)) + (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)) + (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)) + (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF) + (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)) + (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF) + (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF) + (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF) + (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)) + (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF) + (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)) + (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF) + (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF) + (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF) + (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)) + (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF) + (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)) + (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF) + (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF) + (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF) + (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF) + (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF) + (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF) + (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF) + (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF) + (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF) + (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF) + (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF) + (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF) + (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF) + (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF) + (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF) + (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019) + (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)) + (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019) + (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019) + (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019) + (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)) + (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019) + (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)) + (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019) + (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019) + (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019) + (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)) + (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019) + (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)) + (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019) + (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019) + (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019) + (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019) + (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019) + (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019) + (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019) + (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019) + (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019) + (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019) + (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019) + (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019) + (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019) + (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019) + (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019) + (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019) + (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)) + (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019) + (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019) + (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019) + (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)) + (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019) + (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)) + (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019) + (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019) + (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019) + (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)) + (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019) + (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)) + (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019) + (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019) + (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019) + (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019) + (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019) + (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019) + (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019) + (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019) + (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019) + (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019) + (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019) + (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019) + (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019) + (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019) + (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019) + (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019) + (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)) + (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019) + (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019) + (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019) + (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)) + (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019) + (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)) + (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019) + (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019) + (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019) + (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)) + (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019) + (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)) + (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019) + (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019) + (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019) + (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019) + (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019) + (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019) + (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019) + (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019) + (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019) + (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019) + (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019) + (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019) + (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019) + (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019) + (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019) + (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.) + (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)) + (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.) + (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.) + (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.) + (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)) + (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.) + (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)) + (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.) + (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.) + (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.) + (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)) + (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.) + (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)) + (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.) + (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.) + (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.) + (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.) + (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.) + (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.) + (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.) + (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.) + (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.) + (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.) + (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.) + (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.) + (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.) + (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.) + (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.) + (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019) + (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)) + (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019) + (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019) + (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019) + (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)) + (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019) + (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)) + (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019) + (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019) + (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019) + (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)) + (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019) + (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)) + (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019) + (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019) + (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019) + (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019) + (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019) + (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019) + (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019) + (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019) + (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019) + (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019) + (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019) + (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019) + (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019) + (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019) + (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019) + (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019) + (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)) + (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019) + (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019) + (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019) + (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)) + (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019) + (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)) + (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019) + (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019) + (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019) + (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)) + (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019) + (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)) + (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019) + (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019) + (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019) + (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019) + (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019) + (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019) + (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019) + (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019) + (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019) + (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019) + (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019) + (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019) + (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019) + (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019) + (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019) + (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019) + (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)) + (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019) + (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019) + (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019) + (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)) + (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019) + (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)) + (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019) + (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019) + (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019) + (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)) + (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019) + (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)) + (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019) + (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019) + (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019) + (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019) + (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019) + (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019) + (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019) + (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019) + (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019) + (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019) + (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019) + (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019) + (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019) + (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019) + (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019) + (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF) + (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)) + (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF) + (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF) + (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF) + (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)) + (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF) + (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)) + (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF) + (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF) + (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF) + (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)) + (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF) + (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)) + (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF) + (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF) + (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF) + (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF) + (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF) + (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF) + (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF) + (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF) + (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF) + (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF) + (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF) + (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF) + (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF) + (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF) + (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF) + (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019) + (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)) + (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019) + (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019) + (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019) + (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)) + (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019) + (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)) + (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019) + (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019) + (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019) + (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)) + (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019) + (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)) + (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019) + (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019) + (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019) + (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019) + (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019) + (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019) + (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019) + (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019) + (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019) + (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019) + (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019) + (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019) + (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019) + (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019) + (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019) + (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019) + (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)) + (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019) + (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019) + (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019) + (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)) + (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019) + (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)) + (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019) + (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019) + (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019) + (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)) + (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019) + (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)) + (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019) + (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019) + (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019) + (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019) + (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019) + (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019) + (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019) + (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019) + (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019) + (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019) + (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019) + (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019) + (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019) + (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019) + (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019) + (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019) + (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)) + (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019) + (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019) + (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019) + (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)) + (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019) + (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)) + (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019) + (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019) + (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019) + (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)) + (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019) + (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)) + (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019) + (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019) + (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019) + (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019) + (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019) + (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019) + (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019) + (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019) + (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019) + (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019) + (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019) + (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019) + (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019) + (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019) + (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019) + (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 nan nan nan nan)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 nan nan nan nan)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 nan nan nan nan)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 nan nan nan nan)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 nan nan nan nan)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 nan nan nan nan)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 nan nan nan nan)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 nan nan nan nan)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 nan nan nan nan)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 nan nan nan nan)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 nan nan nan nan)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 nan nan nan nan)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 nan nan nan nan)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 nan nan nan nan)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 nan nan nan nan)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 nan nan nan nan)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)) + (v128.const f32x4 nan nan nan nan)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)) + (v128.const f32x4 nan nan nan nan)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)) + (v128.const f32x4 nan nan nan nan)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)) + (v128.const f32x4 nan nan nan nan)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)) + (v128.const f32x4 nan nan nan nan)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)) + (v128.const f32x4 nan nan nan nan)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)) + (v128.const f32x4 nan nan nan nan)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)) + (v128.const f32x4 nan nan nan nan)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)) + (v128.const f32x4 nan nan nan nan)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f32x4 nan nan nan nan)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f32x4 nan nan nan nan)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f32x4 nan nan nan nan)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)) + (v128.const f32x4 nan nan nan nan)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)) + (v128.const f32x4 nan nan nan nan)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)) + (v128.const f32x4 nan nan nan nan)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)) + (v128.const f32x4 nan nan nan nan)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)) + (v128.const f32x4 nan nan nan nan)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)) + (v128.const f32x4 nan nan nan nan)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)) + (v128.const f32x4 nan nan nan nan)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)) + (v128.const f32x4 nan nan nan nan)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)) + (v128.const f32x4 nan nan nan nan)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)) + (v128.const f32x4 nan nan nan nan)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)) + (v128.const f32x4 nan nan nan nan)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)) + (v128.const f32x4 nan nan nan nan)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 nan nan nan nan)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 nan nan nan nan)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 nan nan nan nan)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 nan nan nan nan)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 -nan -nan -nan -nan)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 -nan -nan -nan -nan)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 -nan -nan -nan -nan)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 -nan -nan -nan -nan)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 -nan -nan -nan -nan)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 -nan -nan -nan -nan)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 -nan -nan -nan -nan)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 -nan -nan -nan -nan)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 -nan -nan -nan -nan)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 -nan -nan -nan -nan)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 -nan -nan -nan -nan)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 -nan -nan -nan -nan)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 -nan -nan -nan -nan)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 -nan -nan -nan -nan)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 -nan -nan -nan -nan)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 -nan -nan -nan -nan)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)) + (v128.const f32x4 -nan -nan -nan -nan)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)) + (v128.const f32x4 -nan -nan -nan -nan)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)) + (v128.const f32x4 -nan -nan -nan -nan)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)) + (v128.const f32x4 -nan -nan -nan -nan)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)) + (v128.const f32x4 -nan -nan -nan -nan)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)) + (v128.const f32x4 -nan -nan -nan -nan)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)) + (v128.const f32x4 -nan -nan -nan -nan)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)) + (v128.const f32x4 -nan -nan -nan -nan)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)) + (v128.const f32x4 -nan -nan -nan -nan)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f32x4 -nan -nan -nan -nan)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f32x4 -nan -nan -nan -nan)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f32x4 -nan -nan -nan -nan)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)) + (v128.const f32x4 -nan -nan -nan -nan)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)) + (v128.const f32x4 -nan -nan -nan -nan)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)) + (v128.const f32x4 -nan -nan -nan -nan)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)) + (v128.const f32x4 -nan -nan -nan -nan)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)) + (v128.const f32x4 -nan -nan -nan -nan)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)) + (v128.const f32x4 -nan -nan -nan -nan)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)) + (v128.const f32x4 -nan -nan -nan -nan)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)) + (v128.const f32x4 -nan -nan -nan -nan)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)) + (v128.const f32x4 -nan -nan -nan -nan)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)) + (v128.const f32x4 -nan -nan -nan -nan)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)) + (v128.const f32x4 -nan -nan -nan -nan)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)) + (v128.const f32x4 -nan -nan -nan -nan)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 -nan -nan -nan -nan)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 -nan -nan -nan -nan)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 -nan -nan -nan -nan)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 -nan -nan -nan -nan)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)) +(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)) + (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)) + (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)) + (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)) + (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)) + (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)) + (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)) + (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)) + (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)) + (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)) + (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)) + (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)) + (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)) + (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)) + (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)) + (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)) + (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)) + (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)) + (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)) + (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)) + (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)) + (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)) + (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)) + (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)) + (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)) + (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)) + (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)) + (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)) + (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)) + (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)) + (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)) + (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)) + (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)) + (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)) + (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)) + (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)) + (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)) + (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)) + (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)) + (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)) + (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)) + (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)) + (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)) + (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)) + (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)) + (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)) + (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)) + (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)) + (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)) + (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)) + (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)) + (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)) + (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)) + (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)) + (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)) + (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)) + (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)) + (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)) + (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)) + (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)) + (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)) + (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)) + (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)) + (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)) + (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)) + (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)) + (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)) + (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)) + (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789) + (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)) + (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789) + (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789) + (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789) + (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)) + (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789) + (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)) + (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789) + (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789) + (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789) + (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)) + (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789) + (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)) + (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789) + (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789) + (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789) + (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789) + (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789) + (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789) + (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789) + (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789) + (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789) + (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789) + (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789) + (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789) + (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789) + (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789) + (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789) + (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019) + (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019) + (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019) + (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019) + (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019) + (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019) + (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019) + (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019) + (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019) + (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019) + (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019) + (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019) + (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019) + (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019) + (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019) + (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019) + (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019) + (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019) + (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019) + (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019) + (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019) + (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019) + (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019) + (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019) + (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019) + (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019) + (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019) + (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019) + (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019) + (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019) + (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019) + (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019) + (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019) + (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019) + (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019) + (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019) + (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019) + (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019) + (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019) + (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019) + (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019) + (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019) + (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019) + (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019) + (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019) + (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019) + (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019) + (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019) + (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019) + (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)) + (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019) + (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019) + (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019) + (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)) + (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019) + (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)) + (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019) + (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019) + (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019) + (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)) + (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019) + (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)) + (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019) + (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019) + (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019) + (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019) + (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019) + (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019) + (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019) + (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019) + (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019) + (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019) + (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019) + (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019) + (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019) + (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019) + (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019) + (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.) + (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)) + (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.) + (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.) + (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.) + (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)) + (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.) + (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)) + (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.) + (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.) + (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.) + (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)) + (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.) + (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)) + (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.) + (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.) + (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.) + (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.) + (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.) + (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.) + (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.) + (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.) + (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.) + (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.) + (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.) + (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.) + (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.) + (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.) + (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.) + (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019) + (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019) + (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019) + (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019) + (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019) + (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019) + (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019) + (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019) + (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019) + (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019) + (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019) + (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019) + (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019) + (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019) + (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019) + (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019) + (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019) + (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019) + (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019) + (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019) + (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019) + (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019) + (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019) + (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019) + (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019) + (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019) + (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019) + (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019) + (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019) + (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019) + (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019) + (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019) + (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019) + (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019) + (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019) + (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019) + (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019) + (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019) + (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019) + (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019) + (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019) + (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019) + (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019) + (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019) + (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019) + (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019) + (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019) + (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019) + (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019) + (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)) + (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019) + (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019) + (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019) + (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)) + (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019) + (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)) + (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019) + (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019) + (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019) + (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)) + (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019) + (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)) + (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019) + (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019) + (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019) + (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019) + (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019) + (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019) + (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019) + (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019) + (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019) + (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019) + (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019) + (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019) + (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019) + (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019) + (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019) + (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789) + (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)) + (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789) + (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789) + (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789) + (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)) + (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789) + (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)) + (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789) + (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789) + (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789) + (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)) + (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789) + (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)) + (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789) + (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789) + (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789) + (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789) + (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789) + (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789) + (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789) + (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789) + (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789) + (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789) + (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789) + (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789) + (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789) + (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789) + (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789) + (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)) + (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)) + (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)) + (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)) + (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)) + (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)) + (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)) + (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)) + (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)) + (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)) + (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)) + (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)) + (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)) + (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)) + (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)) + (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)) + (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)) + (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)) + (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)) + (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)) + (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)) + (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)) + (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)) + (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)) + (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)) + (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)) + (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)) + (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)) + (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)) + (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)) + (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)) + (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)) + (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)) + (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)) + (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)) + (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)) + (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)) + (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)) + (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)) + (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)) + (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)) + (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)) + (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)) + (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)) + (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)) + (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)) + (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)) + (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF) + (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF) + (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF) + (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF) + (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF) + (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF) + (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF) + (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF) + (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF) + (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF) + (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF) + (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF) + (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF) + (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF) + (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF) + (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF) + (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF) + (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF) + (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF) + (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF) + (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF) + (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF) + (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF) + (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF) + (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019) + (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019) + (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019) + (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019) + (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019) + (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019) + (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019) + (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019) + (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019) + (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019) + (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019) + (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019) + (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019) + (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019) + (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019) + (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019) + (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019) + (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019) + (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019) + (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019) + (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019) + (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019) + (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019) + (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019) + (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019) + (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019) + (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019) + (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019) + (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019) + (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019) + (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019) + (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019) + (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019) + (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019) + (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019) + (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019) + (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019) + (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019) + (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019) + (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019) + (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019) + (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019) + (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019) + (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019) + (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019) + (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019) + (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019) + (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019) + (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019) + (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019) + (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019) + (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019) + (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019) + (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019) + (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019) + (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019) + (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019) + (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019) + (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019) + (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019) + (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019) + (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019) + (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019) + (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019) + (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019) + (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019) + (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019) + (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019) + (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019) + (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019) + (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019) + (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019) + (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.) + (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.) + (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.) + (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.) + (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.) + (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.) + (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.) + (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.) + (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.) + (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.) + (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.) + (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.) + (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.) + (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.) + (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.) + (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.) + (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.) + (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.) + (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.) + (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.) + (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.) + (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.) + (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.) + (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.) + (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019) + (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019) + (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019) + (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019) + (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019) + (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019) + (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019) + (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019) + (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019) + (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019) + (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019) + (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019) + (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019) + (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019) + (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019) + (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019) + (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019) + (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019) + (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019) + (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019) + (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019) + (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019) + (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019) + (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019) + (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019) + (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019) + (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019) + (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019) + (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019) + (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019) + (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019) + (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019) + (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019) + (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019) + (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019) + (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019) + (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019) + (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019) + (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019) + (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019) + (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019) + (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019) + (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019) + (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019) + (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019) + (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019) + (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019) + (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019) + (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019) + (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019) + (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019) + (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019) + (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019) + (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019) + (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019) + (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019) + (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019) + (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019) + (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019) + (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019) + (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019) + (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019) + (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019) + (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019) + (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019) + (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019) + (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019) + (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019) + (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019) + (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019) + (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019) + (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019) + (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF) + (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF) + (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF) + (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF) + (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF) + (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF) + (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF) + (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF) + (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF) + (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF) + (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF) + (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF) + (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF) + (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF) + (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF) + (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF) + (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF) + (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF) + (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF) + (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF) + (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF) + (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF) + (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF) + (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF) + (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019) + (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019) + (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019) + (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019) + (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019) + (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019) + (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019) + (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019) + (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019) + (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019) + (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019) + (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019) + (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019) + (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019) + (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019) + (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019) + (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019) + (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019) + (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019) + (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019) + (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019) + (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019) + (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019) + (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019) + (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019) + (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019) + (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019) + (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019) + (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019) + (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019) + (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019) + (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019) + (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019) + (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019) + (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019) + (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019) + (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019) + (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019) + (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019) + (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019) + (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019) + (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019) + (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019) + (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019) + (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019) + (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019) + (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019) + (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019) + (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019) + (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019) + (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019) + (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019) + (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019) + (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019) + (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019) + (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)) + (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019) + (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019) + (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019) + (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019) + (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019) + (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019) + (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019) + (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019) + (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019) + (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019) + (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019) + (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019) + (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019) + (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019) + (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)) + (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019) + (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019) + (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)) + (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019) + (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)) + (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 nan nan nan nan)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 nan nan nan nan)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 nan nan nan nan)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 nan nan nan nan)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 nan nan nan nan)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 nan nan nan nan)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 nan nan nan nan)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 nan nan nan nan)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 nan nan nan nan)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 nan nan nan nan)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 nan nan nan nan)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 nan nan nan nan)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 nan nan nan nan)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 nan nan nan nan)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 nan nan nan nan)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 nan nan nan nan)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)) + (v128.const f32x4 nan nan nan nan)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)) + (v128.const f32x4 nan nan nan nan)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)) + (v128.const f32x4 nan nan nan nan)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)) + (v128.const f32x4 nan nan nan nan)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)) + (v128.const f32x4 nan nan nan nan)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)) + (v128.const f32x4 nan nan nan nan)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)) + (v128.const f32x4 nan nan nan nan)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)) + (v128.const f32x4 nan nan nan nan)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)) + (v128.const f32x4 nan nan nan nan)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f32x4 nan nan nan nan)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f32x4 nan nan nan nan)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f32x4 nan nan nan nan)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)) + (v128.const f32x4 nan nan nan nan)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)) + (v128.const f32x4 nan nan nan nan)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)) + (v128.const f32x4 nan nan nan nan)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)) + (v128.const f32x4 nan nan nan nan)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)) + (v128.const f32x4 nan nan nan nan)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)) + (v128.const f32x4 nan nan nan nan)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)) + (v128.const f32x4 nan nan nan nan)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)) + (v128.const f32x4 nan nan nan nan)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)) + (v128.const f32x4 nan nan nan nan)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)) + (v128.const f32x4 nan nan nan nan)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)) + (v128.const f32x4 nan nan nan nan)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)) + (v128.const f32x4 nan nan nan nan)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 nan nan nan nan)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 nan nan nan nan)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 nan nan nan nan)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 nan nan nan nan)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 -nan -nan -nan -nan)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 -nan -nan -nan -nan)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 -nan -nan -nan -nan)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 -nan -nan -nan -nan)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 -nan -nan -nan -nan)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 -nan -nan -nan -nan)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 -nan -nan -nan -nan)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 -nan -nan -nan -nan)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 -nan -nan -nan -nan)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 -nan -nan -nan -nan)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 -nan -nan -nan -nan)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 -nan -nan -nan -nan)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 -nan -nan -nan -nan)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 -nan -nan -nan -nan)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 -nan -nan -nan -nan)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 -nan -nan -nan -nan)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)) + (v128.const f32x4 -nan -nan -nan -nan)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)) + (v128.const f32x4 -nan -nan -nan -nan)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)) + (v128.const f32x4 -nan -nan -nan -nan)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)) + (v128.const f32x4 -nan -nan -nan -nan)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)) + (v128.const f32x4 -nan -nan -nan -nan)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)) + (v128.const f32x4 -nan -nan -nan -nan)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)) + (v128.const f32x4 -nan -nan -nan -nan)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)) + (v128.const f32x4 -nan -nan -nan -nan)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)) + (v128.const f32x4 -nan -nan -nan -nan)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f32x4 -nan -nan -nan -nan)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f32x4 -nan -nan -nan -nan)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f32x4 -nan -nan -nan -nan)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)) + (v128.const f32x4 -nan -nan -nan -nan)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)) + (v128.const f32x4 -nan -nan -nan -nan)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)) + (v128.const f32x4 -nan -nan -nan -nan)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)) + (v128.const f32x4 -nan -nan -nan -nan)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)) + (v128.const f32x4 -nan -nan -nan -nan)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)) + (v128.const f32x4 -nan -nan -nan -nan)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)) + (v128.const f32x4 -nan -nan -nan -nan)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)) + (v128.const f32x4 -nan -nan -nan -nan)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)) + (v128.const f32x4 -nan -nan -nan -nan)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)) + (v128.const f32x4 -nan -nan -nan -nan)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)) + (v128.const f32x4 -nan -nan -nan -nan)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)) + (v128.const f32x4 -nan -nan -nan -nan)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 -nan -nan -nan -nan)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 -nan -nan -nan -nan)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 -nan -nan -nan -nan)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 -nan -nan -nan -nan)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019) + (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019) + (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)) +(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019) + (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)) + + +;; Unknown operators + +(assert_malformed (module quote "(memory 1) (func (result v128) (i8x16.pmin (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0)))") "unknown operator") +(assert_malformed (module quote "(memory 1) (func (result v128) (i8x16.pmax (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0)))") "unknown operator") +(assert_malformed (module quote "(memory 1) (func (result v128) (i16x8.pmin (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0)))") "unknown operator") +(assert_malformed (module quote "(memory 1) (func (result v128) (i16x8.pmax (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0)))") "unknown operator") +(assert_malformed (module quote "(memory 1) (func (result v128) (i32x4.pmin (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0)))") "unknown operator") +(assert_malformed (module quote "(memory 1) (func (result v128) (i32x4.pmax (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0)))") "unknown operator") +(assert_malformed (module quote "(memory 1) (func (result v128) (i64x2.pmin (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0)))") "unknown operator") +(assert_malformed (module quote "(memory 1) (func (result v128) (i64x2.pmax (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0)))") "unknown operator") + +;; type check +(assert_invalid (module (func (result v128) (f32x4.pmin (i32.const 0) (f32.const 0.0)))) "type mismatch") +(assert_invalid (module (func (result v128) (f32x4.pmax (i32.const 0) (f32.const 0.0)))) "type mismatch") + +;; Test operation with empty argument + +(assert_invalid + (module + (func $f32x4.pmin-1st-arg-empty (result v128) + (f32x4.pmin (v128.const f32x4 0 0 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $f32x4.pmin-arg-empty (result v128) + (f32x4.pmin) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $f32x4.pmax-1st-arg-empty (result v128) + (f32x4.pmax (v128.const f32x4 0 0 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $f32x4.pmax-arg-empty (result v128) + (f32x4.pmax) + ) + ) + "type mismatch" +) + diff --git a/runtime/near-vm/tests/wast/spec/proposals/simd/simd_f32x4_rounding.wast b/runtime/near-vm/tests/wast/spec/proposals/simd/simd_f32x4_rounding.wast new file mode 100644 index 00000000000..e59f99a77bd --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/proposals/simd/simd_f32x4_rounding.wast @@ -0,0 +1,424 @@ +;; Tests for f32x4 [ceil, floor, trunc, nearest] operations on major boundary values and all special values. + + +(module + (func (export "f32x4.ceil") (param v128) (result v128) (f32x4.ceil (local.get 0))) + (func (export "f32x4.floor") (param v128) (result v128) (f32x4.floor (local.get 0))) + (func (export "f32x4.trunc") (param v128) (result v128) (f32x4.trunc (local.get 0))) + (func (export "f32x4.nearest") (param v128) (result v128) (f32x4.nearest (local.get 0))) +) + +(assert_return (invoke "f32x4.ceil" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.ceil" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.ceil" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.ceil" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.ceil" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.ceil" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.ceil" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.ceil" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.ceil" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.ceil" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.ceil" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 0x1.c000000000000p+2 0x1.c000000000000p+2 0x1.c000000000000p+2 0x1.c000000000000p+2)) +(assert_return (invoke "f32x4.ceil" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 -0x1.8000000000000p+2 -0x1.8000000000000p+2 -0x1.8000000000000p+2 -0x1.8000000000000p+2)) +(assert_return (invoke "f32x4.ceil" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.ceil" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.ceil" (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.ceil" (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.ceil" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)) + (v128.const f32x4 123456789.0 123456789.0 123456789.0 123456789.0)) +(assert_return (invoke "f32x4.ceil" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)) + (v128.const f32x4 1.23456789e+27 1.23456789e+27 1.23456789e+27 1.23456789e+27)) +(assert_return (invoke "f32x4.ceil" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)) + (v128.const f32x4 1.23456789e+27 1.23456789e+27 1.23456789e+27 1.23456789e+27)) +(assert_return (invoke "f32x4.ceil" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)) + (v128.const f32x4 1.0 1.0 1.0 1.0)) +(assert_return (invoke "f32x4.ceil" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)) + (v128.const f32x4 123456789.0 123456789.0 123456789.0 123456789.0)) +(assert_return (invoke "f32x4.ceil" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)) + (v128.const f32x4 1.23456789e+27 1.23456789e+27 1.23456789e+27 1.23456789e+27)) +(assert_return (invoke "f32x4.ceil" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)) + (v128.const f32x4 1.23456789e+27 1.23456789e+27 1.23456789e+27 1.23456789e+27)) +(assert_return (invoke "f32x4.ceil" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)) + (v128.const f32x4 1.0 1.0 1.0 1.0)) +(assert_return (invoke "f32x4.ceil" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)) + (v128.const f32x4 123456790.0 123456790.0 123456790.0 123456790.0)) +(assert_return (invoke "f32x4.ceil" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f32x4 1.2345678901234569e+27 1.2345678901234569e+27 1.2345678901234569e+27 1.2345678901234569e+27)) +(assert_return (invoke "f32x4.ceil" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f32x4 1.2345678901234569e+27 1.2345678901234569e+27 1.2345678901234569e+27 1.2345678901234569e+27)) +(assert_return (invoke "f32x4.ceil" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f32x4 1.0 1.0 1.0 1.0)) +(assert_return (invoke "f32x4.ceil" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)) + (v128.const f32x4 8.19855292164869e+16 8.19855292164869e+16 8.19855292164869e+16 8.19855292164869e+16)) +(assert_return (invoke "f32x4.ceil" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)) + (v128.const f32x4 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22)) +(assert_return (invoke "f32x4.ceil" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)) + (v128.const f32x4 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22)) +(assert_return (invoke "f32x4.ceil" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)) + (v128.const f32x4 156374987062.0 156374987062.0 156374987062.0 156374987062.0)) +(assert_return (invoke "f32x4.ceil" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)) + (v128.const f32x4 8.19855292164869e+16 8.19855292164869e+16 8.19855292164869e+16 8.19855292164869e+16)) +(assert_return (invoke "f32x4.ceil" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)) + (v128.const f32x4 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22)) +(assert_return (invoke "f32x4.ceil" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)) + (v128.const f32x4 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22)) +(assert_return (invoke "f32x4.ceil" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)) + (v128.const f32x4 156374987062.0 156374987062.0 156374987062.0 156374987062.0)) +(assert_return (invoke "f32x4.ceil" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)) + (v128.const f32x4 8.19855292164869e+16 8.19855292164869e+16 8.19855292164869e+16 8.19855292164869e+16)) +(assert_return (invoke "f32x4.ceil" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)) + (v128.const f32x4 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22)) +(assert_return (invoke "f32x4.ceil" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)) + (v128.const f32x4 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22)) +(assert_return (invoke "f32x4.ceil" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)) + (v128.const f32x4 156374987062.0 156374987062.0 156374987062.0 156374987062.0)) +(assert_return (invoke "f32x4.ceil" (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.ceil" (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.ceil" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.ceil" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.floor" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.floor" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.floor" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.floor" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.floor" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.floor" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.floor" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.floor" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.floor" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.floor" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.floor" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 0x1.8000000000000p+2 0x1.8000000000000p+2 0x1.8000000000000p+2 0x1.8000000000000p+2)) +(assert_return (invoke "f32x4.floor" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 -0x1.c000000000000p+2 -0x1.c000000000000p+2 -0x1.c000000000000p+2 -0x1.c000000000000p+2)) +(assert_return (invoke "f32x4.floor" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.floor" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.floor" (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.floor" (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.floor" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)) + (v128.const f32x4 123456789.0 123456789.0 123456789.0 123456789.0)) +(assert_return (invoke "f32x4.floor" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)) + (v128.const f32x4 1.23456789e+27 1.23456789e+27 1.23456789e+27 1.23456789e+27)) +(assert_return (invoke "f32x4.floor" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)) + (v128.const f32x4 1.23456789e+27 1.23456789e+27 1.23456789e+27 1.23456789e+27)) +(assert_return (invoke "f32x4.floor" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)) + (v128.const f32x4 0.0 0.0 0.0 0.0)) +(assert_return (invoke "f32x4.floor" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)) + (v128.const f32x4 123456789.0 123456789.0 123456789.0 123456789.0)) +(assert_return (invoke "f32x4.floor" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)) + (v128.const f32x4 1.23456789e+27 1.23456789e+27 1.23456789e+27 1.23456789e+27)) +(assert_return (invoke "f32x4.floor" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)) + (v128.const f32x4 1.23456789e+27 1.23456789e+27 1.23456789e+27 1.23456789e+27)) +(assert_return (invoke "f32x4.floor" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)) + (v128.const f32x4 0.0 0.0 0.0 0.0)) +(assert_return (invoke "f32x4.floor" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)) + (v128.const f32x4 123456789.0 123456789.0 123456789.0 123456789.0)) +(assert_return (invoke "f32x4.floor" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f32x4 1.2345678901234569e+27 1.2345678901234569e+27 1.2345678901234569e+27 1.2345678901234569e+27)) +(assert_return (invoke "f32x4.floor" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f32x4 1.2345678901234569e+27 1.2345678901234569e+27 1.2345678901234569e+27 1.2345678901234569e+27)) +(assert_return (invoke "f32x4.floor" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f32x4 0.0 0.0 0.0 0.0)) +(assert_return (invoke "f32x4.floor" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)) + (v128.const f32x4 8.19855292164869e+16 8.19855292164869e+16 8.19855292164869e+16 8.19855292164869e+16)) +(assert_return (invoke "f32x4.floor" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)) + (v128.const f32x4 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22)) +(assert_return (invoke "f32x4.floor" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)) + (v128.const f32x4 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22)) +(assert_return (invoke "f32x4.floor" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)) + (v128.const f32x4 156374987061.0 156374987061.0 156374987061.0 156374987061.0)) +(assert_return (invoke "f32x4.floor" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)) + (v128.const f32x4 8.19855292164869e+16 8.19855292164869e+16 8.19855292164869e+16 8.19855292164869e+16)) +(assert_return (invoke "f32x4.floor" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)) + (v128.const f32x4 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22)) +(assert_return (invoke "f32x4.floor" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)) + (v128.const f32x4 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22)) +(assert_return (invoke "f32x4.floor" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)) + (v128.const f32x4 156374987061.0 156374987061.0 156374987061.0 156374987061.0)) +(assert_return (invoke "f32x4.floor" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)) + (v128.const f32x4 8.19855292164869e+16 8.19855292164869e+16 8.19855292164869e+16 8.19855292164869e+16)) +(assert_return (invoke "f32x4.floor" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)) + (v128.const f32x4 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22)) +(assert_return (invoke "f32x4.floor" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)) + (v128.const f32x4 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22)) +(assert_return (invoke "f32x4.floor" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)) + (v128.const f32x4 156374987061.0 156374987061.0 156374987061.0 156374987061.0)) +(assert_return (invoke "f32x4.floor" (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.floor" (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.floor" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.floor" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.trunc" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.trunc" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.trunc" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.trunc" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.trunc" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.trunc" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.trunc" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.trunc" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.trunc" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.trunc" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.trunc" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 0x1.8000000000000p+2 0x1.8000000000000p+2 0x1.8000000000000p+2 0x1.8000000000000p+2)) +(assert_return (invoke "f32x4.trunc" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 -0x1.8000000000000p+2 -0x1.8000000000000p+2 -0x1.8000000000000p+2 -0x1.8000000000000p+2)) +(assert_return (invoke "f32x4.trunc" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.trunc" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.trunc" (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.trunc" (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.trunc" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)) + (v128.const f32x4 123456789.0 123456789.0 123456789.0 123456789.0)) +(assert_return (invoke "f32x4.trunc" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)) + (v128.const f32x4 1.23456789e+27 1.23456789e+27 1.23456789e+27 1.23456789e+27)) +(assert_return (invoke "f32x4.trunc" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)) + (v128.const f32x4 1.23456789e+27 1.23456789e+27 1.23456789e+27 1.23456789e+27)) +(assert_return (invoke "f32x4.trunc" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)) + (v128.const f32x4 0.0 0.0 0.0 0.0)) +(assert_return (invoke "f32x4.trunc" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)) + (v128.const f32x4 123456789.0 123456789.0 123456789.0 123456789.0)) +(assert_return (invoke "f32x4.trunc" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)) + (v128.const f32x4 1.23456789e+27 1.23456789e+27 1.23456789e+27 1.23456789e+27)) +(assert_return (invoke "f32x4.trunc" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)) + (v128.const f32x4 1.23456789e+27 1.23456789e+27 1.23456789e+27 1.23456789e+27)) +(assert_return (invoke "f32x4.trunc" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)) + (v128.const f32x4 0.0 0.0 0.0 0.0)) +(assert_return (invoke "f32x4.trunc" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)) + (v128.const f32x4 123456789.0 123456789.0 123456789.0 123456789.0)) +(assert_return (invoke "f32x4.trunc" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f32x4 1.2345678901234569e+27 1.2345678901234569e+27 1.2345678901234569e+27 1.2345678901234569e+27)) +(assert_return (invoke "f32x4.trunc" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f32x4 1.2345678901234569e+27 1.2345678901234569e+27 1.2345678901234569e+27 1.2345678901234569e+27)) +(assert_return (invoke "f32x4.trunc" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f32x4 0.0 0.0 0.0 0.0)) +(assert_return (invoke "f32x4.trunc" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)) + (v128.const f32x4 8.19855292164869e+16 8.19855292164869e+16 8.19855292164869e+16 8.19855292164869e+16)) +(assert_return (invoke "f32x4.trunc" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)) + (v128.const f32x4 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22)) +(assert_return (invoke "f32x4.trunc" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)) + (v128.const f32x4 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22)) +(assert_return (invoke "f32x4.trunc" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)) + (v128.const f32x4 156374987061.0 156374987061.0 156374987061.0 156374987061.0)) +(assert_return (invoke "f32x4.trunc" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)) + (v128.const f32x4 8.19855292164869e+16 8.19855292164869e+16 8.19855292164869e+16 8.19855292164869e+16)) +(assert_return (invoke "f32x4.trunc" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)) + (v128.const f32x4 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22)) +(assert_return (invoke "f32x4.trunc" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)) + (v128.const f32x4 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22)) +(assert_return (invoke "f32x4.trunc" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)) + (v128.const f32x4 156374987061.0 156374987061.0 156374987061.0 156374987061.0)) +(assert_return (invoke "f32x4.trunc" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)) + (v128.const f32x4 8.19855292164869e+16 8.19855292164869e+16 8.19855292164869e+16 8.19855292164869e+16)) +(assert_return (invoke "f32x4.trunc" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)) + (v128.const f32x4 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22)) +(assert_return (invoke "f32x4.trunc" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)) + (v128.const f32x4 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22)) +(assert_return (invoke "f32x4.trunc" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)) + (v128.const f32x4 156374987061.0 156374987061.0 156374987061.0 156374987061.0)) +(assert_return (invoke "f32x4.trunc" (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.trunc" (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.trunc" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.trunc" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.nearest" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.nearest" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.nearest" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.nearest" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.nearest" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.nearest" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.nearest" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f32x4.nearest" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f32x4.nearest" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.nearest" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f32x4.nearest" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const f32x4 0x1.8000000000000p+2 0x1.8000000000000p+2 0x1.8000000000000p+2 0x1.8000000000000p+2)) +(assert_return (invoke "f32x4.nearest" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const f32x4 -0x1.8000000000000p+2 -0x1.8000000000000p+2 -0x1.8000000000000p+2 -0x1.8000000000000p+2)) +(assert_return (invoke "f32x4.nearest" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.nearest" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127)) +(assert_return (invoke "f32x4.nearest" (v128.const f32x4 inf inf inf inf)) + (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.nearest" (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.nearest" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)) + (v128.const f32x4 123456789.0 123456789.0 123456789.0 123456789.0)) +(assert_return (invoke "f32x4.nearest" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)) + (v128.const f32x4 1.23456789e+27 1.23456789e+27 1.23456789e+27 1.23456789e+27)) +(assert_return (invoke "f32x4.nearest" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)) + (v128.const f32x4 1.23456789e+27 1.23456789e+27 1.23456789e+27 1.23456789e+27)) +(assert_return (invoke "f32x4.nearest" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)) + (v128.const f32x4 0.0 0.0 0.0 0.0)) +(assert_return (invoke "f32x4.nearest" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)) + (v128.const f32x4 123456789.0 123456789.0 123456789.0 123456789.0)) +(assert_return (invoke "f32x4.nearest" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)) + (v128.const f32x4 1.23456789e+27 1.23456789e+27 1.23456789e+27 1.23456789e+27)) +(assert_return (invoke "f32x4.nearest" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)) + (v128.const f32x4 1.23456789e+27 1.23456789e+27 1.23456789e+27 1.23456789e+27)) +(assert_return (invoke "f32x4.nearest" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)) + (v128.const f32x4 0.0 0.0 0.0 0.0)) +(assert_return (invoke "f32x4.nearest" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)) + (v128.const f32x4 123456789.0 123456789.0 123456789.0 123456789.0)) +(assert_return (invoke "f32x4.nearest" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f32x4 1.2345678901234569e+27 1.2345678901234569e+27 1.2345678901234569e+27 1.2345678901234569e+27)) +(assert_return (invoke "f32x4.nearest" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f32x4 1.2345678901234569e+27 1.2345678901234569e+27 1.2345678901234569e+27 1.2345678901234569e+27)) +(assert_return (invoke "f32x4.nearest" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f32x4 0.0 0.0 0.0 0.0)) +(assert_return (invoke "f32x4.nearest" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)) + (v128.const f32x4 8.19855292164869e+16 8.19855292164869e+16 8.19855292164869e+16 8.19855292164869e+16)) +(assert_return (invoke "f32x4.nearest" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)) + (v128.const f32x4 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22)) +(assert_return (invoke "f32x4.nearest" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)) + (v128.const f32x4 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22)) +(assert_return (invoke "f32x4.nearest" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)) + (v128.const f32x4 156374987061.0 156374987061.0 156374987061.0 156374987061.0)) +(assert_return (invoke "f32x4.nearest" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)) + (v128.const f32x4 8.19855292164869e+16 8.19855292164869e+16 8.19855292164869e+16 8.19855292164869e+16)) +(assert_return (invoke "f32x4.nearest" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)) + (v128.const f32x4 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22)) +(assert_return (invoke "f32x4.nearest" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)) + (v128.const f32x4 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22)) +(assert_return (invoke "f32x4.nearest" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)) + (v128.const f32x4 156374987061.0 156374987061.0 156374987061.0 156374987061.0)) +(assert_return (invoke "f32x4.nearest" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)) + (v128.const f32x4 8.19855292164869e+16 8.19855292164869e+16 8.19855292164869e+16 8.19855292164869e+16)) +(assert_return (invoke "f32x4.nearest" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)) + (v128.const f32x4 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22)) +(assert_return (invoke "f32x4.nearest" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)) + (v128.const f32x4 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22)) +(assert_return (invoke "f32x4.nearest" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)) + (v128.const f32x4 156374987061.0 156374987061.0 156374987061.0 156374987061.0)) +(assert_return (invoke "f32x4.nearest" (v128.const f32x4 nan nan nan nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.nearest" (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical)) +(assert_return (invoke "f32x4.nearest" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f32x4.nearest" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)) + (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic)) + + +;; Unknown operators + +(assert_malformed (module quote "(memory 1) (func (result v128) (i8x16.ceil (v128.const i32x4 0 0 0 0)))") "unknown operator") +(assert_malformed (module quote "(memory 1) (func (result v128) (i8x16.floor (v128.const i32x4 0 0 0 0)))") "unknown operator") +(assert_malformed (module quote "(memory 1) (func (result v128) (i8x16.trunc (v128.const i32x4 0 0 0 0)))") "unknown operator") +(assert_malformed (module quote "(memory 1) (func (result v128) (i8x16.nearest (v128.const i32x4 0 0 0 0)))") "unknown operator") +(assert_malformed (module quote "(memory 1) (func (result v128) (i16x8.ceil (v128.const i32x4 0 0 0 0)))") "unknown operator") +(assert_malformed (module quote "(memory 1) (func (result v128) (i16x8.floor (v128.const i32x4 0 0 0 0)))") "unknown operator") +(assert_malformed (module quote "(memory 1) (func (result v128) (i16x8.trunc (v128.const i32x4 0 0 0 0)))") "unknown operator") +(assert_malformed (module quote "(memory 1) (func (result v128) (i16x8.nearest (v128.const i32x4 0 0 0 0)))") "unknown operator") +(assert_malformed (module quote "(memory 1) (func (result v128) (i32x4.ceil (v128.const i32x4 0 0 0 0)))") "unknown operator") +(assert_malformed (module quote "(memory 1) (func (result v128) (i32x4.floor (v128.const i32x4 0 0 0 0)))") "unknown operator") +(assert_malformed (module quote "(memory 1) (func (result v128) (i32x4.trunc (v128.const i32x4 0 0 0 0)))") "unknown operator") +(assert_malformed (module quote "(memory 1) (func (result v128) (i32x4.nearest (v128.const i32x4 0 0 0 0)))") "unknown operator") +(assert_malformed (module quote "(memory 1) (func (result v128) (i64x2.ceil (v128.const i32x4 0 0 0 0)))") "unknown operator") +(assert_malformed (module quote "(memory 1) (func (result v128) (i64x2.floor (v128.const i32x4 0 0 0 0)))") "unknown operator") +(assert_malformed (module quote "(memory 1) (func (result v128) (i64x2.trunc (v128.const i32x4 0 0 0 0)))") "unknown operator") +(assert_malformed (module quote "(memory 1) (func (result v128) (i64x2.nearest (v128.const i32x4 0 0 0 0)))") "unknown operator") + +;; type check +(assert_invalid (module (func (result v128) (f32x4.ceil (i32.const 0)))) "type mismatch") +(assert_invalid (module (func (result v128) (f32x4.floor (i32.const 0)))) "type mismatch") +(assert_invalid (module (func (result v128) (f32x4.trunc (i32.const 0)))) "type mismatch") +(assert_invalid (module (func (result v128) (f32x4.nearest (i32.const 0)))) "type mismatch") + +;; Test operation with empty argument + +(assert_invalid + (module + (func $f32x4.ceil-arg-empty (result v128) + (f32x4.ceil) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $f32x4.floor-arg-empty (result v128) + (f32x4.floor) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $f32x4.trunc-arg-empty (result v128) + (f32x4.trunc) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $f32x4.nearest-arg-empty (result v128) + (f32x4.nearest) + ) + ) + "type mismatch" +) + diff --git a/runtime/near-vm/tests/wast/spec/proposals/simd/simd_f64x2.wast b/runtime/near-vm/tests/wast/spec/proposals/simd/simd_f64x2.wast new file mode 100644 index 00000000000..8ebd33b3686 --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/proposals/simd/simd_f64x2.wast @@ -0,0 +1,2459 @@ +;; Tests for f64x2 [abs, min, max] operations on major boundary values and all special values. + + +(module + (func (export "f64x2.min") (param v128 v128) (result v128) (f64x2.min (local.get 0) (local.get 1))) + (func (export "f64x2.max") (param v128 v128) (result v128) (f64x2.max (local.get 0) (local.get 1))) + (func (export "f64x2.abs") (param v128) (result v128) (f64x2.abs (local.get 0))) + ;; f64x2.min const vs const + (func (export "f64x2.min_with_const_0") (result v128) (f64x2.min (v128.const f64x2 0 1) (v128.const f64x2 0 2))) + (func (export "f64x2.min_with_const_1") (result v128) (f64x2.min (v128.const f64x2 2 -3) (v128.const f64x2 1 3))) + (func (export "f64x2.min_with_const_2") (result v128) (f64x2.min (v128.const f64x2 0 1) (v128.const f64x2 0 1))) + (func (export "f64x2.min_with_const_3") (result v128) (f64x2.min (v128.const f64x2 2 3) (v128.const f64x2 2 3))) + (func (export "f64x2.min_with_const_4") (result v128) (f64x2.min (v128.const f64x2 0x00 0x01) (v128.const f64x2 0x00 0x02))) + (func (export "f64x2.min_with_const_5") (result v128) (f64x2.min (v128.const f64x2 0x02 0x80000000) (v128.const f64x2 0x01 2147483648))) + (func (export "f64x2.min_with_const_6") (result v128) (f64x2.min (v128.const f64x2 0x00 0x01) (v128.const f64x2 0x00 0x01))) + (func (export "f64x2.min_with_const_7") (result v128) (f64x2.min (v128.const f64x2 0x02 0x80000000) (v128.const f64x2 0x02 0x80000000))) + ;; f64x2.min param vs const + (func (export "f64x2.min_with_const_9") (param v128) (result v128) (f64x2.min (local.get 0) (v128.const f64x2 0 1))) + (func (export "f64x2.min_with_const_10") (param v128) (result v128) (f64x2.min (v128.const f64x2 2 -3) (local.get 0))) + (func (export "f64x2.min_with_const_11") (param v128) (result v128) (f64x2.min (v128.const f64x2 0 1) (local.get 0))) + (func (export "f64x2.min_with_const_12") (param v128) (result v128) (f64x2.min (local.get 0) (v128.const f64x2 2 3))) + (func (export "f64x2.min_with_const_13") (param v128) (result v128) (f64x2.min (v128.const f64x2 0x00 0x01) (local.get 0))) + (func (export "f64x2.min_with_const_14") (param v128) (result v128) (f64x2.min (v128.const f64x2 0x02 0x80000000) (local.get 0))) + (func (export "f64x2.min_with_const_15") (param v128) (result v128) (f64x2.min (v128.const f64x2 0x00 0x01) (local.get 0))) + (func (export "f64x2.min_with_const_16") (param v128) (result v128) (f64x2.min (v128.const f64x2 0x02 0x80000000) (local.get 0))) + ;; f64x2.max const vs const + (func (export "f64x2.max_with_const_18") (result v128) (f64x2.max (v128.const f64x2 0 1) (v128.const f64x2 0 2))) + (func (export "f64x2.max_with_const_19") (result v128) (f64x2.max (v128.const f64x2 2 -3) (v128.const f64x2 1 3))) + (func (export "f64x2.max_with_const_20") (result v128) (f64x2.max (v128.const f64x2 0 1) (v128.const f64x2 0 1))) + (func (export "f64x2.max_with_const_21") (result v128) (f64x2.max (v128.const f64x2 2 3) (v128.const f64x2 2 3))) + (func (export "f64x2.max_with_const_22") (result v128) (f64x2.max (v128.const f64x2 0x00 0x01) (v128.const f64x2 0x00 0x02))) + (func (export "f64x2.max_with_const_23") (result v128) (f64x2.max (v128.const f64x2 0x02 0x80000000) (v128.const f64x2 0x01 2147483648))) + (func (export "f64x2.max_with_const_24") (result v128) (f64x2.max (v128.const f64x2 0x00 0x01) (v128.const f64x2 0x00 0x01))) + (func (export "f64x2.max_with_const_25") (result v128) (f64x2.max (v128.const f64x2 0x02 0x80000000) (v128.const f64x2 0x02 0x80000000))) + ;; f64x2.max param vs const + (func (export "f64x2.max_with_const_27") (param v128) (result v128) (f64x2.max (local.get 0) (v128.const f64x2 0 1))) + (func (export "f64x2.max_with_const_28") (param v128) (result v128) (f64x2.max (v128.const f64x2 2 -3) (local.get 0))) + (func (export "f64x2.max_with_const_29") (param v128) (result v128) (f64x2.max (v128.const f64x2 0 1) (local.get 0))) + (func (export "f64x2.max_with_const_30") (param v128) (result v128) (f64x2.max (local.get 0) (v128.const f64x2 2 3))) + (func (export "f64x2.max_with_const_31") (param v128) (result v128) (f64x2.max (v128.const f64x2 0x00 0x01) (local.get 0))) + (func (export "f64x2.max_with_const_32") (param v128) (result v128) (f64x2.max (v128.const f64x2 0x02 0x80000000) (local.get 0))) + (func (export "f64x2.max_with_const_33") (param v128) (result v128) (f64x2.max (v128.const f64x2 0x00 0x01) (local.get 0))) + (func (export "f64x2.max_with_const_34") (param v128) (result v128) (f64x2.max (v128.const f64x2 0x02 0x80000000) (local.get 0))) + + (func (export "f64x2.abs_with_const_35") (result v128) (f64x2.abs (v128.const f64x2 -0 -1))) + (func (export "f64x2.abs_with_const_36") (result v128) (f64x2.abs (v128.const f64x2 -2 -3))) +) + +;; f64x2.min const vs const +(assert_return (invoke "f64x2.min_with_const_0") (v128.const f64x2 0 1)) +(assert_return (invoke "f64x2.min_with_const_1") (v128.const f64x2 1 -3)) +(assert_return (invoke "f64x2.min_with_const_2") (v128.const f64x2 0 1)) +(assert_return (invoke "f64x2.min_with_const_3") (v128.const f64x2 2 3)) +;; f64x2.min param vs const +(assert_return (invoke "f64x2.min_with_const_4") (v128.const f64x2 0x00 0x01)) +(assert_return (invoke "f64x2.min_with_const_5") (v128.const f64x2 0x01 0x80000000)) +(assert_return (invoke "f64x2.min_with_const_6") (v128.const f64x2 0x00 0x01)) +(assert_return (invoke "f64x2.min_with_const_7") (v128.const f64x2 0x02 0x80000000)) +(assert_return (invoke "f64x2.min_with_const_9" (v128.const f64x2 0 2)) + (v128.const f64x2 0 1)) +(assert_return (invoke "f64x2.min_with_const_10" (v128.const f64x2 1 3)) + (v128.const f64x2 1 -3)) +(assert_return (invoke "f64x2.min_with_const_11" (v128.const f64x2 0 1)) + (v128.const f64x2 0 1)) +(assert_return (invoke "f64x2.min_with_const_12" (v128.const f64x2 2 3)) + (v128.const f64x2 2 3)) +(assert_return (invoke "f64x2.min_with_const_13" (v128.const f64x2 0x00 0x02)) + (v128.const f64x2 0x00 0x01)) +(assert_return (invoke "f64x2.min_with_const_14" (v128.const f64x2 0x01 2147483648)) + (v128.const f64x2 0x01 0x80000000)) +(assert_return (invoke "f64x2.min_with_const_15" (v128.const f64x2 0x00 0x01)) + (v128.const f64x2 0x00 0x01)) +(assert_return (invoke "f64x2.min_with_const_16" (v128.const f64x2 0x02 0x80000000)) + (v128.const f64x2 0x02 0x80000000)) +;; f64x2.max const vs const +(assert_return (invoke "f64x2.max_with_const_18") (v128.const f64x2 0 2)) +(assert_return (invoke "f64x2.max_with_const_19") (v128.const f64x2 2 3)) +(assert_return (invoke "f64x2.max_with_const_20") (v128.const f64x2 0 1)) +(assert_return (invoke "f64x2.max_with_const_21") (v128.const f64x2 2 3)) +;; f64x2.max param vs const +(assert_return (invoke "f64x2.max_with_const_22") (v128.const f64x2 0x00 0x02)) +(assert_return (invoke "f64x2.max_with_const_23") (v128.const f64x2 0x02 2147483648)) +(assert_return (invoke "f64x2.max_with_const_24") (v128.const f64x2 0x00 0x01)) +(assert_return (invoke "f64x2.max_with_const_25") (v128.const f64x2 0x02 0x80000000)) +(assert_return (invoke "f64x2.max_with_const_27" (v128.const f64x2 0 2)) + (v128.const f64x2 0 2)) +(assert_return (invoke "f64x2.max_with_const_28" (v128.const f64x2 1 3)) + (v128.const f64x2 2 3)) +(assert_return (invoke "f64x2.max_with_const_29" (v128.const f64x2 0 1)) + (v128.const f64x2 0 1)) +(assert_return (invoke "f64x2.max_with_const_30" (v128.const f64x2 2 3)) + (v128.const f64x2 2 3)) +(assert_return (invoke "f64x2.max_with_const_31" (v128.const f64x2 0x00 0x02)) + (v128.const f64x2 0x00 0x02)) +(assert_return (invoke "f64x2.max_with_const_32" (v128.const f64x2 0x01 2147483648)) + (v128.const f64x2 0x02 2147483648)) +(assert_return (invoke "f64x2.max_with_const_33" (v128.const f64x2 0x00 0x01)) + (v128.const f64x2 0x00 0x01)) +(assert_return (invoke "f64x2.max_with_const_34" (v128.const f64x2 0x02 0x80000000)) + (v128.const f64x2 0x02 0x80000000)) + +(assert_return (invoke "f64x2.abs_with_const_35") (v128.const f64x2 0 1)) +(assert_return (invoke "f64x2.abs_with_const_36") (v128.const f64x2 2 3)) + +;; Test different lanes go through different if-then clauses +;; f64x2.min +(assert_return + (invoke "f64x2.min" + (v128.const f64x2 nan 0) + (v128.const f64x2 0 1) + ) + (v128.const f64x2 nan:canonical 0) +) +;; f64x2.min +(assert_return + (invoke "f64x2.min" + (v128.const f64x2 0 1) + (v128.const f64x2 -nan 0) + ) + (v128.const f64x2 nan:canonical 0) +) +;; f64x2.min +(assert_return + (invoke "f64x2.min" + (v128.const f64x2 0 1) + (v128.const f64x2 -nan 1) + ) + (v128.const f64x2 nan:canonical 1) +) +;; f64x2.max +(assert_return + (invoke "f64x2.max" + (v128.const f64x2 nan 0) + (v128.const f64x2 0 1) + ) + (v128.const f64x2 nan:canonical 1) +) +;; f64x2.max +(assert_return + (invoke "f64x2.max" + (v128.const f64x2 0 1) + (v128.const f64x2 -nan 0) + ) + (v128.const f64x2 nan:canonical 1) +) +;; f64x2.max +(assert_return + (invoke "f64x2.max" + (v128.const f64x2 0 1) + (v128.const f64x2 -nan 1) + ) + (v128.const f64x2 nan:canonical 1) +) + +(assert_return (invoke "f64x2.min" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 -0x0p+0 -0x0p+0)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 inf inf)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 -0x0p+0 -0x0p+0)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 inf inf)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1074 0x1p-1074) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1074 0x1p-1074) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1074 0x1p-1074) + (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1074 0x1p-1074) + (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1074 0x1p-1074) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1074 0x1p-1074) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1074 0x1p-1074) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1074 0x1p-1074) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1074 0x1p-1074) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1074 0x1p-1074) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1074 0x1p-1074) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1074 0x1p-1074) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1074 0x1p-1074) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1074 0x1p-1074) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1074 0x1p-1074) + (v128.const f64x2 inf inf)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1074 0x1p-1074) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1074 -0x1p-1074) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1074 -0x1p-1074) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1074 -0x1p-1074) + (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1074 -0x1p-1074) + (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1074 -0x1p-1074) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1074 -0x1p-1074) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1074 -0x1p-1074) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1074 -0x1p-1074) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1074 -0x1p-1074) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1074 -0x1p-1074) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1074 -0x1p-1074) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1074 -0x1p-1074) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1074 -0x1p-1074) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1074 -0x1p-1074) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1074 -0x1p-1074) + (v128.const f64x2 inf inf)) + (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1074 -0x1p-1074) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 inf inf)) + (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 inf inf)) + (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 inf inf)) + (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 inf inf)) + (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 inf inf)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 inf inf)) + (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 inf inf)) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 inf inf)) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 inf inf)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 inf inf)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 inf inf) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 inf inf) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 inf inf) + (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 inf inf) + (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 inf inf) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 inf inf) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 inf inf) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 inf inf) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 inf inf) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 inf inf) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 inf inf) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 inf inf) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 inf inf) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 inf inf) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 inf inf) + (v128.const f64x2 inf inf)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 inf inf) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -inf -inf) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -inf -inf) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -inf -inf) + (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -inf -inf) + (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -inf -inf) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -inf -inf) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -inf -inf) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -inf -inf) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -inf -inf) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -inf -inf) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -inf -inf) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -inf -inf) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -inf -inf) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -inf -inf) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -inf -inf) + (v128.const f64x2 inf inf)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -inf -inf) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 nan nan) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 nan nan) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 nan nan) + (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 nan nan) + (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 nan nan) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 nan nan) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 nan nan) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 nan nan) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 nan nan) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 nan nan) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 nan nan) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 nan nan) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 nan nan) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 nan nan) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 nan nan) + (v128.const f64x2 inf inf)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 nan nan) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 nan nan) + (v128.const f64x2 nan nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 nan nan) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 nan nan) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 nan nan) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan -nan) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan -nan) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan -nan) + (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan -nan) + (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan -nan) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan -nan) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan -nan) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan -nan) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan -nan) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan -nan) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan -nan) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan -nan) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan -nan) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan -nan) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan -nan) + (v128.const f64x2 inf inf)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan -nan) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan -nan) + (v128.const f64x2 nan nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan -nan) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan -nan) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan -nan) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 inf inf)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 nan nan)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 inf inf)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 nan nan)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038) + (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)) + (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038) + (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)) + (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038) + (v128.const f64x2 0123456789.e038 0123456789.e038)) + (v128.const f64x2 0123456789.e038 0123456789.e038)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038) + (v128.const f64x2 0123456789.e+038 0123456789.e+038)) + (v128.const f64x2 0123456789.e+038 0123456789.e+038)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038) + (v128.const f64x2 -01234567890123456789.01234567890123456789 -01234567890123456789.01234567890123456789)) + (v128.const f64x2 -01234567890123456789.01234567890123456789 -01234567890123456789.01234567890123456789)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038) + (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)) + (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038) + (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)) + (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038) + (v128.const f64x2 0123456789.e038 0123456789.e038)) + (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038) + (v128.const f64x2 0123456789.e+038 0123456789.e+038)) + (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038) + (v128.const f64x2 -01234567890123456789.01234567890123456789 -01234567890123456789.01234567890123456789)) + (v128.const f64x2 -01234567890123456789.01234567890123456789 -01234567890123456789.01234567890123456789)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 0123456789.e038 0123456789.e038) + (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)) + (v128.const f64x2 0123456789.e038 0123456789.e038)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 0123456789.e038 0123456789.e038) + (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)) + (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 0123456789.e038 0123456789.e038) + (v128.const f64x2 0123456789.e038 0123456789.e038)) + (v128.const f64x2 0123456789.e038 0123456789.e038)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 0123456789.e038 0123456789.e038) + (v128.const f64x2 0123456789.e+038 0123456789.e+038)) + (v128.const f64x2 0123456789.e038 0123456789.e038)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 0123456789.e038 0123456789.e038) + (v128.const f64x2 -01234567890123456789.01234567890123456789 -01234567890123456789.01234567890123456789)) + (v128.const f64x2 -01234567890123456789.01234567890123456789 -01234567890123456789.01234567890123456789)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 0123456789.e+038 0123456789.e+038) + (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)) + (v128.const f64x2 0123456789.e+038 0123456789.e+038)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 0123456789.e+038 0123456789.e+038) + (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)) + (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 0123456789.e+038 0123456789.e+038) + (v128.const f64x2 0123456789.e038 0123456789.e038)) + (v128.const f64x2 0123456789.e+038 0123456789.e+038)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 0123456789.e+038 0123456789.e+038) + (v128.const f64x2 0123456789.e+038 0123456789.e+038)) + (v128.const f64x2 0123456789.e+038 0123456789.e+038)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 0123456789.e+038 0123456789.e+038) + (v128.const f64x2 -01234567890123456789.01234567890123456789 -01234567890123456789.01234567890123456789)) + (v128.const f64x2 -01234567890123456789.01234567890123456789 -01234567890123456789.01234567890123456789)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -01234567890123456789.01234567890123456789 -01234567890123456789.01234567890123456789) + (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)) + (v128.const f64x2 -01234567890123456789.01234567890123456789 -01234567890123456789.01234567890123456789)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -01234567890123456789.01234567890123456789 -01234567890123456789.01234567890123456789) + (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)) + (v128.const f64x2 -01234567890123456789.01234567890123456789 -01234567890123456789.01234567890123456789)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -01234567890123456789.01234567890123456789 -01234567890123456789.01234567890123456789) + (v128.const f64x2 0123456789.e038 0123456789.e038)) + (v128.const f64x2 -01234567890123456789.01234567890123456789 -01234567890123456789.01234567890123456789)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -01234567890123456789.01234567890123456789 -01234567890123456789.01234567890123456789) + (v128.const f64x2 0123456789.e+038 0123456789.e+038)) + (v128.const f64x2 -01234567890123456789.01234567890123456789 -01234567890123456789.01234567890123456789)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -01234567890123456789.01234567890123456789 -01234567890123456789.01234567890123456789) + (v128.const f64x2 -01234567890123456789.01234567890123456789 -01234567890123456789.01234567890123456789)) + (v128.const f64x2 -01234567890123456789.01234567890123456789 -01234567890123456789.01234567890123456789)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 0x0p+0 0x0p+0)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 inf inf)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 0x0p+0 0x0p+0)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 inf inf)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1074 0x1p-1074) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1074 0x1p-1074) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1074 0x1p-1074) + (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1074 0x1p-1074) + (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1074 0x1p-1074) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1074 0x1p-1074) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1074 0x1p-1074) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1074 0x1p-1074) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1074 0x1p-1074) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1074 0x1p-1074) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1074 0x1p-1074) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1074 0x1p-1074) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1074 0x1p-1074) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1074 0x1p-1074) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1074 0x1p-1074) + (v128.const f64x2 inf inf)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1074 0x1p-1074) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1074 -0x1p-1074) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1074 -0x1p-1074) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1074 -0x1p-1074) + (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1074 -0x1p-1074) + (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1074 -0x1p-1074) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1074 -0x1p-1074) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1074 -0x1p-1074) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1074 -0x1p-1074) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1074 -0x1p-1074) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1074 -0x1p-1074) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1074 -0x1p-1074) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1074 -0x1p-1074) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1074 -0x1p-1074) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1074 -0x1p-1074) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1074 -0x1p-1074) + (v128.const f64x2 inf inf)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1074 -0x1p-1074) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 inf inf)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 inf inf)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 inf inf)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 inf inf)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 inf inf)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 inf inf)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 inf inf)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 inf inf)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 inf inf)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 inf inf)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 inf inf) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 inf inf) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 inf inf) + (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 inf inf) + (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 inf inf) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 inf inf) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 inf inf) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 inf inf) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 inf inf) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 inf inf) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 inf inf) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 inf inf) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 inf inf) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 inf inf) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 inf inf) + (v128.const f64x2 inf inf)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 inf inf) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -inf -inf) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -inf -inf) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -inf -inf) + (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -inf -inf) + (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -inf -inf) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -inf -inf) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -inf -inf) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -inf -inf) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -inf -inf) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -inf -inf) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -inf -inf) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -inf -inf) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -inf -inf) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -inf -inf) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -inf -inf) + (v128.const f64x2 inf inf)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -inf -inf) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 nan nan) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 nan nan) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 nan nan) + (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 nan nan) + (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 nan nan) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 nan nan) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 nan nan) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 nan nan) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 nan nan) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 nan nan) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 nan nan) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 nan nan) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 nan nan) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 nan nan) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 nan nan) + (v128.const f64x2 inf inf)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 nan nan) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 nan nan) + (v128.const f64x2 nan nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 nan nan) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 nan nan) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 nan nan) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan -nan) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan -nan) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan -nan) + (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan -nan) + (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan -nan) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan -nan) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan -nan) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan -nan) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan -nan) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan -nan) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan -nan) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan -nan) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan -nan) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan -nan) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan -nan) + (v128.const f64x2 inf inf)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan -nan) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan -nan) + (v128.const f64x2 nan nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan -nan) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan -nan) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan -nan) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 inf inf)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 nan nan)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 inf inf)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 nan nan)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038) + (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)) + (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038) + (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)) + (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038) + (v128.const f64x2 0123456789.e038 0123456789.e038)) + (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038) + (v128.const f64x2 0123456789.e+038 0123456789.e+038)) + (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038) + (v128.const f64x2 -01234567890123456789.01234567890123456789 -01234567890123456789.01234567890123456789)) + (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038) + (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)) + (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038) + (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)) + (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038) + (v128.const f64x2 0123456789.e038 0123456789.e038)) + (v128.const f64x2 0123456789.e038 0123456789.e038)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038) + (v128.const f64x2 0123456789.e+038 0123456789.e+038)) + (v128.const f64x2 0123456789.e+038 0123456789.e+038)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038) + (v128.const f64x2 -01234567890123456789.01234567890123456789 -01234567890123456789.01234567890123456789)) + (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 0123456789.e038 0123456789.e038) + (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)) + (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 0123456789.e038 0123456789.e038) + (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)) + (v128.const f64x2 0123456789.e038 0123456789.e038)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 0123456789.e038 0123456789.e038) + (v128.const f64x2 0123456789.e038 0123456789.e038)) + (v128.const f64x2 0123456789.e038 0123456789.e038)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 0123456789.e038 0123456789.e038) + (v128.const f64x2 0123456789.e+038 0123456789.e+038)) + (v128.const f64x2 0123456789.e+038 0123456789.e+038)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 0123456789.e038 0123456789.e038) + (v128.const f64x2 -01234567890123456789.01234567890123456789 -01234567890123456789.01234567890123456789)) + (v128.const f64x2 0123456789.e038 0123456789.e038)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 0123456789.e+038 0123456789.e+038) + (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)) + (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 0123456789.e+038 0123456789.e+038) + (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)) + (v128.const f64x2 0123456789.e+038 0123456789.e+038)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 0123456789.e+038 0123456789.e+038) + (v128.const f64x2 0123456789.e038 0123456789.e038)) + (v128.const f64x2 0123456789.e038 0123456789.e038)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 0123456789.e+038 0123456789.e+038) + (v128.const f64x2 0123456789.e+038 0123456789.e+038)) + (v128.const f64x2 0123456789.e+038 0123456789.e+038)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 0123456789.e+038 0123456789.e+038) + (v128.const f64x2 -01234567890123456789.01234567890123456789 -01234567890123456789.01234567890123456789)) + (v128.const f64x2 0123456789.e+038 0123456789.e+038)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -01234567890123456789.01234567890123456789 -01234567890123456789.01234567890123456789) + (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)) + (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -01234567890123456789.01234567890123456789 -01234567890123456789.01234567890123456789) + (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)) + (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -01234567890123456789.01234567890123456789 -01234567890123456789.01234567890123456789) + (v128.const f64x2 0123456789.e038 0123456789.e038)) + (v128.const f64x2 0123456789.e038 0123456789.e038)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -01234567890123456789.01234567890123456789 -01234567890123456789.01234567890123456789) + (v128.const f64x2 0123456789.e+038 0123456789.e+038)) + (v128.const f64x2 0123456789.e+038 0123456789.e+038)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -01234567890123456789.01234567890123456789 -01234567890123456789.01234567890123456789) + (v128.const f64x2 -01234567890123456789.01234567890123456789 -01234567890123456789.01234567890123456789)) + (v128.const f64x2 -01234567890123456789.01234567890123456789 -01234567890123456789.01234567890123456789)) + +;; Test opposite signs of zero +(assert_return (invoke "f64x2.min" (v128.const f64x2 0 0) + (v128.const f64x2 +0 -0)) + (v128.const f64x2 0 -0)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -0 +0) + (v128.const f64x2 +0 -0)) + (v128.const f64x2 -0 -0)) +(assert_return (invoke "f64x2.min" (v128.const f64x2 -0 -0) + (v128.const f64x2 +0 +0)) + (v128.const f64x2 -0 -0)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 0 0) + (v128.const f64x2 +0 -0)) + (v128.const f64x2 0 0)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -0 +0) + (v128.const f64x2 +0 -0)) + (v128.const f64x2 0 0)) +(assert_return (invoke "f64x2.max" (v128.const f64x2 -0 -0) + (v128.const f64x2 +0 +0)) + (v128.const f64x2 +0 +0)) + + +(assert_return (invoke "f64x2.abs" (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.abs" (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.abs" (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.abs" (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.abs" (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.abs" (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.abs" (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.abs" (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.abs" (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.abs" (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.abs" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.abs" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.abs" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.abs" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.abs" (v128.const f64x2 inf inf)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.abs" (v128.const f64x2 -inf -inf)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.abs" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)) + (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)) +(assert_return (invoke "f64x2.abs" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)) + (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)) +(assert_return (invoke "f64x2.abs" (v128.const f64x2 0123456789.e038 0123456789.e038)) + (v128.const f64x2 0123456789.e038 0123456789.e038)) +(assert_return (invoke "f64x2.abs" (v128.const f64x2 0123456789.e+038 0123456789.e+038)) + (v128.const f64x2 0123456789.e+038 0123456789.e+038)) +(assert_return (invoke "f64x2.abs" (v128.const f64x2 -01234567890123456789.01234567890123456789 -01234567890123456789.01234567890123456789)) + (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789)) + +;; type check +(assert_invalid (module (func (result v128) (f64x2.abs (i32.const 0)))) "type mismatch") +(assert_invalid (module (func (result v128) (f64x2.min (i32.const 0) (f32.const 0.0)))) "type mismatch") +(assert_invalid (module (func (result v128) (f64x2.max (i32.const 0) (f32.const 0.0)))) "type mismatch") + +;; Test operation with empty argument + +(assert_invalid + (module + (func $f64x2.abs-arg-empty (result v128) + (f64x2.abs) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $f64x2.min-1st-arg-empty (result v128) + (f64x2.min (v128.const f64x2 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $f64x2.min-arg-empty (result v128) + (f64x2.min) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $f64x2.max-1st-arg-empty (result v128) + (f64x2.max (v128.const f64x2 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $f64x2.max-arg-empty (result v128) + (f64x2.max) + ) + ) + "type mismatch" +) + +;; combination +(module + (func (export "max-min") (param v128 v128 v128) (result v128) + (f64x2.max (f64x2.min (local.get 0) (local.get 1))(local.get 2))) + (func (export "min-max") (param v128 v128 v128) (result v128) + (f64x2.min (f64x2.max (local.get 0) (local.get 1))(local.get 2))) + (func (export "max-abs") (param v128 v128) (result v128) + (f64x2.max (f64x2.abs (local.get 0)) (local.get 1))) + (func (export "min-abs") (param v128 v128) (result v128) + (f64x2.min (f64x2.abs (local.get 0)) (local.get 1))) +) + +(assert_return (invoke "max-min" (v128.const f64x2 1.125 1.125) + (v128.const f64x2 0.25 0.25) + (v128.const f64x2 0.125 0.125)) + (v128.const f64x2 0.25 0.25)) +(assert_return (invoke "min-max" (v128.const f64x2 1.125 1.125) + (v128.const f64x2 0.25 0.25) + (v128.const f64x2 0.125 0.125)) + (v128.const f64x2 0.125 0.125)) +(assert_return (invoke "max-abs" (v128.const f64x2 -1.125 -1.125) + (v128.const f64x2 0.125 0.125)) + (v128.const f64x2 1.125 1.125)) +(assert_return (invoke "min-abs" (v128.const f64x2 -1.125 -1.125) + (v128.const f64x2 0.125 0.125)) + (v128.const f64x2 0.125 0.125)) \ No newline at end of file diff --git a/runtime/near-vm/tests/wast/spec/proposals/simd/simd_f64x2_arith.wast b/runtime/near-vm/tests/wast/spec/proposals/simd/simd_f64x2_arith.wast new file mode 100644 index 00000000000..4ab3b01e964 --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/proposals/simd/simd_f64x2_arith.wast @@ -0,0 +1,5483 @@ +;; Tests for f64x2 arithmetic operations on major boundary values and all special values. + + +(module + (func (export "f64x2.add") (param v128 v128) (result v128) (f64x2.add (local.get 0) (local.get 1))) + (func (export "f64x2.sub") (param v128 v128) (result v128) (f64x2.sub (local.get 0) (local.get 1))) + (func (export "f64x2.mul") (param v128 v128) (result v128) (f64x2.mul (local.get 0) (local.get 1))) + (func (export "f64x2.div") (param v128 v128) (result v128) (f64x2.div (local.get 0) (local.get 1))) + (func (export "f64x2.neg") (param v128) (result v128) (f64x2.neg (local.get 0))) + (func (export "f64x2.sqrt") (param v128) (result v128) (f64x2.sqrt (local.get 0))) +) + +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 inf inf)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 inf inf)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 0x1.0000000000000p-1021 0x1.0000000000000p-1021)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x1.0000000000001p-1022 0x1.0000000000001p-1022)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x1.0000000000001p-1022 0x1.0000000000001p-1022)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 inf inf)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 -0x1.0000000000000p-1021 -0x1.0000000000000p-1021)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 -0x0.fffffffffffffp-1022 -0x0.fffffffffffffp-1022)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 -0x0.fffffffffffffp-1022 -0x0.fffffffffffffp-1022)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 inf inf)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 0x1.8000000000000p+0 0x1.8000000000000p+0)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.b21fb54442d18p+2 0x1.b21fb54442d18p+2)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 -0x1.721fb54442d18p+2 -0x1.721fb54442d18p+2)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 inf inf)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 -0x1.8000000000000p+0 -0x1.8000000000000p+0)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.721fb54442d18p+2 0x1.721fb54442d18p+2)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 -0x1.b21fb54442d18p+2 -0x1.b21fb54442d18p+2)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 inf inf)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 0x1.8000000000000p+0 0x1.8000000000000p+0)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 0x1.0000000000000p+1 0x1.0000000000000p+1)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.d21fb54442d18p+2 0x1.d21fb54442d18p+2)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 -0x1.521fb54442d18p+2 -0x1.521fb54442d18p+2)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 inf inf)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 -0x1.8000000000000p+0 -0x1.8000000000000p+0)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 -0x1.0000000000000p+1 -0x1.0000000000000p+1)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.521fb54442d18p+2 0x1.521fb54442d18p+2)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 -0x1.d21fb54442d18p+2 -0x1.d21fb54442d18p+2)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 inf inf)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 0x1.b21fb54442d18p+2 0x1.b21fb54442d18p+2)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 0x1.721fb54442d18p+2 0x1.721fb54442d18p+2)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 0x1.d21fb54442d18p+2 0x1.d21fb54442d18p+2)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 0x1.521fb54442d18p+2 0x1.521fb54442d18p+2)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.921fb54442d18p+3 0x1.921fb54442d18p+3)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 inf inf)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 -0x1.721fb54442d18p+2 -0x1.721fb54442d18p+2)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 -0x1.b21fb54442d18p+2 -0x1.b21fb54442d18p+2)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 -0x1.521fb54442d18p+2 -0x1.521fb54442d18p+2)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 -0x1.d21fb54442d18p+2 -0x1.d21fb54442d18p+2)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 -0x1.921fb54442d18p+3 -0x1.921fb54442d18p+3)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 inf inf)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 inf inf)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 inf inf)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 0x1.0000000000001p-1022 0x1.0000000000001p-1022)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 -0x0.fffffffffffffp-1022 -0x0.fffffffffffffp-1022)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x0.0000000000002p-1022 0x0.0000000000002p-1022)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x0.0000000000002p-1022 0x0.0000000000002p-1022)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 inf inf)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 0x1.0000000000001p-1022 0x1.0000000000001p-1022)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 -0x0.fffffffffffffp-1022 -0x0.fffffffffffffp-1022)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x0.0000000000002p-1022 0x0.0000000000002p-1022)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x0.0000000000002p-1022 0x0.0000000000002p-1022)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 inf inf)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 inf inf) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 inf inf) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 inf inf) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 inf inf) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 inf inf) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 inf inf) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 inf inf) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 inf inf) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 inf inf) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 inf inf) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 inf inf) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 inf inf) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 inf inf) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 inf inf) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 inf inf) + (v128.const f64x2 inf inf)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 inf inf) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -inf -inf) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -inf -inf) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -inf -inf) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -inf -inf) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -inf -inf) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -inf -inf) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -inf -inf) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -inf -inf) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -inf -inf) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -inf -inf) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -inf -inf) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -inf -inf) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -inf -inf) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -inf -inf) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -inf -inf) + (v128.const f64x2 inf inf)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -inf -inf) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 nan nan) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 nan nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 nan nan) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 nan nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 nan nan) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 nan nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 nan nan) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 nan nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 nan nan) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 nan nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 nan nan) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 nan nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 nan nan) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 nan nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 nan nan) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 nan nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 nan nan) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 nan nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 nan nan) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 nan nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 nan nan) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 nan nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 nan nan) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 nan nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 nan nan) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 nan nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 nan nan) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 nan nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 nan nan) + (v128.const f64x2 inf inf)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 inf inf) + (v128.const f64x2 nan nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 nan nan) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -inf -inf) + (v128.const f64x2 nan nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 nan nan) + (v128.const f64x2 nan nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 nan nan) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 nan nan) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 nan nan) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan -nan) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan -nan) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan -nan) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan -nan) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan -nan) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan -nan) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan -nan) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan -nan) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan -nan) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan -nan) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan -nan) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan -nan) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan -nan) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan -nan) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan -nan) + (v128.const f64x2 inf inf)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 inf inf) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan -nan) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -inf -inf) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan -nan) + (v128.const f64x2 nan nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan -nan) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan -nan) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan -nan) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 inf inf)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 inf inf) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -inf -inf) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 nan nan)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 inf inf)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 inf inf) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -inf -inf) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 nan nan)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0123456789 0123456789) + (v128.const f64x2 0123456789 0123456789)) + (v128.const f64x2 246913578.0 246913578.0)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0123456789e019 0123456789e019) + (v128.const f64x2 0123456789e019 0123456789e019)) + (v128.const f64x2 2.46913578e+27 2.46913578e+27)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0123456789e+019 0123456789e+019) + (v128.const f64x2 0123456789e+019 0123456789e+019)) + (v128.const f64x2 2.46913578e+27 2.46913578e+27)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0123456789e-019 0123456789e-019) + (v128.const f64x2 0123456789e-019 0123456789e-019)) + (v128.const f64x2 2.46913578e-11 2.46913578e-11)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0123456789. 0123456789.) + (v128.const f64x2 0123456789. 0123456789.)) + (v128.const f64x2 246913578.0 246913578.0)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0123456789.e019 0123456789.e019) + (v128.const f64x2 0123456789.e019 0123456789.e019)) + (v128.const f64x2 2.46913578e+27 2.46913578e+27)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0123456789.e+019 0123456789.e+019) + (v128.const f64x2 0123456789.e+019 0123456789.e+019)) + (v128.const f64x2 2.46913578e+27 2.46913578e+27)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0123456789.e-019 0123456789.e-019) + (v128.const f64x2 0123456789.e-019 0123456789.e-019)) + (v128.const f64x2 2.46913578e-11 2.46913578e-11)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789) + (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)) + (v128.const f64x2 246913578.02469134 246913578.02469134)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f64x2 2.4691357802469137e+27 2.4691357802469137e+27)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f64x2 2.4691357802469137e+27 2.4691357802469137e+27)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f64x2 2.4691357802469137e-11 2.4691357802469137e-11)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef) + (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)) + (v128.const f64x2 0x1.23456789abcdfp+81 0x1.23456789abcdfp+81)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019) + (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)) + (v128.const f64x2 0x1.23456789abcdfp+100 0x1.23456789abcdfp+100)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019) + (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 0x1.23456789abcdfp+100 0x1.23456789abcdfp+100)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019) + (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 0x1.23456789abcdfp+62 0x1.23456789abcdfp+62)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.) + (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)) + (v128.const f64x2 0x1.23456789abcdfp+81 0x1.23456789abcdfp+81)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)) + (v128.const f64x2 0x1.23456789abcdfp+100 0x1.23456789abcdfp+100)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)) + (v128.const f64x2 0x1.23456789abcdfp+100 0x1.23456789abcdfp+100)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)) + (v128.const f64x2 0x1.23456789abcdfp+62 0x1.23456789abcdfp+62)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)) + (v128.const f64x2 0x1.23456789abcdfp+81 0x1.23456789abcdfp+81)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)) + (v128.const f64x2 0x1.23456789abcdfp+100 0x1.23456789abcdfp+100)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 0x1.23456789abcdfp+100 0x1.23456789abcdfp+100)) +(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 0x1.23456789abcdfp+62 0x1.23456789abcdfp+62)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 inf inf)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 inf inf)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 0x1.0000000000000p-1021 0x1.0000000000000p-1021)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x0.fffffffffffffp-1022 0x0.fffffffffffffp-1022)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x0.fffffffffffffp-1022 0x0.fffffffffffffp-1022)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 inf inf)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 -0x1.0000000000000p-1021 -0x1.0000000000000p-1021)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 -0x1.0000000000001p-1022 -0x1.0000000000001p-1022)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 -0x1.0000000000001p-1022 -0x1.0000000000001p-1022)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 inf inf)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 0x1.8000000000000p+0 0x1.8000000000000p+0)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 -0x1.721fb54442d18p+2 -0x1.721fb54442d18p+2)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.b21fb54442d18p+2 0x1.b21fb54442d18p+2)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 inf inf)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 -0x1.8000000000000p+0 -0x1.8000000000000p+0)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 -0x1.b21fb54442d18p+2 -0x1.b21fb54442d18p+2)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.721fb54442d18p+2 0x1.721fb54442d18p+2)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 inf inf)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 0x1.8000000000000p+0 0x1.8000000000000p+0)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 0x1.0000000000000p+1 0x1.0000000000000p+1)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 -0x1.521fb54442d18p+2 -0x1.521fb54442d18p+2)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.d21fb54442d18p+2 0x1.d21fb54442d18p+2)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 inf inf)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 -0x1.8000000000000p+0 -0x1.8000000000000p+0)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 -0x1.0000000000000p+1 -0x1.0000000000000p+1)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 -0x1.d21fb54442d18p+2 -0x1.d21fb54442d18p+2)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.521fb54442d18p+2 0x1.521fb54442d18p+2)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 inf inf)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 0x1.721fb54442d18p+2 0x1.721fb54442d18p+2)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 0x1.b21fb54442d18p+2 0x1.b21fb54442d18p+2)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 0x1.521fb54442d18p+2 0x1.521fb54442d18p+2)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 0x1.d21fb54442d18p+2 0x1.d21fb54442d18p+2)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.921fb54442d18p+3 0x1.921fb54442d18p+3)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 inf inf)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 -0x1.b21fb54442d18p+2 -0x1.b21fb54442d18p+2)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 -0x1.721fb54442d18p+2 -0x1.721fb54442d18p+2)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 -0x1.d21fb54442d18p+2 -0x1.d21fb54442d18p+2)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 -0x1.521fb54442d18p+2 -0x1.521fb54442d18p+2)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 -0x1.921fb54442d18p+3 -0x1.921fb54442d18p+3)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 inf inf)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 inf inf)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 inf inf)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 -0x0.fffffffffffffp-1022 -0x0.fffffffffffffp-1022)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 0x1.0000000000001p-1022 0x1.0000000000001p-1022)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 inf inf)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 -0x0.fffffffffffffp-1022 -0x0.fffffffffffffp-1022)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 0x1.0000000000001p-1022 0x1.0000000000001p-1022)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 inf inf)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 inf inf) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 inf inf) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 inf inf) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 inf inf) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 inf inf) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 inf inf) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 inf inf) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 inf inf) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 inf inf) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 inf inf) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 inf inf) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 inf inf) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 inf inf) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 inf inf) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 inf inf) + (v128.const f64x2 inf inf)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 inf inf) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -inf -inf) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -inf -inf) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -inf -inf) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -inf -inf) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -inf -inf) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -inf -inf) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -inf -inf) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -inf -inf) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -inf -inf) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -inf -inf) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -inf -inf) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -inf -inf) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -inf -inf) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -inf -inf) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -inf -inf) + (v128.const f64x2 inf inf)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -inf -inf) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan nan) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 nan nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan nan) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 nan nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan nan) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 nan nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan nan) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 nan nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan nan) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 nan nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan nan) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 nan nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan nan) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 nan nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan nan) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 nan nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan nan) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 nan nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan nan) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 nan nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan nan) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 nan nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan nan) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 nan nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan nan) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 nan nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan nan) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 nan nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan nan) + (v128.const f64x2 inf inf)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 inf inf) + (v128.const f64x2 nan nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan nan) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -inf -inf) + (v128.const f64x2 nan nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan nan) + (v128.const f64x2 nan nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan nan) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan nan) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan nan) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan -nan) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan -nan) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan -nan) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan -nan) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan -nan) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan -nan) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan -nan) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan -nan) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan -nan) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan -nan) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan -nan) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan -nan) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan -nan) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan -nan) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan -nan) + (v128.const f64x2 inf inf)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 inf inf) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan -nan) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -inf -inf) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan -nan) + (v128.const f64x2 nan nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan -nan) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan -nan) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan -nan) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 inf inf)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 inf inf) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -inf -inf) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 nan nan)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 inf inf)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 inf inf) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -inf -inf) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 nan nan)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0123456789 0123456789) + (v128.const f64x2 0123456789 0123456789)) + (v128.const f64x2 0.0 0.0)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0123456789e019 0123456789e019) + (v128.const f64x2 0123456789e019 0123456789e019)) + (v128.const f64x2 0.0 0.0)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0123456789e+019 0123456789e+019) + (v128.const f64x2 0123456789e+019 0123456789e+019)) + (v128.const f64x2 0.0 0.0)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0123456789e-019 0123456789e-019) + (v128.const f64x2 0123456789e-019 0123456789e-019)) + (v128.const f64x2 0.0 0.0)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0123456789. 0123456789.) + (v128.const f64x2 0123456789. 0123456789.)) + (v128.const f64x2 0.0 0.0)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0123456789.e019 0123456789.e019) + (v128.const f64x2 0123456789.e019 0123456789.e019)) + (v128.const f64x2 0.0 0.0)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0123456789.e+019 0123456789.e+019) + (v128.const f64x2 0123456789.e+019 0123456789.e+019)) + (v128.const f64x2 0.0 0.0)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0123456789.e-019 0123456789.e-019) + (v128.const f64x2 0123456789.e-019 0123456789.e-019)) + (v128.const f64x2 0.0 0.0)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789) + (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)) + (v128.const f64x2 0.0 0.0)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f64x2 0.0 0.0)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f64x2 0.0 0.0)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f64x2 0.0 0.0)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef) + (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019) + (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019) + (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019) + (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.) + (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 inf inf)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 inf inf)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 0x0.8000000000000p-1022 0x0.8000000000000p-1022)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 -0x0.8000000000000p-1022 -0x0.8000000000000p-1022)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.921fb54442d18p-1020 0x1.921fb54442d18p-1020)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 -0x1.921fb54442d18p-1020 -0x1.921fb54442d18p-1020)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.fffffffffffffp+1 0x1.fffffffffffffp+1)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 -0x1.fffffffffffffp+1 -0x1.fffffffffffffp+1)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 inf inf)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 -0x0.8000000000000p-1022 -0x0.8000000000000p-1022)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 0x0.8000000000000p-1022 0x0.8000000000000p-1022)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 -0x1.921fb54442d18p-1020 -0x1.921fb54442d18p-1020)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.921fb54442d18p-1020 0x1.921fb54442d18p-1020)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 -0x1.fffffffffffffp+1 -0x1.fffffffffffffp+1)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.fffffffffffffp+1 0x1.fffffffffffffp+1)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 inf inf)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 0x0.8000000000000p-1022 0x0.8000000000000p-1022)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 -0x0.8000000000000p-1022 -0x0.8000000000000p-1022)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 0x1.0000000000000p-2 0x1.0000000000000p-2)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 -0x1.0000000000000p-2 -0x1.0000000000000p-2)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.921fb54442d18p+1 0x1.921fb54442d18p+1)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 -0x1.921fb54442d18p+1 -0x1.921fb54442d18p+1)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.fffffffffffffp+1022 0x1.fffffffffffffp+1022)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 -0x1.fffffffffffffp+1022 -0x1.fffffffffffffp+1022)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 inf inf)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 -0x0.8000000000000p-1022 -0x0.8000000000000p-1022)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 0x0.8000000000000p-1022 0x0.8000000000000p-1022)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 -0x1.0000000000000p-2 -0x1.0000000000000p-2)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 0x1.0000000000000p-2 0x1.0000000000000p-2)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 -0x1.921fb54442d18p+1 -0x1.921fb54442d18p+1)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.921fb54442d18p+1 0x1.921fb54442d18p+1)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 -0x1.fffffffffffffp+1022 -0x1.fffffffffffffp+1022)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.fffffffffffffp+1022 0x1.fffffffffffffp+1022)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 inf inf)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 inf inf)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 inf inf)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 0x1.921fb54442d18p-1020 0x1.921fb54442d18p-1020)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 -0x1.921fb54442d18p-1020 -0x1.921fb54442d18p-1020)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 0x1.921fb54442d18p+1 0x1.921fb54442d18p+1)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 -0x1.921fb54442d18p+1 -0x1.921fb54442d18p+1)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.3bd3cc9be45dep+5 0x1.3bd3cc9be45dep+5)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 -0x1.3bd3cc9be45dep+5 -0x1.3bd3cc9be45dep+5)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x0.0000000000006p-1022 0x0.0000000000006p-1022)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x0.0000000000006p-1022 0x0.0000000000006p-1022)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 inf inf)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 -0x1.921fb54442d18p-1020 -0x1.921fb54442d18p-1020)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 0x1.921fb54442d18p-1020 0x1.921fb54442d18p-1020)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 -0x1.921fb54442d18p+1 -0x1.921fb54442d18p+1)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 0x1.921fb54442d18p+1 0x1.921fb54442d18p+1)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 -0x1.3bd3cc9be45dep+5 -0x1.3bd3cc9be45dep+5)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.3bd3cc9be45dep+5 0x1.3bd3cc9be45dep+5)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 -0x0.0000000000006p-1022 -0x0.0000000000006p-1022)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 -0x0.0000000000006p-1022 -0x0.0000000000006p-1022)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 inf inf)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 0x1.fffffffffffffp+1 0x1.fffffffffffffp+1)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 -0x1.fffffffffffffp+1 -0x1.fffffffffffffp+1)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 0x1.fffffffffffffp+1022 0x1.fffffffffffffp+1022)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 -0x1.fffffffffffffp+1022 -0x1.fffffffffffffp+1022)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x1.fffffffffffffp-51 0x1.fffffffffffffp-51)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x1.fffffffffffffp-51 0x1.fffffffffffffp-51)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 inf inf)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 -0x1.fffffffffffffp+1 -0x1.fffffffffffffp+1)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 0x1.fffffffffffffp+1 0x1.fffffffffffffp+1)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 -0x1.fffffffffffffp+1022 -0x1.fffffffffffffp+1022)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 0x1.fffffffffffffp+1022 0x1.fffffffffffffp+1022)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 -0x1.fffffffffffffp-51 -0x1.fffffffffffffp-51)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 -0x1.fffffffffffffp-51 -0x1.fffffffffffffp-51)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 inf inf)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 0x0.0000000000006p-1022 0x0.0000000000006p-1022)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 -0x0.0000000000006p-1022 -0x0.0000000000006p-1022)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.fffffffffffffp-51 0x1.fffffffffffffp-51)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 -0x1.fffffffffffffp-51 -0x1.fffffffffffffp-51)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 inf inf)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 0x0.0000000000006p-1022 0x0.0000000000006p-1022)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 -0x0.0000000000006p-1022 -0x0.0000000000006p-1022)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.fffffffffffffp-51 0x1.fffffffffffffp-51)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 -0x1.fffffffffffffp-51 -0x1.fffffffffffffp-51)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 inf inf)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 inf inf) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 inf inf) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 inf inf) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 inf inf) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 inf inf) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 inf inf) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 inf inf) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 inf inf) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 inf inf) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 inf inf) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 inf inf) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 inf inf) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 inf inf) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 inf inf) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 inf inf) + (v128.const f64x2 inf inf)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 inf inf) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -inf -inf) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -inf -inf) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -inf -inf) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -inf -inf) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -inf -inf) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -inf -inf) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -inf -inf) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -inf -inf) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -inf -inf) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -inf -inf) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -inf -inf) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -inf -inf) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -inf -inf) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -inf -inf) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -inf -inf) + (v128.const f64x2 inf inf)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -inf -inf) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan nan) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 nan nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan nan) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 nan nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan nan) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 nan nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan nan) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 nan nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan nan) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 nan nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan nan) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 nan nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan nan) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 nan nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan nan) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 nan nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan nan) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 nan nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan nan) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 nan nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan nan) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 nan nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan nan) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 nan nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan nan) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 nan nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan nan) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 nan nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan nan) + (v128.const f64x2 inf inf)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 inf inf) + (v128.const f64x2 nan nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan nan) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -inf -inf) + (v128.const f64x2 nan nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan nan) + (v128.const f64x2 nan nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan nan) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan nan) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan nan) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan -nan) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan -nan) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan -nan) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan -nan) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan -nan) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan -nan) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan -nan) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan -nan) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan -nan) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan -nan) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan -nan) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan -nan) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan -nan) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan -nan) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan -nan) + (v128.const f64x2 inf inf)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 inf inf) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan -nan) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -inf -inf) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan -nan) + (v128.const f64x2 nan nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan -nan) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan -nan) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan -nan) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 inf inf)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 inf inf) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -inf -inf) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 nan nan)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 inf inf)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 inf inf) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -inf -inf) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 nan nan)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0123456789 0123456789) + (v128.const f64x2 0123456789 0123456789)) + (v128.const f64x2 1.524157875019052e+16 1.524157875019052e+16)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0123456789e019 0123456789e019) + (v128.const f64x2 0123456789e019 0123456789e019)) + (v128.const f64x2 1.524157875019052e+54 1.524157875019052e+54)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0123456789e+019 0123456789e+019) + (v128.const f64x2 0123456789e+019 0123456789e+019)) + (v128.const f64x2 1.524157875019052e+54 1.524157875019052e+54)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0123456789e-019 0123456789e-019) + (v128.const f64x2 0123456789e-019 0123456789e-019)) + (v128.const f64x2 1.524157875019052e-22 1.524157875019052e-22)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0123456789. 0123456789.) + (v128.const f64x2 0123456789. 0123456789.)) + (v128.const f64x2 1.524157875019052e+16 1.524157875019052e+16)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0123456789.e019 0123456789.e019) + (v128.const f64x2 0123456789.e019 0123456789.e019)) + (v128.const f64x2 1.524157875019052e+54 1.524157875019052e+54)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0123456789.e+019 0123456789.e+019) + (v128.const f64x2 0123456789.e+019 0123456789.e+019)) + (v128.const f64x2 1.524157875019052e+54 1.524157875019052e+54)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0123456789.e-019 0123456789.e-019) + (v128.const f64x2 0123456789.e-019 0123456789.e-019)) + (v128.const f64x2 1.524157875019052e-22 1.524157875019052e-22)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789) + (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)) + (v128.const f64x2 1.5241578753238834e+16 1.5241578753238834e+16)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f64x2 1.5241578753238838e+54 1.5241578753238838e+54)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f64x2 1.5241578753238838e+54 1.5241578753238838e+54)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f64x2 1.524157875323884e-22 1.524157875323884e-22)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef) + (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)) + (v128.const f64x2 0x1.4b66dc33f6acep+160 0x1.4b66dc33f6acep+160)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019) + (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)) + (v128.const f64x2 0x1.4b66dc33f6acep+198 0x1.4b66dc33f6acep+198)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019) + (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 0x1.4b66dc33f6acep+198 0x1.4b66dc33f6acep+198)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019) + (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 0x1.4b66dc33f6acep+122 0x1.4b66dc33f6acep+122)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.) + (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)) + (v128.const f64x2 0x1.4b66dc33f6acep+160 0x1.4b66dc33f6acep+160)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)) + (v128.const f64x2 0x1.4b66dc33f6acep+198 0x1.4b66dc33f6acep+198)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)) + (v128.const f64x2 0x1.4b66dc33f6acep+198 0x1.4b66dc33f6acep+198)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)) + (v128.const f64x2 0x1.4b66dc33f6acep+122 0x1.4b66dc33f6acep+122)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)) + (v128.const f64x2 0x1.4b66dc33f6acep+160 0x1.4b66dc33f6acep+160)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)) + (v128.const f64x2 0x1.4b66dc33f6acep+198 0x1.4b66dc33f6acep+198)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 0x1.4b66dc33f6acep+198 0x1.4b66dc33f6acep+198)) +(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 0x1.4b66dc33f6acep+122 0x1.4b66dc33f6acep+122)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 inf inf)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 inf inf)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 0x1.0000000000000p-1021 0x1.0000000000000p-1021)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 -0x1.0000000000000p-1021 -0x1.0000000000000p-1021)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 0x0.28be60db93910p-1022 0x0.28be60db93910p-1022)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 -0x0.28be60db93910p-1022 -0x0.28be60db93910p-1022)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x1.0000000000000p+52 0x1.0000000000000p+52)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x1.0000000000000p+52 0x1.0000000000000p+52)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 inf inf)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 -0x1.0000000000000p-1021 -0x1.0000000000000p-1021)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 0x1.0000000000000p-1021 0x1.0000000000000p-1021)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 -0x0.28be60db93910p-1022 -0x0.28be60db93910p-1022)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 0x0.28be60db93910p-1022 0x0.28be60db93910p-1022)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 -0x1.0000000000000p+52 -0x1.0000000000000p+52)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 -0x1.0000000000000p+52 -0x1.0000000000000p+52)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 inf inf)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 0x1.0000000000000p+1021 0x1.0000000000000p+1021)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 -0x1.0000000000000p+1021 -0x1.0000000000000p+1021)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.45f306dc9c883p-4 0x1.45f306dc9c883p-4)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 -0x1.45f306dc9c883p-4 -0x1.45f306dc9c883p-4)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x0.2000000000000p-1022 0x0.2000000000000p-1022)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 -0x0.2000000000000p-1022 -0x0.2000000000000p-1022)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 inf inf)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 -0x1.0000000000000p+1021 -0x1.0000000000000p+1021)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 0x1.0000000000000p+1021 0x1.0000000000000p+1021)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 -0x1.45f306dc9c883p-4 -0x1.45f306dc9c883p-4)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.45f306dc9c883p-4 0x1.45f306dc9c883p-4)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 -0x0.2000000000000p-1022 -0x0.2000000000000p-1022)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x0.2000000000000p-1022 0x0.2000000000000p-1022)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 inf inf)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 0x1.0000000000000p+1022 0x1.0000000000000p+1022)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 -0x1.0000000000000p+1022 -0x1.0000000000000p+1022)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 0x1.0000000000000p+1 0x1.0000000000000p+1)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 -0x1.0000000000000p+1 -0x1.0000000000000p+1)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.45f306dc9c883p-3 0x1.45f306dc9c883p-3)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 -0x1.45f306dc9c883p-3 -0x1.45f306dc9c883p-3)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x0.4000000000000p-1022 0x0.4000000000000p-1022)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 -0x0.4000000000000p-1022 -0x0.4000000000000p-1022)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 inf inf)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 -0x1.0000000000000p+1022 -0x1.0000000000000p+1022)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 0x1.0000000000000p+1022 0x1.0000000000000p+1022)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 -0x1.0000000000000p+1 -0x1.0000000000000p+1)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 0x1.0000000000000p+1 0x1.0000000000000p+1)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 -0x1.45f306dc9c883p-3 -0x1.45f306dc9c883p-3)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.45f306dc9c883p-3 0x1.45f306dc9c883p-3)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 -0x0.4000000000000p-1022 -0x0.4000000000000p-1022)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x0.4000000000000p-1022 0x0.4000000000000p-1022)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 inf inf)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 0x1.921fb54442d18p+3 0x1.921fb54442d18p+3)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 -0x1.921fb54442d18p+3 -0x1.921fb54442d18p+3)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.921fb54442d19p-1022 0x1.921fb54442d19p-1022)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 -0x1.921fb54442d19p-1022 -0x1.921fb54442d19p-1022)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 inf inf)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 -0x1.921fb54442d18p+3 -0x1.921fb54442d18p+3)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 0x1.921fb54442d18p+3 0x1.921fb54442d18p+3)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 -0x1.921fb54442d19p-1022 -0x1.921fb54442d19p-1022)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.921fb54442d19p-1022 0x1.921fb54442d19p-1022)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 inf inf)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.45f306dc9c882p+1021 0x1.45f306dc9c882p+1021)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 -0x1.45f306dc9c882p+1021 -0x1.45f306dc9c882p+1021)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 inf inf)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 -0x1.45f306dc9c882p+1021 -0x1.45f306dc9c882p+1021)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.45f306dc9c882p+1021 0x1.45f306dc9c882p+1021)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 inf inf)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 0x1.0000000000000p-52 0x1.0000000000000p-52)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 -0x1.0000000000000p-52 -0x1.0000000000000p-52)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 0x0.0000000000002p-1022 0x0.0000000000002p-1022)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 -0x0.0000000000002p-1022 -0x0.0000000000002p-1022)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 inf inf)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 0x1.0000000000000p-52 0x1.0000000000000p-52)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 -0x1.0000000000000p-52 -0x1.0000000000000p-52)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 0x0.0000000000002p-1022 0x0.0000000000002p-1022)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 -0x0.0000000000002p-1022 -0x0.0000000000002p-1022)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 inf inf)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 inf inf) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 inf inf) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 inf inf) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 inf inf) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 inf inf) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 inf inf) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 inf inf) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 inf inf) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 inf inf) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 inf inf) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 inf inf) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 inf inf) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 inf inf) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 inf inf) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 inf inf) + (v128.const f64x2 inf inf)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 inf inf) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -inf -inf) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -inf -inf) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -inf -inf) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -inf -inf) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -inf -inf) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -inf -inf) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -inf -inf) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -inf -inf) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -inf -inf) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -inf -inf) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -inf -inf) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -inf -inf) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -inf -inf) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -inf -inf) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -inf -inf) + (v128.const f64x2 inf inf)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -inf -inf) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 nan nan) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 nan nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 nan nan) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 nan nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 nan nan) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 nan nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 nan nan) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 nan nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 nan nan) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 nan nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 nan nan) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 nan nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 nan nan) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 nan nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 nan nan) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 nan nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 nan nan) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 nan nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 nan nan) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 nan nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 nan nan) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 nan nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 nan nan) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 nan nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 nan nan) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 nan nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 nan nan) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 nan nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 nan nan) + (v128.const f64x2 inf inf)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 inf inf) + (v128.const f64x2 nan nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 nan nan) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -inf -inf) + (v128.const f64x2 nan nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 nan nan) + (v128.const f64x2 nan nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 nan nan) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 nan nan) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 nan nan) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan -nan) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan -nan) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan -nan) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan -nan) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan -nan) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan -nan) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan -nan) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan -nan) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan -nan) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan -nan) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan -nan) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan -nan) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan -nan) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan -nan) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan -nan) + (v128.const f64x2 inf inf)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 inf inf) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan -nan) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -inf -inf) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan -nan) + (v128.const f64x2 nan nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan -nan) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan -nan) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan -nan) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 inf inf)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 inf inf) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -inf -inf) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 nan nan)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 inf inf)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 inf inf) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -inf -inf) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 nan nan)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0123456789 0123456789) + (v128.const f64x2 0123456789 0123456789)) + (v128.const f64x2 1.0 1.0)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0123456789e019 0123456789e019) + (v128.const f64x2 0123456789e019 0123456789e019)) + (v128.const f64x2 1.0 1.0)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0123456789e+019 0123456789e+019) + (v128.const f64x2 0123456789e+019 0123456789e+019)) + (v128.const f64x2 1.0 1.0)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0123456789e-019 0123456789e-019) + (v128.const f64x2 0123456789e-019 0123456789e-019)) + (v128.const f64x2 1.0 1.0)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0123456789. 0123456789.) + (v128.const f64x2 0123456789. 0123456789.)) + (v128.const f64x2 1.0 1.0)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0123456789.e019 0123456789.e019) + (v128.const f64x2 0123456789.e019 0123456789.e019)) + (v128.const f64x2 1.0 1.0)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0123456789.e+019 0123456789.e+019) + (v128.const f64x2 0123456789.e+019 0123456789.e+019)) + (v128.const f64x2 1.0 1.0)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0123456789.e-019 0123456789.e-019) + (v128.const f64x2 0123456789.e-019 0123456789.e-019)) + (v128.const f64x2 1.0 1.0)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789) + (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)) + (v128.const f64x2 1.0 1.0)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f64x2 1.0 1.0)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f64x2 1.0 1.0)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f64x2 1.0 1.0)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef) + (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019) + (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019) + (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019) + (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.) + (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 -0x0p+0 -0x0p+0)) +(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 0x1.0000000000000p-511 0x1.0000000000000p-511)) +(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 0x1.6a09e667f3bcdp-1 0x1.6a09e667f3bcdp-1)) +(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.40d931ff62705p+1 0x1.40d931ff62705p+1)) +(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.fffffffffffffp+511 0x1.fffffffffffffp+511)) +(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x1.0000000000000p-537 0x1.0000000000000p-537)) +(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x1.0000000000000p-537 0x1.0000000000000p-537)) +(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 inf inf)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 -inf -inf)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 nan nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 -nan -nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 0123456789 0123456789)) + (v128.const f64x2 11111.111060555555 11111.111060555555)) +(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 0123456789e019 0123456789e019)) + (v128.const f64x2 35136418286444.62 35136418286444.62)) +(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 0123456789e+019 0123456789e+019)) + (v128.const f64x2 35136418286444.62 35136418286444.62)) +(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 0123456789e-019 0123456789e-019)) + (v128.const f64x2 3.5136418286444623e-06 3.5136418286444623e-06)) +(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 0123456789. 0123456789.)) + (v128.const f64x2 11111.111060555555 11111.111060555555)) +(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 0123456789.e019 0123456789.e019)) + (v128.const f64x2 35136418286444.62 35136418286444.62)) +(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 0123456789.e+019 0123456789.e+019)) + (v128.const f64x2 35136418286444.62 35136418286444.62)) +(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 0123456789.e-019 0123456789.e-019)) + (v128.const f64x2 3.5136418286444623e-06 3.5136418286444623e-06)) +(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)) + (v128.const f64x2 11111.11106111111 11111.11106111111)) +(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f64x2 35136418288201.445 35136418288201.445)) +(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f64x2 35136418288201.445 35136418288201.445)) +(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f64x2 3.513641828820144e-06 3.513641828820144e-06)) +(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)) + (v128.const f64x2 0x1.1111111111111p+40 0x1.1111111111111p+40)) +(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)) + (v128.const f64x2 0x1.822cb17ff2eb8p+49 0x1.822cb17ff2eb8p+49)) +(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 0x1.822cb17ff2eb8p+49 0x1.822cb17ff2eb8p+49)) +(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 0x1.822cb17ff2eb8p+30 0x1.822cb17ff2eb8p+30)) +(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)) + (v128.const f64x2 0x1.1111111111111p+40 0x1.1111111111111p+40)) +(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)) + (v128.const f64x2 0x1.822cb17ff2eb8p+49 0x1.822cb17ff2eb8p+49)) +(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)) + (v128.const f64x2 0x1.822cb17ff2eb8p+49 0x1.822cb17ff2eb8p+49)) +(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)) + (v128.const f64x2 0x1.822cb17ff2eb8p+30 0x1.822cb17ff2eb8p+30)) +(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)) + (v128.const f64x2 0x1.1111111111111p+40 0x1.1111111111111p+40)) +(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)) + (v128.const f64x2 0x1.822cb17ff2eb8p+49 0x1.822cb17ff2eb8p+49)) +(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 0x1.822cb17ff2eb8p+49 0x1.822cb17ff2eb8p+49)) +(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 0x1.822cb17ff2eb8p+30 0x1.822cb17ff2eb8p+30)) +(assert_return (invoke "f64x2.neg" (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.neg" (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.neg" (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.neg" (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.neg" (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.neg" (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.neg" (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.neg" (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.neg" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.neg" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.neg" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.neg" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.neg" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.neg" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.neg" (v128.const f64x2 inf inf)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.neg" (v128.const f64x2 -inf -inf)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.neg" (v128.const f64x2 nan nan)) + (v128.const f64x2 -nan -nan)) +(assert_return (invoke "f64x2.neg" (v128.const f64x2 -nan -nan)) + (v128.const f64x2 nan nan)) +(assert_return (invoke "f64x2.neg" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) +(assert_return (invoke "f64x2.neg" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) +(assert_return (invoke "f64x2.neg" (v128.const f64x2 0123456789 0123456789)) + (v128.const f64x2 -123456789.0 -123456789.0)) +(assert_return (invoke "f64x2.neg" (v128.const f64x2 0123456789e019 0123456789e019)) + (v128.const f64x2 -1.23456789e+27 -1.23456789e+27)) +(assert_return (invoke "f64x2.neg" (v128.const f64x2 0123456789e+019 0123456789e+019)) + (v128.const f64x2 -1.23456789e+27 -1.23456789e+27)) +(assert_return (invoke "f64x2.neg" (v128.const f64x2 0123456789e-019 0123456789e-019)) + (v128.const f64x2 -1.23456789e-11 -1.23456789e-11)) +(assert_return (invoke "f64x2.neg" (v128.const f64x2 0123456789. 0123456789.)) + (v128.const f64x2 -123456789.0 -123456789.0)) +(assert_return (invoke "f64x2.neg" (v128.const f64x2 0123456789.e019 0123456789.e019)) + (v128.const f64x2 -1.23456789e+27 -1.23456789e+27)) +(assert_return (invoke "f64x2.neg" (v128.const f64x2 0123456789.e+019 0123456789.e+019)) + (v128.const f64x2 -1.23456789e+27 -1.23456789e+27)) +(assert_return (invoke "f64x2.neg" (v128.const f64x2 0123456789.e-019 0123456789.e-019)) + (v128.const f64x2 -1.23456789e-11 -1.23456789e-11)) +(assert_return (invoke "f64x2.neg" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)) + (v128.const f64x2 -123456789.01234567 -123456789.01234567)) +(assert_return (invoke "f64x2.neg" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f64x2 -1.2345678901234569e+27 -1.2345678901234569e+27)) +(assert_return (invoke "f64x2.neg" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f64x2 -1.2345678901234569e+27 -1.2345678901234569e+27)) +(assert_return (invoke "f64x2.neg" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f64x2 -1.2345678901234568e-11 -1.2345678901234568e-11)) +(assert_return (invoke "f64x2.neg" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)) + (v128.const f64x2 -0x1.23456789abcdfp+80 -0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.neg" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)) + (v128.const f64x2 -0x1.23456789abcdfp+99 -0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.neg" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 -0x1.23456789abcdfp+99 -0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.neg" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 -0x1.23456789abcdfp+61 -0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.neg" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)) + (v128.const f64x2 -0x1.23456789abcdfp+80 -0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.neg" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)) + (v128.const f64x2 -0x1.23456789abcdfp+99 -0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.neg" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)) + (v128.const f64x2 -0x1.23456789abcdfp+99 -0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.neg" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)) + (v128.const f64x2 -0x1.23456789abcdfp+61 -0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.neg" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)) + (v128.const f64x2 -0x1.23456789abcdfp+80 -0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.neg" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)) + (v128.const f64x2 -0x1.23456789abcdfp+99 -0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.neg" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 -0x1.23456789abcdfp+99 -0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.neg" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 -0x1.23456789abcdfp+61 -0x1.23456789abcdfp+61)) + +;; Mixed f64x2 tests when some lanes are NaNs +(module + (func (export "f64x2_add_arith") (result v128) + (f64x2.add (v128.const f64x2 nan:0x8000000000000 1.0) (v128.const f64x2 nan 1.0))) + (func (export "f64x2_div_mixed") (result v128) + (f64x2.div (v128.const f64x2 nan 1.0) (v128.const f64x2 2.0 -nan:0x8000000000000))) + (func (export "f64x2_mul_mixed") (result v128) + (f64x2.mul (v128.const f64x2 nan:0x8000000000000 1.0) (v128.const f64x2 2.0 nan))) + (func (export "f64x2_neg_canon") (result v128) + (f64x2.neg (v128.const f64x2 nan 1.0))) + (func (export "f64x2_sqrt_canon") (result v128) + (f64x2.sqrt (v128.const f64x2 4.0 -nan))) + (func (export "f64x2_sub_arith") (result v128) + (f64x2.sub (v128.const f64x2 1.0 -1.0) (v128.const f64x2 -nan 1.0))) +) + +(assert_return (invoke "f64x2_add_arith") (v128.const f64x2 nan:arithmetic 2.0)) +(assert_return (invoke "f64x2_div_mixed") (v128.const f64x2 nan:canonical nan:arithmetic)) +(assert_return (invoke "f64x2_mul_mixed") (v128.const f64x2 nan:arithmetic nan:canonical)) +(assert_return (invoke "f64x2_neg_canon") (v128.const f64x2 nan:canonical -1.0)) +(assert_return (invoke "f64x2_sqrt_canon") (v128.const f64x2 2.0 nan:canonical)) +(assert_return (invoke "f64x2_sub_arith") (v128.const f64x2 nan:canonical -2.0)) + +;; type check +(assert_invalid (module (func (result v128) (f64x2.neg (i64.const 0)))) "type mismatch") +(assert_invalid (module (func (result v128) (f64x2.sqrt (i64.const 0)))) "type mismatch") +(assert_invalid (module (func (result v128) (f64x2.add (i64.const 0) (f64.const 0.0)))) "type mismatch") +(assert_invalid (module (func (result v128) (f64x2.sub (i64.const 0) (f64.const 0.0)))) "type mismatch") +(assert_invalid (module (func (result v128) (f64x2.mul (i64.const 0) (f64.const 0.0)))) "type mismatch") +(assert_invalid (module (func (result v128) (f64x2.div (i64.const 0) (f64.const 0.0)))) "type mismatch") + +;; Test operation with empty argument + +(assert_invalid + (module + (func $f64x2.neg-arg-empty (result v128) + (f64x2.neg) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $f64x2.sqrt-arg-empty (result v128) + (f64x2.sqrt) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $f64x2.add-1st-arg-empty (result v128) + (f64x2.add (v128.const f64x2 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $f64x2.add-arg-empty (result v128) + (f64x2.add) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $f64x2.sub-1st-arg-empty (result v128) + (f64x2.sub (v128.const f64x2 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $f64x2.sub-arg-empty (result v128) + (f64x2.sub) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $f64x2.mul-1st-arg-empty (result v128) + (f64x2.mul (v128.const f64x2 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $f64x2.mul-arg-empty (result v128) + (f64x2.mul) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $f64x2.div-1st-arg-empty (result v128) + (f64x2.div (v128.const f64x2 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $f64x2.div-arg-empty (result v128) + (f64x2.div) + ) + ) + "type mismatch" +) + +;; combination +(module + (func (export "add-sub") (param v128 v128 v128) (result v128) + (f64x2.add (f64x2.sub (local.get 0) (local.get 1))(local.get 2))) + (func (export "div-add") (param v128 v128 v128) (result v128) + (f64x2.div (f64x2.add (local.get 0) (local.get 1))(local.get 2))) + (func (export "div-mul") (param v128 v128 v128) (result v128) + (f64x2.div (f64x2.mul (local.get 0) (local.get 1))(local.get 2))) + (func (export "div-sub") (param v128 v128 v128) (result v128) + (f64x2.div (f64x2.sub (local.get 0) (local.get 1))(local.get 2))) + (func (export "mul-add") (param v128 v128 v128) (result v128) + (f64x2.mul (f64x2.add (local.get 0) (local.get 1))(local.get 2))) + (func (export "mul-div") (param v128 v128 v128) (result v128) + (f64x2.mul (f64x2.div (local.get 0) (local.get 1))(local.get 2))) + (func (export "mul-sub") (param v128 v128 v128) (result v128) + (f64x2.mul (f64x2.sub (local.get 0) (local.get 1))(local.get 2))) + (func (export "sub-add") (param v128 v128 v128) (result v128) + (f64x2.sub (f64x2.add (local.get 0) (local.get 1))(local.get 2))) + (func (export "add-neg") (param v128 v128) (result v128) + (f64x2.add (f64x2.neg (local.get 0)) (local.get 1))) + (func (export "add-sqrt") (param v128 v128) (result v128) + (f64x2.add (f64x2.sqrt (local.get 0)) (local.get 1))) + (func (export "div-neg") (param v128 v128) (result v128) + (f64x2.div (f64x2.neg (local.get 0)) (local.get 1))) + (func (export "div-sqrt") (param v128 v128) (result v128) + (f64x2.div (f64x2.sqrt (local.get 0)) (local.get 1))) + (func (export "mul-neg") (param v128 v128) (result v128) + (f64x2.mul (f64x2.neg (local.get 0)) (local.get 1))) + (func (export "mul-sqrt") (param v128 v128) (result v128) + (f64x2.mul (f64x2.sqrt (local.get 0)) (local.get 1))) + (func (export "sub-neg") (param v128 v128) (result v128) + (f64x2.sub (f64x2.neg (local.get 0)) (local.get 1))) + (func (export "sub-sqrt") (param v128 v128) (result v128) + (f64x2.sub (f64x2.sqrt (local.get 0)) (local.get 1))) +) + +(assert_return (invoke "add-sub" (v128.const f64x2 1.125 1.125) + (v128.const f64x2 0.25 0.25) + (v128.const f64x2 0.125 0.125)) + (v128.const f64x2 1.0 1.0)) +(assert_return (invoke "div-add" (v128.const f64x2 1.125 1.125) + (v128.const f64x2 0.125 0.125) + (v128.const f64x2 0.25 0.25)) + (v128.const f64x2 5.0 5.0)) +(assert_return (invoke "div-mul" (v128.const f64x2 1.125 1.125) + (v128.const f64x2 4 4) + (v128.const f64x2 0.25 0.25)) + (v128.const f64x2 18.0 18.0)) +(assert_return (invoke "div-sub" (v128.const f64x2 1.125 1.125) + (v128.const f64x2 0.125 0.125) + (v128.const f64x2 0.25 0.25)) + (v128.const f64x2 4.0 4.0)) +(assert_return (invoke "mul-add" (v128.const f64x2 1.25 1.25) + (v128.const f64x2 0.25 0.25) + (v128.const f64x2 0.25 0.25)) + (v128.const f64x2 0.375 0.375)) +(assert_return (invoke "mul-div" (v128.const f64x2 1.125 1.125) + (v128.const f64x2 0.125 0.125) + (v128.const f64x2 0.25 0.25)) + (v128.const f64x2 2.25 2.25)) +(assert_return (invoke "mul-sub" (v128.const f64x2 1.125 1.125) + (v128.const f64x2 0.125 0.125) + (v128.const f64x2 0.25 0.25)) + (v128.const f64x2 0.25 0.25)) +(assert_return (invoke "sub-add" (v128.const f64x2 1.125 1.125) + (v128.const f64x2 0.25 0.25) + (v128.const f64x2 0.125 0.125)) + (v128.const f64x2 1.25 1.25)) +(assert_return (invoke "add-neg" (v128.const f64x2 1.125 1.125) + (v128.const f64x2 0.125 0.125)) + (v128.const f64x2 -1.0 -1.0)) +(assert_return (invoke "add-sqrt" (v128.const f64x2 2.25 2.25) + (v128.const f64x2 0.25 0.25)) + (v128.const f64x2 1.75 1.75)) +(assert_return (invoke "div-neg" (v128.const f64x2 1.5 1.5) + (v128.const f64x2 0.25 0.25)) + (v128.const f64x2 -6 -6)) +(assert_return (invoke "div-sqrt" (v128.const f64x2 2.25 2.25) + (v128.const f64x2 0.25 0.25)) + (v128.const f64x2 6 6)) +(assert_return (invoke "mul-neg" (v128.const f64x2 1.5 1.5) + (v128.const f64x2 0.25 0.25)) + (v128.const f64x2 -0.375 -0.375)) +(assert_return (invoke "mul-sqrt" (v128.const f64x2 2.25 2.25) + (v128.const f64x2 0.25 0.25)) + (v128.const f64x2 0.375 0.375)) +(assert_return (invoke "sub-neg" (v128.const f64x2 1.125 1.125) + (v128.const f64x2 0.125 0.125)) + (v128.const f64x2 -1.25 -1.25)) +(assert_return (invoke "sub-sqrt" (v128.const f64x2 2.25 2.25) + (v128.const f64x2 0.25 0.25)) + (v128.const f64x2 1.25 1.25)) \ No newline at end of file diff --git a/runtime/near-vm/tests/wast/spec/proposals/simd/simd_f64x2_cmp.wast b/runtime/near-vm/tests/wast/spec/proposals/simd/simd_f64x2_cmp.wast new file mode 100644 index 00000000000..cab815ea56d --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/proposals/simd/simd_f64x2_cmp.wast @@ -0,0 +1,8337 @@ +;; Tests for f64x2 comparison operations on major boundary values and all special values. + + +(module + (func (export "f64x2.eq") (param v128 v128) (result v128) (f64x2.eq (local.get 0) (local.get 1))) + (func (export "f64x2.ne") (param v128 v128) (result v128) (f64x2.ne (local.get 0) (local.get 1))) + (func (export "f64x2.lt") (param v128 v128) (result v128) (f64x2.lt (local.get 0) (local.get 1))) + (func (export "f64x2.le") (param v128 v128) (result v128) (f64x2.le (local.get 0) (local.get 1))) + (func (export "f64x2.gt") (param v128 v128) (result v128) (f64x2.gt (local.get 0) (local.get 1))) + (func (export "f64x2.ge") (param v128 v128) (result v128) (f64x2.ge (local.get 0) (local.get 1))) +) + +(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1074 0x1p-1074) + (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1074 0x1p-1074) + (v128.const f64x2 -inf -inf)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1074 0x1p-1074) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1074 0x1p-1074) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1074 0x1p-1074) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1074 0x1p-1074) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1074 0x1p-1074) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1074 0x1p-1074) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1074 0x1p-1074) + (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1074 0x1p-1074) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1074 0x1p-1074) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1074 0x1p-1074) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1074 0x1p-1074) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1074 0x1p-1074) + (v128.const f64x2 inf inf)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1074 0x1p-1074) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1074 0x1p-1074) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1074 0x1p-1074) + (v128.const f64x2 nan nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1074 0x1p-1074) + (v128.const f64x2 -nan -nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1074 0x1p-1074) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1074 0x1p-1074) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -inf -inf) + (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -inf -inf) + (v128.const f64x2 -inf -inf)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -inf -inf) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -inf -inf) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -inf -inf) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -inf -inf) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -inf -inf) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -inf -inf) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -inf -inf) + (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -inf -inf) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -inf -inf) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -inf -inf) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -inf -inf) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -inf -inf) + (v128.const f64x2 inf inf)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -inf -inf) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -inf -inf) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -inf -inf) + (v128.const f64x2 nan nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -inf -inf) + (v128.const f64x2 -nan -nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -inf -inf) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -inf -inf) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 -inf -inf)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 inf inf)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 nan nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 -nan -nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 -inf -inf)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 inf inf)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 nan nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 -nan -nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 -inf -inf)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 inf inf)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 nan nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 -nan -nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 -inf -inf)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 inf inf)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 nan nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 -nan -nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 -inf -inf)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 inf inf)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 nan nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 -nan -nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 -inf -inf)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 inf inf)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 nan nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 -nan -nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1074 -0x1p-1074) + (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1074 -0x1p-1074) + (v128.const f64x2 -inf -inf)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1074 -0x1p-1074) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1074 -0x1p-1074) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1074 -0x1p-1074) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1074 -0x1p-1074) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1074 -0x1p-1074) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1074 -0x1p-1074) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1074 -0x1p-1074) + (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1074 -0x1p-1074) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1074 -0x1p-1074) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1074 -0x1p-1074) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1074 -0x1p-1074) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1074 -0x1p-1074) + (v128.const f64x2 inf inf)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1074 -0x1p-1074) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1074 -0x1p-1074) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1074 -0x1p-1074) + (v128.const f64x2 nan nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1074 -0x1p-1074) + (v128.const f64x2 -nan -nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1074 -0x1p-1074) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1074 -0x1p-1074) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 -inf -inf)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 inf inf)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 nan nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 -nan -nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 -inf -inf)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 inf inf)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 nan nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 -nan -nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 -inf -inf)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 inf inf)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 nan nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 -nan -nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 -inf -inf)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 inf inf)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 nan nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 -nan -nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 inf inf) + (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 inf inf) + (v128.const f64x2 -inf -inf)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 inf inf) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 inf inf) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 inf inf) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 inf inf) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 inf inf) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 inf inf) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 inf inf) + (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 inf inf) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 inf inf) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 inf inf) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 inf inf) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 inf inf) + (v128.const f64x2 inf inf)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 inf inf) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 inf inf) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 inf inf) + (v128.const f64x2 nan nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 inf inf) + (v128.const f64x2 -nan -nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 inf inf) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 inf inf) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 -inf -inf)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 inf inf)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 nan nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 -nan -nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 -inf -inf)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 inf inf)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 nan nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 -nan -nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038) + (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038) + (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038) + (v128.const f64x2 0123456789.e038 0123456789.e038)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038) + (v128.const f64x2 0123456789.e+038 0123456789.e+038)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038) + (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038) + (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038) + (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038) + (v128.const f64x2 0123456789.e038 0123456789.e038)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038) + (v128.const f64x2 0123456789.e+038 0123456789.e+038)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038) + (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 0123456789.e038 0123456789.e038) + (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 0123456789.e038 0123456789.e038) + (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 0123456789.e038 0123456789.e038) + (v128.const f64x2 0123456789.e038 0123456789.e038)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 0123456789.e038 0123456789.e038) + (v128.const f64x2 0123456789.e+038 0123456789.e+038)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 0123456789.e038 0123456789.e038) + (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 0123456789.e+038 0123456789.e+038) + (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 0123456789.e+038 0123456789.e+038) + (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 0123456789.e+038 0123456789.e+038) + (v128.const f64x2 0123456789.e038 0123456789.e038)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 0123456789.e+038 0123456789.e+038) + (v128.const f64x2 0123456789.e+038 0123456789.e+038)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 0123456789.e+038 0123456789.e+038) + (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789) + (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789) + (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789) + (v128.const f64x2 0123456789.e038 0123456789.e038)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789) + (v128.const f64x2 0123456789.e+038 0123456789.e+038)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789) + (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan nan) + (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan nan) + (v128.const f64x2 -inf -inf)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan nan) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan nan) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan nan) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan nan) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan nan) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan nan) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan nan) + (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan nan) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan nan) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan nan) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan nan) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan nan) + (v128.const f64x2 inf inf)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan nan) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan nan) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan nan) + (v128.const f64x2 nan nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan nan) + (v128.const f64x2 -nan -nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan nan) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan nan) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan -nan) + (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan -nan) + (v128.const f64x2 -inf -inf)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan -nan) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan -nan) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan -nan) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan -nan) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan -nan) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan -nan) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan -nan) + (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan -nan) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan -nan) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan -nan) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan -nan) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan -nan) + (v128.const f64x2 inf inf)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan -nan) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan -nan) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan -nan) + (v128.const f64x2 nan nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan -nan) + (v128.const f64x2 -nan -nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan -nan) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan -nan) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 -inf -inf)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 inf inf)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 nan nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 -nan -nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 -inf -inf)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 inf inf)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 nan nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 -nan -nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1074 0x1p-1074) + (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1074 0x1p-1074) + (v128.const f64x2 -inf -inf)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1074 0x1p-1074) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1074 0x1p-1074) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1074 0x1p-1074) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1074 0x1p-1074) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1074 0x1p-1074) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1074 0x1p-1074) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1074 0x1p-1074) + (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1074 0x1p-1074) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1074 0x1p-1074) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1074 0x1p-1074) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1074 0x1p-1074) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1074 0x1p-1074) + (v128.const f64x2 inf inf)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1074 0x1p-1074) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1074 0x1p-1074) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1074 0x1p-1074) + (v128.const f64x2 nan nan)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1074 0x1p-1074) + (v128.const f64x2 -nan -nan)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1074 0x1p-1074) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1074 0x1p-1074) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -inf -inf) + (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -inf -inf) + (v128.const f64x2 -inf -inf)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -inf -inf) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -inf -inf) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -inf -inf) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -inf -inf) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -inf -inf) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -inf -inf) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -inf -inf) + (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -inf -inf) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -inf -inf) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -inf -inf) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -inf -inf) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -inf -inf) + (v128.const f64x2 inf inf)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -inf -inf) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -inf -inf) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -inf -inf) + (v128.const f64x2 nan nan)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -inf -inf) + (v128.const f64x2 -nan -nan)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -inf -inf) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -inf -inf) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 -inf -inf)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 inf inf)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 nan nan)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 -nan -nan)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 -inf -inf)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 inf inf)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 nan nan)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 -nan -nan)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 -inf -inf)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 inf inf)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 nan nan)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 -nan -nan)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 -inf -inf)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 inf inf)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 nan nan)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 -nan -nan)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 -inf -inf)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 inf inf)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 nan nan)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 -nan -nan)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 -inf -inf)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 inf inf)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 nan nan)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 -nan -nan)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1074 -0x1p-1074) + (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1074 -0x1p-1074) + (v128.const f64x2 -inf -inf)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1074 -0x1p-1074) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1074 -0x1p-1074) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1074 -0x1p-1074) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1074 -0x1p-1074) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1074 -0x1p-1074) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1074 -0x1p-1074) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1074 -0x1p-1074) + (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1074 -0x1p-1074) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1074 -0x1p-1074) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1074 -0x1p-1074) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1074 -0x1p-1074) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1074 -0x1p-1074) + (v128.const f64x2 inf inf)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1074 -0x1p-1074) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1074 -0x1p-1074) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1074 -0x1p-1074) + (v128.const f64x2 nan nan)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1074 -0x1p-1074) + (v128.const f64x2 -nan -nan)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1074 -0x1p-1074) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1074 -0x1p-1074) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 -inf -inf)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 inf inf)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 nan nan)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 -nan -nan)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 -inf -inf)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 inf inf)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 nan nan)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 -nan -nan)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 -inf -inf)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 inf inf)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 nan nan)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 -nan -nan)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 -inf -inf)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 inf inf)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 nan nan)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 -nan -nan)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 inf inf) + (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 inf inf) + (v128.const f64x2 -inf -inf)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 inf inf) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 inf inf) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 inf inf) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 inf inf) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 inf inf) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 inf inf) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 inf inf) + (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 inf inf) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 inf inf) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 inf inf) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 inf inf) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 inf inf) + (v128.const f64x2 inf inf)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 inf inf) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 inf inf) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 inf inf) + (v128.const f64x2 nan nan)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 inf inf) + (v128.const f64x2 -nan -nan)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 inf inf) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 inf inf) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 -inf -inf)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 inf inf)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 nan nan)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 -nan -nan)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 -inf -inf)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 inf inf)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 nan nan)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 -nan -nan)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038) + (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038) + (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038) + (v128.const f64x2 0123456789.e038 0123456789.e038)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038) + (v128.const f64x2 0123456789.e+038 0123456789.e+038)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038) + (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038) + (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038) + (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038) + (v128.const f64x2 0123456789.e038 0123456789.e038)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038) + (v128.const f64x2 0123456789.e+038 0123456789.e+038)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038) + (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 0123456789.e038 0123456789.e038) + (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 0123456789.e038 0123456789.e038) + (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 0123456789.e038 0123456789.e038) + (v128.const f64x2 0123456789.e038 0123456789.e038)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 0123456789.e038 0123456789.e038) + (v128.const f64x2 0123456789.e+038 0123456789.e+038)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 0123456789.e038 0123456789.e038) + (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 0123456789.e+038 0123456789.e+038) + (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 0123456789.e+038 0123456789.e+038) + (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 0123456789.e+038 0123456789.e+038) + (v128.const f64x2 0123456789.e038 0123456789.e038)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 0123456789.e+038 0123456789.e+038) + (v128.const f64x2 0123456789.e+038 0123456789.e+038)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 0123456789.e+038 0123456789.e+038) + (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789) + (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789) + (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789) + (v128.const f64x2 0123456789.e038 0123456789.e038)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789) + (v128.const f64x2 0123456789.e+038 0123456789.e+038)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789) + (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan nan) + (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan nan) + (v128.const f64x2 -inf -inf)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan nan) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan nan) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan nan) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan nan) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan nan) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan nan) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan nan) + (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan nan) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan nan) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan nan) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan nan) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan nan) + (v128.const f64x2 inf inf)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan nan) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan nan) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan nan) + (v128.const f64x2 nan nan)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan nan) + (v128.const f64x2 -nan -nan)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan nan) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan nan) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan -nan) + (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan -nan) + (v128.const f64x2 -inf -inf)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan -nan) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan -nan) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan -nan) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan -nan) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan -nan) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan -nan) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan -nan) + (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan -nan) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan -nan) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan -nan) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan -nan) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan -nan) + (v128.const f64x2 inf inf)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan -nan) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan -nan) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan -nan) + (v128.const f64x2 nan nan)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan -nan) + (v128.const f64x2 -nan -nan)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan -nan) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan -nan) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 -inf -inf)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 inf inf)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 nan nan)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 -nan -nan)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 -inf -inf)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 inf inf)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 nan nan)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 -nan -nan)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1074 0x1p-1074) + (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1074 0x1p-1074) + (v128.const f64x2 -inf -inf)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1074 0x1p-1074) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1074 0x1p-1074) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1074 0x1p-1074) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1074 0x1p-1074) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1074 0x1p-1074) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1074 0x1p-1074) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1074 0x1p-1074) + (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1074 0x1p-1074) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1074 0x1p-1074) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1074 0x1p-1074) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1074 0x1p-1074) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1074 0x1p-1074) + (v128.const f64x2 inf inf)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1074 0x1p-1074) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1074 0x1p-1074) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1074 0x1p-1074) + (v128.const f64x2 nan nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1074 0x1p-1074) + (v128.const f64x2 -nan -nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1074 0x1p-1074) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1074 0x1p-1074) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -inf -inf) + (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -inf -inf) + (v128.const f64x2 -inf -inf)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -inf -inf) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -inf -inf) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -inf -inf) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -inf -inf) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -inf -inf) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -inf -inf) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -inf -inf) + (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -inf -inf) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -inf -inf) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -inf -inf) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -inf -inf) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -inf -inf) + (v128.const f64x2 inf inf)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -inf -inf) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -inf -inf) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -inf -inf) + (v128.const f64x2 nan nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -inf -inf) + (v128.const f64x2 -nan -nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -inf -inf) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -inf -inf) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 -inf -inf)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 inf inf)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 nan nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 -nan -nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 -inf -inf)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 inf inf)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 nan nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 -nan -nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 -inf -inf)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 inf inf)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 nan nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 -nan -nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 -inf -inf)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 inf inf)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 nan nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 -nan -nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 -inf -inf)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 inf inf)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 nan nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 -nan -nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 -inf -inf)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 inf inf)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 nan nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 -nan -nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1074 -0x1p-1074) + (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1074 -0x1p-1074) + (v128.const f64x2 -inf -inf)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1074 -0x1p-1074) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1074 -0x1p-1074) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1074 -0x1p-1074) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1074 -0x1p-1074) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1074 -0x1p-1074) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1074 -0x1p-1074) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1074 -0x1p-1074) + (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1074 -0x1p-1074) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1074 -0x1p-1074) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1074 -0x1p-1074) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1074 -0x1p-1074) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1074 -0x1p-1074) + (v128.const f64x2 inf inf)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1074 -0x1p-1074) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1074 -0x1p-1074) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1074 -0x1p-1074) + (v128.const f64x2 nan nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1074 -0x1p-1074) + (v128.const f64x2 -nan -nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1074 -0x1p-1074) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1074 -0x1p-1074) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 -inf -inf)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 inf inf)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 nan nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 -nan -nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 -inf -inf)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 inf inf)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 nan nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 -nan -nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 -inf -inf)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 inf inf)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 nan nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 -nan -nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 -inf -inf)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 inf inf)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 nan nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 -nan -nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 inf inf) + (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 inf inf) + (v128.const f64x2 -inf -inf)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 inf inf) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 inf inf) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 inf inf) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 inf inf) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 inf inf) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 inf inf) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 inf inf) + (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 inf inf) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 inf inf) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 inf inf) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 inf inf) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 inf inf) + (v128.const f64x2 inf inf)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 inf inf) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 inf inf) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 inf inf) + (v128.const f64x2 nan nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 inf inf) + (v128.const f64x2 -nan -nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 inf inf) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 inf inf) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 -inf -inf)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 inf inf)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 nan nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 -nan -nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 -inf -inf)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 inf inf)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 nan nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 -nan -nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038) + (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038) + (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038) + (v128.const f64x2 0123456789.e038 0123456789.e038)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038) + (v128.const f64x2 0123456789.e+038 0123456789.e+038)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038) + (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038) + (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038) + (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038) + (v128.const f64x2 0123456789.e038 0123456789.e038)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038) + (v128.const f64x2 0123456789.e+038 0123456789.e+038)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038) + (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 0123456789.e038 0123456789.e038) + (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 0123456789.e038 0123456789.e038) + (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 0123456789.e038 0123456789.e038) + (v128.const f64x2 0123456789.e038 0123456789.e038)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 0123456789.e038 0123456789.e038) + (v128.const f64x2 0123456789.e+038 0123456789.e+038)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 0123456789.e038 0123456789.e038) + (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 0123456789.e+038 0123456789.e+038) + (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 0123456789.e+038 0123456789.e+038) + (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 0123456789.e+038 0123456789.e+038) + (v128.const f64x2 0123456789.e038 0123456789.e038)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 0123456789.e+038 0123456789.e+038) + (v128.const f64x2 0123456789.e+038 0123456789.e+038)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 0123456789.e+038 0123456789.e+038) + (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789) + (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789) + (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789) + (v128.const f64x2 0123456789.e038 0123456789.e038)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789) + (v128.const f64x2 0123456789.e+038 0123456789.e+038)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789) + (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan nan) + (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan nan) + (v128.const f64x2 -inf -inf)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan nan) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan nan) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan nan) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan nan) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan nan) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan nan) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan nan) + (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan nan) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan nan) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan nan) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan nan) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan nan) + (v128.const f64x2 inf inf)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan nan) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan nan) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan nan) + (v128.const f64x2 nan nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan nan) + (v128.const f64x2 -nan -nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan nan) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan nan) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan -nan) + (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan -nan) + (v128.const f64x2 -inf -inf)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan -nan) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan -nan) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan -nan) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan -nan) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan -nan) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan -nan) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan -nan) + (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan -nan) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan -nan) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan -nan) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan -nan) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan -nan) + (v128.const f64x2 inf inf)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan -nan) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan -nan) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan -nan) + (v128.const f64x2 nan nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan -nan) + (v128.const f64x2 -nan -nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan -nan) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan -nan) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 -inf -inf)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 inf inf)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 nan nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 -nan -nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 -inf -inf)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 inf inf)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 nan nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 -nan -nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1074 0x1p-1074) + (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1074 0x1p-1074) + (v128.const f64x2 -inf -inf)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1074 0x1p-1074) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1074 0x1p-1074) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1074 0x1p-1074) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1074 0x1p-1074) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1074 0x1p-1074) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1074 0x1p-1074) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1074 0x1p-1074) + (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1074 0x1p-1074) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1074 0x1p-1074) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1074 0x1p-1074) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1074 0x1p-1074) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1074 0x1p-1074) + (v128.const f64x2 inf inf)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1074 0x1p-1074) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1074 0x1p-1074) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1074 0x1p-1074) + (v128.const f64x2 nan nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1074 0x1p-1074) + (v128.const f64x2 -nan -nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1074 0x1p-1074) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1074 0x1p-1074) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -inf -inf) + (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -inf -inf) + (v128.const f64x2 -inf -inf)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -inf -inf) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -inf -inf) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -inf -inf) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -inf -inf) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -inf -inf) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -inf -inf) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -inf -inf) + (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -inf -inf) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -inf -inf) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -inf -inf) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -inf -inf) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -inf -inf) + (v128.const f64x2 inf inf)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -inf -inf) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -inf -inf) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -inf -inf) + (v128.const f64x2 nan nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -inf -inf) + (v128.const f64x2 -nan -nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -inf -inf) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -inf -inf) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 -inf -inf)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 inf inf)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 nan nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 -nan -nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 -inf -inf)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 inf inf)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 nan nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 -nan -nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 -inf -inf)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 inf inf)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 nan nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 -nan -nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 -inf -inf)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 inf inf)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 nan nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 -nan -nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 -inf -inf)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 inf inf)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 nan nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 -nan -nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 -inf -inf)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 inf inf)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 nan nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 -nan -nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1074 -0x1p-1074) + (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1074 -0x1p-1074) + (v128.const f64x2 -inf -inf)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1074 -0x1p-1074) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1074 -0x1p-1074) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1074 -0x1p-1074) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1074 -0x1p-1074) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1074 -0x1p-1074) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1074 -0x1p-1074) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1074 -0x1p-1074) + (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1074 -0x1p-1074) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1074 -0x1p-1074) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1074 -0x1p-1074) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1074 -0x1p-1074) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1074 -0x1p-1074) + (v128.const f64x2 inf inf)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1074 -0x1p-1074) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1074 -0x1p-1074) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1074 -0x1p-1074) + (v128.const f64x2 nan nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1074 -0x1p-1074) + (v128.const f64x2 -nan -nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1074 -0x1p-1074) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1074 -0x1p-1074) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 -inf -inf)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 inf inf)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 nan nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 -nan -nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 -inf -inf)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 inf inf)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 nan nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 -nan -nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 -inf -inf)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 inf inf)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 nan nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 -nan -nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 -inf -inf)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 inf inf)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 nan nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 -nan -nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 inf inf) + (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 inf inf) + (v128.const f64x2 -inf -inf)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 inf inf) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 inf inf) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 inf inf) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 inf inf) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 inf inf) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 inf inf) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 inf inf) + (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 inf inf) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 inf inf) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 inf inf) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 inf inf) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 inf inf) + (v128.const f64x2 inf inf)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 inf inf) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 inf inf) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 inf inf) + (v128.const f64x2 nan nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 inf inf) + (v128.const f64x2 -nan -nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 inf inf) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 inf inf) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 -inf -inf)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 inf inf)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 nan nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 -nan -nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 -inf -inf)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 inf inf)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 nan nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 -nan -nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038) + (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038) + (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038) + (v128.const f64x2 0123456789.e038 0123456789.e038)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038) + (v128.const f64x2 0123456789.e+038 0123456789.e+038)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038) + (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038) + (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038) + (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038) + (v128.const f64x2 0123456789.e038 0123456789.e038)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038) + (v128.const f64x2 0123456789.e+038 0123456789.e+038)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038) + (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 0123456789.e038 0123456789.e038) + (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 0123456789.e038 0123456789.e038) + (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 0123456789.e038 0123456789.e038) + (v128.const f64x2 0123456789.e038 0123456789.e038)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 0123456789.e038 0123456789.e038) + (v128.const f64x2 0123456789.e+038 0123456789.e+038)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 0123456789.e038 0123456789.e038) + (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 0123456789.e+038 0123456789.e+038) + (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 0123456789.e+038 0123456789.e+038) + (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 0123456789.e+038 0123456789.e+038) + (v128.const f64x2 0123456789.e038 0123456789.e038)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 0123456789.e+038 0123456789.e+038) + (v128.const f64x2 0123456789.e+038 0123456789.e+038)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 0123456789.e+038 0123456789.e+038) + (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789) + (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789) + (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789) + (v128.const f64x2 0123456789.e038 0123456789.e038)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789) + (v128.const f64x2 0123456789.e+038 0123456789.e+038)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789) + (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 nan nan) + (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 nan nan) + (v128.const f64x2 -inf -inf)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 nan nan) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 nan nan) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 nan nan) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 nan nan) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 nan nan) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 nan nan) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 nan nan) + (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 nan nan) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 nan nan) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 nan nan) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 nan nan) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 nan nan) + (v128.const f64x2 inf inf)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 nan nan) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 nan nan) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 nan nan) + (v128.const f64x2 nan nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 nan nan) + (v128.const f64x2 -nan -nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 nan nan) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 nan nan) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan -nan) + (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan -nan) + (v128.const f64x2 -inf -inf)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan -nan) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan -nan) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan -nan) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan -nan) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan -nan) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan -nan) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan -nan) + (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan -nan) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan -nan) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan -nan) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan -nan) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan -nan) + (v128.const f64x2 inf inf)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan -nan) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan -nan) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan -nan) + (v128.const f64x2 nan nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan -nan) + (v128.const f64x2 -nan -nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan -nan) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan -nan) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 -inf -inf)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 inf inf)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 nan nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 -nan -nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 -inf -inf)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 inf inf)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 nan nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 -nan -nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1074 0x1p-1074) + (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1074 0x1p-1074) + (v128.const f64x2 -inf -inf)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1074 0x1p-1074) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1074 0x1p-1074) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1074 0x1p-1074) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1074 0x1p-1074) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1074 0x1p-1074) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1074 0x1p-1074) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1074 0x1p-1074) + (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1074 0x1p-1074) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1074 0x1p-1074) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1074 0x1p-1074) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1074 0x1p-1074) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1074 0x1p-1074) + (v128.const f64x2 inf inf)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1074 0x1p-1074) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1074 0x1p-1074) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1074 0x1p-1074) + (v128.const f64x2 nan nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1074 0x1p-1074) + (v128.const f64x2 -nan -nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1074 0x1p-1074) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1074 0x1p-1074) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -inf -inf) + (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -inf -inf) + (v128.const f64x2 -inf -inf)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -inf -inf) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -inf -inf) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -inf -inf) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -inf -inf) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -inf -inf) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -inf -inf) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -inf -inf) + (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -inf -inf) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -inf -inf) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -inf -inf) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -inf -inf) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -inf -inf) + (v128.const f64x2 inf inf)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -inf -inf) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -inf -inf) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -inf -inf) + (v128.const f64x2 nan nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -inf -inf) + (v128.const f64x2 -nan -nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -inf -inf) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -inf -inf) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 -inf -inf)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 inf inf)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 nan nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 -nan -nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 -inf -inf)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 inf inf)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 nan nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 -nan -nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 -inf -inf)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 inf inf)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 nan nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 -nan -nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 -inf -inf)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 inf inf)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 nan nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 -nan -nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 -inf -inf)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 inf inf)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 nan nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 -nan -nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 -inf -inf)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 inf inf)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 nan nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 -nan -nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1074 -0x1p-1074) + (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1074 -0x1p-1074) + (v128.const f64x2 -inf -inf)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1074 -0x1p-1074) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1074 -0x1p-1074) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1074 -0x1p-1074) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1074 -0x1p-1074) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1074 -0x1p-1074) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1074 -0x1p-1074) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1074 -0x1p-1074) + (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1074 -0x1p-1074) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1074 -0x1p-1074) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1074 -0x1p-1074) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1074 -0x1p-1074) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1074 -0x1p-1074) + (v128.const f64x2 inf inf)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1074 -0x1p-1074) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1074 -0x1p-1074) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1074 -0x1p-1074) + (v128.const f64x2 nan nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1074 -0x1p-1074) + (v128.const f64x2 -nan -nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1074 -0x1p-1074) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1074 -0x1p-1074) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 -inf -inf)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 inf inf)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 nan nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 -nan -nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 -inf -inf)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 inf inf)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 nan nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 -nan -nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 -inf -inf)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 inf inf)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 nan nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 -nan -nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 -inf -inf)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 inf inf)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 nan nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 -nan -nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 inf inf) + (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 inf inf) + (v128.const f64x2 -inf -inf)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 inf inf) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 inf inf) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 inf inf) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 inf inf) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 inf inf) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 inf inf) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 inf inf) + (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 inf inf) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 inf inf) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 inf inf) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 inf inf) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 inf inf) + (v128.const f64x2 inf inf)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 inf inf) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 inf inf) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 inf inf) + (v128.const f64x2 nan nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 inf inf) + (v128.const f64x2 -nan -nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 inf inf) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 inf inf) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 -inf -inf)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 inf inf)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 nan nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 -nan -nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 -inf -inf)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 inf inf)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 nan nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 -nan -nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038) + (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038) + (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038) + (v128.const f64x2 0123456789.e038 0123456789.e038)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038) + (v128.const f64x2 0123456789.e+038 0123456789.e+038)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038) + (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038) + (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038) + (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038) + (v128.const f64x2 0123456789.e038 0123456789.e038)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038) + (v128.const f64x2 0123456789.e+038 0123456789.e+038)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038) + (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 0123456789.e038 0123456789.e038) + (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 0123456789.e038 0123456789.e038) + (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 0123456789.e038 0123456789.e038) + (v128.const f64x2 0123456789.e038 0123456789.e038)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 0123456789.e038 0123456789.e038) + (v128.const f64x2 0123456789.e+038 0123456789.e+038)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 0123456789.e038 0123456789.e038) + (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 0123456789.e+038 0123456789.e+038) + (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 0123456789.e+038 0123456789.e+038) + (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 0123456789.e+038 0123456789.e+038) + (v128.const f64x2 0123456789.e038 0123456789.e038)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 0123456789.e+038 0123456789.e+038) + (v128.const f64x2 0123456789.e+038 0123456789.e+038)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 0123456789.e+038 0123456789.e+038) + (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789) + (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789) + (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789) + (v128.const f64x2 0123456789.e038 0123456789.e038)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789) + (v128.const f64x2 0123456789.e+038 0123456789.e+038)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789) + (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan nan) + (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan nan) + (v128.const f64x2 -inf -inf)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan nan) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan nan) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan nan) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan nan) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan nan) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan nan) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan nan) + (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan nan) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan nan) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan nan) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan nan) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan nan) + (v128.const f64x2 inf inf)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan nan) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan nan) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan nan) + (v128.const f64x2 nan nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan nan) + (v128.const f64x2 -nan -nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan nan) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan nan) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan -nan) + (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan -nan) + (v128.const f64x2 -inf -inf)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan -nan) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan -nan) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan -nan) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan -nan) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan -nan) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan -nan) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan -nan) + (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan -nan) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan -nan) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan -nan) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan -nan) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan -nan) + (v128.const f64x2 inf inf)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan -nan) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan -nan) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan -nan) + (v128.const f64x2 nan nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan -nan) + (v128.const f64x2 -nan -nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan -nan) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan -nan) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 -inf -inf)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 inf inf)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 nan nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 -nan -nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 -inf -inf)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 inf inf)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 nan nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 -nan -nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1074 0x1p-1074) + (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1074 0x1p-1074) + (v128.const f64x2 -inf -inf)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1074 0x1p-1074) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1074 0x1p-1074) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1074 0x1p-1074) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1074 0x1p-1074) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1074 0x1p-1074) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1074 0x1p-1074) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1074 0x1p-1074) + (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1074 0x1p-1074) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1074 0x1p-1074) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1074 0x1p-1074) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1074 0x1p-1074) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1074 0x1p-1074) + (v128.const f64x2 inf inf)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1074 0x1p-1074) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1074 0x1p-1074) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1074 0x1p-1074) + (v128.const f64x2 nan nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1074 0x1p-1074) + (v128.const f64x2 -nan -nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1074 0x1p-1074) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1074 0x1p-1074) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -inf -inf) + (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -inf -inf) + (v128.const f64x2 -inf -inf)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -inf -inf) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -inf -inf) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -inf -inf) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -inf -inf) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -inf -inf) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -inf -inf) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -inf -inf) + (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -inf -inf) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -inf -inf) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -inf -inf) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -inf -inf) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -inf -inf) + (v128.const f64x2 inf inf)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -inf -inf) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -inf -inf) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -inf -inf) + (v128.const f64x2 nan nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -inf -inf) + (v128.const f64x2 -nan -nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -inf -inf) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -inf -inf) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 -inf -inf)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 inf inf)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 nan nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 -nan -nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 -inf -inf)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 inf inf)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 nan nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 -nan -nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 -inf -inf)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 inf inf)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 nan nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 -nan -nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 -inf -inf)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 inf inf)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 nan nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 -nan -nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 -inf -inf)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 inf inf)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 nan nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 -nan -nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 -inf -inf)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 inf inf)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 nan nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 -nan -nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1074 -0x1p-1074) + (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1074 -0x1p-1074) + (v128.const f64x2 -inf -inf)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1074 -0x1p-1074) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1074 -0x1p-1074) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1074 -0x1p-1074) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1074 -0x1p-1074) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1074 -0x1p-1074) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1074 -0x1p-1074) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1074 -0x1p-1074) + (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1074 -0x1p-1074) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1074 -0x1p-1074) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1074 -0x1p-1074) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1074 -0x1p-1074) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1074 -0x1p-1074) + (v128.const f64x2 inf inf)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1074 -0x1p-1074) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1074 -0x1p-1074) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1074 -0x1p-1074) + (v128.const f64x2 nan nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1074 -0x1p-1074) + (v128.const f64x2 -nan -nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1074 -0x1p-1074) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1074 -0x1p-1074) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 -inf -inf)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 inf inf)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 nan nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 -nan -nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 -inf -inf)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 inf inf)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 nan nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 -nan -nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 -inf -inf)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 inf inf)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 nan nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 -nan -nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 -inf -inf)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 inf inf)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 nan nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 -nan -nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 inf inf) + (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 inf inf) + (v128.const f64x2 -inf -inf)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 inf inf) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 inf inf) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 inf inf) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 inf inf) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 inf inf) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 inf inf) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 inf inf) + (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 inf inf) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 inf inf) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 inf inf) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 inf inf) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 inf inf) + (v128.const f64x2 inf inf)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 inf inf) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 inf inf) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 inf inf) + (v128.const f64x2 nan nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 inf inf) + (v128.const f64x2 -nan -nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 inf inf) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 inf inf) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 -inf -inf)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 inf inf)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 nan nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 -nan -nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 -inf -inf)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 inf inf)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 nan nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 -nan -nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038) + (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038) + (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038) + (v128.const f64x2 0123456789.e038 0123456789.e038)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038) + (v128.const f64x2 0123456789.e+038 0123456789.e+038)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038) + (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038) + (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038) + (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038) + (v128.const f64x2 0123456789.e038 0123456789.e038)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038) + (v128.const f64x2 0123456789.e+038 0123456789.e+038)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038) + (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 0123456789.e038 0123456789.e038) + (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 0123456789.e038 0123456789.e038) + (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 0123456789.e038 0123456789.e038) + (v128.const f64x2 0123456789.e038 0123456789.e038)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 0123456789.e038 0123456789.e038) + (v128.const f64x2 0123456789.e+038 0123456789.e+038)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 0123456789.e038 0123456789.e038) + (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 0123456789.e+038 0123456789.e+038) + (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 0123456789.e+038 0123456789.e+038) + (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 0123456789.e+038 0123456789.e+038) + (v128.const f64x2 0123456789.e038 0123456789.e038)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 0123456789.e+038 0123456789.e+038) + (v128.const f64x2 0123456789.e+038 0123456789.e+038)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 0123456789.e+038 0123456789.e+038) + (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789) + (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789) + (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789) + (v128.const f64x2 0123456789.e038 0123456789.e038)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789) + (v128.const f64x2 0123456789.e+038 0123456789.e+038)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789) + (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan nan) + (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan nan) + (v128.const f64x2 -inf -inf)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan nan) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan nan) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan nan) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan nan) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan nan) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan nan) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan nan) + (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan nan) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan nan) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan nan) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan nan) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan nan) + (v128.const f64x2 inf inf)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan nan) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan nan) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan nan) + (v128.const f64x2 nan nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan nan) + (v128.const f64x2 -nan -nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan nan) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan nan) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan -nan) + (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan -nan) + (v128.const f64x2 -inf -inf)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan -nan) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan -nan) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan -nan) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan -nan) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan -nan) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan -nan) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan -nan) + (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan -nan) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan -nan) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan -nan) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan -nan) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan -nan) + (v128.const f64x2 inf inf)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan -nan) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan -nan) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan -nan) + (v128.const f64x2 nan nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan -nan) + (v128.const f64x2 -nan -nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan -nan) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan -nan) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 -inf -inf)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 inf inf)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 nan nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 -nan -nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 0x1p-1074 0x1p-1074)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 -inf -inf)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 -0x1p-1074 -0x1p-1074)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 inf inf)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 nan nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 -nan -nan)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -1 -1) + (v128.const f64x2 -1 -1)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -1 -1) + (v128.const f64x2 0 0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -1 -1) + (v128.const f64x2 1 1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 -1 -1) + (v128.const f64x2 2.0 2.0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 0 0) + (v128.const f64x2 -1 -1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 0 0) + (v128.const f64x2 0 0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 0 0) + (v128.const f64x2 1 1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 0 0) + (v128.const f64x2 2.0 2.0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 1 1) + (v128.const f64x2 -1 -1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 1 1) + (v128.const f64x2 0 0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 1 1) + (v128.const f64x2 1 1)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 1 1) + (v128.const f64x2 2.0 2.0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 2.0 2.0) + (v128.const f64x2 -1 -1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 2.0 2.0) + (v128.const f64x2 0 0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 2.0 2.0) + (v128.const f64x2 1 1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.eq" (v128.const f64x2 2.0 2.0) + (v128.const f64x2 2.0 2.0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -1 -1) + (v128.const f64x2 -1 -1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -1 -1) + (v128.const f64x2 0 0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -1 -1) + (v128.const f64x2 1 1)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 -1 -1) + (v128.const f64x2 2.0 2.0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 0 0) + (v128.const f64x2 -1 -1)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 0 0) + (v128.const f64x2 0 0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 0 0) + (v128.const f64x2 1 1)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 0 0) + (v128.const f64x2 2.0 2.0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 1 1) + (v128.const f64x2 -1 -1)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 1 1) + (v128.const f64x2 0 0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 1 1) + (v128.const f64x2 1 1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 1 1) + (v128.const f64x2 2.0 2.0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 2.0 2.0) + (v128.const f64x2 -1 -1)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 2.0 2.0) + (v128.const f64x2 0 0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 2.0 2.0) + (v128.const f64x2 1 1)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ne" (v128.const f64x2 2.0 2.0) + (v128.const f64x2 2.0 2.0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -1 -1) + (v128.const f64x2 -1 -1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -1 -1) + (v128.const f64x2 0 0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -1 -1) + (v128.const f64x2 1 1)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 -1 -1) + (v128.const f64x2 2.0 2.0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 0 0) + (v128.const f64x2 -1 -1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 0 0) + (v128.const f64x2 0 0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 0 0) + (v128.const f64x2 1 1)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 0 0) + (v128.const f64x2 2.0 2.0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 1 1) + (v128.const f64x2 -1 -1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 1 1) + (v128.const f64x2 0 0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 1 1) + (v128.const f64x2 1 1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 1 1) + (v128.const f64x2 2.0 2.0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 2.0 2.0) + (v128.const f64x2 -1 -1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 2.0 2.0) + (v128.const f64x2 0 0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 2.0 2.0) + (v128.const f64x2 1 1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.lt" (v128.const f64x2 2.0 2.0) + (v128.const f64x2 2.0 2.0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -1 -1) + (v128.const f64x2 -1 -1)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -1 -1) + (v128.const f64x2 0 0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -1 -1) + (v128.const f64x2 1 1)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 -1 -1) + (v128.const f64x2 2.0 2.0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 0 0) + (v128.const f64x2 -1 -1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 0 0) + (v128.const f64x2 0 0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 0 0) + (v128.const f64x2 1 1)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 0 0) + (v128.const f64x2 2.0 2.0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 1 1) + (v128.const f64x2 -1 -1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 1 1) + (v128.const f64x2 0 0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 1 1) + (v128.const f64x2 1 1)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 1 1) + (v128.const f64x2 2.0 2.0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 2.0 2.0) + (v128.const f64x2 -1 -1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 2.0 2.0) + (v128.const f64x2 0 0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 2.0 2.0) + (v128.const f64x2 1 1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.le" (v128.const f64x2 2.0 2.0) + (v128.const f64x2 2.0 2.0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -1 -1) + (v128.const f64x2 -1 -1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -1 -1) + (v128.const f64x2 0 0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -1 -1) + (v128.const f64x2 1 1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 -1 -1) + (v128.const f64x2 2.0 2.0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 0 0) + (v128.const f64x2 -1 -1)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 0 0) + (v128.const f64x2 0 0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 0 0) + (v128.const f64x2 1 1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 0 0) + (v128.const f64x2 2.0 2.0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 1 1) + (v128.const f64x2 -1 -1)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 1 1) + (v128.const f64x2 0 0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 1 1) + (v128.const f64x2 1 1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 1 1) + (v128.const f64x2 2.0 2.0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 2.0 2.0) + (v128.const f64x2 -1 -1)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 2.0 2.0) + (v128.const f64x2 0 0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 2.0 2.0) + (v128.const f64x2 1 1)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.gt" (v128.const f64x2 2.0 2.0) + (v128.const f64x2 2.0 2.0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -1 -1) + (v128.const f64x2 -1 -1)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -1 -1) + (v128.const f64x2 0 0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -1 -1) + (v128.const f64x2 1 1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 -1 -1) + (v128.const f64x2 2.0 2.0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 0 0) + (v128.const f64x2 -1 -1)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 0 0) + (v128.const f64x2 0 0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 0 0) + (v128.const f64x2 1 1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 0 0) + (v128.const f64x2 2.0 2.0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 1 1) + (v128.const f64x2 -1 -1)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 1 1) + (v128.const f64x2 0 0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 1 1) + (v128.const f64x2 1 1)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 1 1) + (v128.const f64x2 2.0 2.0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 2.0 2.0) + (v128.const f64x2 -1 -1)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 2.0 2.0) + (v128.const f64x2 0 0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 2.0 2.0) + (v128.const f64x2 1 1)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "f64x2.ge" (v128.const f64x2 2.0 2.0) + (v128.const f64x2 2.0 2.0)) + (v128.const i64x2 -1 -1)) + + +;; unknown operators +(assert_malformed (module quote "(memory 1) (func (param $x v128) (param $y v128) (result v128) (f2x64.eq (local.get $x) (local.get $y)))") "unknown operator") +(assert_malformed (module quote "(memory 1) (func (param $x v128) (param $y v128) (result v128) (f2x64.ne (local.get $x) (local.get $y)))") "unknown operator") +(assert_malformed (module quote "(memory 1) (func (param $x v128) (param $y v128) (result v128) (f2x64.lt (local.get $x) (local.get $y)))") "unknown operator") +(assert_malformed (module quote "(memory 1) (func (param $x v128) (param $y v128) (result v128) (f2x64.le (local.get $x) (local.get $y)))") "unknown operator") +(assert_malformed (module quote "(memory 1) (func (param $x v128) (param $y v128) (result v128) (f2x64.gt (local.get $x) (local.get $y)))") "unknown operator") +(assert_malformed (module quote "(memory 1) (func (param $x v128) (param $y v128) (result v128) (f2x64.ge (local.get $x) (local.get $y)))") "unknown operator") + +;; type check +(assert_invalid (module (func (result v128) (f64x2.eq (i32.const 0) (f32.const 0.0)))) "type mismatch") +(assert_invalid (module (func (result v128) (f64x2.ne (i32.const 0) (f32.const 0.0)))) "type mismatch") +(assert_invalid (module (func (result v128) (f64x2.lt (i32.const 0) (f32.const 0.0)))) "type mismatch") +(assert_invalid (module (func (result v128) (f64x2.le (i32.const 0) (f32.const 0.0)))) "type mismatch") +(assert_invalid (module (func (result v128) (f64x2.gt (i32.const 0) (f32.const 0.0)))) "type mismatch") +(assert_invalid (module (func (result v128) (f64x2.ge (i32.const 0) (f32.const 0.0)))) "type mismatch") + +;; Test operation with empty argument + +(assert_invalid + (module + (func $f64x2.eq-1st-arg-empty (result v128) + (f64x2.eq (v128.const f64x2 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $f64x2.eq-arg-empty (result v128) + (f64x2.eq) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $f64x2.ne-1st-arg-empty (result v128) + (f64x2.ne (v128.const f64x2 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $f64x2.ne-arg-empty (result v128) + (f64x2.ne) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $f64x2.lt-1st-arg-empty (result v128) + (f64x2.lt (v128.const f64x2 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $f64x2.lt-arg-empty (result v128) + (f64x2.lt) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $f64x2.le-1st-arg-empty (result v128) + (f64x2.le (v128.const f64x2 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $f64x2.le-arg-empty (result v128) + (f64x2.le) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $f64x2.gt-1st-arg-empty (result v128) + (f64x2.gt (v128.const f64x2 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $f64x2.gt-arg-empty (result v128) + (f64x2.gt) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $f64x2.ge-1st-arg-empty (result v128) + (f64x2.ge (v128.const f64x2 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $f64x2.ge-arg-empty (result v128) + (f64x2.ge) + ) + ) + "type mismatch" +) + +;; combination +(module (memory 1) + (func (export "f64x2.eq-in-block") + (block + (drop + (block (result v128) + (f64x2.eq + (block (result v128) (v128.load (i32.const 0))) + (block (result v128) (v128.load (i32.const 1))) + ) + ) + ) + ) + ) + (func (export "f64x2.ne-in-block") + (block + (drop + (block (result v128) + (f64x2.ne + (block (result v128) (v128.load (i32.const 0))) + (block (result v128) (v128.load (i32.const 1))) + ) + ) + ) + ) + ) + (func (export "f64x2.lt-in-block") + (block + (drop + (block (result v128) + (f64x2.lt + (block (result v128) (v128.load (i32.const 0))) + (block (result v128) (v128.load (i32.const 1))) + ) + ) + ) + ) + ) + (func (export "f64x2.le-in-block") + (block + (drop + (block (result v128) + (f64x2.le + (block (result v128) (v128.load (i32.const 0))) + (block (result v128) (v128.load (i32.const 1))) + ) + ) + ) + ) + ) + (func (export "f64x2.gt-in-block") + (block + (drop + (block (result v128) + (f64x2.gt + (block (result v128) (v128.load (i32.const 0))) + (block (result v128) (v128.load (i32.const 1))) + ) + ) + ) + ) + ) + (func (export "f64x2.ge-in-block") + (block + (drop + (block (result v128) + (f64x2.ge + (block (result v128) (v128.load (i32.const 0))) + (block (result v128) (v128.load (i32.const 1))) + ) + ) + ) + ) + ) + (func (export "nested-f64x2.eq") + (drop + (f64x2.eq + (f64x2.eq + (f64x2.eq + (v128.load (i32.const 0)) + (v128.load (i32.const 1)) + ) + (f64x2.eq + (v128.load (i32.const 2)) + (v128.load (i32.const 3)) + ) + ) + (f64x2.eq + (f64x2.eq + (v128.load (i32.const 0)) + (v128.load (i32.const 1)) + ) + (f64x2.eq + (v128.load (i32.const 2)) + (v128.load (i32.const 3)) + ) + ) + ) + ) + ) + (func (export "nested-f64x2.ne") + (drop + (f64x2.ne + (f64x2.ne + (f64x2.ne + (v128.load (i32.const 0)) + (v128.load (i32.const 1)) + ) + (f64x2.ne + (v128.load (i32.const 2)) + (v128.load (i32.const 3)) + ) + ) + (f64x2.ne + (f64x2.ne + (v128.load (i32.const 0)) + (v128.load (i32.const 1)) + ) + (f64x2.ne + (v128.load (i32.const 2)) + (v128.load (i32.const 3)) + ) + ) + ) + ) + ) + (func (export "nested-f64x2.lt") + (drop + (f64x2.lt + (f64x2.lt + (f64x2.lt + (v128.load (i32.const 0)) + (v128.load (i32.const 1)) + ) + (f64x2.lt + (v128.load (i32.const 2)) + (v128.load (i32.const 3)) + ) + ) + (f64x2.lt + (f64x2.lt + (v128.load (i32.const 0)) + (v128.load (i32.const 1)) + ) + (f64x2.lt + (v128.load (i32.const 2)) + (v128.load (i32.const 3)) + ) + ) + ) + ) + ) + (func (export "nested-f64x2.le") + (drop + (f64x2.le + (f64x2.le + (f64x2.le + (v128.load (i32.const 0)) + (v128.load (i32.const 1)) + ) + (f64x2.le + (v128.load (i32.const 2)) + (v128.load (i32.const 3)) + ) + ) + (f64x2.le + (f64x2.le + (v128.load (i32.const 0)) + (v128.load (i32.const 1)) + ) + (f64x2.le + (v128.load (i32.const 2)) + (v128.load (i32.const 3)) + ) + ) + ) + ) + ) + (func (export "nested-f64x2.gt") + (drop + (f64x2.gt + (f64x2.gt + (f64x2.gt + (v128.load (i32.const 0)) + (v128.load (i32.const 1)) + ) + (f64x2.gt + (v128.load (i32.const 2)) + (v128.load (i32.const 3)) + ) + ) + (f64x2.gt + (f64x2.gt + (v128.load (i32.const 0)) + (v128.load (i32.const 1)) + ) + (f64x2.gt + (v128.load (i32.const 2)) + (v128.load (i32.const 3)) + ) + ) + ) + ) + ) + (func (export "nested-f64x2.ge") + (drop + (f64x2.ge + (f64x2.ge + (f64x2.ge + (v128.load (i32.const 0)) + (v128.load (i32.const 1)) + ) + (f64x2.ge + (v128.load (i32.const 2)) + (v128.load (i32.const 3)) + ) + ) + (f64x2.ge + (f64x2.ge + (v128.load (i32.const 0)) + (v128.load (i32.const 1)) + ) + (f64x2.ge + (v128.load (i32.const 2)) + (v128.load (i32.const 3)) + ) + ) + ) + ) + ) + (func (export "as-param") + (drop + (f64x2.eq + (f64x2.ne + (f64x2.lt + (v128.load (i32.const 0)) + (v128.load (i32.const 1)) + ) + (f64x2.le + (v128.load (i32.const 2)) + (v128.load (i32.const 3)) + ) + ) + (f64x2.gt + (f64x2.ge + (v128.load (i32.const 0)) + (v128.load (i32.const 1)) + ) + (f64x2.eq + (v128.load (i32.const 2)) + (v128.load (i32.const 3)) + ) + ) + ) + ) + ) +) +(assert_return (invoke "f64x2.eq-in-block")) +(assert_return (invoke "f64x2.ne-in-block")) +(assert_return (invoke "f64x2.lt-in-block")) +(assert_return (invoke "f64x2.le-in-block")) +(assert_return (invoke "f64x2.gt-in-block")) +(assert_return (invoke "f64x2.ge-in-block")) +(assert_return (invoke "nested-f64x2.eq")) +(assert_return (invoke "nested-f64x2.ne")) +(assert_return (invoke "nested-f64x2.lt")) +(assert_return (invoke "nested-f64x2.le")) +(assert_return (invoke "nested-f64x2.gt")) +(assert_return (invoke "nested-f64x2.ge")) +(assert_return (invoke "as-param")) diff --git a/runtime/near-vm/tests/wast/spec/proposals/simd/simd_f64x2_pmin_pmax.wast b/runtime/near-vm/tests/wast/spec/proposals/simd/simd_f64x2_pmin_pmax.wast new file mode 100644 index 00000000000..e8167b0e549 --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/proposals/simd/simd_f64x2_pmin_pmax.wast @@ -0,0 +1,11676 @@ +;; Tests for f64x2 [pmin, pmax] operations on major boundary values and all special values. + + +(module + (func (export "f64x2.pmin") (param v128 v128) (result v128) (f64x2.pmin (local.get 0) (local.get 1))) + (func (export "f64x2.pmax") (param v128 v128) (result v128) (f64x2.pmax (local.get 0) (local.get 1))) +) + +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 inf inf)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 0123456789 0123456789)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 0123456789e019 0123456789e019)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 0123456789e+019 0123456789e+019)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 0123456789e-019 0123456789e-019)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 0123456789. 0123456789.)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 0123456789.e019 0123456789.e019)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 0123456789.e+019 0123456789.e+019)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 0123456789.e-019 0123456789.e-019)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 inf inf)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 0123456789 0123456789)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 0123456789e019 0123456789e019)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 0123456789e+019 0123456789e+019)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 0123456789e-019 0123456789e-019)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 0123456789. 0123456789.)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 0123456789.e019 0123456789.e019)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 0123456789.e+019 0123456789.e+019)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 0123456789.e-019 0123456789.e-019)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 inf inf)) + (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 0123456789 0123456789)) + (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 0123456789e019 0123456789e019)) + (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 0123456789e+019 0123456789e+019)) + (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 0123456789e-019 0123456789e-019)) + (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 0123456789. 0123456789.)) + (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 0123456789.e019 0123456789.e019)) + (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 0123456789.e+019 0123456789.e+019)) + (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 0123456789.e-019 0123456789.e-019)) + (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)) + (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)) + (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)) + (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)) + (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)) + (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)) + (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)) + (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)) + (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)) + (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 inf inf)) + (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 0123456789 0123456789)) + (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 0123456789e019 0123456789e019)) + (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 0123456789e+019 0123456789e+019)) + (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 0123456789e-019 0123456789e-019)) + (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 0123456789. 0123456789.)) + (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 0123456789.e019 0123456789.e019)) + (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 0123456789.e+019 0123456789.e+019)) + (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 0123456789.e-019 0123456789.e-019)) + (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)) + (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)) + (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)) + (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)) + (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)) + (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)) + (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)) + (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)) + (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)) + (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 inf inf)) + (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 0123456789 0123456789)) + (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 0123456789e019 0123456789e019)) + (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 0123456789e+019 0123456789e+019)) + (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 0123456789e-019 0123456789e-019)) + (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 0123456789. 0123456789.)) + (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 0123456789.e019 0123456789.e019)) + (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 0123456789.e+019 0123456789.e+019)) + (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 0123456789.e-019 0123456789.e-019)) + (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)) + (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)) + (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)) + (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)) + (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)) + (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)) + (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)) + (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)) + (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)) + (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 inf inf)) + (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 0123456789 0123456789)) + (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 0123456789e019 0123456789e019)) + (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 0123456789e+019 0123456789e+019)) + (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 0123456789e-019 0123456789e-019)) + (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 0123456789. 0123456789.)) + (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 0123456789.e019 0123456789.e019)) + (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 0123456789.e+019 0123456789.e+019)) + (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 0123456789.e-019 0123456789.e-019)) + (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)) + (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)) + (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)) + (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)) + (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)) + (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)) + (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)) + (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)) + (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)) + (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 inf inf)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 0123456789 0123456789)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 0123456789e019 0123456789e019)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 0123456789e+019 0123456789e+019)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 0123456789e-019 0123456789e-019)) + (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 0123456789. 0123456789.)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 0123456789.e019 0123456789.e019)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 0123456789.e+019 0123456789.e+019)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 0123456789.e-019 0123456789.e-019)) + (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 inf inf)) + (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 0123456789 0123456789)) + (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 0123456789e019 0123456789e019)) + (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 0123456789e+019 0123456789e+019)) + (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 0123456789e-019 0123456789e-019)) + (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 0123456789. 0123456789.)) + (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 0123456789.e019 0123456789.e019)) + (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 0123456789.e+019 0123456789.e+019)) + (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 0123456789.e-019 0123456789.e-019)) + (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)) + (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)) + (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)) + (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)) + (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)) + (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)) + (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)) + (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)) + (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)) + (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 inf inf)) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 0123456789 0123456789)) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 0123456789e019 0123456789e019)) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 0123456789e+019 0123456789e+019)) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 0123456789e-019 0123456789e-019)) + (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 0123456789. 0123456789.)) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 0123456789.e019 0123456789.e019)) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 0123456789.e+019 0123456789.e+019)) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 0123456789.e-019 0123456789.e-019)) + (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 inf inf)) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 0123456789 0123456789)) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 0123456789e019 0123456789e019)) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 0123456789e+019 0123456789e+019)) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 0123456789e-019 0123456789e-019)) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 0123456789. 0123456789.)) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 0123456789.e019 0123456789.e019)) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 0123456789.e+019 0123456789.e+019)) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 0123456789.e-019 0123456789.e-019)) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 inf inf)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 0123456789 0123456789)) + (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 0123456789e019 0123456789e019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 0123456789e+019 0123456789e+019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 0123456789e-019 0123456789e-019)) + (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 0123456789. 0123456789.)) + (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 0123456789.e019 0123456789.e019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 0123456789.e+019 0123456789.e+019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 0123456789.e-019 0123456789.e-019)) + (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)) + (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 inf inf)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 0123456789 0123456789)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 0123456789e019 0123456789e019)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 0123456789e+019 0123456789e+019)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 0123456789e-019 0123456789e-019)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 0123456789. 0123456789.)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 0123456789.e019 0123456789.e019)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 0123456789.e+019 0123456789.e+019)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 0123456789.e-019 0123456789.e-019)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 inf inf)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0123456789 0123456789)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0123456789e019 0123456789e019)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0123456789e+019 0123456789e+019)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0123456789e-019 0123456789e-019)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0123456789. 0123456789.)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0123456789.e019 0123456789.e019)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0123456789.e+019 0123456789.e+019)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0123456789.e-019 0123456789.e-019)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 inf inf)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0123456789 0123456789)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0123456789e019 0123456789e019)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0123456789e+019 0123456789e+019)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0123456789e-019 0123456789e-019)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0123456789. 0123456789.)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0123456789.e019 0123456789.e019)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0123456789.e+019 0123456789.e+019)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0123456789.e-019 0123456789.e-019)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf) + (v128.const f64x2 inf inf)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf) + (v128.const f64x2 0123456789 0123456789)) + (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf) + (v128.const f64x2 0123456789e019 0123456789e019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf) + (v128.const f64x2 0123456789e+019 0123456789e+019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf) + (v128.const f64x2 0123456789e-019 0123456789e-019)) + (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf) + (v128.const f64x2 0123456789. 0123456789.)) + (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf) + (v128.const f64x2 0123456789.e019 0123456789.e019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf) + (v128.const f64x2 0123456789.e+019 0123456789.e+019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf) + (v128.const f64x2 0123456789.e-019 0123456789.e-019)) + (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf) + (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)) + (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf) + (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf) + (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf) + (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf) + (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf) + (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf) + (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf) + (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf) + (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf) + (v128.const f64x2 inf inf)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf) + (v128.const f64x2 0123456789 0123456789)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf) + (v128.const f64x2 0123456789e019 0123456789e019)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf) + (v128.const f64x2 0123456789e+019 0123456789e+019)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf) + (v128.const f64x2 0123456789e-019 0123456789e-019)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf) + (v128.const f64x2 0123456789. 0123456789.)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf) + (v128.const f64x2 0123456789.e019 0123456789.e019)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf) + (v128.const f64x2 0123456789.e+019 0123456789.e+019)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf) + (v128.const f64x2 0123456789.e-019 0123456789.e-019)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf) + (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf) + (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf) + (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf) + (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf) + (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf) + (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf) + (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf) + (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf) + (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789) + (v128.const f64x2 inf inf)) + (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789) + (v128.const f64x2 0123456789 0123456789)) + (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789) + (v128.const f64x2 0123456789e019 0123456789e019)) + (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789) + (v128.const f64x2 0123456789e+019 0123456789e+019)) + (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789) + (v128.const f64x2 0123456789e-019 0123456789e-019)) + (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789) + (v128.const f64x2 0123456789. 0123456789.)) + (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789) + (v128.const f64x2 0123456789.e019 0123456789.e019)) + (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789) + (v128.const f64x2 0123456789.e+019 0123456789.e+019)) + (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789) + (v128.const f64x2 0123456789.e-019 0123456789.e-019)) + (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789) + (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)) + (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789) + (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789) + (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789) + (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789) + (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)) + (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789) + (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)) + (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789) + (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789) + (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789) + (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)) + (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)) + (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)) + (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)) + (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)) + (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)) + (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019) + (v128.const f64x2 inf inf)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019) + (v128.const f64x2 0123456789 0123456789)) + (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019) + (v128.const f64x2 0123456789e019 0123456789e019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019) + (v128.const f64x2 0123456789e+019 0123456789e+019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019) + (v128.const f64x2 0123456789e-019 0123456789e-019)) + (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019) + (v128.const f64x2 0123456789. 0123456789.)) + (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019) + (v128.const f64x2 0123456789.e019 0123456789.e019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019) + (v128.const f64x2 0123456789.e+019 0123456789.e+019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019) + (v128.const f64x2 0123456789.e-019 0123456789.e-019)) + (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019) + (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)) + (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019) + (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019) + (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019) + (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019) + (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019) + (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019) + (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019) + (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019) + (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019) + (v128.const f64x2 inf inf)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019) + (v128.const f64x2 0123456789 0123456789)) + (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019) + (v128.const f64x2 0123456789e019 0123456789e019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019) + (v128.const f64x2 0123456789e+019 0123456789e+019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019) + (v128.const f64x2 0123456789e-019 0123456789e-019)) + (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019) + (v128.const f64x2 0123456789. 0123456789.)) + (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019) + (v128.const f64x2 0123456789.e019 0123456789.e019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019) + (v128.const f64x2 0123456789.e+019 0123456789.e+019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019) + (v128.const f64x2 0123456789.e-019 0123456789.e-019)) + (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019) + (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)) + (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019) + (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019) + (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019) + (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019) + (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019) + (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019) + (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019) + (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019) + (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019) + (v128.const f64x2 inf inf)) + (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019) + (v128.const f64x2 0123456789 0123456789)) + (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019) + (v128.const f64x2 0123456789e019 0123456789e019)) + (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019) + (v128.const f64x2 0123456789e+019 0123456789e+019)) + (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019) + (v128.const f64x2 0123456789e-019 0123456789e-019)) + (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019) + (v128.const f64x2 0123456789. 0123456789.)) + (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019) + (v128.const f64x2 0123456789.e019 0123456789.e019)) + (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019) + (v128.const f64x2 0123456789.e+019 0123456789.e+019)) + (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019) + (v128.const f64x2 0123456789.e-019 0123456789.e-019)) + (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019) + (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)) + (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019) + (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019) + (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019) + (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019) + (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)) + (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019) + (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)) + (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019) + (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019) + (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019) + (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)) + (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)) + (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)) + (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)) + (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)) + (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)) + (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.) + (v128.const f64x2 inf inf)) + (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.) + (v128.const f64x2 0123456789 0123456789)) + (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.) + (v128.const f64x2 0123456789e019 0123456789e019)) + (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.) + (v128.const f64x2 0123456789e+019 0123456789e+019)) + (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.) + (v128.const f64x2 0123456789e-019 0123456789e-019)) + (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.) + (v128.const f64x2 0123456789. 0123456789.)) + (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.) + (v128.const f64x2 0123456789.e019 0123456789.e019)) + (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.) + (v128.const f64x2 0123456789.e+019 0123456789.e+019)) + (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.) + (v128.const f64x2 0123456789.e-019 0123456789.e-019)) + (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.) + (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)) + (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.) + (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.) + (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.) + (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.) + (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)) + (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.) + (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)) + (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.) + (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.) + (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.) + (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)) + (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)) + (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)) + (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)) + (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)) + (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)) + (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019) + (v128.const f64x2 inf inf)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019) + (v128.const f64x2 0123456789 0123456789)) + (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019) + (v128.const f64x2 0123456789e019 0123456789e019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019) + (v128.const f64x2 0123456789e+019 0123456789e+019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019) + (v128.const f64x2 0123456789e-019 0123456789e-019)) + (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019) + (v128.const f64x2 0123456789. 0123456789.)) + (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019) + (v128.const f64x2 0123456789.e019 0123456789.e019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019) + (v128.const f64x2 0123456789.e+019 0123456789.e+019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019) + (v128.const f64x2 0123456789.e-019 0123456789.e-019)) + (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019) + (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)) + (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019) + (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019) + (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019) + (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019) + (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019) + (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019) + (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019) + (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019) + (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019) + (v128.const f64x2 inf inf)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019) + (v128.const f64x2 0123456789 0123456789)) + (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019) + (v128.const f64x2 0123456789e019 0123456789e019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019) + (v128.const f64x2 0123456789e+019 0123456789e+019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019) + (v128.const f64x2 0123456789e-019 0123456789e-019)) + (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019) + (v128.const f64x2 0123456789. 0123456789.)) + (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019) + (v128.const f64x2 0123456789.e019 0123456789.e019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019) + (v128.const f64x2 0123456789.e+019 0123456789.e+019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019) + (v128.const f64x2 0123456789.e-019 0123456789.e-019)) + (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019) + (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)) + (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019) + (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019) + (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019) + (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019) + (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019) + (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019) + (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019) + (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019) + (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019) + (v128.const f64x2 inf inf)) + (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019) + (v128.const f64x2 0123456789 0123456789)) + (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019) + (v128.const f64x2 0123456789e019 0123456789e019)) + (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019) + (v128.const f64x2 0123456789e+019 0123456789e+019)) + (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019) + (v128.const f64x2 0123456789e-019 0123456789e-019)) + (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019) + (v128.const f64x2 0123456789. 0123456789.)) + (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019) + (v128.const f64x2 0123456789.e019 0123456789.e019)) + (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019) + (v128.const f64x2 0123456789.e+019 0123456789.e+019)) + (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019) + (v128.const f64x2 0123456789.e-019 0123456789.e-019)) + (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019) + (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)) + (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019) + (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019) + (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019) + (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019) + (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)) + (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019) + (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)) + (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019) + (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019) + (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019) + (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)) + (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)) + (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)) + (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)) + (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)) + (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)) + (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789) + (v128.const f64x2 inf inf)) + (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789) + (v128.const f64x2 0123456789 0123456789)) + (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789) + (v128.const f64x2 0123456789e019 0123456789e019)) + (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789) + (v128.const f64x2 0123456789e+019 0123456789e+019)) + (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789) + (v128.const f64x2 0123456789e-019 0123456789e-019)) + (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789) + (v128.const f64x2 0123456789. 0123456789.)) + (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789) + (v128.const f64x2 0123456789.e019 0123456789.e019)) + (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789) + (v128.const f64x2 0123456789.e+019 0123456789.e+019)) + (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789) + (v128.const f64x2 0123456789.e-019 0123456789.e-019)) + (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789) + (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)) + (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789) + (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789) + (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789) + (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789) + (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)) + (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789) + (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)) + (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789) + (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789) + (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789) + (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)) + (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)) + (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)) + (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)) + (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)) + (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)) + (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f64x2 inf inf)) + (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f64x2 0123456789 0123456789)) + (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f64x2 0123456789e019 0123456789e019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f64x2 0123456789e+019 0123456789e+019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f64x2 0123456789e-019 0123456789e-019)) + (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f64x2 0123456789. 0123456789.)) + (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f64x2 0123456789.e019 0123456789.e019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f64x2 0123456789.e+019 0123456789.e+019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f64x2 0123456789.e-019 0123456789.e-019)) + (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)) + (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)) + (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)) + (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)) + (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)) + (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f64x2 inf inf)) + (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f64x2 0123456789 0123456789)) + (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f64x2 0123456789e019 0123456789e019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f64x2 0123456789e+019 0123456789e+019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f64x2 0123456789e-019 0123456789e-019)) + (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f64x2 0123456789. 0123456789.)) + (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f64x2 0123456789.e019 0123456789.e019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f64x2 0123456789.e+019 0123456789.e+019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f64x2 0123456789.e-019 0123456789.e-019)) + (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)) + (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)) + (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)) + (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)) + (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)) + (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f64x2 inf inf)) + (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f64x2 0123456789 0123456789)) + (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f64x2 0123456789e019 0123456789e019)) + (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f64x2 0123456789e+019 0123456789e+019)) + (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f64x2 0123456789e-019 0123456789e-019)) + (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f64x2 0123456789. 0123456789.)) + (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f64x2 0123456789.e019 0123456789.e019)) + (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f64x2 0123456789.e+019 0123456789.e+019)) + (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f64x2 0123456789.e-019 0123456789.e-019)) + (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)) + (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)) + (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)) + (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)) + (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)) + (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)) + (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)) + (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)) + (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)) + (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef) + (v128.const f64x2 inf inf)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef) + (v128.const f64x2 0123456789 0123456789)) + (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef) + (v128.const f64x2 0123456789e019 0123456789e019)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef) + (v128.const f64x2 0123456789e+019 0123456789e+019)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef) + (v128.const f64x2 0123456789e-019 0123456789e-019)) + (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef) + (v128.const f64x2 0123456789. 0123456789.)) + (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef) + (v128.const f64x2 0123456789.e019 0123456789.e019)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef) + (v128.const f64x2 0123456789.e+019 0123456789.e+019)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef) + (v128.const f64x2 0123456789.e-019 0123456789.e-019)) + (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef) + (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)) + (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef) + (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef) + (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef) + (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef) + (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef) + (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef) + (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef) + (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef) + (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019) + (v128.const f64x2 inf inf)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019) + (v128.const f64x2 0123456789 0123456789)) + (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019) + (v128.const f64x2 0123456789e019 0123456789e019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019) + (v128.const f64x2 0123456789e+019 0123456789e+019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019) + (v128.const f64x2 0123456789e-019 0123456789e-019)) + (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019) + (v128.const f64x2 0123456789. 0123456789.)) + (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019) + (v128.const f64x2 0123456789.e019 0123456789.e019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019) + (v128.const f64x2 0123456789.e+019 0123456789.e+019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019) + (v128.const f64x2 0123456789.e-019 0123456789.e-019)) + (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019) + (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)) + (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019) + (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019) + (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019) + (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019) + (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019) + (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019) + (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019) + (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019) + (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019) + (v128.const f64x2 inf inf)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019) + (v128.const f64x2 0123456789 0123456789)) + (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019) + (v128.const f64x2 0123456789e019 0123456789e019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019) + (v128.const f64x2 0123456789e+019 0123456789e+019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019) + (v128.const f64x2 0123456789e-019 0123456789e-019)) + (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019) + (v128.const f64x2 0123456789. 0123456789.)) + (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019) + (v128.const f64x2 0123456789.e019 0123456789.e019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019) + (v128.const f64x2 0123456789.e+019 0123456789.e+019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019) + (v128.const f64x2 0123456789.e-019 0123456789.e-019)) + (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019) + (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)) + (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019) + (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019) + (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019) + (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019) + (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019) + (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019) + (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019) + (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019) + (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019) + (v128.const f64x2 inf inf)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019) + (v128.const f64x2 0123456789 0123456789)) + (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019) + (v128.const f64x2 0123456789e019 0123456789e019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019) + (v128.const f64x2 0123456789e+019 0123456789e+019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019) + (v128.const f64x2 0123456789e-019 0123456789e-019)) + (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019) + (v128.const f64x2 0123456789. 0123456789.)) + (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019) + (v128.const f64x2 0123456789.e019 0123456789.e019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019) + (v128.const f64x2 0123456789.e+019 0123456789.e+019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019) + (v128.const f64x2 0123456789.e-019 0123456789.e-019)) + (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019) + (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)) + (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019) + (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019) + (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019) + (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019) + (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019) + (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019) + (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019) + (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019) + (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.) + (v128.const f64x2 inf inf)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.) + (v128.const f64x2 0123456789 0123456789)) + (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.) + (v128.const f64x2 0123456789e019 0123456789e019)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.) + (v128.const f64x2 0123456789e+019 0123456789e+019)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.) + (v128.const f64x2 0123456789e-019 0123456789e-019)) + (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.) + (v128.const f64x2 0123456789. 0123456789.)) + (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.) + (v128.const f64x2 0123456789.e019 0123456789.e019)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.) + (v128.const f64x2 0123456789.e+019 0123456789.e+019)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.) + (v128.const f64x2 0123456789.e-019 0123456789.e-019)) + (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.) + (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)) + (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.) + (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.) + (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.) + (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.) + (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.) + (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.) + (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.) + (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.) + (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019) + (v128.const f64x2 inf inf)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019) + (v128.const f64x2 0123456789 0123456789)) + (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019) + (v128.const f64x2 0123456789e019 0123456789e019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019) + (v128.const f64x2 0123456789e+019 0123456789e+019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019) + (v128.const f64x2 0123456789e-019 0123456789e-019)) + (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019) + (v128.const f64x2 0123456789. 0123456789.)) + (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019) + (v128.const f64x2 0123456789.e019 0123456789.e019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019) + (v128.const f64x2 0123456789.e+019 0123456789.e+019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019) + (v128.const f64x2 0123456789.e-019 0123456789.e-019)) + (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019) + (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)) + (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019) + (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019) + (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019) + (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019) + (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019) + (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019) + (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019) + (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019) + (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019) + (v128.const f64x2 inf inf)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019) + (v128.const f64x2 0123456789 0123456789)) + (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019) + (v128.const f64x2 0123456789e019 0123456789e019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019) + (v128.const f64x2 0123456789e+019 0123456789e+019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019) + (v128.const f64x2 0123456789e-019 0123456789e-019)) + (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019) + (v128.const f64x2 0123456789. 0123456789.)) + (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019) + (v128.const f64x2 0123456789.e019 0123456789.e019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019) + (v128.const f64x2 0123456789.e+019 0123456789.e+019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019) + (v128.const f64x2 0123456789.e-019 0123456789.e-019)) + (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019) + (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)) + (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019) + (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019) + (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019) + (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019) + (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019) + (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019) + (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019) + (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019) + (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019) + (v128.const f64x2 inf inf)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019) + (v128.const f64x2 0123456789 0123456789)) + (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019) + (v128.const f64x2 0123456789e019 0123456789e019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019) + (v128.const f64x2 0123456789e+019 0123456789e+019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019) + (v128.const f64x2 0123456789e-019 0123456789e-019)) + (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019) + (v128.const f64x2 0123456789. 0123456789.)) + (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019) + (v128.const f64x2 0123456789.e019 0123456789.e019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019) + (v128.const f64x2 0123456789.e+019 0123456789.e+019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019) + (v128.const f64x2 0123456789.e-019 0123456789.e-019)) + (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019) + (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)) + (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019) + (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019) + (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019) + (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019) + (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019) + (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019) + (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019) + (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019) + (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef) + (v128.const f64x2 inf inf)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef) + (v128.const f64x2 0123456789 0123456789)) + (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef) + (v128.const f64x2 0123456789e019 0123456789e019)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef) + (v128.const f64x2 0123456789e+019 0123456789e+019)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef) + (v128.const f64x2 0123456789e-019 0123456789e-019)) + (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef) + (v128.const f64x2 0123456789. 0123456789.)) + (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef) + (v128.const f64x2 0123456789.e019 0123456789.e019)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef) + (v128.const f64x2 0123456789.e+019 0123456789.e+019)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef) + (v128.const f64x2 0123456789.e-019 0123456789.e-019)) + (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef) + (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)) + (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef) + (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef) + (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef) + (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef) + (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef) + (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef) + (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef) + (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef) + (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019) + (v128.const f64x2 inf inf)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019) + (v128.const f64x2 0123456789 0123456789)) + (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019) + (v128.const f64x2 0123456789e019 0123456789e019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019) + (v128.const f64x2 0123456789e+019 0123456789e+019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019) + (v128.const f64x2 0123456789e-019 0123456789e-019)) + (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019) + (v128.const f64x2 0123456789. 0123456789.)) + (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019) + (v128.const f64x2 0123456789.e019 0123456789.e019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019) + (v128.const f64x2 0123456789.e+019 0123456789.e+019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019) + (v128.const f64x2 0123456789.e-019 0123456789.e-019)) + (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019) + (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)) + (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019) + (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019) + (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019) + (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019) + (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019) + (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019) + (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019) + (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019) + (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019) + (v128.const f64x2 inf inf)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019) + (v128.const f64x2 0123456789 0123456789)) + (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019) + (v128.const f64x2 0123456789e019 0123456789e019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019) + (v128.const f64x2 0123456789e+019 0123456789e+019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019) + (v128.const f64x2 0123456789e-019 0123456789e-019)) + (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019) + (v128.const f64x2 0123456789. 0123456789.)) + (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019) + (v128.const f64x2 0123456789.e019 0123456789.e019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019) + (v128.const f64x2 0123456789.e+019 0123456789.e+019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019) + (v128.const f64x2 0123456789.e-019 0123456789.e-019)) + (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019) + (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)) + (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019) + (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019) + (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019) + (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019) + (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019) + (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019) + (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019) + (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019) + (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019) + (v128.const f64x2 inf inf)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019) + (v128.const f64x2 0123456789 0123456789)) + (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019) + (v128.const f64x2 0123456789e019 0123456789e019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019) + (v128.const f64x2 0123456789e+019 0123456789e+019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019) + (v128.const f64x2 0123456789e-019 0123456789e-019)) + (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019) + (v128.const f64x2 0123456789. 0123456789.)) + (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019) + (v128.const f64x2 0123456789.e019 0123456789.e019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019) + (v128.const f64x2 0123456789.e+019 0123456789.e+019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019) + (v128.const f64x2 0123456789.e-019 0123456789.e-019)) + (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019) + (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)) + (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019) + (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019) + (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019) + (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019) + (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019) + (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019) + (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019) + (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019) + (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 nan nan)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 nan nan)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 nan nan)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 nan nan)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 nan nan)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 nan nan)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 nan nan)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 nan nan)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 nan nan)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 nan nan)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 nan nan)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 nan nan)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 nan nan)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 nan nan)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan) + (v128.const f64x2 inf inf)) + (v128.const f64x2 nan nan)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 nan nan)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan) + (v128.const f64x2 0123456789 0123456789)) + (v128.const f64x2 nan nan)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan) + (v128.const f64x2 0123456789e019 0123456789e019)) + (v128.const f64x2 nan nan)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan) + (v128.const f64x2 0123456789e+019 0123456789e+019)) + (v128.const f64x2 nan nan)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan) + (v128.const f64x2 0123456789e-019 0123456789e-019)) + (v128.const f64x2 nan nan)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan) + (v128.const f64x2 0123456789. 0123456789.)) + (v128.const f64x2 nan nan)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan) + (v128.const f64x2 0123456789.e019 0123456789.e019)) + (v128.const f64x2 nan nan)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan) + (v128.const f64x2 0123456789.e+019 0123456789.e+019)) + (v128.const f64x2 nan nan)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan) + (v128.const f64x2 0123456789.e-019 0123456789.e-019)) + (v128.const f64x2 nan nan)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan) + (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)) + (v128.const f64x2 nan nan)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan) + (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f64x2 nan nan)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan) + (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f64x2 nan nan)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan) + (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f64x2 nan nan)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan) + (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)) + (v128.const f64x2 nan nan)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan) + (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)) + (v128.const f64x2 nan nan)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan) + (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 nan nan)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan) + (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 nan nan)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan) + (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)) + (v128.const f64x2 nan nan)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)) + (v128.const f64x2 nan nan)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)) + (v128.const f64x2 nan nan)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)) + (v128.const f64x2 nan nan)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)) + (v128.const f64x2 nan nan)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)) + (v128.const f64x2 nan nan)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 nan nan)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 nan nan)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan) + (v128.const f64x2 nan nan)) + (v128.const f64x2 nan nan)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 nan nan)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 nan nan)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 nan nan)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 -nan -nan)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 -nan -nan)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 -nan -nan)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 -nan -nan)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 -nan -nan)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 -nan -nan)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 -nan -nan)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 -nan -nan)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 -nan -nan)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 -nan -nan)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 -nan -nan)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 -nan -nan)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 -nan -nan)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 -nan -nan)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan) + (v128.const f64x2 inf inf)) + (v128.const f64x2 -nan -nan)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 -nan -nan)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan) + (v128.const f64x2 0123456789 0123456789)) + (v128.const f64x2 -nan -nan)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan) + (v128.const f64x2 0123456789e019 0123456789e019)) + (v128.const f64x2 -nan -nan)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan) + (v128.const f64x2 0123456789e+019 0123456789e+019)) + (v128.const f64x2 -nan -nan)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan) + (v128.const f64x2 0123456789e-019 0123456789e-019)) + (v128.const f64x2 -nan -nan)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan) + (v128.const f64x2 0123456789. 0123456789.)) + (v128.const f64x2 -nan -nan)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan) + (v128.const f64x2 0123456789.e019 0123456789.e019)) + (v128.const f64x2 -nan -nan)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan) + (v128.const f64x2 0123456789.e+019 0123456789.e+019)) + (v128.const f64x2 -nan -nan)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan) + (v128.const f64x2 0123456789.e-019 0123456789.e-019)) + (v128.const f64x2 -nan -nan)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan) + (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)) + (v128.const f64x2 -nan -nan)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan) + (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f64x2 -nan -nan)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan) + (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f64x2 -nan -nan)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan) + (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f64x2 -nan -nan)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan) + (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)) + (v128.const f64x2 -nan -nan)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan) + (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)) + (v128.const f64x2 -nan -nan)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan) + (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 -nan -nan)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan) + (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 -nan -nan)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan) + (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)) + (v128.const f64x2 -nan -nan)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)) + (v128.const f64x2 -nan -nan)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)) + (v128.const f64x2 -nan -nan)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)) + (v128.const f64x2 -nan -nan)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)) + (v128.const f64x2 -nan -nan)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)) + (v128.const f64x2 -nan -nan)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 -nan -nan)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 -nan -nan)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan) + (v128.const f64x2 nan nan)) + (v128.const f64x2 -nan -nan)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 -nan -nan)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 -nan -nan)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 -nan -nan)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 inf inf)) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 0123456789 0123456789)) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 0123456789e019 0123456789e019)) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 0123456789e+019 0123456789e+019)) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 0123456789e-019 0123456789e-019)) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 0123456789. 0123456789.)) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 0123456789.e019 0123456789.e019)) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 0123456789.e+019 0123456789.e+019)) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 0123456789.e-019 0123456789.e-019)) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 nan nan)) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 inf inf)) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 0123456789 0123456789)) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 0123456789e019 0123456789e019)) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 0123456789e+019 0123456789e+019)) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 0123456789e-019 0123456789e-019)) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 0123456789. 0123456789.)) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 0123456789.e019 0123456789.e019)) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 0123456789.e+019 0123456789.e+019)) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 0123456789.e-019 0123456789.e-019)) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 nan nan)) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 nan nan)) + (v128.const f64x2 0x0p+0 0x0p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 nan nan)) + (v128.const f64x2 -0x0p+0 -0x0p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 nan nan)) + (v128.const f64x2 0x1p-1022 0x1p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 nan nan)) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 nan nan)) + (v128.const f64x2 0x1p-1 0x1p-1)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 nan nan)) + (v128.const f64x2 -0x1p-1 -0x1p-1)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 nan nan)) + (v128.const f64x2 0x1p+0 0x1p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 nan nan)) + (v128.const f64x2 -0x1p+0 -0x1p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 nan nan)) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 nan nan)) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 nan nan)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 nan nan)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 nan nan)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 nan nan)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf) + (v128.const f64x2 nan nan)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf) + (v128.const f64x2 nan nan)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789) + (v128.const f64x2 nan nan)) + (v128.const f64x2 0123456789 0123456789)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019) + (v128.const f64x2 nan nan)) + (v128.const f64x2 0123456789e019 0123456789e019)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019) + (v128.const f64x2 nan nan)) + (v128.const f64x2 0123456789e+019 0123456789e+019)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019) + (v128.const f64x2 nan nan)) + (v128.const f64x2 0123456789e-019 0123456789e-019)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.) + (v128.const f64x2 nan nan)) + (v128.const f64x2 0123456789. 0123456789.)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019) + (v128.const f64x2 nan nan)) + (v128.const f64x2 0123456789.e019 0123456789.e019)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019) + (v128.const f64x2 nan nan)) + (v128.const f64x2 0123456789.e+019 0123456789.e+019)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019) + (v128.const f64x2 nan nan)) + (v128.const f64x2 0123456789.e-019 0123456789.e-019)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789) + (v128.const f64x2 nan nan)) + (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f64x2 nan nan)) + (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f64x2 nan nan)) + (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f64x2 nan nan)) + (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef) + (v128.const f64x2 nan nan)) + (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019) + (v128.const f64x2 nan nan)) + (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019) + (v128.const f64x2 nan nan)) + (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019) + (v128.const f64x2 nan nan)) + (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.) + (v128.const f64x2 nan nan)) + (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019) + (v128.const f64x2 nan nan)) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019) + (v128.const f64x2 nan nan)) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019) + (v128.const f64x2 nan nan)) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef) + (v128.const f64x2 nan nan)) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019) + (v128.const f64x2 nan nan)) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019) + (v128.const f64x2 nan nan)) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019) + (v128.const f64x2 nan nan)) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 0x0p+0 0x0p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 -0x0p+0 -0x0p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 0x1p-1022 0x1p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 0x1p-1 0x1p-1)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 -0x1p-1 -0x1p-1)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 0x1p+0 0x1p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 -0x1p+0 -0x1p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 0123456789 0123456789)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 0123456789e019 0123456789e019)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 0123456789e+019 0123456789e+019)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 0123456789e-019 0123456789e-019)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 0123456789. 0123456789.)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 0123456789.e019 0123456789.e019)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 0123456789.e+019 0123456789.e+019)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 0123456789.e-019 0123456789.e-019)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 0x0p+0 0x0p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 -0x0p+0 -0x0p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 0x1p-1022 0x1p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 0x1p-1 0x1p-1)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 -0x1p-1 -0x1p-1)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 0x1p+0 0x1p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 -0x1p+0 -0x1p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 0123456789 0123456789)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 0123456789e019 0123456789e019)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 0123456789e+019 0123456789e+019)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 0123456789e-019 0123456789e-019)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 0123456789. 0123456789.)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 0123456789.e019 0123456789.e019)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 0123456789.e+019 0123456789.e+019)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 0123456789.e-019 0123456789.e-019)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 0x0p+0 0x0p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 -0x0p+0 -0x0p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 0x1p-1022 0x1p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 0x1p-1 0x1p-1)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 -0x1p-1 -0x1p-1)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 0x1p+0 0x1p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 -0x1p+0 -0x1p+0)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 0123456789 0123456789)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 0123456789e019 0123456789e019)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 0123456789e+019 0123456789e+019)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 0123456789e-019 0123456789e-019)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 0123456789. 0123456789.)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 0123456789.e019 0123456789.e019)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 0123456789.e+019 0123456789.e+019)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 0123456789.e-019 0123456789.e-019)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)) +(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 inf inf)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 0123456789 0123456789)) + (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 0123456789e019 0123456789e019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 0123456789e+019 0123456789e+019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 0123456789e-019 0123456789e-019)) + (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 0123456789. 0123456789.)) + (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 0123456789.e019 0123456789.e019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 0123456789.e+019 0123456789.e+019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 0123456789.e-019 0123456789.e-019)) + (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)) + (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 inf inf)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 0123456789 0123456789)) + (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 0123456789e019 0123456789e019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 0123456789e+019 0123456789e+019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 0123456789e-019 0123456789e-019)) + (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 0123456789. 0123456789.)) + (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 0123456789.e019 0123456789.e019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 0123456789.e+019 0123456789.e+019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 0123456789.e-019 0123456789.e-019)) + (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)) + (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 inf inf)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 0123456789 0123456789)) + (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 0123456789e019 0123456789e019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 0123456789e+019 0123456789e+019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 0123456789e-019 0123456789e-019)) + (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 0123456789. 0123456789.)) + (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 0123456789.e019 0123456789.e019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 0123456789.e+019 0123456789.e+019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 0123456789.e-019 0123456789.e-019)) + (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)) + (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 inf inf)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 0123456789 0123456789)) + (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 0123456789e019 0123456789e019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 0123456789e+019 0123456789e+019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 0123456789e-019 0123456789e-019)) + (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 0123456789. 0123456789.)) + (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 0123456789.e019 0123456789.e019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 0123456789.e+019 0123456789.e+019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 0123456789.e-019 0123456789.e-019)) + (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)) + (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 inf inf)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 0123456789 0123456789)) + (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 0123456789e019 0123456789e019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 0123456789e+019 0123456789e+019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 0123456789e-019 0123456789e-019)) + (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 0123456789. 0123456789.)) + (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 0123456789.e019 0123456789.e019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 0123456789.e+019 0123456789.e+019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 0123456789.e-019 0123456789.e-019)) + (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)) + (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 inf inf)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 0123456789 0123456789)) + (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 0123456789e019 0123456789e019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 0123456789e+019 0123456789e+019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 0123456789e-019 0123456789e-019)) + (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 0123456789. 0123456789.)) + (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 0123456789.e019 0123456789.e019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 0123456789.e+019 0123456789.e+019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 0123456789.e-019 0123456789.e-019)) + (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)) + (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 inf inf)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 0123456789 0123456789)) + (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 0123456789e019 0123456789e019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 0123456789e+019 0123456789e+019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 0123456789e-019 0123456789e-019)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 0123456789. 0123456789.)) + (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 0123456789.e019 0123456789.e019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 0123456789.e+019 0123456789.e+019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 0123456789.e-019 0123456789.e-019)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)) + (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 inf inf)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 0123456789 0123456789)) + (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 0123456789e019 0123456789e019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 0123456789e+019 0123456789e+019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 0123456789e-019 0123456789e-019)) + (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 0123456789. 0123456789.)) + (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 0123456789.e019 0123456789.e019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 0123456789.e+019 0123456789.e+019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 0123456789.e-019 0123456789.e-019)) + (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)) + (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 inf inf)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 0123456789 0123456789)) + (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 0123456789e019 0123456789e019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 0123456789e+019 0123456789e+019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 0123456789e-019 0123456789e-019)) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 0123456789. 0123456789.)) + (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 0123456789.e019 0123456789.e019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 0123456789.e+019 0123456789.e+019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 0123456789.e-019 0123456789.e-019)) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)) + (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 inf inf)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 0123456789 0123456789)) + (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 0123456789e019 0123456789e019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 0123456789e+019 0123456789e+019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 0123456789e-019 0123456789e-019)) + (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 0123456789. 0123456789.)) + (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 0123456789.e019 0123456789.e019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 0123456789.e+019 0123456789.e+019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 0123456789.e-019 0123456789.e-019)) + (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)) + (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 inf inf)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 0123456789 0123456789)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 0123456789e019 0123456789e019)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 0123456789e+019 0123456789e+019)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 0123456789e-019 0123456789e-019)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 0123456789. 0123456789.)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 0123456789.e019 0123456789.e019)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 0123456789.e+019 0123456789.e+019)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 0123456789.e-019 0123456789.e-019)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 inf inf)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 0123456789 0123456789)) + (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 0123456789e019 0123456789e019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 0123456789e+019 0123456789e+019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 0123456789e-019 0123456789e-019)) + (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 0123456789. 0123456789.)) + (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 0123456789.e019 0123456789.e019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 0123456789.e+019 0123456789.e+019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 0123456789.e-019 0123456789.e-019)) + (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)) + (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 inf inf)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0123456789 0123456789)) + (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0123456789e019 0123456789e019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0123456789e+019 0123456789e+019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0123456789e-019 0123456789e-019)) + (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0123456789. 0123456789.)) + (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0123456789.e019 0123456789.e019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0123456789.e+019 0123456789.e+019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0123456789.e-019 0123456789.e-019)) + (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)) + (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 inf inf)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0123456789 0123456789)) + (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0123456789e019 0123456789e019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0123456789e+019 0123456789e+019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0123456789e-019 0123456789e-019)) + (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0123456789. 0123456789.)) + (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0123456789.e019 0123456789.e019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0123456789.e+019 0123456789.e+019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0123456789.e-019 0123456789.e-019)) + (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)) + (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf) + (v128.const f64x2 inf inf)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf) + (v128.const f64x2 0123456789 0123456789)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf) + (v128.const f64x2 0123456789e019 0123456789e019)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf) + (v128.const f64x2 0123456789e+019 0123456789e+019)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf) + (v128.const f64x2 0123456789e-019 0123456789e-019)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf) + (v128.const f64x2 0123456789. 0123456789.)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf) + (v128.const f64x2 0123456789.e019 0123456789.e019)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf) + (v128.const f64x2 0123456789.e+019 0123456789.e+019)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf) + (v128.const f64x2 0123456789.e-019 0123456789.e-019)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf) + (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf) + (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf) + (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf) + (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf) + (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf) + (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf) + (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf) + (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf) + (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf) + (v128.const f64x2 inf inf)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf) + (v128.const f64x2 0123456789 0123456789)) + (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf) + (v128.const f64x2 0123456789e019 0123456789e019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf) + (v128.const f64x2 0123456789e+019 0123456789e+019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf) + (v128.const f64x2 0123456789e-019 0123456789e-019)) + (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf) + (v128.const f64x2 0123456789. 0123456789.)) + (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf) + (v128.const f64x2 0123456789.e019 0123456789.e019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf) + (v128.const f64x2 0123456789.e+019 0123456789.e+019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf) + (v128.const f64x2 0123456789.e-019 0123456789.e-019)) + (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf) + (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)) + (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf) + (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf) + (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf) + (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf) + (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf) + (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf) + (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf) + (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf) + (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789) + (v128.const f64x2 inf inf)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789) + (v128.const f64x2 0123456789 0123456789)) + (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789) + (v128.const f64x2 0123456789e019 0123456789e019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789) + (v128.const f64x2 0123456789e+019 0123456789e+019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789) + (v128.const f64x2 0123456789e-019 0123456789e-019)) + (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789) + (v128.const f64x2 0123456789. 0123456789.)) + (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789) + (v128.const f64x2 0123456789.e019 0123456789.e019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789) + (v128.const f64x2 0123456789.e+019 0123456789.e+019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789) + (v128.const f64x2 0123456789.e-019 0123456789.e-019)) + (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789) + (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)) + (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789) + (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789) + (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789) + (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789) + (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789) + (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789) + (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789) + (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789) + (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019) + (v128.const f64x2 inf inf)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019) + (v128.const f64x2 0123456789 0123456789)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019) + (v128.const f64x2 0123456789e019 0123456789e019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019) + (v128.const f64x2 0123456789e+019 0123456789e+019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019) + (v128.const f64x2 0123456789e-019 0123456789e-019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019) + (v128.const f64x2 0123456789. 0123456789.)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019) + (v128.const f64x2 0123456789.e019 0123456789.e019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019) + (v128.const f64x2 0123456789.e+019 0123456789.e+019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019) + (v128.const f64x2 0123456789.e-019 0123456789.e-019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019) + (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019) + (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019) + (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019) + (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019) + (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019) + (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019) + (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019) + (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019) + (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019) + (v128.const f64x2 inf inf)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019) + (v128.const f64x2 0123456789 0123456789)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019) + (v128.const f64x2 0123456789e019 0123456789e019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019) + (v128.const f64x2 0123456789e+019 0123456789e+019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019) + (v128.const f64x2 0123456789e-019 0123456789e-019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019) + (v128.const f64x2 0123456789. 0123456789.)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019) + (v128.const f64x2 0123456789.e019 0123456789.e019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019) + (v128.const f64x2 0123456789.e+019 0123456789.e+019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019) + (v128.const f64x2 0123456789.e-019 0123456789.e-019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019) + (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019) + (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019) + (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019) + (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019) + (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019) + (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019) + (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019) + (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019) + (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019) + (v128.const f64x2 inf inf)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019) + (v128.const f64x2 0123456789 0123456789)) + (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019) + (v128.const f64x2 0123456789e019 0123456789e019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019) + (v128.const f64x2 0123456789e+019 0123456789e+019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019) + (v128.const f64x2 0123456789e-019 0123456789e-019)) + (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019) + (v128.const f64x2 0123456789. 0123456789.)) + (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019) + (v128.const f64x2 0123456789.e019 0123456789.e019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019) + (v128.const f64x2 0123456789.e+019 0123456789.e+019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019) + (v128.const f64x2 0123456789.e-019 0123456789.e-019)) + (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019) + (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)) + (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019) + (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019) + (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019) + (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019) + (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019) + (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019) + (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019) + (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019) + (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.) + (v128.const f64x2 inf inf)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.) + (v128.const f64x2 0123456789 0123456789)) + (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.) + (v128.const f64x2 0123456789e019 0123456789e019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.) + (v128.const f64x2 0123456789e+019 0123456789e+019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.) + (v128.const f64x2 0123456789e-019 0123456789e-019)) + (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.) + (v128.const f64x2 0123456789. 0123456789.)) + (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.) + (v128.const f64x2 0123456789.e019 0123456789.e019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.) + (v128.const f64x2 0123456789.e+019 0123456789.e+019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.) + (v128.const f64x2 0123456789.e-019 0123456789.e-019)) + (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.) + (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)) + (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.) + (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.) + (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.) + (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.) + (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.) + (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.) + (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.) + (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.) + (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019) + (v128.const f64x2 inf inf)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019) + (v128.const f64x2 0123456789 0123456789)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019) + (v128.const f64x2 0123456789e019 0123456789e019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019) + (v128.const f64x2 0123456789e+019 0123456789e+019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019) + (v128.const f64x2 0123456789e-019 0123456789e-019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019) + (v128.const f64x2 0123456789. 0123456789.)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019) + (v128.const f64x2 0123456789.e019 0123456789.e019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019) + (v128.const f64x2 0123456789.e+019 0123456789.e+019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019) + (v128.const f64x2 0123456789.e-019 0123456789.e-019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019) + (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019) + (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019) + (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019) + (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019) + (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019) + (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019) + (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019) + (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019) + (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019) + (v128.const f64x2 inf inf)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019) + (v128.const f64x2 0123456789 0123456789)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019) + (v128.const f64x2 0123456789e019 0123456789e019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019) + (v128.const f64x2 0123456789e+019 0123456789e+019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019) + (v128.const f64x2 0123456789e-019 0123456789e-019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019) + (v128.const f64x2 0123456789. 0123456789.)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019) + (v128.const f64x2 0123456789.e019 0123456789.e019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019) + (v128.const f64x2 0123456789.e+019 0123456789.e+019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019) + (v128.const f64x2 0123456789.e-019 0123456789.e-019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019) + (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019) + (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019) + (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019) + (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019) + (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019) + (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019) + (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019) + (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019) + (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019) + (v128.const f64x2 inf inf)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019) + (v128.const f64x2 0123456789 0123456789)) + (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019) + (v128.const f64x2 0123456789e019 0123456789e019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019) + (v128.const f64x2 0123456789e+019 0123456789e+019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019) + (v128.const f64x2 0123456789e-019 0123456789e-019)) + (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019) + (v128.const f64x2 0123456789. 0123456789.)) + (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019) + (v128.const f64x2 0123456789.e019 0123456789.e019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019) + (v128.const f64x2 0123456789.e+019 0123456789.e+019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019) + (v128.const f64x2 0123456789.e-019 0123456789.e-019)) + (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019) + (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)) + (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019) + (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019) + (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019) + (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019) + (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019) + (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019) + (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019) + (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019) + (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789) + (v128.const f64x2 inf inf)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789) + (v128.const f64x2 0123456789 0123456789)) + (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789) + (v128.const f64x2 0123456789e019 0123456789e019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789) + (v128.const f64x2 0123456789e+019 0123456789e+019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789) + (v128.const f64x2 0123456789e-019 0123456789e-019)) + (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789) + (v128.const f64x2 0123456789. 0123456789.)) + (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789) + (v128.const f64x2 0123456789.e019 0123456789.e019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789) + (v128.const f64x2 0123456789.e+019 0123456789.e+019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789) + (v128.const f64x2 0123456789.e-019 0123456789.e-019)) + (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789) + (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)) + (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789) + (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789) + (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789) + (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789) + (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789) + (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789) + (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789) + (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789) + (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f64x2 inf inf)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f64x2 0123456789 0123456789)) + (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f64x2 0123456789e019 0123456789e019)) + (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f64x2 0123456789e+019 0123456789e+019)) + (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f64x2 0123456789e-019 0123456789e-019)) + (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f64x2 0123456789. 0123456789.)) + (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f64x2 0123456789.e019 0123456789.e019)) + (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f64x2 0123456789.e+019 0123456789.e+019)) + (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f64x2 0123456789.e-019 0123456789.e-019)) + (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)) + (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)) + (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)) + (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)) + (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)) + (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f64x2 inf inf)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f64x2 0123456789 0123456789)) + (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f64x2 0123456789e019 0123456789e019)) + (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f64x2 0123456789e+019 0123456789e+019)) + (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f64x2 0123456789e-019 0123456789e-019)) + (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f64x2 0123456789. 0123456789.)) + (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f64x2 0123456789.e019 0123456789.e019)) + (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f64x2 0123456789.e+019 0123456789.e+019)) + (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f64x2 0123456789.e-019 0123456789.e-019)) + (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)) + (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)) + (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)) + (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)) + (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)) + (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f64x2 inf inf)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f64x2 0123456789 0123456789)) + (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f64x2 0123456789e019 0123456789e019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f64x2 0123456789e+019 0123456789e+019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f64x2 0123456789e-019 0123456789e-019)) + (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f64x2 0123456789. 0123456789.)) + (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f64x2 0123456789.e019 0123456789.e019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f64x2 0123456789.e+019 0123456789.e+019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f64x2 0123456789.e-019 0123456789.e-019)) + (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)) + (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef) + (v128.const f64x2 inf inf)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef) + (v128.const f64x2 0123456789 0123456789)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef) + (v128.const f64x2 0123456789e019 0123456789e019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef) + (v128.const f64x2 0123456789e+019 0123456789e+019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef) + (v128.const f64x2 0123456789e-019 0123456789e-019)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef) + (v128.const f64x2 0123456789. 0123456789.)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef) + (v128.const f64x2 0123456789.e019 0123456789.e019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef) + (v128.const f64x2 0123456789.e+019 0123456789.e+019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef) + (v128.const f64x2 0123456789.e-019 0123456789.e-019)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef) + (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef) + (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef) + (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef) + (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef) + (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef) + (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef) + (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef) + (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef) + (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019) + (v128.const f64x2 inf inf)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019) + (v128.const f64x2 0123456789 0123456789)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019) + (v128.const f64x2 0123456789e019 0123456789e019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019) + (v128.const f64x2 0123456789e+019 0123456789e+019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019) + (v128.const f64x2 0123456789e-019 0123456789e-019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019) + (v128.const f64x2 0123456789. 0123456789.)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019) + (v128.const f64x2 0123456789.e019 0123456789.e019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019) + (v128.const f64x2 0123456789.e+019 0123456789.e+019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019) + (v128.const f64x2 0123456789.e-019 0123456789.e-019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019) + (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019) + (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019) + (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019) + (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019) + (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019) + (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019) + (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019) + (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019) + (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019) + (v128.const f64x2 inf inf)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019) + (v128.const f64x2 0123456789 0123456789)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019) + (v128.const f64x2 0123456789e019 0123456789e019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019) + (v128.const f64x2 0123456789e+019 0123456789e+019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019) + (v128.const f64x2 0123456789e-019 0123456789e-019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019) + (v128.const f64x2 0123456789. 0123456789.)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019) + (v128.const f64x2 0123456789.e019 0123456789.e019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019) + (v128.const f64x2 0123456789.e+019 0123456789.e+019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019) + (v128.const f64x2 0123456789.e-019 0123456789.e-019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019) + (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019) + (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019) + (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019) + (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019) + (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019) + (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019) + (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019) + (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019) + (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019) + (v128.const f64x2 inf inf)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019) + (v128.const f64x2 0123456789 0123456789)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019) + (v128.const f64x2 0123456789e019 0123456789e019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019) + (v128.const f64x2 0123456789e+019 0123456789e+019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019) + (v128.const f64x2 0123456789e-019 0123456789e-019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019) + (v128.const f64x2 0123456789. 0123456789.)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019) + (v128.const f64x2 0123456789.e019 0123456789.e019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019) + (v128.const f64x2 0123456789.e+019 0123456789.e+019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019) + (v128.const f64x2 0123456789.e-019 0123456789.e-019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019) + (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019) + (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019) + (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019) + (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019) + (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019) + (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019) + (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019) + (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019) + (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.) + (v128.const f64x2 inf inf)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.) + (v128.const f64x2 0123456789 0123456789)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.) + (v128.const f64x2 0123456789e019 0123456789e019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.) + (v128.const f64x2 0123456789e+019 0123456789e+019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.) + (v128.const f64x2 0123456789e-019 0123456789e-019)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.) + (v128.const f64x2 0123456789. 0123456789.)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.) + (v128.const f64x2 0123456789.e019 0123456789.e019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.) + (v128.const f64x2 0123456789.e+019 0123456789.e+019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.) + (v128.const f64x2 0123456789.e-019 0123456789.e-019)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.) + (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.) + (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.) + (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.) + (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.) + (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.) + (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.) + (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.) + (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.) + (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019) + (v128.const f64x2 inf inf)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019) + (v128.const f64x2 0123456789 0123456789)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019) + (v128.const f64x2 0123456789e019 0123456789e019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019) + (v128.const f64x2 0123456789e+019 0123456789e+019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019) + (v128.const f64x2 0123456789e-019 0123456789e-019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019) + (v128.const f64x2 0123456789. 0123456789.)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019) + (v128.const f64x2 0123456789.e019 0123456789.e019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019) + (v128.const f64x2 0123456789.e+019 0123456789.e+019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019) + (v128.const f64x2 0123456789.e-019 0123456789.e-019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019) + (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019) + (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019) + (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019) + (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019) + (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019) + (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019) + (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019) + (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019) + (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019) + (v128.const f64x2 inf inf)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019) + (v128.const f64x2 0123456789 0123456789)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019) + (v128.const f64x2 0123456789e019 0123456789e019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019) + (v128.const f64x2 0123456789e+019 0123456789e+019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019) + (v128.const f64x2 0123456789e-019 0123456789e-019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019) + (v128.const f64x2 0123456789. 0123456789.)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019) + (v128.const f64x2 0123456789.e019 0123456789.e019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019) + (v128.const f64x2 0123456789.e+019 0123456789.e+019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019) + (v128.const f64x2 0123456789.e-019 0123456789.e-019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019) + (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019) + (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019) + (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019) + (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019) + (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019) + (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019) + (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019) + (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019) + (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019) + (v128.const f64x2 inf inf)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019) + (v128.const f64x2 0123456789 0123456789)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019) + (v128.const f64x2 0123456789e019 0123456789e019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019) + (v128.const f64x2 0123456789e+019 0123456789e+019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019) + (v128.const f64x2 0123456789e-019 0123456789e-019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019) + (v128.const f64x2 0123456789. 0123456789.)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019) + (v128.const f64x2 0123456789.e019 0123456789.e019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019) + (v128.const f64x2 0123456789.e+019 0123456789.e+019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019) + (v128.const f64x2 0123456789.e-019 0123456789.e-019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019) + (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019) + (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019) + (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019) + (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019) + (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019) + (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019) + (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019) + (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019) + (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef) + (v128.const f64x2 inf inf)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef) + (v128.const f64x2 0123456789 0123456789)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef) + (v128.const f64x2 0123456789e019 0123456789e019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef) + (v128.const f64x2 0123456789e+019 0123456789e+019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef) + (v128.const f64x2 0123456789e-019 0123456789e-019)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef) + (v128.const f64x2 0123456789. 0123456789.)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef) + (v128.const f64x2 0123456789.e019 0123456789.e019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef) + (v128.const f64x2 0123456789.e+019 0123456789.e+019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef) + (v128.const f64x2 0123456789.e-019 0123456789.e-019)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef) + (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef) + (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef) + (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef) + (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef) + (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef) + (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef) + (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef) + (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef) + (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019) + (v128.const f64x2 inf inf)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019) + (v128.const f64x2 0123456789 0123456789)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019) + (v128.const f64x2 0123456789e019 0123456789e019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019) + (v128.const f64x2 0123456789e+019 0123456789e+019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019) + (v128.const f64x2 0123456789e-019 0123456789e-019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019) + (v128.const f64x2 0123456789. 0123456789.)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019) + (v128.const f64x2 0123456789.e019 0123456789.e019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019) + (v128.const f64x2 0123456789.e+019 0123456789.e+019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019) + (v128.const f64x2 0123456789.e-019 0123456789.e-019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019) + (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019) + (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019) + (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019) + (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019) + (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019) + (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019) + (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019) + (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019) + (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019) + (v128.const f64x2 inf inf)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019) + (v128.const f64x2 0123456789 0123456789)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019) + (v128.const f64x2 0123456789e019 0123456789e019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019) + (v128.const f64x2 0123456789e+019 0123456789e+019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019) + (v128.const f64x2 0123456789e-019 0123456789e-019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019) + (v128.const f64x2 0123456789. 0123456789.)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019) + (v128.const f64x2 0123456789.e019 0123456789.e019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019) + (v128.const f64x2 0123456789.e+019 0123456789.e+019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019) + (v128.const f64x2 0123456789.e-019 0123456789.e-019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019) + (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019) + (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019) + (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019) + (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019) + (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019) + (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019) + (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019) + (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019) + (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019) + (v128.const f64x2 inf inf)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019) + (v128.const f64x2 0123456789 0123456789)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019) + (v128.const f64x2 0123456789e019 0123456789e019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019) + (v128.const f64x2 0123456789e+019 0123456789e+019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019) + (v128.const f64x2 0123456789e-019 0123456789e-019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019) + (v128.const f64x2 0123456789. 0123456789.)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019) + (v128.const f64x2 0123456789.e019 0123456789.e019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019) + (v128.const f64x2 0123456789.e+019 0123456789.e+019)) + (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019) + (v128.const f64x2 0123456789.e-019 0123456789.e-019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019) + (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019) + (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019) + (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019) + (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019) + (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019) + (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019) + (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019) + (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019) + (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)) + (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 nan nan)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 nan nan)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 nan nan)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 nan nan)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 nan nan)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 nan nan)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 nan nan)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 nan nan)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 nan nan)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 nan nan)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 nan nan)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 nan nan)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 nan nan)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 nan nan)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan) + (v128.const f64x2 inf inf)) + (v128.const f64x2 nan nan)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 nan nan)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan) + (v128.const f64x2 0123456789 0123456789)) + (v128.const f64x2 nan nan)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan) + (v128.const f64x2 0123456789e019 0123456789e019)) + (v128.const f64x2 nan nan)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan) + (v128.const f64x2 0123456789e+019 0123456789e+019)) + (v128.const f64x2 nan nan)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan) + (v128.const f64x2 0123456789e-019 0123456789e-019)) + (v128.const f64x2 nan nan)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan) + (v128.const f64x2 0123456789. 0123456789.)) + (v128.const f64x2 nan nan)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan) + (v128.const f64x2 0123456789.e019 0123456789.e019)) + (v128.const f64x2 nan nan)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan) + (v128.const f64x2 0123456789.e+019 0123456789.e+019)) + (v128.const f64x2 nan nan)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan) + (v128.const f64x2 0123456789.e-019 0123456789.e-019)) + (v128.const f64x2 nan nan)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan) + (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)) + (v128.const f64x2 nan nan)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan) + (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f64x2 nan nan)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan) + (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f64x2 nan nan)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan) + (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f64x2 nan nan)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan) + (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)) + (v128.const f64x2 nan nan)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan) + (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)) + (v128.const f64x2 nan nan)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan) + (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 nan nan)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan) + (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 nan nan)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan) + (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)) + (v128.const f64x2 nan nan)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)) + (v128.const f64x2 nan nan)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)) + (v128.const f64x2 nan nan)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)) + (v128.const f64x2 nan nan)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)) + (v128.const f64x2 nan nan)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)) + (v128.const f64x2 nan nan)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 nan nan)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 nan nan)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan) + (v128.const f64x2 nan nan)) + (v128.const f64x2 nan nan)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 nan nan)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 nan nan)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 nan nan)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 -nan -nan)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 -nan -nan)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 -nan -nan)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 -nan -nan)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 -nan -nan)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 -nan -nan)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 -nan -nan)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 -nan -nan)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 -nan -nan)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 -nan -nan)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 -nan -nan)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 -nan -nan)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 -nan -nan)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 -nan -nan)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan) + (v128.const f64x2 inf inf)) + (v128.const f64x2 -nan -nan)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 -nan -nan)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan) + (v128.const f64x2 0123456789 0123456789)) + (v128.const f64x2 -nan -nan)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan) + (v128.const f64x2 0123456789e019 0123456789e019)) + (v128.const f64x2 -nan -nan)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan) + (v128.const f64x2 0123456789e+019 0123456789e+019)) + (v128.const f64x2 -nan -nan)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan) + (v128.const f64x2 0123456789e-019 0123456789e-019)) + (v128.const f64x2 -nan -nan)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan) + (v128.const f64x2 0123456789. 0123456789.)) + (v128.const f64x2 -nan -nan)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan) + (v128.const f64x2 0123456789.e019 0123456789.e019)) + (v128.const f64x2 -nan -nan)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan) + (v128.const f64x2 0123456789.e+019 0123456789.e+019)) + (v128.const f64x2 -nan -nan)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan) + (v128.const f64x2 0123456789.e-019 0123456789.e-019)) + (v128.const f64x2 -nan -nan)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan) + (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)) + (v128.const f64x2 -nan -nan)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan) + (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f64x2 -nan -nan)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan) + (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f64x2 -nan -nan)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan) + (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f64x2 -nan -nan)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan) + (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)) + (v128.const f64x2 -nan -nan)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan) + (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)) + (v128.const f64x2 -nan -nan)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan) + (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 -nan -nan)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan) + (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 -nan -nan)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan) + (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)) + (v128.const f64x2 -nan -nan)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)) + (v128.const f64x2 -nan -nan)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)) + (v128.const f64x2 -nan -nan)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)) + (v128.const f64x2 -nan -nan)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)) + (v128.const f64x2 -nan -nan)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)) + (v128.const f64x2 -nan -nan)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 -nan -nan)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 -nan -nan)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan) + (v128.const f64x2 nan nan)) + (v128.const f64x2 -nan -nan)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 -nan -nan)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 -nan -nan)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 -nan -nan)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 inf inf)) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 0123456789 0123456789)) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 0123456789e019 0123456789e019)) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 0123456789e+019 0123456789e+019)) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 0123456789e-019 0123456789e-019)) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 0123456789. 0123456789.)) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 0123456789.e019 0123456789.e019)) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 0123456789.e+019 0123456789.e+019)) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 0123456789.e-019 0123456789.e-019)) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 nan nan)) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 inf inf)) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 -inf -inf)) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 0123456789 0123456789)) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 0123456789e019 0123456789e019)) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 0123456789e+019 0123456789e+019)) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 0123456789e-019 0123456789e-019)) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 0123456789. 0123456789.)) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 0123456789.e019 0123456789.e019)) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 0123456789.e+019 0123456789.e+019)) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 0123456789.e-019 0123456789.e-019)) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 nan nan)) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 nan nan)) + (v128.const f64x2 0x0p+0 0x0p+0)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 nan nan)) + (v128.const f64x2 -0x0p+0 -0x0p+0)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 nan nan)) + (v128.const f64x2 0x1p-1022 0x1p-1022)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 nan nan)) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 nan nan)) + (v128.const f64x2 0x1p-1 0x1p-1)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 nan nan)) + (v128.const f64x2 -0x1p-1 -0x1p-1)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 nan nan)) + (v128.const f64x2 0x1p+0 0x1p+0)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 nan nan)) + (v128.const f64x2 -0x1p+0 -0x1p+0)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 nan nan)) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 nan nan)) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 nan nan)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 nan nan)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 nan nan)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 nan nan)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf) + (v128.const f64x2 nan nan)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf) + (v128.const f64x2 nan nan)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789) + (v128.const f64x2 nan nan)) + (v128.const f64x2 0123456789 0123456789)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019) + (v128.const f64x2 nan nan)) + (v128.const f64x2 0123456789e019 0123456789e019)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019) + (v128.const f64x2 nan nan)) + (v128.const f64x2 0123456789e+019 0123456789e+019)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019) + (v128.const f64x2 nan nan)) + (v128.const f64x2 0123456789e-019 0123456789e-019)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.) + (v128.const f64x2 nan nan)) + (v128.const f64x2 0123456789. 0123456789.)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019) + (v128.const f64x2 nan nan)) + (v128.const f64x2 0123456789.e019 0123456789.e019)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019) + (v128.const f64x2 nan nan)) + (v128.const f64x2 0123456789.e+019 0123456789.e+019)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019) + (v128.const f64x2 nan nan)) + (v128.const f64x2 0123456789.e-019 0123456789.e-019)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789) + (v128.const f64x2 nan nan)) + (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f64x2 nan nan)) + (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f64x2 nan nan)) + (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f64x2 nan nan)) + (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef) + (v128.const f64x2 nan nan)) + (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019) + (v128.const f64x2 nan nan)) + (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019) + (v128.const f64x2 nan nan)) + (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019) + (v128.const f64x2 nan nan)) + (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.) + (v128.const f64x2 nan nan)) + (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019) + (v128.const f64x2 nan nan)) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019) + (v128.const f64x2 nan nan)) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019) + (v128.const f64x2 nan nan)) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef) + (v128.const f64x2 nan nan)) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019) + (v128.const f64x2 nan nan)) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019) + (v128.const f64x2 nan nan)) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019) + (v128.const f64x2 nan nan)) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 0x0p+0 0x0p+0)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 -0x0p+0 -0x0p+0)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 0x1p-1022 0x1p-1022)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 0x1p-1 0x1p-1)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 -0x1p-1 -0x1p-1)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 0x1p+0 0x1p+0)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 -0x1p+0 -0x1p+0)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 0123456789 0123456789)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 0123456789e019 0123456789e019)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 0123456789e+019 0123456789e+019)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 0123456789e-019 0123456789e-019)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 0123456789. 0123456789.)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 0123456789.e019 0123456789.e019)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 0123456789.e+019 0123456789.e+019)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 0123456789.e-019 0123456789.e-019)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019) + (v128.const f64x2 -nan -nan)) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 0x0p+0 0x0p+0)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 -0x0p+0 -0x0p+0)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 0x1p-1022 0x1p-1022)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 0x1p-1 0x1p-1)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 -0x1p-1 -0x1p-1)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 0x1p+0 0x1p+0)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 -0x1p+0 -0x1p+0)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 0123456789 0123456789)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 0123456789e019 0123456789e019)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 0123456789e+019 0123456789e+019)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 0123456789e-019 0123456789e-019)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 0123456789. 0123456789.)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 0123456789.e019 0123456789.e019)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 0123456789.e+019 0123456789.e+019)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 0123456789.e-019 0123456789.e-019)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019) + (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 0x0p+0 0x0p+0)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 -0x0p+0 -0x0p+0)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 0x1p-1022 0x1p-1022)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 -0x1p-1022 -0x1p-1022)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 0x1p-1 0x1p-1)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 -0x1p-1 -0x1p-1)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 0x1p+0 0x1p+0)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 -0x1p+0 -0x1p+0)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 0123456789 0123456789)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 0123456789e019 0123456789e019)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 0123456789e+019 0123456789e+019)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 0123456789e-019 0123456789e-019)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 0123456789. 0123456789.)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 0123456789.e019 0123456789.e019)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 0123456789.e+019 0123456789.e+019)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 0123456789.e-019 0123456789.e-019)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)) +(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019) + (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)) + + +;; Unknown operators + +(assert_malformed (module quote "(memory 1) (func (result v128) (i8x16.pmin (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0)))") "unknown operator") +(assert_malformed (module quote "(memory 1) (func (result v128) (i8x16.pmax (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0)))") "unknown operator") +(assert_malformed (module quote "(memory 1) (func (result v128) (i16x8.pmin (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0)))") "unknown operator") +(assert_malformed (module quote "(memory 1) (func (result v128) (i16x8.pmax (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0)))") "unknown operator") +(assert_malformed (module quote "(memory 1) (func (result v128) (i32x4.pmin (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0)))") "unknown operator") +(assert_malformed (module quote "(memory 1) (func (result v128) (i32x4.pmax (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0)))") "unknown operator") +(assert_malformed (module quote "(memory 1) (func (result v128) (i64x2.pmin (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0)))") "unknown operator") +(assert_malformed (module quote "(memory 1) (func (result v128) (i64x2.pmax (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0)))") "unknown operator") + +;; type check +(assert_invalid (module (func (result v128) (f64x2.pmin (i32.const 0) (f32.const 0.0)))) "type mismatch") +(assert_invalid (module (func (result v128) (f64x2.pmax (i32.const 0) (f32.const 0.0)))) "type mismatch") + +;; Test operation with empty argument + +(assert_invalid + (module + (func $f64x2.pmin-1st-arg-empty (result v128) + (f64x2.pmin (v128.const f64x2 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $f64x2.pmin-arg-empty (result v128) + (f64x2.pmin) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $f64x2.pmax-1st-arg-empty (result v128) + (f64x2.pmax (v128.const f64x2 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $f64x2.pmax-arg-empty (result v128) + (f64x2.pmax) + ) + ) + "type mismatch" +) + diff --git a/runtime/near-vm/tests/wast/spec/proposals/simd/simd_f64x2_rounding.wast b/runtime/near-vm/tests/wast/spec/proposals/simd/simd_f64x2_rounding.wast new file mode 100644 index 00000000000..f82c6d2941c --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/proposals/simd/simd_f64x2_rounding.wast @@ -0,0 +1,424 @@ +;; Tests for f64x2 [ceil, floor, trunc, nearest] operations on major boundary values and all special values. + + +(module + (func (export "f64x2.ceil") (param v128) (result v128) (f64x2.ceil (local.get 0))) + (func (export "f64x2.floor") (param v128) (result v128) (f64x2.floor (local.get 0))) + (func (export "f64x2.trunc") (param v128) (result v128) (f64x2.trunc (local.get 0))) + (func (export "f64x2.nearest") (param v128) (result v128) (f64x2.nearest (local.get 0))) +) + +(assert_return (invoke "f64x2.ceil" (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.ceil" (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.ceil" (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.ceil" (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.ceil" (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.ceil" (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.ceil" (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.ceil" (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.ceil" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.c000000000000p+2 0x1.c000000000000p+2)) +(assert_return (invoke "f64x2.ceil" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 -0x1.8000000000000p+2 -0x1.8000000000000p+2)) +(assert_return (invoke "f64x2.ceil" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.ceil" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.ceil" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.ceil" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.ceil" (v128.const f64x2 inf inf)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.ceil" (v128.const f64x2 -inf -inf)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.ceil" (v128.const f64x2 0123456789 0123456789)) + (v128.const f64x2 123456789.0 123456789.0)) +(assert_return (invoke "f64x2.ceil" (v128.const f64x2 0123456789e019 0123456789e019)) + (v128.const f64x2 1.23456789e+27 1.23456789e+27)) +(assert_return (invoke "f64x2.ceil" (v128.const f64x2 0123456789e+019 0123456789e+019)) + (v128.const f64x2 1.23456789e+27 1.23456789e+27)) +(assert_return (invoke "f64x2.ceil" (v128.const f64x2 0123456789e-019 0123456789e-019)) + (v128.const f64x2 1.0 1.0)) +(assert_return (invoke "f64x2.ceil" (v128.const f64x2 0123456789. 0123456789.)) + (v128.const f64x2 123456789.0 123456789.0)) +(assert_return (invoke "f64x2.ceil" (v128.const f64x2 0123456789.e019 0123456789.e019)) + (v128.const f64x2 1.23456789e+27 1.23456789e+27)) +(assert_return (invoke "f64x2.ceil" (v128.const f64x2 0123456789.e+019 0123456789.e+019)) + (v128.const f64x2 1.23456789e+27 1.23456789e+27)) +(assert_return (invoke "f64x2.ceil" (v128.const f64x2 0123456789.e-019 0123456789.e-019)) + (v128.const f64x2 1.0 1.0)) +(assert_return (invoke "f64x2.ceil" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)) + (v128.const f64x2 123456790.0 123456790.0)) +(assert_return (invoke "f64x2.ceil" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f64x2 1.2345678901234569e+27 1.2345678901234569e+27)) +(assert_return (invoke "f64x2.ceil" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f64x2 1.2345678901234569e+27 1.2345678901234569e+27)) +(assert_return (invoke "f64x2.ceil" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f64x2 1.0 1.0)) +(assert_return (invoke "f64x2.ceil" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)) + (v128.const f64x2 1.3754889325393114e+24 1.3754889325393114e+24)) +(assert_return (invoke "f64x2.ceil" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)) + (v128.const f64x2 7.211523414631705e+29 7.211523414631705e+29)) +(assert_return (invoke "f64x2.ceil" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 7.211523414631705e+29 7.211523414631705e+29)) +(assert_return (invoke "f64x2.ceil" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 2.6235369349275807e+18 2.6235369349275807e+18)) +(assert_return (invoke "f64x2.ceil" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)) + (v128.const f64x2 1.3754889325393114e+24 1.3754889325393114e+24)) +(assert_return (invoke "f64x2.ceil" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)) + (v128.const f64x2 7.211523414631705e+29 7.211523414631705e+29)) +(assert_return (invoke "f64x2.ceil" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)) + (v128.const f64x2 7.211523414631705e+29 7.211523414631705e+29)) +(assert_return (invoke "f64x2.ceil" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)) + (v128.const f64x2 2.6235369349275807e+18 2.6235369349275807e+18)) +(assert_return (invoke "f64x2.ceil" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)) + (v128.const f64x2 1.3754889325393114e+24 1.3754889325393114e+24)) +(assert_return (invoke "f64x2.ceil" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)) + (v128.const f64x2 7.211523414631705e+29 7.211523414631705e+29)) +(assert_return (invoke "f64x2.ceil" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 7.211523414631705e+29 7.211523414631705e+29)) +(assert_return (invoke "f64x2.ceil" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 2.6235369349275807e+18 2.6235369349275807e+18)) +(assert_return (invoke "f64x2.ceil" (v128.const f64x2 nan nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.ceil" (v128.const f64x2 -nan -nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.ceil" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.ceil" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.floor" (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.floor" (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.floor" (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.floor" (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.floor" (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.floor" (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.floor" (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.floor" (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.floor" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.8000000000000p+2 0x1.8000000000000p+2)) +(assert_return (invoke "f64x2.floor" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 -0x1.c000000000000p+2 -0x1.c000000000000p+2)) +(assert_return (invoke "f64x2.floor" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.floor" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.floor" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.floor" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.floor" (v128.const f64x2 inf inf)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.floor" (v128.const f64x2 -inf -inf)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.floor" (v128.const f64x2 0123456789 0123456789)) + (v128.const f64x2 123456789.0 123456789.0)) +(assert_return (invoke "f64x2.floor" (v128.const f64x2 0123456789e019 0123456789e019)) + (v128.const f64x2 1.23456789e+27 1.23456789e+27)) +(assert_return (invoke "f64x2.floor" (v128.const f64x2 0123456789e+019 0123456789e+019)) + (v128.const f64x2 1.23456789e+27 1.23456789e+27)) +(assert_return (invoke "f64x2.floor" (v128.const f64x2 0123456789e-019 0123456789e-019)) + (v128.const f64x2 0.0 0.0)) +(assert_return (invoke "f64x2.floor" (v128.const f64x2 0123456789. 0123456789.)) + (v128.const f64x2 123456789.0 123456789.0)) +(assert_return (invoke "f64x2.floor" (v128.const f64x2 0123456789.e019 0123456789.e019)) + (v128.const f64x2 1.23456789e+27 1.23456789e+27)) +(assert_return (invoke "f64x2.floor" (v128.const f64x2 0123456789.e+019 0123456789.e+019)) + (v128.const f64x2 1.23456789e+27 1.23456789e+27)) +(assert_return (invoke "f64x2.floor" (v128.const f64x2 0123456789.e-019 0123456789.e-019)) + (v128.const f64x2 0.0 0.0)) +(assert_return (invoke "f64x2.floor" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)) + (v128.const f64x2 123456789.0 123456789.0)) +(assert_return (invoke "f64x2.floor" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f64x2 1.2345678901234569e+27 1.2345678901234569e+27)) +(assert_return (invoke "f64x2.floor" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f64x2 1.2345678901234569e+27 1.2345678901234569e+27)) +(assert_return (invoke "f64x2.floor" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f64x2 0.0 0.0)) +(assert_return (invoke "f64x2.floor" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)) + (v128.const f64x2 1.3754889325393114e+24 1.3754889325393114e+24)) +(assert_return (invoke "f64x2.floor" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)) + (v128.const f64x2 7.211523414631705e+29 7.211523414631705e+29)) +(assert_return (invoke "f64x2.floor" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 7.211523414631705e+29 7.211523414631705e+29)) +(assert_return (invoke "f64x2.floor" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 2.6235369349275807e+18 2.6235369349275807e+18)) +(assert_return (invoke "f64x2.floor" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)) + (v128.const f64x2 1.3754889325393114e+24 1.3754889325393114e+24)) +(assert_return (invoke "f64x2.floor" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)) + (v128.const f64x2 7.211523414631705e+29 7.211523414631705e+29)) +(assert_return (invoke "f64x2.floor" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)) + (v128.const f64x2 7.211523414631705e+29 7.211523414631705e+29)) +(assert_return (invoke "f64x2.floor" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)) + (v128.const f64x2 2.6235369349275807e+18 2.6235369349275807e+18)) +(assert_return (invoke "f64x2.floor" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)) + (v128.const f64x2 1.3754889325393114e+24 1.3754889325393114e+24)) +(assert_return (invoke "f64x2.floor" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)) + (v128.const f64x2 7.211523414631705e+29 7.211523414631705e+29)) +(assert_return (invoke "f64x2.floor" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 7.211523414631705e+29 7.211523414631705e+29)) +(assert_return (invoke "f64x2.floor" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 2.6235369349275807e+18 2.6235369349275807e+18)) +(assert_return (invoke "f64x2.floor" (v128.const f64x2 nan nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.floor" (v128.const f64x2 -nan -nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.floor" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.floor" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.trunc" (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.trunc" (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.trunc" (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.trunc" (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.trunc" (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.trunc" (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.trunc" (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.trunc" (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.trunc" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.8000000000000p+2 0x1.8000000000000p+2)) +(assert_return (invoke "f64x2.trunc" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 -0x1.8000000000000p+2 -0x1.8000000000000p+2)) +(assert_return (invoke "f64x2.trunc" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.trunc" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.trunc" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.trunc" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.trunc" (v128.const f64x2 inf inf)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.trunc" (v128.const f64x2 -inf -inf)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.trunc" (v128.const f64x2 0123456789 0123456789)) + (v128.const f64x2 123456789.0 123456789.0)) +(assert_return (invoke "f64x2.trunc" (v128.const f64x2 0123456789e019 0123456789e019)) + (v128.const f64x2 1.23456789e+27 1.23456789e+27)) +(assert_return (invoke "f64x2.trunc" (v128.const f64x2 0123456789e+019 0123456789e+019)) + (v128.const f64x2 1.23456789e+27 1.23456789e+27)) +(assert_return (invoke "f64x2.trunc" (v128.const f64x2 0123456789e-019 0123456789e-019)) + (v128.const f64x2 0.0 0.0)) +(assert_return (invoke "f64x2.trunc" (v128.const f64x2 0123456789. 0123456789.)) + (v128.const f64x2 123456789.0 123456789.0)) +(assert_return (invoke "f64x2.trunc" (v128.const f64x2 0123456789.e019 0123456789.e019)) + (v128.const f64x2 1.23456789e+27 1.23456789e+27)) +(assert_return (invoke "f64x2.trunc" (v128.const f64x2 0123456789.e+019 0123456789.e+019)) + (v128.const f64x2 1.23456789e+27 1.23456789e+27)) +(assert_return (invoke "f64x2.trunc" (v128.const f64x2 0123456789.e-019 0123456789.e-019)) + (v128.const f64x2 0.0 0.0)) +(assert_return (invoke "f64x2.trunc" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)) + (v128.const f64x2 123456789.0 123456789.0)) +(assert_return (invoke "f64x2.trunc" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f64x2 1.2345678901234569e+27 1.2345678901234569e+27)) +(assert_return (invoke "f64x2.trunc" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f64x2 1.2345678901234569e+27 1.2345678901234569e+27)) +(assert_return (invoke "f64x2.trunc" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f64x2 0.0 0.0)) +(assert_return (invoke "f64x2.trunc" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)) + (v128.const f64x2 1.3754889325393114e+24 1.3754889325393114e+24)) +(assert_return (invoke "f64x2.trunc" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)) + (v128.const f64x2 7.211523414631705e+29 7.211523414631705e+29)) +(assert_return (invoke "f64x2.trunc" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 7.211523414631705e+29 7.211523414631705e+29)) +(assert_return (invoke "f64x2.trunc" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 2.6235369349275807e+18 2.6235369349275807e+18)) +(assert_return (invoke "f64x2.trunc" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)) + (v128.const f64x2 1.3754889325393114e+24 1.3754889325393114e+24)) +(assert_return (invoke "f64x2.trunc" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)) + (v128.const f64x2 7.211523414631705e+29 7.211523414631705e+29)) +(assert_return (invoke "f64x2.trunc" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)) + (v128.const f64x2 7.211523414631705e+29 7.211523414631705e+29)) +(assert_return (invoke "f64x2.trunc" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)) + (v128.const f64x2 2.6235369349275807e+18 2.6235369349275807e+18)) +(assert_return (invoke "f64x2.trunc" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)) + (v128.const f64x2 1.3754889325393114e+24 1.3754889325393114e+24)) +(assert_return (invoke "f64x2.trunc" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)) + (v128.const f64x2 7.211523414631705e+29 7.211523414631705e+29)) +(assert_return (invoke "f64x2.trunc" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 7.211523414631705e+29 7.211523414631705e+29)) +(assert_return (invoke "f64x2.trunc" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 2.6235369349275807e+18 2.6235369349275807e+18)) +(assert_return (invoke "f64x2.trunc" (v128.const f64x2 nan nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.trunc" (v128.const f64x2 -nan -nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.trunc" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.trunc" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.nearest" (v128.const f64x2 0x0p+0 0x0p+0)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.nearest" (v128.const f64x2 -0x0p+0 -0x0p+0)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.nearest" (v128.const f64x2 0x1p-1022 0x1p-1022)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.nearest" (v128.const f64x2 -0x1p-1022 -0x1p-1022)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.nearest" (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.nearest" (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const f64x2 -0x0.0p+0 -0x0.0p+0)) +(assert_return (invoke "f64x2.nearest" (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.nearest" (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0)) +(assert_return (invoke "f64x2.nearest" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) + (v128.const f64x2 0x1.8000000000000p+2 0x1.8000000000000p+2)) +(assert_return (invoke "f64x2.nearest" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) + (v128.const f64x2 -0x1.8000000000000p+2 -0x1.8000000000000p+2)) +(assert_return (invoke "f64x2.nearest" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) + (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.nearest" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) + (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.nearest" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.nearest" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) + (v128.const f64x2 0x0.0p+0 0x0.0p+0)) +(assert_return (invoke "f64x2.nearest" (v128.const f64x2 inf inf)) + (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.nearest" (v128.const f64x2 -inf -inf)) + (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.nearest" (v128.const f64x2 0123456789 0123456789)) + (v128.const f64x2 123456789.0 123456789.0)) +(assert_return (invoke "f64x2.nearest" (v128.const f64x2 0123456789e019 0123456789e019)) + (v128.const f64x2 1.23456789e+27 1.23456789e+27)) +(assert_return (invoke "f64x2.nearest" (v128.const f64x2 0123456789e+019 0123456789e+019)) + (v128.const f64x2 1.23456789e+27 1.23456789e+27)) +(assert_return (invoke "f64x2.nearest" (v128.const f64x2 0123456789e-019 0123456789e-019)) + (v128.const f64x2 0.0 0.0)) +(assert_return (invoke "f64x2.nearest" (v128.const f64x2 0123456789. 0123456789.)) + (v128.const f64x2 123456789.0 123456789.0)) +(assert_return (invoke "f64x2.nearest" (v128.const f64x2 0123456789.e019 0123456789.e019)) + (v128.const f64x2 1.23456789e+27 1.23456789e+27)) +(assert_return (invoke "f64x2.nearest" (v128.const f64x2 0123456789.e+019 0123456789.e+019)) + (v128.const f64x2 1.23456789e+27 1.23456789e+27)) +(assert_return (invoke "f64x2.nearest" (v128.const f64x2 0123456789.e-019 0123456789.e-019)) + (v128.const f64x2 0.0 0.0)) +(assert_return (invoke "f64x2.nearest" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)) + (v128.const f64x2 123456789.0 123456789.0)) +(assert_return (invoke "f64x2.nearest" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)) + (v128.const f64x2 1.2345678901234569e+27 1.2345678901234569e+27)) +(assert_return (invoke "f64x2.nearest" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)) + (v128.const f64x2 1.2345678901234569e+27 1.2345678901234569e+27)) +(assert_return (invoke "f64x2.nearest" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)) + (v128.const f64x2 0.0 0.0)) +(assert_return (invoke "f64x2.nearest" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)) + (v128.const f64x2 1.3754889325393114e+24 1.3754889325393114e+24)) +(assert_return (invoke "f64x2.nearest" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)) + (v128.const f64x2 7.211523414631705e+29 7.211523414631705e+29)) +(assert_return (invoke "f64x2.nearest" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 7.211523414631705e+29 7.211523414631705e+29)) +(assert_return (invoke "f64x2.nearest" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 2.6235369349275807e+18 2.6235369349275807e+18)) +(assert_return (invoke "f64x2.nearest" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)) + (v128.const f64x2 1.3754889325393114e+24 1.3754889325393114e+24)) +(assert_return (invoke "f64x2.nearest" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)) + (v128.const f64x2 7.211523414631705e+29 7.211523414631705e+29)) +(assert_return (invoke "f64x2.nearest" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)) + (v128.const f64x2 7.211523414631705e+29 7.211523414631705e+29)) +(assert_return (invoke "f64x2.nearest" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)) + (v128.const f64x2 2.6235369349275807e+18 2.6235369349275807e+18)) +(assert_return (invoke "f64x2.nearest" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)) + (v128.const f64x2 1.3754889325393114e+24 1.3754889325393114e+24)) +(assert_return (invoke "f64x2.nearest" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)) + (v128.const f64x2 7.211523414631705e+29 7.211523414631705e+29)) +(assert_return (invoke "f64x2.nearest" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)) + (v128.const f64x2 7.211523414631705e+29 7.211523414631705e+29)) +(assert_return (invoke "f64x2.nearest" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)) + (v128.const f64x2 2.6235369349275807e+18 2.6235369349275807e+18)) +(assert_return (invoke "f64x2.nearest" (v128.const f64x2 nan nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.nearest" (v128.const f64x2 -nan -nan)) + (v128.const f64x2 nan:canonical nan:canonical)) +(assert_return (invoke "f64x2.nearest" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) +(assert_return (invoke "f64x2.nearest" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) + (v128.const f64x2 nan:arithmetic nan:arithmetic)) + + +;; Unknown operators + +(assert_malformed (module quote "(memory 1) (func (result v128) (i8x16.ceil (v128.const i32x4 0 0 0 0)))") "unknown operator") +(assert_malformed (module quote "(memory 1) (func (result v128) (i8x16.floor (v128.const i32x4 0 0 0 0)))") "unknown operator") +(assert_malformed (module quote "(memory 1) (func (result v128) (i8x16.trunc (v128.const i32x4 0 0 0 0)))") "unknown operator") +(assert_malformed (module quote "(memory 1) (func (result v128) (i8x16.nearest (v128.const i32x4 0 0 0 0)))") "unknown operator") +(assert_malformed (module quote "(memory 1) (func (result v128) (i16x8.ceil (v128.const i32x4 0 0 0 0)))") "unknown operator") +(assert_malformed (module quote "(memory 1) (func (result v128) (i16x8.floor (v128.const i32x4 0 0 0 0)))") "unknown operator") +(assert_malformed (module quote "(memory 1) (func (result v128) (i16x8.trunc (v128.const i32x4 0 0 0 0)))") "unknown operator") +(assert_malformed (module quote "(memory 1) (func (result v128) (i16x8.nearest (v128.const i32x4 0 0 0 0)))") "unknown operator") +(assert_malformed (module quote "(memory 1) (func (result v128) (i32x4.ceil (v128.const i32x4 0 0 0 0)))") "unknown operator") +(assert_malformed (module quote "(memory 1) (func (result v128) (i32x4.floor (v128.const i32x4 0 0 0 0)))") "unknown operator") +(assert_malformed (module quote "(memory 1) (func (result v128) (i32x4.trunc (v128.const i32x4 0 0 0 0)))") "unknown operator") +(assert_malformed (module quote "(memory 1) (func (result v128) (i32x4.nearest (v128.const i32x4 0 0 0 0)))") "unknown operator") +(assert_malformed (module quote "(memory 1) (func (result v128) (i64x2.ceil (v128.const i32x4 0 0 0 0)))") "unknown operator") +(assert_malformed (module quote "(memory 1) (func (result v128) (i64x2.floor (v128.const i32x4 0 0 0 0)))") "unknown operator") +(assert_malformed (module quote "(memory 1) (func (result v128) (i64x2.trunc (v128.const i32x4 0 0 0 0)))") "unknown operator") +(assert_malformed (module quote "(memory 1) (func (result v128) (i64x2.nearest (v128.const i32x4 0 0 0 0)))") "unknown operator") + +;; type check +(assert_invalid (module (func (result v128) (f64x2.ceil (i32.const 0)))) "type mismatch") +(assert_invalid (module (func (result v128) (f64x2.floor (i32.const 0)))) "type mismatch") +(assert_invalid (module (func (result v128) (f64x2.trunc (i32.const 0)))) "type mismatch") +(assert_invalid (module (func (result v128) (f64x2.nearest (i32.const 0)))) "type mismatch") + +;; Test operation with empty argument + +(assert_invalid + (module + (func $f64x2.ceil-arg-empty (result v128) + (f64x2.ceil) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $f64x2.floor-arg-empty (result v128) + (f64x2.floor) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $f64x2.trunc-arg-empty (result v128) + (f64x2.trunc) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $f64x2.nearest-arg-empty (result v128) + (f64x2.nearest) + ) + ) + "type mismatch" +) + diff --git a/runtime/near-vm/tests/wast/spec/proposals/simd/simd_i16x8_arith.wast b/runtime/near-vm/tests/wast/spec/proposals/simd/simd_i16x8_arith.wast new file mode 100644 index 00000000000..3dc4d5ed734 --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/proposals/simd/simd_i16x8_arith.wast @@ -0,0 +1,634 @@ +;; Tests for i16x8 arithmetic operations on major boundary values and all special values. + + +(module + (func (export "i16x8.add") (param v128 v128) (result v128) (i16x8.add (local.get 0) (local.get 1))) + (func (export "i16x8.sub") (param v128 v128) (result v128) (i16x8.sub (local.get 0) (local.get 1))) + (func (export "i16x8.mul") (param v128 v128) (result v128) (i16x8.mul (local.get 0) (local.get 1))) + (func (export "i16x8.neg") (param v128) (result v128) (i16x8.neg (local.get 0))) +) + + +;; i16x8.add +(assert_return (invoke "i16x8.add" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i16x8 0 0 0 0 0 0 0 0)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.add" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i16x8 1 1 1 1 1 1 1 1)) + (v128.const i16x8 1 1 1 1 1 1 1 1)) +(assert_return (invoke "i16x8.add" (v128.const i16x8 1 1 1 1 1 1 1 1) + (v128.const i16x8 1 1 1 1 1 1 1 1)) + (v128.const i16x8 2 2 2 2 2 2 2 2)) +(assert_return (invoke "i16x8.add" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "i16x8.add" (v128.const i16x8 1 1 1 1 1 1 1 1) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.add" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i16x8 -2 -2 -2 -2 -2 -2 -2 -2)) +(assert_return (invoke "i16x8.add" (v128.const i16x8 16383 16383 16383 16383 16383 16383 16383 16383) + (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384)) + (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767)) +(assert_return (invoke "i16x8.add" (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384) + (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384)) + (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)) +(assert_return (invoke "i16x8.add" (v128.const i16x8 -16383 -16383 -16383 -16383 -16383 -16383 -16383 -16383) + (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384)) + (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767)) +(assert_return (invoke "i16x8.add" (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384) + (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384)) + (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)) +(assert_return (invoke "i16x8.add" (v128.const i16x8 -16385 -16385 -16385 -16385 -16385 -16385 -16385 -16385) + (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384)) + (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767)) +(assert_return (invoke "i16x8.add" (v128.const i16x8 32765 32765 32765 32765 32765 32765 32765 32765) + (v128.const i16x8 1 1 1 1 1 1 1 1)) + (v128.const i16x8 32766 32766 32766 32766 32766 32766 32766 32766)) +(assert_return (invoke "i16x8.add" (v128.const i16x8 32766 32766 32766 32766 32766 32766 32766 32766) + (v128.const i16x8 1 1 1 1 1 1 1 1)) + (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767)) +(assert_return (invoke "i16x8.add" (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768) + (v128.const i16x8 1 1 1 1 1 1 1 1)) + (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767)) +(assert_return (invoke "i16x8.add" (v128.const i16x8 -32766 -32766 -32766 -32766 -32766 -32766 -32766 -32766) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767)) +(assert_return (invoke "i16x8.add" (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)) +(assert_return (invoke "i16x8.add" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767)) +(assert_return (invoke "i16x8.add" (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767) + (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767)) + (v128.const i16x8 -2 -2 -2 -2 -2 -2 -2 -2)) +(assert_return (invoke "i16x8.add" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768) + (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.add" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768) + (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767)) + (v128.const i16x8 1 1 1 1 1 1 1 1)) +(assert_return (invoke "i16x8.add" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535) + (v128.const i16x8 0 0 0 0 0 0 0 0)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "i16x8.add" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535) + (v128.const i16x8 1 1 1 1 1 1 1 1)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.add" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i16x8 -2 -2 -2 -2 -2 -2 -2 -2)) +(assert_return (invoke "i16x8.add" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535) + (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767)) + (v128.const i16x8 32766 32766 32766 32766 32766 32766 32766 32766)) +(assert_return (invoke "i16x8.add" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535) + (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)) + (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767)) +(assert_return (invoke "i16x8.add" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535) + (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)) + (v128.const i16x8 -2 -2 -2 -2 -2 -2 -2 -2)) +(assert_return (invoke "i16x8.add" (v128.const i16x8 0x3fff 0x3fff 0x3fff 0x3fff 0x3fff 0x3fff 0x3fff 0x3fff) + (v128.const i16x8 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000)) + (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767)) +(assert_return (invoke "i16x8.add" (v128.const i16x8 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000) + (v128.const i16x8 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000)) + (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)) +(assert_return (invoke "i16x8.add" (v128.const i16x8 -0x3fff -0x3fff -0x3fff -0x3fff -0x3fff -0x3fff -0x3fff -0x3fff) + (v128.const i16x8 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000)) + (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767)) +(assert_return (invoke "i16x8.add" (v128.const i16x8 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000) + (v128.const i16x8 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000)) + (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)) +(assert_return (invoke "i16x8.add" (v128.const i16x8 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000) + (v128.const i16x8 -0x4001 -0x4001 -0x4001 -0x4001 -0x4001 -0x4001 -0x4001 -0x4001)) + (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767)) +(assert_return (invoke "i16x8.add" (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff) + (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff)) + (v128.const i16x8 -2 -2 -2 -2 -2 -2 -2 -2)) +(assert_return (invoke "i16x8.add" (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff) + (v128.const i16x8 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01)) + (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)) +(assert_return (invoke "i16x8.add" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000) + (v128.const i16x8 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01)) + (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767)) +(assert_return (invoke "i16x8.add" (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff) + (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "i16x8.add" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000) + (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.add" (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff) + (v128.const i16x8 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.add" (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff) + (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff)) + (v128.const i16x8 -2 -2 -2 -2 -2 -2 -2 -2)) +(assert_return (invoke "i16x8.add" (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff) + (v128.const i8x16 0 0x80 0 0x80 0 0x80 0 0x80 0 0x80 0 0x80 0 0x80 0 0x80)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "i16x8.add" (v128.const i16x8 1 1 1 1 1 1 1 1) + (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.add" (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff) + (v128.const i32x4 0x80008000 0x80008000 0x80008000 0x80008000)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "i16x8.add" (v128.const i16x8 1 1 1 1 1 1 1 1) + (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.add" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000) + (v128.const f32x4 +0.0 +0.0 +0.0 +0.0)) + (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)) +(assert_return (invoke "i16x8.add" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000) + (v128.const f32x4 -0.0 -0.0 -0.0 -0.0)) + (v128.const i16x8 0x8000 0 0x8000 0 0x8000 0 0x8000 0)) +(assert_return (invoke "i16x8.add" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000) + (v128.const f32x4 1.0 1.0 1.0 1.0)) + (v128.const i16x8 0x8000 0xbf80 0x8000 0xbf80 0x8000 0xbf80 0x8000 0xbf80)) +(assert_return (invoke "i16x8.add" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000) + (v128.const f32x4 -1.0 -1.0 -1.0 -1.0)) + (v128.const i16x8 0x8000 0x3f80 0x8000 0x3f80 0x8000 0x3f80 0x8000 0x3f80)) +(assert_return (invoke "i16x8.add" (v128.const i16x8 1 1 1 1 1 1 1 1) + (v128.const f32x4 +inf +inf +inf +inf)) + (v128.const i16x8 0x01 0x7f81 0x01 0x7f81 0x01 0x7f81 0x01 0x7f81)) +(assert_return (invoke "i16x8.add" (v128.const i16x8 1 1 1 1 1 1 1 1) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const i16x8 0x01 0xff81 0x01 0xff81 0x01 0xff81 0x01 0xff81)) +(assert_return (invoke "i16x8.add" (v128.const i16x8 1 1 1 1 1 1 1 1) + (v128.const f32x4 nan nan nan nan)) + (v128.const i16x8 0x01 0x7fc1 0x01 0x7fc1 0x01 0x7fc1 0x01 0x7fc1)) +(assert_return (invoke "i16x8.add" (v128.const i16x8 0 1 2 3 4 5 6 7) + (v128.const i16x8 0 0xffff 0xfffe 0xfffd 0xfffc 0xfffb 0xfffa 0xfff9)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.add" (v128.const i16x8 0 1 2 3 4 5 6 7) + (v128.const i16x8 0 2 4 6 8 10 12 14)) + (v128.const i16x8 0 3 6 9 12 15 18 21)) +(assert_return (invoke "i16x8.add" (v128.const i16x8 012_345 012_345 012_345 012_345 012_345 012_345 012_345 012_345) + (v128.const i16x8 056_789 056_789 056_789 056_789 056_789 056_789 056_789 056_789)) + (v128.const i16x8 03_598 03_598 03_598 03_598 03_598 03_598 03_598 03_598)) +(assert_return (invoke "i16x8.add" (v128.const i16x8 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234) + (v128.const i16x8 0x0_5678 0x0_5678 0x0_5678 0x0_5678 0x0_5678 0x0_5678 0x0_5678 0x0_5678)) + (v128.const i16x8 0x0_68ac 0x0_68ac 0x0_68ac 0x0_68ac 0x0_68ac 0x0_68ac 0x0_68ac 0x0_68ac)) + +;; i16x8.sub +(assert_return (invoke "i16x8.sub" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i16x8 0 0 0 0 0 0 0 0)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.sub" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i16x8 1 1 1 1 1 1 1 1)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "i16x8.sub" (v128.const i16x8 1 1 1 1 1 1 1 1) + (v128.const i16x8 1 1 1 1 1 1 1 1)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.sub" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i16x8 1 1 1 1 1 1 1 1)) +(assert_return (invoke "i16x8.sub" (v128.const i16x8 1 1 1 1 1 1 1 1) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i16x8 2 2 2 2 2 2 2 2)) +(assert_return (invoke "i16x8.sub" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.sub" (v128.const i16x8 16383 16383 16383 16383 16383 16383 16383 16383) + (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "i16x8.sub" (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384) + (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.sub" (v128.const i16x8 -16383 -16383 -16383 -16383 -16383 -16383 -16383 -16383) + (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384)) + (v128.const i16x8 1 1 1 1 1 1 1 1)) +(assert_return (invoke "i16x8.sub" (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384) + (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.sub" (v128.const i16x8 -16385 -16385 -16385 -16385 -16385 -16385 -16385 -16385) + (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "i16x8.sub" (v128.const i16x8 32765 32765 32765 32765 32765 32765 32765 32765) + (v128.const i16x8 1 1 1 1 1 1 1 1)) + (v128.const i16x8 32764 32764 32764 32764 32764 32764 32764 32764)) +(assert_return (invoke "i16x8.sub" (v128.const i16x8 32766 32766 32766 32766 32766 32766 32766 32766) + (v128.const i16x8 1 1 1 1 1 1 1 1)) + (v128.const i16x8 32765 32765 32765 32765 32765 32765 32765 32765)) +(assert_return (invoke "i16x8.sub" (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768) + (v128.const i16x8 1 1 1 1 1 1 1 1)) + (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767)) +(assert_return (invoke "i16x8.sub" (v128.const i16x8 -32766 -32766 -32766 -32766 -32766 -32766 -32766 -32766) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i16x8 -32765 -32765 -32765 -32765 -32765 -32765 -32765 -32765)) +(assert_return (invoke "i16x8.sub" (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i16x8 -32766 -32766 -32766 -32766 -32766 -32766 -32766 -32766)) +(assert_return (invoke "i16x8.sub" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767)) +(assert_return (invoke "i16x8.sub" (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767) + (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.sub" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768) + (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.sub" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768) + (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "i16x8.sub" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535) + (v128.const i16x8 0 0 0 0 0 0 0 0)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "i16x8.sub" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535) + (v128.const i16x8 1 1 1 1 1 1 1 1)) + (v128.const i16x8 -2 -2 -2 -2 -2 -2 -2 -2)) +(assert_return (invoke "i16x8.sub" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.sub" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535) + (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767)) + (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)) +(assert_return (invoke "i16x8.sub" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535) + (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)) + (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767)) +(assert_return (invoke "i16x8.sub" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535) + (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.sub" (v128.const i16x8 0x3fff 0x3fff 0x3fff 0x3fff 0x3fff 0x3fff 0x3fff 0x3fff) + (v128.const i16x8 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "i16x8.sub" (v128.const i16x8 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000) + (v128.const i16x8 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.sub" (v128.const i16x8 -0x3fff -0x3fff -0x3fff -0x3fff -0x3fff -0x3fff -0x3fff -0x3fff) + (v128.const i16x8 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000)) + (v128.const i16x8 1 1 1 1 1 1 1 1)) +(assert_return (invoke "i16x8.sub" (v128.const i16x8 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000) + (v128.const i16x8 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.sub" (v128.const i16x8 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000) + (v128.const i16x8 -0x4001 -0x4001 -0x4001 -0x4001 -0x4001 -0x4001 -0x4001 -0x4001)) + (v128.const i16x8 1 1 1 1 1 1 1 1)) +(assert_return (invoke "i16x8.sub" (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff) + (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.sub" (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff) + (v128.const i16x8 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01)) + (v128.const i16x8 32766 32766 32766 32766 32766 32766 32766 32766)) +(assert_return (invoke "i16x8.sub" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000) + (v128.const i16x8 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01)) + (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767)) +(assert_return (invoke "i16x8.sub" (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff) + (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "i16x8.sub" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000) + (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.sub" (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff) + (v128.const i16x8 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01)) + (v128.const i16x8 -2 -2 -2 -2 -2 -2 -2 -2)) +(assert_return (invoke "i16x8.sub" (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff) + (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.sub" (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff) + (v128.const i8x16 0 0x80 0 0x80 0 0x80 0 0x80 0 0x80 0 0x80 0 0x80 0 0x80)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "i16x8.sub" (v128.const i16x8 1 1 1 1 1 1 1 1) + (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)) + (v128.const i16x8 0x02 0x02 0x02 0x02 0x02 0x02 0x02 0x02)) +(assert_return (invoke "i16x8.sub" (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff) + (v128.const i32x4 0x80008000 0x80008000 0x80008000 0x80008000)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "i16x8.sub" (v128.const i16x8 1 1 1 1 1 1 1 1) + (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff)) + (v128.const i16x8 0x02 0x02 0x02 0x02 0x02 0x02 0x02 0x02)) +(assert_return (invoke "i16x8.sub" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000) + (v128.const f32x4 +0.0 +0.0 +0.0 +0.0)) + (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)) +(assert_return (invoke "i16x8.sub" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000) + (v128.const f32x4 -0.0 -0.0 -0.0 -0.0)) + (v128.const i16x8 0x8000 0 0x8000 0 0x8000 0 0x8000 0)) +(assert_return (invoke "i16x8.sub" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000) + (v128.const f32x4 1.0 1.0 1.0 1.0)) + (v128.const i16x8 0x8000 0x4080 0x8000 0x4080 0x8000 0x4080 0x8000 0x4080)) +(assert_return (invoke "i16x8.sub" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000) + (v128.const f32x4 -1.0 -1.0 -1.0 -1.0)) + (v128.const i16x8 0x8000 0xc080 0x8000 0xc080 0x8000 0xc080 0x8000 0xc080)) +(assert_return (invoke "i16x8.sub" (v128.const i16x8 1 1 1 1 1 1 1 1) + (v128.const f32x4 +inf +inf +inf +inf)) + (v128.const i16x8 0x01 0x8081 0x01 0x8081 0x01 0x8081 0x01 0x8081)) +(assert_return (invoke "i16x8.sub" (v128.const i16x8 1 1 1 1 1 1 1 1) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const i16x8 0x01 0x81 0x01 0x81 0x01 0x81 0x01 0x81)) +(assert_return (invoke "i16x8.sub" (v128.const i16x8 1 1 1 1 1 1 1 1) + (v128.const f32x4 nan nan nan nan)) + (v128.const i16x8 0x01 0x8041 0x01 0x8041 0x01 0x8041 0x01 0x8041)) +(assert_return (invoke "i16x8.sub" (v128.const i16x8 0 1 2 3 4 5 6 7) + (v128.const i16x8 0 0xffff 0xfffe 0xfffd 0xfffc 0xfffb 0xfffa 0xfff9)) + (v128.const i16x8 0 0x02 0x04 0x06 0x08 0x0a 0x0c 0x0e)) +(assert_return (invoke "i16x8.sub" (v128.const i16x8 0 1 2 3 4 5 6 7) + (v128.const i16x8 0 2 4 6 8 10 12 14)) + (v128.const i16x8 0 -1 -2 -3 -4 -5 -6 -7)) +(assert_return (invoke "i16x8.sub" (v128.const i16x8 056_789 056_789 056_789 056_789 056_789 056_789 056_789 056_789) + (v128.const i16x8 012_345 012_345 012_345 012_345 012_345 012_345 012_345 012_345)) + (v128.const i16x8 044_444 044_444 044_444 044_444 044_444 044_444 044_444 044_444)) +(assert_return (invoke "i16x8.sub" (v128.const i16x8 0x0_5678 0x0_5678 0x0_5678 0x0_5678 0x0_5678 0x0_5678 0x0_5678 0x0_5678) + (v128.const i16x8 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234)) + (v128.const i16x8 0x0_4444 0x0_4444 0x0_4444 0x0_4444 0x0_4444 0x0_4444 0x0_4444 0x0_4444)) + +;; i16x8.mul +(assert_return (invoke "i16x8.mul" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i16x8 0 0 0 0 0 0 0 0)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.mul" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i16x8 1 1 1 1 1 1 1 1)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.mul" (v128.const i16x8 1 1 1 1 1 1 1 1) + (v128.const i16x8 1 1 1 1 1 1 1 1)) + (v128.const i16x8 1 1 1 1 1 1 1 1)) +(assert_return (invoke "i16x8.mul" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.mul" (v128.const i16x8 1 1 1 1 1 1 1 1) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "i16x8.mul" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i16x8 1 1 1 1 1 1 1 1)) +(assert_return (invoke "i16x8.mul" (v128.const i16x8 16383 16383 16383 16383 16383 16383 16383 16383) + (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384)) + (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384)) +(assert_return (invoke "i16x8.mul" (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384) + (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.mul" (v128.const i16x8 -16383 -16383 -16383 -16383 -16383 -16383 -16383 -16383) + (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384)) + (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384)) +(assert_return (invoke "i16x8.mul" (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384) + (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.mul" (v128.const i16x8 -16385 -16385 -16385 -16385 -16385 -16385 -16385 -16385) + (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384)) + (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384)) +(assert_return (invoke "i16x8.mul" (v128.const i16x8 32765 32765 32765 32765 32765 32765 32765 32765) + (v128.const i16x8 1 1 1 1 1 1 1 1)) + (v128.const i16x8 32765 32765 32765 32765 32765 32765 32765 32765)) +(assert_return (invoke "i16x8.mul" (v128.const i16x8 32766 32766 32766 32766 32766 32766 32766 32766) + (v128.const i16x8 1 1 1 1 1 1 1 1)) + (v128.const i16x8 32766 32766 32766 32766 32766 32766 32766 32766)) +(assert_return (invoke "i16x8.mul" (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768) + (v128.const i16x8 1 1 1 1 1 1 1 1)) + (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)) +(assert_return (invoke "i16x8.mul" (v128.const i16x8 -32766 -32766 -32766 -32766 -32766 -32766 -32766 -32766) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i16x8 32766 32766 32766 32766 32766 32766 32766 32766)) +(assert_return (invoke "i16x8.mul" (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767)) +(assert_return (invoke "i16x8.mul" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)) +(assert_return (invoke "i16x8.mul" (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767) + (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767)) + (v128.const i16x8 1 1 1 1 1 1 1 1)) +(assert_return (invoke "i16x8.mul" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768) + (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.mul" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768) + (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767)) + (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)) +(assert_return (invoke "i16x8.mul" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535) + (v128.const i16x8 0 0 0 0 0 0 0 0)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.mul" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535) + (v128.const i16x8 1 1 1 1 1 1 1 1)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "i16x8.mul" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i16x8 1 1 1 1 1 1 1 1)) +(assert_return (invoke "i16x8.mul" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535) + (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767)) + (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767)) +(assert_return (invoke "i16x8.mul" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535) + (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)) + (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)) +(assert_return (invoke "i16x8.mul" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535) + (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)) + (v128.const i16x8 1 1 1 1 1 1 1 1)) +(assert_return (invoke "i16x8.mul" (v128.const i16x8 0x3fff 0x3fff 0x3fff 0x3fff 0x3fff 0x3fff 0x3fff 0x3fff) + (v128.const i16x8 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000)) + (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384)) +(assert_return (invoke "i16x8.mul" (v128.const i16x8 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000) + (v128.const i16x8 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.mul" (v128.const i16x8 -0x3fff -0x3fff -0x3fff -0x3fff -0x3fff -0x3fff -0x3fff -0x3fff) + (v128.const i16x8 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000)) + (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384)) +(assert_return (invoke "i16x8.mul" (v128.const i16x8 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000) + (v128.const i16x8 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.mul" (v128.const i16x8 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000) + (v128.const i16x8 -0x4001 -0x4001 -0x4001 -0x4001 -0x4001 -0x4001 -0x4001 -0x4001)) + (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384)) +(assert_return (invoke "i16x8.mul" (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff) + (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff)) + (v128.const i16x8 1 1 1 1 1 1 1 1)) +(assert_return (invoke "i16x8.mul" (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff) + (v128.const i16x8 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01)) + (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767)) +(assert_return (invoke "i16x8.mul" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000) + (v128.const i16x8 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01)) + (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)) +(assert_return (invoke "i16x8.mul" (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff) + (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)) + (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)) +(assert_return (invoke "i16x8.mul" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000) + (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.mul" (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff) + (v128.const i16x8 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "i16x8.mul" (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff) + (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff)) + (v128.const i16x8 1 1 1 1 1 1 1 1)) +(assert_return (invoke "i16x8.mul" (v128.const i16x8 0x1000 0x1000 0x1000 0x1000 0x1000 0x1000 0x1000 0x1000) + (v128.const i8x16 0x10 0x10 0x10 0x10 0x10 0x10 0x10 0x10 0x10 0x10 0x10 0x10 0x10 0x10 0x10 0x10)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.mul" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535) + (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)) + (v128.const i16x8 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01)) +(assert_return (invoke "i16x8.mul" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000) + (v128.const i32x4 0x00020002 0x00020002 0x00020002 0x00020002)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.mul" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535) + (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff)) + (v128.const i16x8 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01)) +(assert_return (invoke "i16x8.mul" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000) + (v128.const f32x4 +0.0 +0.0 +0.0 +0.0)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.mul" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000) + (v128.const f32x4 -0.0 -0.0 -0.0 -0.0)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.mul" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000) + (v128.const f32x4 1.0 1.0 1.0 1.0)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.mul" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000) + (v128.const f32x4 -1.0 -1.0 -1.0 -1.0)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.mul" (v128.const i16x8 1 1 1 1 1 1 1 1) + (v128.const f32x4 +inf +inf +inf +inf)) + (v128.const i16x8 0 0x7f80 0 0x7f80 0 0x7f80 0 0x7f80)) +(assert_return (invoke "i16x8.mul" (v128.const i16x8 1 1 1 1 1 1 1 1) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const i16x8 0 0xff80 0 0xff80 0 0xff80 0 0xff80)) +(assert_return (invoke "i16x8.mul" (v128.const i16x8 1 1 1 1 1 1 1 1) + (v128.const f32x4 nan nan nan nan)) + (v128.const i16x8 0 0x7fc0 0 0x7fc0 0 0x7fc0 0 0x7fc0)) +(assert_return (invoke "i16x8.mul" (v128.const i16x8 0 1 2 3 4 5 6 7) + (v128.const i16x8 0 0xffff 0xfffe 0xfffd 0xfffc 0xfffb 0xfffa 0xfff9)) + (v128.const i16x8 0 0xffff 0xfffc 0xfff7 0xfff0 0xffe7 0xffdc 0xffcf)) +(assert_return (invoke "i16x8.mul" (v128.const i16x8 0 1 2 3 4 5 6 7) + (v128.const i16x8 0 2 4 6 8 10 12 14)) + (v128.const i16x8 0 0x02 0x08 0x12 0x20 0x32 0x48 0x62)) +(assert_return (invoke "i16x8.mul" (v128.const i16x8 012_345 012_345 012_345 012_345 012_345 012_345 012_345 012_345) + (v128.const i16x8 056_789 056_789 056_789 056_789 056_789 056_789 056_789 056_789)) + (v128.const i16x8 021_613 021_613 021_613 021_613 021_613 021_613 021_613 021_613)) +(assert_return (invoke "i16x8.mul" (v128.const i16x8 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234) + (v128.const i16x8 0x0_cdef 0x0_cdef 0x0_cdef 0x0_cdef 0x0_cdef 0x0_cdef 0x0_cdef 0x0_cdef)) + (v128.const i16x8 0x0_a28c 0x0_a28c 0x0_a28c 0x0_a28c 0x0_a28c 0x0_a28c 0x0_a28c 0x0_a28c)) + +;; i16x8.neg +(assert_return (invoke "i16x8.neg" (v128.const i16x8 0 0 0 0 0 0 0 0)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.neg" (v128.const i16x8 1 1 1 1 1 1 1 1)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "i16x8.neg" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i16x8 1 1 1 1 1 1 1 1)) +(assert_return (invoke "i16x8.neg" (v128.const i16x8 32766 32766 32766 32766 32766 32766 32766 32766)) + (v128.const i16x8 -32766 -32766 -32766 -32766 -32766 -32766 -32766 -32766)) +(assert_return (invoke "i16x8.neg" (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767)) + (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767)) +(assert_return (invoke "i16x8.neg" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)) + (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)) +(assert_return (invoke "i16x8.neg" (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767)) + (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767)) +(assert_return (invoke "i16x8.neg" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)) + (v128.const i16x8 1 1 1 1 1 1 1 1)) +(assert_return (invoke "i16x8.neg" (v128.const i16x8 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "i16x8.neg" (v128.const i16x8 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01)) + (v128.const i16x8 1 1 1 1 1 1 1 1)) +(assert_return (invoke "i16x8.neg" (v128.const i16x8 -0x8000 -0x8000 -0x8000 -0x8000 -0x8000 -0x8000 -0x8000 -0x8000)) + (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)) +(assert_return (invoke "i16x8.neg" (v128.const i16x8 -0x7fff -0x7fff -0x7fff -0x7fff -0x7fff -0x7fff -0x7fff -0x7fff)) + (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767)) +(assert_return (invoke "i16x8.neg" (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff)) + (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767)) +(assert_return (invoke "i16x8.neg" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)) + (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)) +(assert_return (invoke "i16x8.neg" (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff)) + (v128.const i16x8 1 1 1 1 1 1 1 1)) + +;; type check +(assert_invalid (module (func (result v128) (i16x8.neg (i32.const 0)))) "type mismatch") +(assert_invalid (module (func (result v128) (i16x8.add (i32.const 0) (f32.const 0.0)))) "type mismatch") +(assert_invalid (module (func (result v128) (i16x8.sub (i32.const 0) (f32.const 0.0)))) "type mismatch") +(assert_invalid (module (func (result v128) (i16x8.mul (i32.const 0) (f32.const 0.0)))) "type mismatch") + +;; Test operation with empty argument + +(assert_invalid + (module + (func $i16x8.neg-arg-empty (result v128) + (i16x8.neg) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i16x8.add-1st-arg-empty (result v128) + (i16x8.add (v128.const i16x8 0 0 0 0 0 0 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i16x8.add-arg-empty (result v128) + (i16x8.add) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i16x8.sub-1st-arg-empty (result v128) + (i16x8.sub (v128.const i16x8 0 0 0 0 0 0 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i16x8.sub-arg-empty (result v128) + (i16x8.sub) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i16x8.mul-1st-arg-empty (result v128) + (i16x8.mul (v128.const i16x8 0 0 0 0 0 0 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i16x8.mul-arg-empty (result v128) + (i16x8.mul) + ) + ) + "type mismatch" +) + +;; combination +(module + (func (export "add-sub") (param v128 v128 v128) (result v128) + (i16x8.add (i16x8.sub (local.get 0) (local.get 1))(local.get 2))) + (func (export "mul-add") (param v128 v128 v128) (result v128) + (i16x8.mul (i16x8.add (local.get 0) (local.get 1))(local.get 2))) + (func (export "mul-sub") (param v128 v128 v128) (result v128) + (i16x8.mul (i16x8.sub (local.get 0) (local.get 1))(local.get 2))) + (func (export "sub-add") (param v128 v128 v128) (result v128) + (i16x8.sub (i16x8.add (local.get 0) (local.get 1))(local.get 2))) + (func (export "add-neg") (param v128 v128) (result v128) + (i16x8.add (i16x8.neg (local.get 0)) (local.get 1))) + (func (export "mul-neg") (param v128 v128) (result v128) + (i16x8.mul (i16x8.neg (local.get 0)) (local.get 1))) + (func (export "sub-neg") (param v128 v128) (result v128) + (i16x8.sub (i16x8.neg (local.get 0)) (local.get 1))) +) + +(assert_return (invoke "add-sub" (v128.const i16x8 0 1 2 3 4 5 6 7) + (v128.const i16x8 0 2 4 6 8 10 12 14) + (v128.const i16x8 0 2 4 6 8 10 12 14)) + (v128.const i16x8 0 1 2 3 4 5 6 7)) +(assert_return (invoke "mul-add" (v128.const i16x8 0 1 2 3 4 5 6 7) + (v128.const i16x8 0 1 2 3 4 5 6 7) + (v128.const i16x8 2 2 2 2 2 2 2 2)) + (v128.const i16x8 0 4 8 12 16 20 24 28)) +(assert_return (invoke "mul-sub" (v128.const i16x8 0 2 4 6 8 10 12 14) + (v128.const i16x8 0 1 2 3 4 5 6 7) + (v128.const i16x8 0 1 2 3 4 5 6 7)) + (v128.const i16x8 0 1 4 9 16 25 36 49)) +(assert_return (invoke "sub-add" (v128.const i16x8 0 1 2 3 4 5 6 7) + (v128.const i16x8 0 2 4 6 8 10 12 14) + (v128.const i16x8 0 2 4 6 8 10 12 14)) + (v128.const i16x8 0 1 2 3 4 5 6 7)) +(assert_return (invoke "add-neg" (v128.const i16x8 0 1 2 3 4 5 6 7) + (v128.const i16x8 0 1 2 3 4 5 6 7)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "mul-neg" (v128.const i16x8 0 1 2 3 4 5 6 7) + (v128.const i16x8 2 2 2 2 2 2 2 2)) + (v128.const i16x8 0 -2 -4 -6 -8 -10 -12 -14)) +(assert_return (invoke "sub-neg" (v128.const i16x8 0 1 2 3 4 5 6 7) + (v128.const i16x8 0 1 2 3 4 5 6 7)) + (v128.const i16x8 0 -2 -4 -6 -8 -10 -12 -14)) \ No newline at end of file diff --git a/runtime/near-vm/tests/wast/spec/proposals/simd/simd_i16x8_arith2.wast b/runtime/near-vm/tests/wast/spec/proposals/simd/simd_i16x8_arith2.wast new file mode 100644 index 00000000000..454f598df42 --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/proposals/simd/simd_i16x8_arith2.wast @@ -0,0 +1,610 @@ +;; Tests for i16x8 [min_s, min_u, max_s, max_u, avgr_u, abs] operations. + +(module + (func (export "i16x8.min_s") (param v128 v128) (result v128) (i16x8.min_s (local.get 0) (local.get 1))) + (func (export "i16x8.min_u") (param v128 v128) (result v128) (i16x8.min_u (local.get 0) (local.get 1))) + (func (export "i16x8.max_s") (param v128 v128) (result v128) (i16x8.max_s (local.get 0) (local.get 1))) + (func (export "i16x8.max_u") (param v128 v128) (result v128) (i16x8.max_u (local.get 0) (local.get 1))) + (func (export "i16x8.avgr_u") (param v128 v128) (result v128) (i16x8.avgr_u (local.get 0) (local.get 1))) + (func (export "i16x8.abs") (param v128) (result v128) (i16x8.abs (local.get 0))) + (func (export "i16x8.min_s_with_const_0") (result v128) (i16x8.min_s (v128.const i16x8 -32768 -32768 32767 32767 16384 16384 65535 65535) (v128.const i16x8 65535 65535 16384 16384 32767 32767 -32768 -32768))) + (func (export "i16x8.min_s_with_const_1") (result v128) (i16x8.min_s (v128.const i16x8 0 0 1 1 2 2 3 3) (v128.const i16x8 3 3 2 2 1 1 0 0))) + (func (export "i16x8.min_u_with_const_2") (result v128) (i16x8.min_u (v128.const i16x8 -32768 -32768 32767 32767 16384 16384 65535 65535) (v128.const i16x8 65535 65535 16384 16384 32767 32767 -32768 -32768))) + (func (export "i16x8.min_u_with_const_3") (result v128) (i16x8.min_u (v128.const i16x8 0 0 1 1 2 2 3 3) (v128.const i16x8 3 3 2 2 1 1 0 0))) + (func (export "i16x8.max_s_with_const_4") (result v128) (i16x8.max_s (v128.const i16x8 -32768 -32768 32767 32767 16384 16384 65535 65535) (v128.const i16x8 65535 65535 16384 16384 32767 32767 -32768 -32768))) + (func (export "i16x8.max_s_with_const_5") (result v128) (i16x8.max_s (v128.const i16x8 0 0 1 1 2 2 3 3) (v128.const i16x8 3 3 2 2 1 1 0 0))) + (func (export "i16x8.max_u_with_const_6") (result v128) (i16x8.max_u (v128.const i16x8 -32768 -32768 32767 32767 16384 16384 65535 65535) (v128.const i16x8 65535 65535 16384 16384 32767 32767 -32768 -32768))) + (func (export "i16x8.max_u_with_const_7") (result v128) (i16x8.max_u (v128.const i16x8 0 0 1 1 2 2 3 3) (v128.const i16x8 3 3 2 2 1 1 0 0))) + (func (export "i16x8.avgr_u_with_const_8") (result v128) (i16x8.avgr_u (v128.const i16x8 -32768 -32768 32767 32767 16384 16384 65535 65535) (v128.const i16x8 65535 65535 16384 16384 32767 32767 -32768 -32768))) + (func (export "i16x8.avgr_u_with_const_9") (result v128) (i16x8.avgr_u (v128.const i16x8 0 0 1 1 2 2 3 3) (v128.const i16x8 3 3 2 2 1 1 0 0))) + (func (export "i16x8.abs_with_const_10") (result v128) (i16x8.abs (v128.const i16x8 -32768 -32768 32767 32767 16384 16384 65535 65535))) + (func (export "i16x8.min_s_with_const_11") (param v128) (result v128) (i16x8.min_s (local.get 0) (v128.const i16x8 -32768 -32768 32767 32767 16384 16384 65535 65535))) + (func (export "i16x8.min_s_with_const_12") (param v128) (result v128) (i16x8.min_s (local.get 0) (v128.const i16x8 0 0 1 1 2 2 3 3))) + (func (export "i16x8.min_u_with_const_13") (param v128) (result v128) (i16x8.min_u (local.get 0) (v128.const i16x8 -32768 -32768 32767 32767 16384 16384 65535 65535))) + (func (export "i16x8.min_u_with_const_14") (param v128) (result v128) (i16x8.min_u (local.get 0) (v128.const i16x8 0 0 1 1 2 2 3 3))) + (func (export "i16x8.max_s_with_const_15") (param v128) (result v128) (i16x8.max_s (local.get 0) (v128.const i16x8 -32768 -32768 32767 32767 16384 16384 65535 65535))) + (func (export "i16x8.max_s_with_const_16") (param v128) (result v128) (i16x8.max_s (local.get 0) (v128.const i16x8 0 0 1 1 2 2 3 3))) + (func (export "i16x8.max_u_with_const_17") (param v128) (result v128) (i16x8.max_u (local.get 0) (v128.const i16x8 -32768 -32768 32767 32767 16384 16384 65535 65535))) + (func (export "i16x8.max_u_with_const_18") (param v128) (result v128) (i16x8.max_u (local.get 0) (v128.const i16x8 0 0 1 1 2 2 3 3))) + (func (export "i16x8.avgr_u_with_const_19") (param v128) (result v128) (i16x8.avgr_u (local.get 0) (v128.const i16x8 -32768 -32768 32767 32767 16384 16384 65535 65535))) + (func (export "i16x8.avgr_u_with_const_20") (param v128) (result v128) (i16x8.avgr_u (local.get 0) (v128.const i16x8 0 0 1 1 2 2 3 3))) +) + +(assert_return (invoke "i16x8.min_s" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i16x8 0 0 0 0 0 0 0 0)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.min_s" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "i16x8.min_s" (v128.const i16x8 0 0 0 0 -1 -1 -1 -1) + (v128.const i16x8 0 0 -1 -1 0 0 -1 -1)) + (v128.const i16x8 0 0 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "i16x8.min_s" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff)) + (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff)) +(assert_return (invoke "i16x8.min_s" (v128.const i16x8 1 1 1 1 1 1 1 1) + (v128.const i16x8 1 1 1 1 1 1 1 1)) + (v128.const i16x8 1 1 1 1 1 1 1 1)) +(assert_return (invoke "i16x8.min_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535) + (v128.const i16x8 1 1 1 1 1 1 1 1)) + (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)) +(assert_return (invoke "i16x8.min_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535) + (v128.const i16x8 128 128 128 128 128 128 128 128)) + (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)) +(assert_return (invoke "i16x8.min_s" (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768) + (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)) + (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768)) +(assert_return (invoke "i16x8.min_s" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000) + (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)) + (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)) +(assert_return (invoke "i16x8.min_s" (v128.const i16x8 123 123 123 123 123 123 123 123) + (v128.const i16x8 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3)) + (v128.const i16x8 123 123 123 123 123 123 123 123)) +(assert_return (invoke "i16x8.min_s" (v128.const i16x8 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80) + (v128.const i16x8 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0)) + (v128.const i16x8 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)) +(assert_return (invoke "i16x8.min_u" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i16x8 0 0 0 0 0 0 0 0)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.min_u" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.min_u" (v128.const i16x8 0 0 0 0 -1 -1 -1 -1) + (v128.const i16x8 0 0 -1 -1 0 0 -1 -1)) + (v128.const i16x8 0 0 0 0 0 0 -1 -1)) +(assert_return (invoke "i16x8.min_u" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.min_u" (v128.const i16x8 1 1 1 1 1 1 1 1) + (v128.const i16x8 1 1 1 1 1 1 1 1)) + (v128.const i16x8 1 1 1 1 1 1 1 1)) +(assert_return (invoke "i16x8.min_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535) + (v128.const i16x8 1 1 1 1 1 1 1 1)) + (v128.const i16x8 1 1 1 1 1 1 1 1)) +(assert_return (invoke "i16x8.min_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535) + (v128.const i16x8 128 128 128 128 128 128 128 128)) + (v128.const i16x8 128 128 128 128 128 128 128 128)) +(assert_return (invoke "i16x8.min_u" (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768) + (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)) + (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768)) +(assert_return (invoke "i16x8.min_u" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000) + (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)) + (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)) +(assert_return (invoke "i16x8.min_u" (v128.const i16x8 123 123 123 123 123 123 123 123) + (v128.const i16x8 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3)) + (v128.const i16x8 123 123 123 123 123 123 123 123)) +(assert_return (invoke "i16x8.min_u" (v128.const i16x8 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80) + (v128.const i16x8 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0)) + (v128.const i16x8 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)) +(assert_return (invoke "i16x8.max_s" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i16x8 0 0 0 0 0 0 0 0)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.max_s" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.max_s" (v128.const i16x8 0 0 0 0 -1 -1 -1 -1) + (v128.const i16x8 0 0 -1 -1 0 0 -1 -1)) + (v128.const i16x8 0 0 0 0 0 0 -1 -1)) +(assert_return (invoke "i16x8.max_s" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.max_s" (v128.const i16x8 1 1 1 1 1 1 1 1) + (v128.const i16x8 1 1 1 1 1 1 1 1)) + (v128.const i16x8 1 1 1 1 1 1 1 1)) +(assert_return (invoke "i16x8.max_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535) + (v128.const i16x8 1 1 1 1 1 1 1 1)) + (v128.const i16x8 1 1 1 1 1 1 1 1)) +(assert_return (invoke "i16x8.max_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535) + (v128.const i16x8 128 128 128 128 128 128 128 128)) + (v128.const i16x8 128 128 128 128 128 128 128 128)) +(assert_return (invoke "i16x8.max_s" (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768) + (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)) + (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768)) +(assert_return (invoke "i16x8.max_s" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000) + (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)) + (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)) +(assert_return (invoke "i16x8.max_s" (v128.const i16x8 123 123 123 123 123 123 123 123) + (v128.const i16x8 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3)) + (v128.const i16x8 123 123 123 123 123 123 123 123)) +(assert_return (invoke "i16x8.max_s" (v128.const i16x8 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80) + (v128.const i16x8 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0)) + (v128.const i16x8 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)) +(assert_return (invoke "i16x8.max_u" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i16x8 0 0 0 0 0 0 0 0)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.max_u" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "i16x8.max_u" (v128.const i16x8 0 0 0 0 -1 -1 -1 -1) + (v128.const i16x8 0 0 -1 -1 0 0 -1 -1)) + (v128.const i16x8 0 0 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "i16x8.max_u" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff)) + (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff)) +(assert_return (invoke "i16x8.max_u" (v128.const i16x8 1 1 1 1 1 1 1 1) + (v128.const i16x8 1 1 1 1 1 1 1 1)) + (v128.const i16x8 1 1 1 1 1 1 1 1)) +(assert_return (invoke "i16x8.max_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535) + (v128.const i16x8 1 1 1 1 1 1 1 1)) + (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)) +(assert_return (invoke "i16x8.max_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535) + (v128.const i16x8 128 128 128 128 128 128 128 128)) + (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)) +(assert_return (invoke "i16x8.max_u" (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768) + (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)) + (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768)) +(assert_return (invoke "i16x8.max_u" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000) + (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)) + (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)) +(assert_return (invoke "i16x8.max_u" (v128.const i16x8 123 123 123 123 123 123 123 123) + (v128.const i16x8 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3)) + (v128.const i16x8 123 123 123 123 123 123 123 123)) +(assert_return (invoke "i16x8.max_u" (v128.const i16x8 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80) + (v128.const i16x8 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0)) + (v128.const i16x8 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)) +(assert_return (invoke "i16x8.avgr_u" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i16x8 0 0 0 0 0 0 0 0)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.avgr_u" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768)) +(assert_return (invoke "i16x8.avgr_u" (v128.const i16x8 0 0 0 0 -1 -1 -1 -1) + (v128.const i16x8 0 0 -1 -1 0 0 -1 -1)) + (v128.const i16x8 0 0 32768 32768 32768 32768 65535 65535)) +(assert_return (invoke "i16x8.avgr_u" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff)) + (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)) +(assert_return (invoke "i16x8.avgr_u" (v128.const i16x8 1 1 1 1 1 1 1 1) + (v128.const i16x8 1 1 1 1 1 1 1 1)) + (v128.const i16x8 1 1 1 1 1 1 1 1)) +(assert_return (invoke "i16x8.avgr_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535) + (v128.const i16x8 1 1 1 1 1 1 1 1)) + (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768)) +(assert_return (invoke "i16x8.avgr_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535) + (v128.const i16x8 128 128 128 128 128 128 128 128)) + (v128.const i16x8 32832 32832 32832 32832 32832 32832 32832 32832)) +(assert_return (invoke "i16x8.avgr_u" (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768) + (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)) + (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768)) +(assert_return (invoke "i16x8.avgr_u" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000) + (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)) + (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)) +(assert_return (invoke "i16x8.avgr_u" (v128.const i16x8 123 123 123 123 123 123 123 123) + (v128.const i16x8 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3)) + (v128.const i16x8 123 123 123 123 123 123 123 123)) +(assert_return (invoke "i16x8.avgr_u" (v128.const i16x8 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80) + (v128.const i16x8 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0)) + (v128.const i16x8 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)) +(assert_return (invoke "i16x8.abs" (v128.const i16x8 1 1 1 1 1 1 1 1)) + (v128.const i16x8 1 1 1 1 1 1 1 1)) +(assert_return (invoke "i16x8.abs" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i16x8 1 1 1 1 1 1 1 1)) +(assert_return (invoke "i16x8.abs" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)) + (v128.const i16x8 1 1 1 1 1 1 1 1)) +(assert_return (invoke "i16x8.abs" (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff)) + (v128.const i16x8 0x1 0x1 0x1 0x1 0x1 0x1 0x1 0x1)) +(assert_return (invoke "i16x8.abs" (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768)) + (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768)) +(assert_return (invoke "i16x8.abs" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)) + (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768)) +(assert_return (invoke "i16x8.abs" (v128.const i16x8 -0x8000 -0x8000 -0x8000 -0x8000 -0x8000 -0x8000 -0x8000 -0x8000)) + (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)) +(assert_return (invoke "i16x8.abs" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)) + (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)) +(assert_return (invoke "i16x8.abs" (v128.const i16x8 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3)) + (v128.const i16x8 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3)) +(assert_return (invoke "i16x8.abs" (v128.const i16x8 -01_2_3 -01_2_3 -01_2_3 -01_2_3 -01_2_3 -01_2_3 -01_2_3 -01_2_3)) + (v128.const i16x8 123 123 123 123 123 123 123 123)) +(assert_return (invoke "i16x8.abs" (v128.const i16x8 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)) + (v128.const i16x8 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)) +(assert_return (invoke "i16x8.abs" (v128.const i16x8 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80)) + (v128.const i16x8 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)) +(assert_return (invoke "i16x8.abs" (v128.const i16x8 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0)) + (v128.const i16x8 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0)) +(assert_return (invoke "i16x8.abs" (v128.const i16x8 -0x0_8_0 -0x0_8_0 -0x0_8_0 -0x0_8_0 -0x0_8_0 -0x0_8_0 -0x0_8_0 -0x0_8_0)) + (v128.const i16x8 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)) + +;; Const vs const +(assert_return (invoke "i16x8.min_s_with_const_0") (v128.const i16x8 -32768 -32768 16384 16384 16384 16384 -32768 -32768)) +(assert_return (invoke "i16x8.min_s_with_const_1") (v128.const i16x8 0 0 1 1 1 1 0 0)) +(assert_return (invoke "i16x8.min_u_with_const_2") (v128.const i16x8 -32768 -32768 16384 16384 16384 16384 -32768 -32768)) +(assert_return (invoke "i16x8.min_u_with_const_3") (v128.const i16x8 0 0 1 1 1 1 0 0)) +(assert_return (invoke "i16x8.max_s_with_const_4") (v128.const i16x8 65535 65535 32767 32767 32767 32767 65535 65535)) +(assert_return (invoke "i16x8.max_s_with_const_5") (v128.const i16x8 3 3 2 2 2 2 3 3)) +(assert_return (invoke "i16x8.max_u_with_const_6") (v128.const i16x8 65535 65535 32767 32767 32767 32767 65535 65535)) +(assert_return (invoke "i16x8.max_u_with_const_7") (v128.const i16x8 3 3 2 2 2 2 3 3)) +(assert_return (invoke "i16x8.avgr_u_with_const_8") (v128.const i16x8 49152 49152 24576 24576 24576 24576 49152 49152)) +(assert_return (invoke "i16x8.avgr_u_with_const_9") (v128.const i16x8 2 2 2 2 2 2 2 2)) +(assert_return (invoke "i16x8.abs_with_const_10") (v128.const i16x8 32768 32768 32767 32767 16384 16384 1 1)) + +;; Param vs const +(assert_return (invoke "i16x8.min_s_with_const_11" (v128.const i16x8 65535 65535 16384 16384 32767 32767 -32768 -32768)) + (v128.const i16x8 -32768 -32768 16384 16384 16384 16384 -32768 -32768)) +(assert_return (invoke "i16x8.min_s_with_const_12" (v128.const i16x8 3 3 2 2 1 1 0 0)) + (v128.const i16x8 0 0 1 1 1 1 0 0)) +(assert_return (invoke "i16x8.min_u_with_const_13" (v128.const i16x8 65535 65535 16384 16384 32767 32767 -32768 -32768)) + (v128.const i16x8 -32768 -32768 16384 16384 16384 16384 -32768 -32768)) +(assert_return (invoke "i16x8.min_u_with_const_14" (v128.const i16x8 3 3 2 2 1 1 0 0)) + (v128.const i16x8 0 0 1 1 1 1 0 0)) +(assert_return (invoke "i16x8.max_s_with_const_15" (v128.const i16x8 65535 65535 16384 16384 32767 32767 -32768 -32768)) + (v128.const i16x8 65535 65535 32767 32767 32767 32767 65535 65535)) +(assert_return (invoke "i16x8.max_s_with_const_16" (v128.const i16x8 3 3 2 2 1 1 0 0)) + (v128.const i16x8 3 3 2 2 2 2 3 3)) +(assert_return (invoke "i16x8.max_u_with_const_17" (v128.const i16x8 65535 65535 16384 16384 32767 32767 -32768 -32768)) + (v128.const i16x8 65535 65535 32767 32767 32767 32767 65535 65535)) +(assert_return (invoke "i16x8.max_u_with_const_18" (v128.const i16x8 3 3 2 2 1 1 0 0)) + (v128.const i16x8 3 3 2 2 2 2 3 3)) +(assert_return (invoke "i16x8.avgr_u_with_const_19" (v128.const i16x8 65535 65535 16384 16384 32767 32767 -32768 -32768)) + (v128.const i16x8 49152 49152 24576 24576 24576 24576 49152 49152)) +(assert_return (invoke "i16x8.avgr_u_with_const_20" (v128.const i16x8 3 3 2 2 1 1 0 0)) + (v128.const i16x8 2 2 2 2 2 2 2 2)) + +;; Test different lanes go through different if-then clauses +(assert_return (invoke "i16x8.min_s" (v128.const i16x8 -32768 -32768 32767 32767 16384 16384 65535 65535) + (v128.const i16x8 65535 65535 16384 16384 32767 32767 -32768 -32768)) + (v128.const i16x8 -32768 -32768 16384 16384 16384 16384 -32768 -32768)) +(assert_return (invoke "i16x8.min_s" (v128.const i16x8 0 0 1 1 2 2 128 128) + (v128.const i16x8 0 0 2 2 1 1 128 128)) + (v128.const i16x8 0 0 1 1 1 1 128 128)) +(assert_return (invoke "i16x8.min_u" (v128.const i16x8 -32768 -32768 32767 32767 16384 16384 65535 65535) + (v128.const i16x8 65535 65535 16384 16384 32767 32767 -32768 -32768)) + (v128.const i16x8 -32768 -32768 16384 16384 16384 16384 -32768 -32768)) +(assert_return (invoke "i16x8.min_u" (v128.const i16x8 0 0 1 1 2 2 128 128) + (v128.const i16x8 0 0 2 2 1 1 128 128)) + (v128.const i16x8 0 0 1 1 1 1 128 128)) +(assert_return (invoke "i16x8.max_s" (v128.const i16x8 -32768 -32768 32767 32767 16384 16384 65535 65535) + (v128.const i16x8 65535 65535 16384 16384 32767 32767 -32768 -32768)) + (v128.const i16x8 65535 65535 32767 32767 32767 32767 65535 65535)) +(assert_return (invoke "i16x8.max_s" (v128.const i16x8 0 0 1 1 2 2 128 128) + (v128.const i16x8 0 0 2 2 1 1 128 128)) + (v128.const i16x8 0 0 2 2 2 2 128 128)) +(assert_return (invoke "i16x8.max_u" (v128.const i16x8 -32768 -32768 32767 32767 16384 16384 65535 65535) + (v128.const i16x8 65535 65535 16384 16384 32767 32767 -32768 -32768)) + (v128.const i16x8 65535 65535 32767 32767 32767 32767 65535 65535)) +(assert_return (invoke "i16x8.max_u" (v128.const i16x8 0 0 1 1 2 2 128 128) + (v128.const i16x8 0 0 2 2 1 1 128 128)) + (v128.const i16x8 0 0 2 2 2 2 128 128)) +(assert_return (invoke "i16x8.avgr_u" (v128.const i16x8 -32768 -32768 32767 32767 16384 16384 65535 65535) + (v128.const i16x8 65535 65535 16384 16384 32767 32767 -32768 -32768)) + (v128.const i16x8 49152 49152 24576 24576 24576 24576 49152 49152)) +(assert_return (invoke "i16x8.avgr_u" (v128.const i16x8 0 0 1 1 2 2 128 128) + (v128.const i16x8 0 0 2 2 1 1 128 128)) + (v128.const i16x8 0 0 2 2 2 2 128 128)) +(assert_return (invoke "i16x8.abs" (v128.const i16x8 -32768 -32768 32767 32767 16384 16384 65535 65535)) + (v128.const i16x8 32768 32768 32767 32767 16384 16384 1 1)) + +;; Test opposite signs of zero +(assert_return (invoke "i16x8.min_s" (v128.const i16x8 -0 -0 -0 -0 +0 +0 +0 +0) + (v128.const i16x8 +0 +0 0 0 -0 -0 0 0)) + (v128.const i16x8 -0 -0 -0 -0 +0 +0 +0 +0)) +(assert_return (invoke "i16x8.min_s" (v128.const i16x8 -0 -0 -0 -0 -0 -0 -0 -0) + (v128.const i16x8 +0 +0 +0 +0 +0 +0 +0 +0)) + (v128.const i16x8 -0 -0 -0 -0 -0 -0 -0 -0)) +(assert_return (invoke "i16x8.min_u" (v128.const i16x8 -0 -0 -0 -0 +0 +0 +0 +0) + (v128.const i16x8 +0 +0 0 0 -0 -0 0 0)) + (v128.const i16x8 -0 -0 -0 -0 +0 +0 +0 +0)) +(assert_return (invoke "i16x8.min_u" (v128.const i16x8 -0 -0 -0 -0 -0 -0 -0 -0) + (v128.const i16x8 +0 +0 +0 +0 +0 +0 +0 +0)) + (v128.const i16x8 -0 -0 -0 -0 -0 -0 -0 -0)) +(assert_return (invoke "i16x8.max_s" (v128.const i16x8 -0 -0 -0 -0 +0 +0 +0 +0) + (v128.const i16x8 +0 +0 0 0 -0 -0 0 0)) + (v128.const i16x8 -0 -0 -0 -0 +0 +0 +0 +0)) +(assert_return (invoke "i16x8.max_s" (v128.const i16x8 -0 -0 -0 -0 -0 -0 -0 -0) + (v128.const i16x8 +0 +0 +0 +0 +0 +0 +0 +0)) + (v128.const i16x8 -0 -0 -0 -0 -0 -0 -0 -0)) +(assert_return (invoke "i16x8.max_u" (v128.const i16x8 -0 -0 -0 -0 +0 +0 +0 +0) + (v128.const i16x8 +0 +0 0 0 -0 -0 0 0)) + (v128.const i16x8 -0 -0 -0 -0 +0 +0 +0 +0)) +(assert_return (invoke "i16x8.max_u" (v128.const i16x8 -0 -0 -0 -0 -0 -0 -0 -0) + (v128.const i16x8 +0 +0 +0 +0 +0 +0 +0 +0)) + (v128.const i16x8 -0 -0 -0 -0 -0 -0 -0 -0)) +(assert_return (invoke "i16x8.avgr_u" (v128.const i16x8 -0 -0 -0 -0 +0 +0 +0 +0) + (v128.const i16x8 +0 +0 0 0 -0 -0 0 0)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.avgr_u" (v128.const i16x8 -0 -0 -0 -0 -0 -0 -0 -0) + (v128.const i16x8 +0 +0 +0 +0 +0 +0 +0 +0)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.abs" (v128.const i16x8 -0 -0 -0 -0 +0 +0 +0 +0)) + (v128.const i16x8 -0 -0 -0 -0 +0 +0 +0 +0)) +(assert_return (invoke "i16x8.abs" (v128.const i16x8 +0 +0 0 0 -0 -0 0 0)) + (v128.const i16x8 +0 +0 0 0 -0 -0 0 0)) +(assert_return (invoke "i16x8.abs" (v128.const i16x8 -0 -0 -0 -0 -0 -0 -0 -0)) + (v128.const i16x8 -0 -0 -0 -0 -0 -0 -0 -0)) +(assert_return (invoke "i16x8.abs" (v128.const i16x8 +0 +0 +0 +0 +0 +0 +0 +0)) + (v128.const i16x8 +0 +0 +0 +0 +0 +0 +0 +0)) + +;; Unknown operators +(assert_malformed (module quote "(memory 1) (func (result v128) (i16x8.avgr (v128.const i16x8 0 0 0 0 0 0 0 0) (v128.const i16x8 1 1 1 1 1 1 1 1)))") "unknown operator") +(assert_malformed (module quote "(memory 1) (func (result v128) (i16x8.avgr_s (v128.const i16x8 0 0 0 0 0 0 0 0) (v128.const i16x8 1 1 1 1 1 1 1 1)))") "unknown operator") + +;; Type check +(assert_invalid (module (func (result v128) (i16x8.min_s (i32.const 0) (f32.const 0.0)))) "type mismatch") +(assert_invalid (module (func (result v128) (i16x8.min_u (i32.const 0) (f32.const 0.0)))) "type mismatch") +(assert_invalid (module (func (result v128) (i16x8.max_s (i32.const 0) (f32.const 0.0)))) "type mismatch") +(assert_invalid (module (func (result v128) (i16x8.max_u (i32.const 0) (f32.const 0.0)))) "type mismatch") +(assert_invalid (module (func (result v128) (i16x8.avgr_u (i32.const 0) (f32.const 0.0)))) "type mismatch") +(assert_invalid (module (func (result v128) (i16x8.abs (f32.const 0.0)))) "type mismatch") + +;; Test operation with empty argument + +(assert_invalid + (module + (func $i16x8.min_s-1st-arg-empty (result v128) + (i16x8.min_s (v128.const i16x8 0 0 0 0 0 0 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i16x8.min_s-arg-empty (result v128) + (i16x8.min_s) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i16x8.min_u-1st-arg-empty (result v128) + (i16x8.min_u (v128.const i16x8 0 0 0 0 0 0 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i16x8.min_u-arg-empty (result v128) + (i16x8.min_u) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i16x8.max_s-1st-arg-empty (result v128) + (i16x8.max_s (v128.const i16x8 0 0 0 0 0 0 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i16x8.max_s-arg-empty (result v128) + (i16x8.max_s) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i16x8.max_u-1st-arg-empty (result v128) + (i16x8.max_u (v128.const i16x8 0 0 0 0 0 0 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i16x8.max_u-arg-empty (result v128) + (i16x8.max_u) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i16x8.avgr_u-1st-arg-empty (result v128) + (i16x8.avgr_u (v128.const i16x8 0 0 0 0 0 0 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i16x8.avgr_u-arg-empty (result v128) + (i16x8.avgr_u) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i16x8.abs-arg-empty (result v128) + (i16x8.abs) + ) + ) + "type mismatch" +) + +;; Combination +(module + (func (export "i16x8.min_s-i16x8.avgr_u") (param v128 v128 v128) (result v128) (i16x8.min_s (i16x8.avgr_u (local.get 0) (local.get 1))(local.get 2))) + (func (export "i16x8.min_s-i16x8.max_u") (param v128 v128 v128) (result v128) (i16x8.min_s (i16x8.max_u (local.get 0) (local.get 1))(local.get 2))) + (func (export "i16x8.min_s-i16x8.max_s") (param v128 v128 v128) (result v128) (i16x8.min_s (i16x8.max_s (local.get 0) (local.get 1))(local.get 2))) + (func (export "i16x8.min_s-i16x8.min_u") (param v128 v128 v128) (result v128) (i16x8.min_s (i16x8.min_u (local.get 0) (local.get 1))(local.get 2))) + (func (export "i16x8.min_s-i16x8.min_s") (param v128 v128 v128) (result v128) (i16x8.min_s (i16x8.min_s (local.get 0) (local.get 1))(local.get 2))) + (func (export "i16x8.min_s-i16x8.abs") (param v128 v128) (result v128) (i16x8.min_s (i16x8.abs (local.get 0))(local.get 1))) + (func (export "i16x8.abs-i16x8.min_s") (param v128 v128) (result v128) (i16x8.abs (i16x8.min_s (local.get 0) (local.get 1)))) + (func (export "i16x8.min_u-i16x8.avgr_u") (param v128 v128 v128) (result v128) (i16x8.min_u (i16x8.avgr_u (local.get 0) (local.get 1))(local.get 2))) + (func (export "i16x8.min_u-i16x8.max_u") (param v128 v128 v128) (result v128) (i16x8.min_u (i16x8.max_u (local.get 0) (local.get 1))(local.get 2))) + (func (export "i16x8.min_u-i16x8.max_s") (param v128 v128 v128) (result v128) (i16x8.min_u (i16x8.max_s (local.get 0) (local.get 1))(local.get 2))) + (func (export "i16x8.min_u-i16x8.min_u") (param v128 v128 v128) (result v128) (i16x8.min_u (i16x8.min_u (local.get 0) (local.get 1))(local.get 2))) + (func (export "i16x8.min_u-i16x8.min_s") (param v128 v128 v128) (result v128) (i16x8.min_u (i16x8.min_s (local.get 0) (local.get 1))(local.get 2))) + (func (export "i16x8.min_u-i16x8.abs") (param v128 v128) (result v128) (i16x8.min_u (i16x8.abs (local.get 0))(local.get 1))) + (func (export "i16x8.abs-i16x8.min_u") (param v128 v128) (result v128) (i16x8.abs (i16x8.min_u (local.get 0) (local.get 1)))) + (func (export "i16x8.max_s-i16x8.avgr_u") (param v128 v128 v128) (result v128) (i16x8.max_s (i16x8.avgr_u (local.get 0) (local.get 1))(local.get 2))) + (func (export "i16x8.max_s-i16x8.max_u") (param v128 v128 v128) (result v128) (i16x8.max_s (i16x8.max_u (local.get 0) (local.get 1))(local.get 2))) + (func (export "i16x8.max_s-i16x8.max_s") (param v128 v128 v128) (result v128) (i16x8.max_s (i16x8.max_s (local.get 0) (local.get 1))(local.get 2))) + (func (export "i16x8.max_s-i16x8.min_u") (param v128 v128 v128) (result v128) (i16x8.max_s (i16x8.min_u (local.get 0) (local.get 1))(local.get 2))) + (func (export "i16x8.max_s-i16x8.min_s") (param v128 v128 v128) (result v128) (i16x8.max_s (i16x8.min_s (local.get 0) (local.get 1))(local.get 2))) + (func (export "i16x8.max_s-i16x8.abs") (param v128 v128) (result v128) (i16x8.max_s (i16x8.abs (local.get 0))(local.get 1))) + (func (export "i16x8.abs-i16x8.max_s") (param v128 v128) (result v128) (i16x8.abs (i16x8.max_s (local.get 0) (local.get 1)))) + (func (export "i16x8.max_u-i16x8.avgr_u") (param v128 v128 v128) (result v128) (i16x8.max_u (i16x8.avgr_u (local.get 0) (local.get 1))(local.get 2))) + (func (export "i16x8.max_u-i16x8.max_u") (param v128 v128 v128) (result v128) (i16x8.max_u (i16x8.max_u (local.get 0) (local.get 1))(local.get 2))) + (func (export "i16x8.max_u-i16x8.max_s") (param v128 v128 v128) (result v128) (i16x8.max_u (i16x8.max_s (local.get 0) (local.get 1))(local.get 2))) + (func (export "i16x8.max_u-i16x8.min_u") (param v128 v128 v128) (result v128) (i16x8.max_u (i16x8.min_u (local.get 0) (local.get 1))(local.get 2))) + (func (export "i16x8.max_u-i16x8.min_s") (param v128 v128 v128) (result v128) (i16x8.max_u (i16x8.min_s (local.get 0) (local.get 1))(local.get 2))) + (func (export "i16x8.max_u-i16x8.abs") (param v128 v128) (result v128) (i16x8.max_u (i16x8.abs (local.get 0))(local.get 1))) + (func (export "i16x8.abs-i16x8.max_u") (param v128 v128) (result v128) (i16x8.abs (i16x8.max_u (local.get 0) (local.get 1)))) + (func (export "i16x8.avgr_u-i16x8.avgr_u") (param v128 v128 v128) (result v128) (i16x8.avgr_u (i16x8.avgr_u (local.get 0) (local.get 1))(local.get 2))) + (func (export "i16x8.avgr_u-i16x8.max_u") (param v128 v128 v128) (result v128) (i16x8.avgr_u (i16x8.max_u (local.get 0) (local.get 1))(local.get 2))) + (func (export "i16x8.avgr_u-i16x8.max_s") (param v128 v128 v128) (result v128) (i16x8.avgr_u (i16x8.max_s (local.get 0) (local.get 1))(local.get 2))) + (func (export "i16x8.avgr_u-i16x8.min_u") (param v128 v128 v128) (result v128) (i16x8.avgr_u (i16x8.min_u (local.get 0) (local.get 1))(local.get 2))) + (func (export "i16x8.avgr_u-i16x8.min_s") (param v128 v128 v128) (result v128) (i16x8.avgr_u (i16x8.min_s (local.get 0) (local.get 1))(local.get 2))) + (func (export "i16x8.avgr_u-i16x8.abs") (param v128 v128) (result v128) (i16x8.avgr_u (i16x8.abs (local.get 0))(local.get 1))) + (func (export "i16x8.abs-i16x8.avgr_u") (param v128 v128) (result v128) (i16x8.abs (i16x8.avgr_u (local.get 0) (local.get 1)))) + (func (export "i16x8.abs-i16x8.abs") (param v128) (result v128) (i16x8.abs (i16x8.abs (local.get 0)))) +) + +(assert_return (invoke "i16x8.min_s-i16x8.avgr_u" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i16x8 1 1 1 1 1 1 1 1) + (v128.const i16x8 2 2 2 2 2 2 2 2)) + (v128.const i16x8 1 1 1 1 1 1 1 1)) +(assert_return (invoke "i16x8.min_s-i16x8.max_u" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i16x8 1 1 1 1 1 1 1 1) + (v128.const i16x8 2 2 2 2 2 2 2 2)) + (v128.const i16x8 1 1 1 1 1 1 1 1)) +(assert_return (invoke "i16x8.min_s-i16x8.max_s" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i16x8 1 1 1 1 1 1 1 1) + (v128.const i16x8 2 2 2 2 2 2 2 2)) + (v128.const i16x8 1 1 1 1 1 1 1 1)) +(assert_return (invoke "i16x8.min_s-i16x8.min_u" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i16x8 1 1 1 1 1 1 1 1) + (v128.const i16x8 2 2 2 2 2 2 2 2)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.min_s-i16x8.min_s" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i16x8 1 1 1 1 1 1 1 1) + (v128.const i16x8 2 2 2 2 2 2 2 2)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.min_s-i16x8.abs" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1) + (v128.const i16x8 0 0 0 0 0 0 0 0)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.abs-i16x8.min_s" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i16x8 1 1 1 1 1 1 1 1)) +(assert_return (invoke "i16x8.min_u-i16x8.avgr_u" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i16x8 1 1 1 1 1 1 1 1) + (v128.const i16x8 2 2 2 2 2 2 2 2)) + (v128.const i16x8 1 1 1 1 1 1 1 1)) +(assert_return (invoke "i16x8.min_u-i16x8.max_u" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i16x8 1 1 1 1 1 1 1 1) + (v128.const i16x8 2 2 2 2 2 2 2 2)) + (v128.const i16x8 1 1 1 1 1 1 1 1)) +(assert_return (invoke "i16x8.min_u-i16x8.max_s" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i16x8 1 1 1 1 1 1 1 1) + (v128.const i16x8 2 2 2 2 2 2 2 2)) + (v128.const i16x8 1 1 1 1 1 1 1 1)) +(assert_return (invoke "i16x8.min_u-i16x8.min_u" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i16x8 1 1 1 1 1 1 1 1) + (v128.const i16x8 2 2 2 2 2 2 2 2)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.min_u-i16x8.min_s" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i16x8 1 1 1 1 1 1 1 1) + (v128.const i16x8 2 2 2 2 2 2 2 2)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.min_u-i16x8.abs" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1) + (v128.const i16x8 0 0 0 0 0 0 0 0)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.abs-i16x8.min_u" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.max_s-i16x8.avgr_u" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i16x8 1 1 1 1 1 1 1 1) + (v128.const i16x8 2 2 2 2 2 2 2 2)) + (v128.const i16x8 2 2 2 2 2 2 2 2)) +(assert_return (invoke "i16x8.max_s-i16x8.max_u" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i16x8 1 1 1 1 1 1 1 1) + (v128.const i16x8 2 2 2 2 2 2 2 2)) + (v128.const i16x8 2 2 2 2 2 2 2 2)) +(assert_return (invoke "i16x8.max_s-i16x8.max_s" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i16x8 1 1 1 1 1 1 1 1) + (v128.const i16x8 2 2 2 2 2 2 2 2)) + (v128.const i16x8 2 2 2 2 2 2 2 2)) +(assert_return (invoke "i16x8.max_s-i16x8.min_u" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i16x8 1 1 1 1 1 1 1 1) + (v128.const i16x8 2 2 2 2 2 2 2 2)) + (v128.const i16x8 2 2 2 2 2 2 2 2)) +(assert_return (invoke "i16x8.max_s-i16x8.min_s" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i16x8 1 1 1 1 1 1 1 1) + (v128.const i16x8 2 2 2 2 2 2 2 2)) + (v128.const i16x8 2 2 2 2 2 2 2 2)) +(assert_return (invoke "i16x8.max_s-i16x8.abs" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1) + (v128.const i16x8 0 0 0 0 0 0 0 0)) + (v128.const i16x8 1 1 1 1 1 1 1 1)) +(assert_return (invoke "i16x8.abs-i16x8.max_s" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.max_u-i16x8.avgr_u" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i16x8 1 1 1 1 1 1 1 1) + (v128.const i16x8 2 2 2 2 2 2 2 2)) + (v128.const i16x8 2 2 2 2 2 2 2 2)) +(assert_return (invoke "i16x8.max_u-i16x8.max_u" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i16x8 1 1 1 1 1 1 1 1) + (v128.const i16x8 2 2 2 2 2 2 2 2)) + (v128.const i16x8 2 2 2 2 2 2 2 2)) +(assert_return (invoke "i16x8.max_u-i16x8.max_s" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i16x8 1 1 1 1 1 1 1 1) + (v128.const i16x8 2 2 2 2 2 2 2 2)) + (v128.const i16x8 2 2 2 2 2 2 2 2)) +(assert_return (invoke "i16x8.max_u-i16x8.min_u" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i16x8 1 1 1 1 1 1 1 1) + (v128.const i16x8 2 2 2 2 2 2 2 2)) + (v128.const i16x8 2 2 2 2 2 2 2 2)) +(assert_return (invoke "i16x8.max_u-i16x8.min_s" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i16x8 1 1 1 1 1 1 1 1) + (v128.const i16x8 2 2 2 2 2 2 2 2)) + (v128.const i16x8 2 2 2 2 2 2 2 2)) +(assert_return (invoke "i16x8.max_u-i16x8.abs" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1) + (v128.const i16x8 0 0 0 0 0 0 0 0)) + (v128.const i16x8 1 1 1 1 1 1 1 1)) +(assert_return (invoke "i16x8.abs-i16x8.max_u" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i16x8 1 1 1 1 1 1 1 1)) +(assert_return (invoke "i16x8.avgr_u-i16x8.avgr_u" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i16x8 1 1 1 1 1 1 1 1) + (v128.const i16x8 2 2 2 2 2 2 2 2)) + (v128.const i16x8 2 2 2 2 2 2 2 2)) +(assert_return (invoke "i16x8.avgr_u-i16x8.max_u" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i16x8 1 1 1 1 1 1 1 1) + (v128.const i16x8 2 2 2 2 2 2 2 2)) + (v128.const i16x8 2 2 2 2 2 2 2 2)) +(assert_return (invoke "i16x8.avgr_u-i16x8.max_s" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i16x8 1 1 1 1 1 1 1 1) + (v128.const i16x8 2 2 2 2 2 2 2 2)) + (v128.const i16x8 2 2 2 2 2 2 2 2)) +(assert_return (invoke "i16x8.avgr_u-i16x8.min_u" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i16x8 1 1 1 1 1 1 1 1) + (v128.const i16x8 2 2 2 2 2 2 2 2)) + (v128.const i16x8 1 1 1 1 1 1 1 1)) +(assert_return (invoke "i16x8.avgr_u-i16x8.min_s" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i16x8 1 1 1 1 1 1 1 1) + (v128.const i16x8 2 2 2 2 2 2 2 2)) + (v128.const i16x8 1 1 1 1 1 1 1 1)) +(assert_return (invoke "i16x8.avgr_u-i16x8.abs" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1) + (v128.const i16x8 0 0 0 0 0 0 0 0)) + (v128.const i16x8 1 1 1 1 1 1 1 1)) +(assert_return (invoke "i16x8.abs-i16x8.avgr_u" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768)) +(assert_return (invoke "i16x8.abs-i16x8.abs" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i16x8 1 1 1 1 1 1 1 1)) diff --git a/runtime/near-vm/tests/wast/spec/proposals/simd/simd_i16x8_cmp.wast b/runtime/near-vm/tests/wast/spec/proposals/simd/simd_i16x8_cmp.wast new file mode 100644 index 00000000000..24068ce321c --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/proposals/simd/simd_i16x8_cmp.wast @@ -0,0 +1,1901 @@ + +;; Test all the i16x8 comparison operators on major boundary values and all special values. + +(module + (func (export "eq") (param $x v128) (param $y v128) (result v128) (i16x8.eq (local.get $x) (local.get $y))) + (func (export "ne") (param $x v128) (param $y v128) (result v128) (i16x8.ne (local.get $x) (local.get $y))) + (func (export "lt_s") (param $x v128) (param $y v128) (result v128) (i16x8.lt_s (local.get $x) (local.get $y))) + (func (export "lt_u") (param $x v128) (param $y v128) (result v128) (i16x8.lt_u (local.get $x) (local.get $y))) + (func (export "le_s") (param $x v128) (param $y v128) (result v128) (i16x8.le_s (local.get $x) (local.get $y))) + (func (export "le_u") (param $x v128) (param $y v128) (result v128) (i16x8.le_u (local.get $x) (local.get $y))) + (func (export "gt_s") (param $x v128) (param $y v128) (result v128) (i16x8.gt_s (local.get $x) (local.get $y))) + (func (export "gt_u") (param $x v128) (param $y v128) (result v128) (i16x8.gt_u (local.get $x) (local.get $y))) + (func (export "ge_s") (param $x v128) (param $y v128) (result v128) (i16x8.ge_s (local.get $x) (local.get $y))) + (func (export "ge_u") (param $x v128) (param $y v128) (result v128) (i16x8.ge_u (local.get $x) (local.get $y))) +) + + +;; eq + +;; i16x8.eq (i16x8) (i16x8) + +;; hex vs hex +(assert_return (invoke "eq" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF) + (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "eq" (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000) + (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "eq" (v128.const i16x8 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0) + (v128.const i16x8 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "eq" (v128.const i16x8 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F) + (v128.const i16x8 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "eq" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0x0000 0x0000 0x0000 0x0000) + (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0x0000 0x0000 0x0000 0x0000)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "eq" (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0xFFFF 0xFFFF 0xFFFF 0xFFFF) + (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0xFFFF 0xFFFF 0xFFFF 0xFFFF)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "eq" (v128.const i16x8 0x0100 0x0302 0x0904 0x1110 0x0A12 0x1A0B 0xAA1B 0xFFAB) + (v128.const i16x8 0x0100 0x0302 0x0904 0x1110 0x0A12 0x1A0B 0xAA1B 0xFFAB)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + +;; hex vs dec +(assert_return (invoke "eq" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF) + (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "eq" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "eq" (v128.const i16x8 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080) + (v128.const i16x8 32896 32896 32896 32896 32896 32896 32896 32896)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "eq" (v128.const i16x8 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080) + (v128.const i16x8 -32640 -32640 -32640 -32640 -32640 -32640 -32640 -32640)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "eq" (v128.const i16x8 0x8180 0x8382 0xFEFD 0x00FF 0x0100 0x7F02 0xFD80 0xFFFE) + (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + +;; dec vs dec +(assert_return (invoke "eq" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "eq" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i16x8 0 0 0 0 0 0 0 0)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "eq" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535) + (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "eq" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "eq" (v128.const i16x8 65535 65535 65535 65535 0 0 0 0) + (v128.const i16x8 65535 65535 65535 65535 0 0 0 0)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "eq" (v128.const i16x8 0 0 0 0 65535 65535 65535 65535) + (v128.const i16x8 0 0 0 0 65535 65535 65535 65535)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "eq" (v128.const i16x8 -32768 65534 -1 -0 0 1 2 65535) + (v128.const i16x8 32768 -2 -1 -0 0 1 2 -1)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + +;; hex vs float +(assert_return (invoke "eq" (v128.const i16x8 0x0000 0xc300 0x0000 0xc2fe 0x0000 0xbf80 0x0000 0x0000) + (v128.const f32x4 -128.0 -127.0 -1.0 0.0)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "eq" (v128.const i16x8 0x0000 0x3f80 0x0000 0x42fe 0x0000 0x4300 0x0000 0x437f) + (v128.const f32x4 1.0 127.0 128.0 255.0)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + +;; not equal +(assert_return (invoke "eq" (v128.const i16x8 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F) + (v128.const i16x8 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "eq" (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0xFFFF 0xFFFF 0xFFFF 0xFFFF) + (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0x0000 0x0000 0x0000 0x0000)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "eq" (v128.const i16x8 0x0001 0x0203 0x0409 0x1011 0x120A 0x0B1A 0x1BAA 0xABFF) + (v128.const i16x8 0xFFAB 0xAA1B 0x1A0B 0x0A12 0x1110 0x0904 0x0302 0x0100)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "eq" (v128.const i16x8 0x8000 0x8001 0x8002 0x8003 0x8004 0x8005 0x8006 0x8007) + (v128.const i16x8 32775 32774 32773 32772 32771 32770 32769 32768)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "eq" (v128.const i16x8 32768 32769 65534 65535 0 -1 -32767 -32768) + (v128.const i16x8 -32768 -32767 -1 0 65535 65534 32769 32768)) + (v128.const i16x8 -1 -1 0 0 0 0 -1 -1)) + +;; i16x8.eq (i16x8) (i8x16) +(assert_return (invoke "eq" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF) + (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "eq" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535) + (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "eq" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "eq" (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E) + (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "eq" (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534) + (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "eq" (v128.const i16x8 -128 -128 0 0 1 1 255 255) + (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255)) + (v128.const i16x8 0 0 -1 -1 0 0 0 0)) +(assert_return (invoke "eq" (v128.const i16x8 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555) + (v128.const i8x16 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) + +;; i16x8.eq (i16x8) (i32x4) +(assert_return (invoke "eq" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF) + (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "eq" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535) + (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "eq" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i32x4 0 0 0 0)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "eq" (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E) + (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "eq" (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534) + (v128.const i32x4 2206368128 16776957 2130837760 4294901120)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "eq" (v128.const i16x8 65535 65535 0 0 1 1 32768 32768) + (v128.const i32x4 65535 0 1 32768)) + (v128.const i16x8 -1 0 -1 -1 -1 0 -1 0)) +(assert_return (invoke "eq" (v128.const i16x8 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555) + (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "eq" (v128.const i16x8 012_345 012_345 012_345 012_345 012_345 012_345 012_345 012_345) + (v128.const i16x8 12345 12345 12345 12345 12345 12345 12345 12345)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "eq" (v128.const i16x8 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234) + (v128.const i16x8 0x1234 0x1234 0x1234 0x1234 0x1234 0x1234 0x1234 0x1234)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + +;; ne + +;; i16x8.ne (i16x8) (i16x8) + +;; hex vs hex +(assert_return (invoke "ne" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF) + (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "ne" (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000) + (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "ne" (v128.const i16x8 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0) + (v128.const i16x8 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "ne" (v128.const i16x8 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F) + (v128.const i16x8 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "ne" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0x0000 0x0000 0x0000 0x0000) + (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0x0000 0x0000 0x0000 0x0000)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "ne" (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0xFFFF 0xFFFF 0xFFFF 0xFFFF) + (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0xFFFF 0xFFFF 0xFFFF 0xFFFF)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "ne" (v128.const i16x8 0x0100 0x0302 0x0904 0x1110 0x0A12 0x1A0B 0xAA1B 0xFFAB) + (v128.const i16x8 0x0100 0x0302 0x0904 0x1110 0x0A12 0x1A0B 0xAA1B 0xFFAB)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) + +;; hex vs dec +(assert_return (invoke "ne" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF) + (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "ne" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "ne" (v128.const i16x8 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080) + (v128.const i16x8 32896 32896 32896 32896 32896 32896 32896 32896)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "ne" (v128.const i16x8 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080) + (v128.const i16x8 -32640 -32640 -32640 -32640 -32640 -32640 -32640 -32640)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "ne" (v128.const i16x8 0x8180 0x8382 0xFEFD 0x00FF 0x0100 0x7F02 0xFD80 0xFFFE) + (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) + +;; dec vs dec +(assert_return (invoke "ne" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "ne" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i16x8 0 0 0 0 0 0 0 0)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "ne" (v128.const i16x8 255 255 255 255 255 255 255 255) + (v128.const i16x8 255 255 255 255 255 255 255 255)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "ne" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "ne" (v128.const i16x8 255 255 255 255 0 0 0 0) + (v128.const i16x8 255 255 255 255 0 0 0 0)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "ne" (v128.const i16x8 0 0 0 0 255 255 255 255) + (v128.const i16x8 0 0 0 0 255 255 255 255)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "ne" (v128.const i16x8 255 32767 -0 0 1 2 65534 65535) + (v128.const i16x8 255 32767 0 0 1 2 -2 -1)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) + +;; hex vs float +(assert_return (invoke "ne" (v128.const i16x8 0x0000 0xc300 0x0000 0xc2fe 0x0000 0xbf80 0x0000 0x0000) + (v128.const f32x4 -128.0 -127.0 -1.0 0.0)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "ne" (v128.const i16x8 0x0000 0x3f80 0x0000 0x42fe 0x0000 0x4300 0x0000 0x437f) + (v128.const f32x4 1.0 127.0 128.0 255.0)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) + +;; not equal +(assert_return (invoke "ne" (v128.const i16x8 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F) + (v128.const i16x8 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0xFFFF 0xFFFF 0xFFFF 0xFFFF) + (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0x0000 0x0000 0x0000 0x0000)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const i16x8 0x0001 0x0203 0x0409 0x1011 0x120A 0x0B1A 0x1BAA 0xABFF) + (v128.const i16x8 0xFFAB 0xAA1B 0x1A0B 0x0A12 0x1110 0x0904 0x0302 0x0100)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const i16x8 0x8081 0x8283 0xFDFE 0xFF00 0x0001 0x027F 0x80FD 0xFEFF) + (v128.const i16x8 65279 33021 639 1 65280 65022 33411 32897)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const i16x8 128 129 130 131 -0 255 32766 32767) + (v128.const i16x8 32767 32766 255 -0 131 130 129 28)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + +;; i16x8.ne (i16x8) (i8x16) +(assert_return (invoke "ne" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF) + (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "ne" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535) + (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "ne" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "ne" (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E) + (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "ne" (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534) + (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "ne" (v128.const i16x8 -128 -128 0 0 1 1 255 255) + (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255)) + (v128.const i16x8 -1 -1 0 0 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const i16x8 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555) + (v128.const i8x16 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + +;; i16x8.ne (i16x8) (i32x4) +(assert_return (invoke "ne" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF) + (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "ne" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535) + (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "ne" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i32x4 0 0 0 0)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "ne" (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E) + (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "ne" (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534) + (v128.const i32x4 2206368128 16776957 2130837760 4294901120)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "ne" (v128.const i16x8 -128 -128 0 0 1 1 255 255) + (v128.const i32x4 -128 0 1 255)) + (v128.const i16x8 0 -1 0 0 0 -1 0 -1)) +(assert_return (invoke "ne" (v128.const i16x8 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555) + (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const i16x8 012_345 012_345 012_345 012_345 012_345 012_345 012_345 012_345) + (v128.const i16x8 12345 12345 12345 12345 12345 12345 12345 12345)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "ne" (v128.const i16x8 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234) + (v128.const i16x8 0x1234 0x1234 0x1234 0x1234 0x1234 0x1234 0x1234 0x1234)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) + +;; lt_s + +;; i16x8.lt_s (i16x8) (i16x8) + +;; hex vs hex +(assert_return (invoke "lt_s" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF) + (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "lt_s" (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000) + (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "lt_s" (v128.const i16x8 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0) + (v128.const i16x8 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "lt_s" (v128.const i16x8 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F) + (v128.const i16x8 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "lt_s" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0x0000 0x0000 0x0000 0x0000) + (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0x0000 0x0000 0x0000 0x0000)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "lt_s" (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0xFFFF 0xFFFF 0xFFFF 0xFFFF) + (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0xFFFF 0xFFFF 0xFFFF 0xFFFF)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "lt_s" (v128.const i16x8 0x0100 0x0302 0x0904 0x1110 0x0A12 0x1A0B 0xAA1B 0xFFAB) + (v128.const i16x8 0x0100 0x0302 0x0904 0x1110 0x0A12 0x1A0B 0xAA1B 0xFFAB)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "lt_s" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF) + (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "lt_s" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "lt_s" (v128.const i16x8 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080) + (v128.const i16x8 32896 32896 32896 32896 32896 32896 32896 32896)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "lt_s" (v128.const i16x8 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080) + (v128.const i16x8 -32640 -32640 -32640 -32640 -32640 -32640 -32640 -32640)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "lt_s" (v128.const i16x8 0x8180 0x8382 0xFEFD 0x00FF 0x0100 0x7F02 0xFD80 0xFFFE) + (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "lt_s" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "lt_s" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i16x8 0 0 0 0 0 0 0 0)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "lt_s" (v128.const i16x8 255 255 255 255 255 255 255 255) + (v128.const i16x8 255 255 255 255 255 255 255 255)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "lt_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "lt_s" (v128.const i16x8 255 255 255 255 0 0 0 0) + (v128.const i16x8 255 255 255 255 0 0 0 0)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "lt_s" (v128.const i16x8 0 0 0 0 255 255 255 255) + (v128.const i16x8 0 0 0 0 255 255 255 255)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "lt_s" (v128.const i16x8 255 32767 -0 0 1 2 65534 65535) + (v128.const i16x8 255 32767 0 0 1 2 -2 -1)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "lt_s" (v128.const i16x8 0x0000 0xc300 0x0000 0xc2fe 0x0000 0xbf80 0x0000 0x0000) + (v128.const f32x4 -128.0 -127.0 -1.0 0.0)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "lt_s" (v128.const i16x8 0x0000 0x3f80 0x0000 0x42fe 0x0000 0x4300 0x0000 0x437f) + (v128.const f32x4 1.0 127.0 128.0 255.0)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) + +;; not equal +(assert_return (invoke "lt_s" (v128.const i16x8 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F) + (v128.const i16x8 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "lt_s" (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0xFFFF 0xFFFF 0xFFFF 0xFFFF) + (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0x0000 0x0000 0x0000 0x0000)) + (v128.const i16x8 0 0 0 0 -1 -1 -1 -1)) +(assert_return (invoke "lt_s" (v128.const i16x8 0x0001 0x0203 0x0409 0x1011 0x120A 0x0B1A 0x1BAA 0xABFF) + (v128.const i16x8 0xFFAB 0xAA1B 0x1A0B 0x0A12 0x1110 0x0904 0x0302 0x0100)) + (v128.const i16x8 0 0 -1 0 0 0 0 -1)) +(assert_return (invoke "lt_s" (v128.const i16x8 0x8081 0x8283 0xFDFE 0xFF00 0x0001 0x027F 0x80FD 0xFEFF) + (v128.const i16x8 65279 33021 639 1 65280 65022 33411 32897)) + (v128.const i16x8 -1 0 -1 -1 0 0 -1 0)) +(assert_return (invoke "lt_s" (v128.const i16x8 128 129 130 131 -0 255 32766 32767) + (v128.const i16x8 32767 32766 255 -0 131 130 129 28)) + (v128.const i16x8 -1 -1 -1 0 -1 0 0 0)) + +;; i16x8.lt_s (i16x8) (i8x16) +(assert_return (invoke "lt_s" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF) + (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "lt_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535) + (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "lt_s" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "lt_s" (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E) + (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "lt_s" (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534) + (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "lt_s" (v128.const i16x8 -128 -128 0 0 1 1 255 255) + (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255)) + (v128.const i16x8 0 0 0 0 -1 -1 0 0)) +(assert_return (invoke "lt_s" (v128.const i16x8 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555) + (v128.const i8x16 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) + +;; i16x8.lt_s (i16x8) (i32x4) +(assert_return (invoke "lt_s" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF) + (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "lt_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535) + (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "lt_s" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i32x4 0 0 0 0)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "lt_s" (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E) + (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "lt_s" (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534) + (v128.const i32x4 2206368128 16776957 2130837760 4294901120)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "lt_s" (v128.const i16x8 -128 -128 0 0 1 1 255 255) + (v128.const i32x4 -128 0 1 255)) + (v128.const i16x8 0 -1 0 0 0 0 0 0)) +(assert_return (invoke "lt_s" (v128.const i16x8 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555) + (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "lt_s" (v128.const i16x8 012_345 012_345 012_345 012_345 012_345 012_345 012_345 012_345) + (v128.const i16x8 12345 12345 12345 12345 12345 12345 12345 12345)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "lt_s" (v128.const i16x8 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234) + (v128.const i16x8 0x1234 0x1234 0x1234 0x1234 0x1234 0x1234 0x1234 0x1234)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) + +;; lt_u + +;; i16x8.lt_u (i16x8) (i16x8) + +;; hex vs hex +(assert_return (invoke "lt_u" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF) + (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "lt_u" (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000) + (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "lt_u" (v128.const i16x8 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0) + (v128.const i16x8 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "lt_u" (v128.const i16x8 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F) + (v128.const i16x8 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "lt_u" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0x0000 0x0000 0x0000 0x0000) + (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0x0000 0x0000 0x0000 0x0000)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "lt_u" (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0xFFFF 0xFFFF 0xFFFF 0xFFFF) + (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0xFFFF 0xFFFF 0xFFFF 0xFFFF)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "lt_u" (v128.const i16x8 0x0100 0x0302 0x0904 0x1110 0x0A12 0x1A0B 0xAA1B 0xFFAB) + (v128.const i16x8 0x0100 0x0302 0x0904 0x1110 0x0A12 0x1A0B 0xAA1B 0xFFAB)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) + +;; hex vs dec +(assert_return (invoke "lt_u" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF) + (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "lt_u" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "lt_u" (v128.const i16x8 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080) + (v128.const i16x8 32896 32896 32896 32896 32896 32896 32896 32896)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "lt_u" (v128.const i16x8 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080) + (v128.const i16x8 -32640 -32640 -32640 -32640 -32640 -32640 -32640 -32640)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "lt_u" (v128.const i16x8 0x8180 0x8382 0xFEFD 0x00FF 0x0100 0x7F02 0xFD80 0xFFFE) + (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) + +;; dec vs dec +(assert_return (invoke "lt_u" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "lt_u" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i16x8 0 0 0 0 0 0 0 0)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "lt_u" (v128.const i16x8 255 255 255 255 255 255 255 255) + (v128.const i16x8 255 255 255 255 255 255 255 255)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "lt_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "lt_u" (v128.const i16x8 255 255 255 255 0 0 0 0) + (v128.const i16x8 255 255 255 255 0 0 0 0)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "lt_u" (v128.const i16x8 0 0 0 0 255 255 255 255) + (v128.const i16x8 0 0 0 0 255 255 255 255)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "lt_u" (v128.const i16x8 255 32767 -0 0 1 2 65534 65535) + (v128.const i16x8 255 32767 0 0 1 2 -2 -1)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) + +;; hex vs float +(assert_return (invoke "lt_u" (v128.const i16x8 0x0000 0xc300 0x0000 0xc2fe 0x0000 0xbf80 0x0000 0x0000) + (v128.const f32x4 -128.0 -127.0 -1.0 0.0)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "lt_u" (v128.const i16x8 0x0000 0x3f80 0x0000 0x42fe 0x0000 0x4300 0x0000 0x437f) + (v128.const f32x4 1.0 127.0 128.0 255.0)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) + +;; not equal +(assert_return (invoke "lt_u" (v128.const i16x8 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F) + (v128.const i16x8 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "lt_u" (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0xFFFF 0xFFFF 0xFFFF 0xFFFF) + (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0x0000 0x0000 0x0000 0x0000)) + (v128.const i16x8 -1 -1 -1 -1 0 0 0 0)) +(assert_return (invoke "lt_u" (v128.const i16x8 0x0001 0x0203 0x0409 0x1011 0x120A 0x0B1A 0x1BAA 0xABFF) + (v128.const i16x8 0xFFAB 0xAA1B 0x1A0B 0x0A12 0x1110 0x0904 0x0302 0x0100)) + (v128.const i16x8 -1 -1 -1 0 0 0 0 0)) +(assert_return (invoke "lt_u" (v128.const i16x8 0x8081 0x8283 0xFDFE 0xFF00 0x0001 0x027F 0x80FD 0xFEFF) + (v128.const i16x8 65279 33021 639 1 65280 65022 33411 32897)) + (v128.const i16x8 -1 0 0 0 -1 -1 -1 0)) +(assert_return (invoke "lt_u" (v128.const i16x8 128 129 130 131 -0 255 32766 32767) + (v128.const i16x8 32767 32766 255 -0 131 130 129 28)) + (v128.const i16x8 -1 -1 -1 0 -1 0 0 0)) + +;; i16x8.lt_u (i16x8) (i8x16) +(assert_return (invoke "lt_u" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF) + (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "lt_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535) + (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "lt_u" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "lt_u" (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E) + (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "lt_u" (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534) + (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "lt_u" (v128.const i16x8 -128 -128 0 0 1 1 255 255) + (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255)) + (v128.const i16x8 0 0 0 0 -1 -1 -1 -1)) +(assert_return (invoke "lt_u" (v128.const i16x8 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555) + (v128.const i8x16 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + +;; i16x8.lt_u (i16x8) (i32x4) +(assert_return (invoke "lt_u" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF) + (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "lt_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535) + (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "lt_u" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i32x4 0 0 0 0)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "lt_u" (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E) + (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "lt_u" (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534) + (v128.const i32x4 2206368128 16776957 2130837760 4294901120)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "lt_u" (v128.const i16x8 -128 -128 0 0 1 1 255 255) + (v128.const i32x4 -128 0 1 255)) + (v128.const i16x8 0 -1 0 0 0 0 0 0)) +(assert_return (invoke "lt_u" (v128.const i16x8 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555) + (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "lt_u" (v128.const i16x8 012_345 012_345 012_345 012_345 012_345 012_345 012_345 012_345) + (v128.const i16x8 12345 12345 12345 12345 12345 12345 12345 12345)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "lt_u" (v128.const i16x8 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234) + (v128.const i16x8 0x1234 0x1234 0x1234 0x1234 0x1234 0x1234 0x1234 0x1234)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) + +;; le_s + +;; i16x8.le_s (i16x8) (i16x8) + +;; hex vs hex +(assert_return (invoke "le_s" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF) + (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "le_s" (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000) + (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "le_s" (v128.const i16x8 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0) + (v128.const i16x8 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "le_s" (v128.const i16x8 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F) + (v128.const i16x8 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "le_s" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0x0000 0x0000 0x0000 0x0000) + (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0x0000 0x0000 0x0000 0x0000)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "le_s" (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0xFFFF 0xFFFF 0xFFFF 0xFFFF) + (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0xFFFF 0xFFFF 0xFFFF 0xFFFF)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "le_s" (v128.const i16x8 0x0100 0x0302 0x0904 0x1110 0x0A12 0x1A0B 0xAA1B 0xFFAB) + (v128.const i16x8 0x0100 0x0302 0x0904 0x1110 0x0A12 0x1A0B 0xAA1B 0xFFAB)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + +;; hex vs dec +(assert_return (invoke "le_s" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF) + (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "le_s" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "le_s" (v128.const i16x8 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080) + (v128.const i16x8 32896 32896 32896 32896 32896 32896 32896 32896)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "le_s" (v128.const i16x8 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080) + (v128.const i16x8 -32640 -32640 -32640 -32640 -32640 -32640 -32640 -32640)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "le_s" (v128.const i16x8 0x8180 0x8382 0xFEFD 0x00FF 0x0100 0x7F02 0xFD80 0xFFFE) + (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + +;; dec vs dec +(assert_return (invoke "le_s" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "le_s" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i16x8 0 0 0 0 0 0 0 0)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "le_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535) + (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "le_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "le_s" (v128.const i16x8 65535 65535 65535 65535 0 0 0 0) + (v128.const i16x8 65535 65535 65535 65535 0 0 0 0)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "le_s" (v128.const i16x8 0 0 0 0 65535 65535 65535 65535) + (v128.const i16x8 0 0 0 0 65535 65535 65535 65535)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "le_s" (v128.const i16x8 -32768 65534 -1 -0 0 1 2 65535) + (v128.const i16x8 32768 -2 -1 -0 0 1 2 -1)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + +;; hex vs float +(assert_return (invoke "le_s" (v128.const i16x8 0x0000 0xc300 0x0000 0xc2fe 0x0000 0xbf80 0x0000 0x0000) + (v128.const f32x4 -128.0 -127.0 -1.0 0.0)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "le_s" (v128.const i16x8 0x0000 0x3f80 0x0000 0x42fe 0x0000 0x4300 0x0000 0x437f) + (v128.const f32x4 1.0 127.0 128.0 255.0)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + +;; not equal +(assert_return (invoke "le_s" (v128.const i16x8 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F) + (v128.const i16x8 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "le_s" (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0xFFFF 0xFFFF 0xFFFF 0xFFFF) + (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0x0000 0x0000 0x0000 0x0000)) + (v128.const i16x8 0 0 0 0 -1 -1 -1 -1)) +(assert_return (invoke "le_s" (v128.const i16x8 0x0001 0x0203 0x0409 0x1011 0x120A 0x0B1A 0x1BAA 0xABFF) + (v128.const i16x8 0xFFAB 0xAA1B 0x1A0B 0x0A12 0x1110 0x0904 0x0302 0x0100)) + (v128.const i16x8 0 0 -1 0 0 0 0 -1)) +(assert_return (invoke "le_s" (v128.const i16x8 0x8000 0x8001 0x8002 0x8003 0x8004 0x8005 0x8006 0x8007) + (v128.const i16x8 32775 32774 32773 32772 32771 32770 32769 32768)) + (v128.const i16x8 -1 -1 -1 -1 0 0 0 0)) +(assert_return (invoke "le_s" (v128.const i16x8 32768 32769 65534 65535 0 -1 -32767 -32768) + (v128.const i16x8 -32768 -32767 -1 0 65535 65534 32769 32768)) + (v128.const i16x8 -1 -1 -1 -1 0 0 -1 -1)) + +;; i16x8.le_s (i16x8) (i8x16) +(assert_return (invoke "le_s" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF) + (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "le_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535) + (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "le_s" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "le_s" (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E) + (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "le_s" (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534) + (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "le_s" (v128.const i16x8 -128 -128 0 0 1 1 255 255) + (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255)) + (v128.const i16x8 0 0 -1 -1 -1 -1 0 0)) +(assert_return (invoke "le_s" (v128.const i16x8 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555) + (v128.const i8x16 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) + +;; i16x8.le_s (i16x8) (i32x4) +(assert_return (invoke "le_s" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF) + (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "le_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535) + (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "le_s" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i32x4 0 0 0 0)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "le_s" (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E) + (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "le_s" (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534) + (v128.const i32x4 2206368128 16776957 2130837760 4294901120)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "le_s" (v128.const i16x8 -128 -128 0 0 1 1 255 255) + (v128.const i32x4 -128 0 1 255)) + (v128.const i16x8 -1 -1 -1 -1 -1 0 -1 0)) +(assert_return (invoke "le_s" (v128.const i16x8 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555) + (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "le_s" (v128.const i16x8 012_345 012_345 012_345 012_345 012_345 012_345 012_345 012_345) + (v128.const i16x8 12345 12345 12345 12345 12345 12345 12345 12345)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "le_s" (v128.const i16x8 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234) + (v128.const i16x8 0x1234 0x1234 0x1234 0x1234 0x1234 0x1234 0x1234 0x1234)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + +;; le_u + +;; i16x8.le_u (i16x8) (i16x8) + +;; hex vs hex +(assert_return (invoke "le_u" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF) + (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "le_u" (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000) + (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "le_u" (v128.const i16x8 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0) + (v128.const i16x8 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "le_u" (v128.const i16x8 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F) + (v128.const i16x8 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "le_u" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0x0000 0x0000 0x0000 0x0000) + (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0x0000 0x0000 0x0000 0x0000)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "le_u" (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0xFFFF 0xFFFF 0xFFFF 0xFFFF) + (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0xFFFF 0xFFFF 0xFFFF 0xFFFF)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "le_u" (v128.const i16x8 0x0100 0x0302 0x0904 0x1110 0x0A12 0x1A0B 0xAA1B 0xFFAB) + (v128.const i16x8 0x0100 0x0302 0x0904 0x1110 0x0A12 0x1A0B 0xAA1B 0xFFAB)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + +;; hex vs dec +(assert_return (invoke "le_u" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF) + (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "le_u" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "le_u" (v128.const i16x8 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080) + (v128.const i16x8 32896 32896 32896 32896 32896 32896 32896 32896)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "le_u" (v128.const i16x8 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080) + (v128.const i16x8 -32640 -32640 -32640 -32640 -32640 -32640 -32640 -32640)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "le_u" (v128.const i16x8 0x8180 0x8382 0xFEFD 0x00FF 0x0100 0x7F02 0xFD80 0xFFFE) + (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + +;; dec vs dec +(assert_return (invoke "le_u" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "le_u" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i16x8 0 0 0 0 0 0 0 0)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "le_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535) + (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "le_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "le_u" (v128.const i16x8 65535 65535 65535 65535 0 0 0 0) + (v128.const i16x8 65535 65535 65535 65535 0 0 0 0)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "le_u" (v128.const i16x8 0 0 0 0 65535 65535 65535 65535) + (v128.const i16x8 0 0 0 0 65535 65535 65535 65535)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "le_u" (v128.const i16x8 -32768 65534 -1 -0 0 1 2 65535) + (v128.const i16x8 32768 -2 -1 -0 0 1 2 -1)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + +;; hex vs float +(assert_return (invoke "le_u" (v128.const i16x8 0x0000 0xc300 0x0000 0xc2fe 0x0000 0xbf80 0x0000 0x0000) + (v128.const f32x4 -128.0 -127.0 -1.0 0.0)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "le_u" (v128.const i16x8 0x0000 0x3f80 0x0000 0x42fe 0x0000 0x4300 0x0000 0x437f) + (v128.const f32x4 1.0 127.0 128.0 255.0)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + +;; not equal +(assert_return (invoke "le_u" (v128.const i16x8 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F) + (v128.const i16x8 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "le_u" (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0xFFFF 0xFFFF 0xFFFF 0xFFFF) + (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0x0000 0x0000 0x0000 0x0000)) + (v128.const i16x8 -1 -1 -1 -1 0 0 0 0)) +(assert_return (invoke "le_u" (v128.const i16x8 0x0001 0x0203 0x0409 0x1011 0x120A 0x0B1A 0x1BAA 0xABFF) + (v128.const i16x8 0xFFAB 0xAA1B 0x1A0B 0x0A12 0x1110 0x0904 0x0302 0x0100)) + (v128.const i16x8 -1 -1 -1 0 0 0 0 0)) +(assert_return (invoke "le_u" (v128.const i16x8 0x8000 0x8001 0x8002 0x8003 0x8004 0x8005 0x8006 0x8007) + (v128.const i16x8 32775 32774 32773 32772 32771 32770 32769 32768)) + (v128.const i16x8 -1 -1 -1 -1 0 0 0 0)) +(assert_return (invoke "le_u" (v128.const i16x8 32768 32769 65534 65535 0 -1 -32767 -32768) + (v128.const i16x8 -32768 -32767 -1 0 65535 65534 32769 32768)) + (v128.const i16x8 -1 -1 -1 0 -1 0 -1 -1)) + +;; i16x8.le_u (i16x8) (i8x16) +(assert_return (invoke "le_u" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF) + (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "le_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535) + (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "le_u" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "le_u" (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E) + (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "le_u" (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534) + (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "le_u" (v128.const i16x8 -128 -128 0 0 1 1 255 255) + (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255)) + (v128.const i16x8 0 0 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "le_u" (v128.const i16x8 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555) + (v128.const i8x16 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + +;; i16x8.le_u (i16x8) (i32x4) +(assert_return (invoke "le_u" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF) + (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "le_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535) + (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "le_u" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i32x4 0 0 0 0)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "le_u" (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E) + (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "le_u" (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534) + (v128.const i32x4 2206368128 16776957 2130837760 4294901120)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "le_u" (v128.const i16x8 -128 -128 0 0 1 1 255 255) + (v128.const i32x4 -128 0 1 255)) + (v128.const i16x8 -1 -1 -1 -1 -1 0 -1 0)) +(assert_return (invoke "le_u" (v128.const i16x8 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555) + (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "le_u" (v128.const i16x8 012_345 012_345 012_345 012_345 012_345 012_345 012_345 012_345) + (v128.const i16x8 12345 12345 12345 12345 12345 12345 12345 12345)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "le_u" (v128.const i16x8 0x0_edcb 0x0_edcb 0x0_edcb 0x0_edcb 0x0_edcb 0x0_edcb 0x0_edcb 0x0_edcb) + (v128.const i16x8 -0x1234 -0x1234 -0x1234 -0x1234 -0x1234 -0x1234 -0x1234 -0x1234)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + +;; gt_s + +;; i16x8.gt_s (i16x8) (i16x8) + +;; hex vs hex +(assert_return (invoke "gt_s" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF) + (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "gt_s" (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000) + (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "gt_s" (v128.const i16x8 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0) + (v128.const i16x8 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "gt_s" (v128.const i16x8 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F) + (v128.const i16x8 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "gt_s" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0x0000 0x0000 0x0000 0x0000) + (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0x0000 0x0000 0x0000 0x0000)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "gt_s" (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0xFFFF 0xFFFF 0xFFFF 0xFFFF) + (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0xFFFF 0xFFFF 0xFFFF 0xFFFF)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "gt_s" (v128.const i16x8 0x0100 0x0302 0x0904 0x1110 0x0A12 0x1A0B 0xAA1B 0xFFAB) + (v128.const i16x8 0x0100 0x0302 0x0904 0x1110 0x0A12 0x1A0B 0xAA1B 0xFFAB)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) + +;; hex vs dec +(assert_return (invoke "gt_s" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF) + (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "gt_s" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "gt_s" (v128.const i16x8 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080) + (v128.const i16x8 32896 32896 32896 32896 32896 32896 32896 32896)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "gt_s" (v128.const i16x8 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080) + (v128.const i16x8 -32640 -32640 -32640 -32640 -32640 -32640 -32640 -32640)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "gt_s" (v128.const i16x8 0x8180 0x8382 0xFEFD 0x00FF 0x0100 0x7F02 0xFD80 0xFFFE) + (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) + +;; dec vs dec +(assert_return (invoke "gt_s" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "gt_s" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i16x8 0 0 0 0 0 0 0 0)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "gt_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535) + (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "gt_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "gt_s" (v128.const i16x8 65535 65535 65535 65535 0 0 0 0) + (v128.const i16x8 65535 65535 65535 65535 0 0 0 0)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "gt_s" (v128.const i16x8 0 0 0 0 65535 65535 65535 65535) + (v128.const i16x8 0 0 0 0 65535 65535 65535 65535)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "gt_s" (v128.const i16x8 -32768 65534 -1 -0 0 1 2 65535) + (v128.const i16x8 32768 -2 -1 -0 0 1 2 -1)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) + +;; hex vs float +(assert_return (invoke "gt_s" (v128.const i16x8 0x0000 0xc300 0x0000 0xc2fe 0x0000 0xbf80 0x0000 0x0000) + (v128.const f32x4 -128.0 -127.0 -1.0 0.0)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "gt_s" (v128.const i16x8 0x0000 0x3f80 0x0000 0x42fe 0x0000 0x4300 0x0000 0x437f) + (v128.const f32x4 1.0 127.0 128.0 255.0)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) + +;; not equal +(assert_return (invoke "gt_s" (v128.const i16x8 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F) + (v128.const i16x8 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "gt_s" (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0xFFFF 0xFFFF 0xFFFF 0xFFFF) + (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0x0000 0x0000 0x0000 0x0000)) + (v128.const i16x8 -1 -1 -1 -1 0 0 0 0)) +(assert_return (invoke "gt_s" (v128.const i16x8 0x0001 0x0203 0x0409 0x1011 0x120A 0x0B1A 0x1BAA 0xABFF) + (v128.const i16x8 0xFFAB 0xAA1B 0x1A0B 0x0A12 0x1110 0x0904 0x0302 0x0100)) + (v128.const i16x8 -1 -1 0 -1 -1 -1 -1 0)) +(assert_return (invoke "gt_s" (v128.const i16x8 0x8000 0x8001 0x8002 0x8003 0x8004 0x8005 0x8006 0x8007) + (v128.const i16x8 32775 32774 32773 32772 32771 32770 32769 32768)) + (v128.const i16x8 0 0 0 0 -1 -1 -1 -1)) +(assert_return (invoke "gt_s" (v128.const i16x8 32768 32769 65534 65535 0 -1 -32767 -32768) + (v128.const i16x8 -32768 -32767 -1 0 65535 65534 32769 32768)) + (v128.const i16x8 0 0 0 0 -1 -1 0 0)) + +;; i16x8.gt_s (i16x8) (i8x16) +(assert_return (invoke "gt_s" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF) + (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "gt_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535) + (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "gt_s" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "gt_s" (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E) + (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "gt_s" (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534) + (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "gt_s" (v128.const i16x8 -128 -128 0 0 1 1 255 255) + (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255)) + (v128.const i16x8 -1 -1 0 0 0 0 -1 -1)) +(assert_return (invoke "gt_s" (v128.const i16x8 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555) + (v128.const i8x16 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + +;; i16x8.gt_s (i16x8) (i32x4) +(assert_return (invoke "gt_s" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF) + (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "gt_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535) + (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "gt_s" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i32x4 0 0 0 0)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "gt_s" (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E) + (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "gt_s" (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534) + (v128.const i32x4 2206368128 16776957 2130837760 4294901120)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "gt_s" (v128.const i16x8 65535 65535 0 0 1 1 32768 32768) + (v128.const i32x4 65535 0 1 32768)) + (v128.const i16x8 0 0 0 0 0 -1 0 0)) +(assert_return (invoke "gt_s" (v128.const i16x8 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555) + (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "gt_s" (v128.const i16x8 012_345 012_345 012_345 012_345 012_345 012_345 012_345 012_345) + (v128.const i16x8 12345 12345 12345 12345 12345 12345 12345 12345)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "gt_s" (v128.const i16x8 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234) + (v128.const i16x8 0x1234 0x1234 0x1234 0x1234 0x1234 0x1234 0x1234 0x1234)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) + +;; gt_u + +;; i16x8.gt_u (i16x8) (i16x8) + +;; hex vs hex +(assert_return (invoke "gt_u" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF) + (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "gt_u" (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000) + (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "gt_u" (v128.const i16x8 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0) + (v128.const i16x8 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "gt_u" (v128.const i16x8 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F) + (v128.const i16x8 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "gt_u" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0x0000 0x0000 0x0000 0x0000) + (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0x0000 0x0000 0x0000 0x0000)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "gt_u" (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0xFFFF 0xFFFF 0xFFFF 0xFFFF) + (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0xFFFF 0xFFFF 0xFFFF 0xFFFF)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "gt_u" (v128.const i16x8 0x0100 0x0302 0x0904 0x1110 0x0A12 0x1A0B 0xAA1B 0xFFAB) + (v128.const i16x8 0x0100 0x0302 0x0904 0x1110 0x0A12 0x1A0B 0xAA1B 0xFFAB)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) + +;; hex vs dec +(assert_return (invoke "gt_u" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF) + (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "gt_u" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "gt_u" (v128.const i16x8 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080) + (v128.const i16x8 32896 32896 32896 32896 32896 32896 32896 32896)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "gt_u" (v128.const i16x8 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080) + (v128.const i16x8 -32640 -32640 -32640 -32640 -32640 -32640 -32640 -32640)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "gt_u" (v128.const i16x8 0x8180 0x8382 0xFEFD 0x00FF 0x0100 0x7F02 0xFD80 0xFFFE) + (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) + +;; dec vs dec +(assert_return (invoke "eq" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "eq" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i16x8 0 0 0 0 0 0 0 0)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "eq" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535) + (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "eq" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "eq" (v128.const i16x8 65535 65535 65535 65535 0 0 0 0) + (v128.const i16x8 65535 65535 65535 65535 0 0 0 0)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "eq" (v128.const i16x8 0 0 0 0 65535 65535 65535 65535) + (v128.const i16x8 0 0 0 0 65535 65535 65535 65535)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "eq" (v128.const i16x8 -32768 65534 -1 -0 0 1 2 65535) + (v128.const i16x8 32768 -2 -1 -0 0 1 2 -1)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + +;; hex vs float +(assert_return (invoke "gt_u" (v128.const i16x8 0x0000 0xc300 0x0000 0xc2fe 0x0000 0xbf80 0x0000 0x0000) + (v128.const f32x4 -128.0 -127.0 -1.0 0.0)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "gt_u" (v128.const i16x8 0x0000 0x3f80 0x0000 0x42fe 0x0000 0x4300 0x0000 0x437f) + (v128.const f32x4 1.0 127.0 128.0 255.0)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) + +;; not equal +(assert_return (invoke "gt_u" (v128.const i16x8 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F) + (v128.const i16x8 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "gt_u" (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0xFFFF 0xFFFF 0xFFFF 0xFFFF) + (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0x0000 0x0000 0x0000 0x0000)) + (v128.const i16x8 0 0 0 0 -1 -1 -1 -1)) +(assert_return (invoke "gt_u" (v128.const i16x8 0x0001 0x0203 0x0409 0x1011 0x120A 0x0B1A 0x1BAA 0xABFF) + (v128.const i16x8 0xFFAB 0xAA1B 0x1A0B 0x0A12 0x1110 0x0904 0x0302 0x0100)) + (v128.const i16x8 0 0 0 -1 -1 -1 -1 -1)) +(assert_return (invoke "gt_u" (v128.const i16x8 0x8000 0x8001 0x8002 0x8003 0x8004 0x8005 0x8006 0x8007) + (v128.const i16x8 32775 32774 32773 32772 32771 32770 32769 32768)) + (v128.const i16x8 0 0 0 0 -1 -1 -1 -1)) +(assert_return (invoke "gt_u" (v128.const i16x8 32768 32769 65534 65535 0 -1 -32767 -32768) + (v128.const i16x8 -32768 -32767 -1 0 65535 65534 32769 32768)) + (v128.const i16x8 0 0 0 -1 0 -1 0 0)) + +;; i16x8.gt_u (i16x8) (i8x16) +(assert_return (invoke "gt_u" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF) + (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "gt_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535) + (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "gt_u" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "gt_u" (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E) + (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "gt_u" (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534) + (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "gt_u" (v128.const i16x8 -128 -128 0 0 1 1 255 255) + (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255)) + (v128.const i16x8 -1 -1 0 0 0 0 0 0)) +(assert_return (invoke "gt_u" (v128.const i16x8 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555) + (v128.const i8x16 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) + +;; i16x8.gt_u (i16x8) (i32x4) +(assert_return (invoke "gt_u" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF) + (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "gt_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535) + (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "gt_u" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i32x4 0 0 0 0)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "gt_u" (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E) + (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "gt_u" (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534) + (v128.const i32x4 2206368128 16776957 2130837760 4294901120)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "gt_u" (v128.const i16x8 -128 -128 0 0 1 1 255 255) + (v128.const i32x4 -128 0 1 255)) + (v128.const i16x8 0 0 0 0 0 -1 0 -1)) +(assert_return (invoke "gt_u" (v128.const i16x8 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555) + (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "gt_u" (v128.const i16x8 012_345 012_345 012_345 012_345 012_345 012_345 012_345 012_345) + (v128.const i16x8 12345 12345 12345 12345 12345 12345 12345 12345)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "gt_u" (v128.const i16x8 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234) + (v128.const i16x8 0x1234 0x1234 0x1234 0x1234 0x1234 0x1234 0x1234 0x1234)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) + +;; ge_s + +;; i16x8.ge_s (i16x8) (i16x8) + +;; hex vs hex +(assert_return (invoke "ge_s" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF) + (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "ge_s" (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000) + (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "ge_s" (v128.const i16x8 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0) + (v128.const i16x8 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "ge_s" (v128.const i16x8 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F) + (v128.const i16x8 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "ge_s" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0x0000 0x0000 0x0000 0x0000) + (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0x0000 0x0000 0x0000 0x0000)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "ge_s" (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0xFFFF 0xFFFF 0xFFFF 0xFFFF) + (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0xFFFF 0xFFFF 0xFFFF 0xFFFF)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "ge_s" (v128.const i16x8 0x0100 0x0302 0x0904 0x1110 0x0A12 0x1A0B 0xAA1B 0xFFAB) + (v128.const i16x8 0x0100 0x0302 0x0904 0x1110 0x0A12 0x1A0B 0xAA1B 0xFFAB)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + +;; hex vs dec +(assert_return (invoke "ge_s" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF) + (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "ge_s" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "ge_s" (v128.const i16x8 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080) + (v128.const i16x8 32896 32896 32896 32896 32896 32896 32896 32896)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "ge_s" (v128.const i16x8 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080) + (v128.const i16x8 -32640 -32640 -32640 -32640 -32640 -32640 -32640 -32640)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "ge_s" (v128.const i16x8 0x8180 0x8382 0xFEFD 0x00FF 0x0100 0x7F02 0xFD80 0xFFFE) + (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + +;; dec vs dec +(assert_return (invoke "ge_s" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "ge_s" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i16x8 0 0 0 0 0 0 0 0)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "ge_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535) + (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "ge_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "ge_s" (v128.const i16x8 65535 65535 65535 65535 0 0 0 0) + (v128.const i16x8 65535 65535 65535 65535 0 0 0 0)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "ge_s" (v128.const i16x8 0 0 0 0 65535 65535 65535 65535) + (v128.const i16x8 0 0 0 0 65535 65535 65535 65535)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "ge_s" (v128.const i16x8 -32768 65534 -1 -0 0 1 2 65535) + (v128.const i16x8 32768 -2 -1 -0 0 1 2 -1)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + +;; hex vs float +(assert_return (invoke "ge_s" (v128.const i16x8 0x0000 0xc300 0x0000 0xc2fe 0x0000 0xbf80 0x0000 0x0000) + (v128.const f32x4 -128.0 -127.0 -1.0 0.0)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "ge_s" (v128.const i16x8 0x0000 0x3f80 0x0000 0x42fe 0x0000 0x4300 0x0000 0x437f) + (v128.const f32x4 1.0 127.0 128.0 255.0)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + +;; not equal +(assert_return (invoke "ge_s" (v128.const i16x8 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F) + (v128.const i16x8 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "ge_s" (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0xFFFF 0xFFFF 0xFFFF 0xFFFF) + (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0x0000 0x0000 0x0000 0x0000)) + (v128.const i16x8 -1 -1 -1 -1 0 0 0 0)) +(assert_return (invoke "ge_s" (v128.const i16x8 0x0001 0x0203 0x0409 0x1011 0x120A 0x0B1A 0x1BAA 0xABFF) + (v128.const i16x8 0xFFAB 0xAA1B 0x1A0B 0x0A12 0x1110 0x0904 0x0302 0x0100)) + (v128.const i16x8 -1 -1 0 -1 -1 -1 -1 0)) +(assert_return (invoke "ge_s" (v128.const i16x8 0x8000 0x8001 0x8002 0x8003 0x8004 0x8005 0x8006 0x8007) + (v128.const i16x8 32775 32774 32773 32772 32771 32770 32769 32768)) + (v128.const i16x8 0 0 0 0 -1 -1 -1 -1)) +(assert_return (invoke "ge_s" (v128.const i16x8 32768 32769 65534 65535 0 -1 -32767 -32768) + (v128.const i16x8 -32768 -32767 -1 0 65535 65534 32769 32768)) + (v128.const i16x8 -1 -1 0 0 -1 -1 -1 -1)) + +;; i16x8.ge_s (i16x8) (i8x16) +(assert_return (invoke "ge_s" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF) + (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "ge_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535) + (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "ge_s" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "ge_s" (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E) + (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "ge_s" (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534) + (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "ge_s" (v128.const i16x8 -128 -128 0 0 1 1 255 255) + (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255)) + (v128.const i16x8 -1 -1 -1 -1 0 0 -1 -1)) +(assert_return (invoke "ge_s" (v128.const i16x8 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA) + (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) + +;; i16x8.ge_s (i16x8) (i32x4) +(assert_return (invoke "ge_s" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF) + (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "ge_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535) + (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "ge_s" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i32x4 0 0 0 0)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "ge_s" (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E) + (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "ge_s" (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534) + (v128.const i32x4 2206368128 16776957 2130837760 4294901120)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "ge_s" (v128.const i16x8 65535 65535 0 0 1 1 32768 32768) + (v128.const i32x4 65535 0 1 32768)) + (v128.const i16x8 -1 0 -1 -1 -1 -1 -1 0)) +(assert_return (invoke "ge_s" (v128.const i16x8 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555) + (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "ge_s" (v128.const i16x8 012_345 012_345 012_345 012_345 012_345 012_345 012_345 012_345) + (v128.const i16x8 12345 12345 12345 12345 12345 12345 12345 12345)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "ge_s" (v128.const i16x8 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234) + (v128.const i16x8 0x1234 0x1234 0x1234 0x1234 0x1234 0x1234 0x1234 0x1234)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + +;; ge_u + +;; i16x8.ge_u (i16x8) (i16x8) + +;; hex vs hex +(assert_return (invoke "ge_u" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF) + (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "ge_u" (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000) + (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "ge_u" (v128.const i16x8 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0) + (v128.const i16x8 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "ge_u" (v128.const i16x8 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F) + (v128.const i16x8 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "ge_u" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0x0000 0x0000 0x0000 0x0000) + (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0x0000 0x0000 0x0000 0x0000)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "ge_u" (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0xFFFF 0xFFFF 0xFFFF 0xFFFF) + (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0xFFFF 0xFFFF 0xFFFF 0xFFFF)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "ge_u" (v128.const i16x8 0x0100 0x0302 0x0904 0x1110 0x0A12 0x1A0B 0xAA1B 0xFFAB) + (v128.const i16x8 0x0100 0x0302 0x0904 0x1110 0x0A12 0x1A0B 0xAA1B 0xFFAB)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + +;; hex vs dec +(assert_return (invoke "ge_u" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF) + (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "ge_u" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "ge_u" (v128.const i16x8 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080) + (v128.const i16x8 32896 32896 32896 32896 32896 32896 32896 32896)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "ge_u" (v128.const i16x8 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080) + (v128.const i16x8 -32640 -32640 -32640 -32640 -32640 -32640 -32640 -32640)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "ge_u" (v128.const i16x8 0x8180 0x8382 0xFEFD 0x00FF 0x0100 0x7F02 0xFD80 0xFFFE) + (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + +;; dec vs dec +(assert_return (invoke "ge_u" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "ge_u" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i16x8 0 0 0 0 0 0 0 0)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "ge_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535) + (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "ge_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "ge_u" (v128.const i16x8 65535 65535 65535 65535 0 0 0 0) + (v128.const i16x8 65535 65535 65535 65535 0 0 0 0)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "ge_u" (v128.const i16x8 0 0 0 0 65535 65535 65535 65535) + (v128.const i16x8 0 0 0 0 65535 65535 65535 65535)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "ge_u" (v128.const i16x8 -32768 65534 -1 -0 0 1 2 65535) + (v128.const i16x8 32768 -2 -1 -0 0 1 2 -1)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + +;; hex vs float +(assert_return (invoke "ge_u" (v128.const i16x8 0x0000 0xc300 0x0000 0xc2fe 0x0000 0xbf80 0x0000 0x0000) + (v128.const f32x4 -128.0 -127.0 -1.0 0.0)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "ge_u" (v128.const i16x8 0x0000 0x3f80 0x0000 0x42fe 0x0000 0x4300 0x0000 0x437f) + (v128.const f32x4 1.0 127.0 128.0 255.0)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + +;; not equal +(assert_return (invoke "ge_u" (v128.const i16x8 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F) + (v128.const i16x8 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "ge_u" (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0xFFFF 0xFFFF 0xFFFF 0xFFFF) + (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0x0000 0x0000 0x0000 0x0000)) + (v128.const i16x8 0 0 0 0 -1 -1 -1 -1)) +(assert_return (invoke "ge_u" (v128.const i16x8 0x0001 0x0203 0x0409 0x1011 0x120A 0x0B1A 0x1BAA 0xABFF) + (v128.const i16x8 0xFFAB 0xAA1B 0x1A0B 0x0A12 0x1110 0x0904 0x0302 0x0100)) + (v128.const i16x8 0 0 0 -1 -1 -1 -1 -1)) +(assert_return (invoke "ge_u" (v128.const i16x8 0x8000 0x8001 0x8002 0x8003 0x8004 0x8005 0x8006 0x8007) + (v128.const i16x8 32775 32774 32773 32772 32771 32770 32769 32768)) + (v128.const i16x8 0 0 0 0 -1 -1 -1 -1)) +(assert_return (invoke "ge_u" (v128.const i16x8 32768 32769 65534 65535 0 -1 -32767 -32768) + (v128.const i16x8 -32768 -32767 -1 0 65535 65534 32769 32768)) + (v128.const i16x8 -1 -1 0 -1 0 -1 -1 -1)) + +;; i16x8.ge_u (i16x8) (i8x16) +(assert_return (invoke "ge_u" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF) + (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "ge_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535) + (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "ge_u" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "ge_u" (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E) + (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "ge_u" (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534) + (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "ge_u" (v128.const i16x8 -128 -128 0 0 1 1 255 255) + (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255)) + (v128.const i16x8 -1 -1 -1 -1 0 0 0 0)) +(assert_return (invoke "ge_u" (v128.const i16x8 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA) + (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + +;; i16x8.ge_u (i16x8) (i32x4) +(assert_return (invoke "ge_u" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF) + (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "ge_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535) + (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "ge_u" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i32x4 0 0 0 0)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "ge_u" (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E) + (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "ge_u" (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534) + (v128.const i32x4 2206368128 16776957 2130837760 4294901120)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "ge_u" (v128.const i16x8 65535 65535 0 0 1 1 32768 32768) + (v128.const i32x4 -128 0 1 255)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "ge_u" (v128.const i16x8 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555) + (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "ge_u" (v128.const i16x8 012_345 012_345 012_345 012_345 012_345 012_345 012_345 012_345) + (v128.const i16x8 12345 12345 12345 12345 12345 12345 12345 12345)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "ge_u" (v128.const i16x8 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234) + (v128.const i16x8 0x1234 0x1234 0x1234 0x1234 0x1234 0x1234 0x1234 0x1234)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + + +;; Type check + +(assert_invalid (module (func (result v128) (i16x8.eq (i32.const 0) (f32.const 0)))) "type mismatch") +(assert_invalid (module (func (result v128) (i16x8.ge_s (i32.const 0) (f32.const 0)))) "type mismatch") +(assert_invalid (module (func (result v128) (i16x8.ge_u (i32.const 0) (f32.const 0)))) "type mismatch") +(assert_invalid (module (func (result v128) (i16x8.gt_s (i32.const 0) (f32.const 0)))) "type mismatch") +(assert_invalid (module (func (result v128) (i16x8.gt_u (i32.const 0) (f32.const 0)))) "type mismatch") +(assert_invalid (module (func (result v128) (i16x8.le_s (i32.const 0) (f32.const 0)))) "type mismatch") +(assert_invalid (module (func (result v128) (i16x8.le_u (i32.const 0) (f32.const 0)))) "type mismatch") +(assert_invalid (module (func (result v128) (i16x8.lt_s (i32.const 0) (f32.const 0)))) "type mismatch") +(assert_invalid (module (func (result v128) (i16x8.lt_u (i32.const 0) (f32.const 0)))) "type mismatch") +(assert_invalid (module (func (result v128) (i16x8.ne (i32.const 0) (f32.const 0)))) "type mismatch") + + +;; combination + +(module (memory 1) + (func (export "eq-in-block") + (block + (drop + (block (result v128) + (i16x8.eq + (block (result v128) (v128.load (i32.const 0))) + (block (result v128) (v128.load (i32.const 1))) + ) + ) + ) + ) + ) + (func (export "ne-in-block") + (block + (drop + (block (result v128) + (i16x8.ne + (block (result v128) (v128.load (i32.const 0))) + (block (result v128) (v128.load (i32.const 1))) + ) + ) + ) + ) + ) + (func (export "lt_s-in-block") + (block + (drop + (block (result v128) + (i16x8.lt_s + (block (result v128) (v128.load (i32.const 0))) + (block (result v128) (v128.load (i32.const 1))) + ) + ) + ) + ) + ) + (func (export "le_u-in-block") + (block + (drop + (block (result v128) + (i16x8.le_u + (block (result v128) (v128.load (i32.const 0))) + (block (result v128) (v128.load (i32.const 1))) + ) + ) + ) + ) + ) + (func (export "gt_u-in-block") + (block + (drop + (block (result v128) + (i16x8.gt_u + (block (result v128) (v128.load (i32.const 0))) + (block (result v128) (v128.load (i32.const 1))) + ) + ) + ) + ) + ) + (func (export "ge_s-in-block") + (block + (drop + (block (result v128) + (i16x8.ge_s + (block (result v128) (v128.load (i32.const 0))) + (block (result v128) (v128.load (i32.const 1))) + ) + ) + ) + ) + ) + (func (export "nested-eq") + (drop + (i16x8.eq + (i16x8.eq + (i16x8.eq + (v128.load (i32.const 0)) + (v128.load (i32.const 1)) + ) + (i16x8.eq + (v128.load (i32.const 2)) + (v128.load (i32.const 3)) + ) + ) + (i16x8.eq + (i16x8.eq + (v128.load (i32.const 0)) + (v128.load (i32.const 1)) + ) + (i16x8.eq + (v128.load (i32.const 2)) + (v128.load (i32.const 3)) + ) + ) + ) + ) + ) + (func (export "nested-ne") + (drop + (i16x8.ne + (i16x8.ne + (i16x8.ne + (v128.load (i32.const 0)) + (v128.load (i32.const 1)) + ) + (i16x8.ne + (v128.load (i32.const 2)) + (v128.load (i32.const 3)) + ) + ) + (i16x8.ne + (i16x8.ne + (v128.load (i32.const 0)) + (v128.load (i32.const 1)) + ) + (i16x8.ne + (v128.load (i32.const 2)) + (v128.load (i32.const 3)) + ) + ) + ) + ) + ) + (func (export "nested-lt_s") + (drop + (i16x8.lt_s + (i16x8.lt_s + (i16x8.lt_s + (v128.load (i32.const 0)) + (v128.load (i32.const 1)) + ) + (i16x8.lt_s + (v128.load (i32.const 2)) + (v128.load (i32.const 3)) + ) + ) + (i16x8.lt_s + (i16x8.lt_s + (v128.load (i32.const 0)) + (v128.load (i32.const 1)) + ) + (i16x8.lt_s + (v128.load (i32.const 2)) + (v128.load (i32.const 3)) + ) + ) + ) + ) + ) + (func (export "nested-le_u") + (drop + (i16x8.le_u + (i16x8.le_u + (i16x8.le_u + (v128.load (i32.const 0)) + (v128.load (i32.const 1)) + ) + (i16x8.le_u + (v128.load (i32.const 2)) + (v128.load (i32.const 3)) + ) + ) + (i16x8.le_u + (i16x8.le_u + (v128.load (i32.const 0)) + (v128.load (i32.const 1)) + ) + (i16x8.le_u + (v128.load (i32.const 2)) + (v128.load (i32.const 3)) + ) + ) + ) + ) + ) + (func (export "nested-gt_u") + (drop + (i16x8.gt_u + (i16x8.gt_u + (i16x8.gt_u + (v128.load (i32.const 0)) + (v128.load (i32.const 1)) + ) + (i16x8.gt_u + (v128.load (i32.const 2)) + (v128.load (i32.const 3)) + ) + ) + (i16x8.gt_u + (i16x8.gt_u + (v128.load (i32.const 0)) + (v128.load (i32.const 1)) + ) + (i16x8.gt_u + (v128.load (i32.const 2)) + (v128.load (i32.const 3)) + ) + ) + ) + ) + ) + (func (export "nested-ge_s") + (drop + (i16x8.ge_s + (i16x8.ge_s + (i16x8.ge_s + (v128.load (i32.const 0)) + (v128.load (i32.const 1)) + ) + (i16x8.ge_s + (v128.load (i32.const 2)) + (v128.load (i32.const 3)) + ) + ) + (i16x8.ge_s + (i16x8.ge_s + (v128.load (i32.const 0)) + (v128.load (i32.const 1)) + ) + (i16x8.ge_s + (v128.load (i32.const 2)) + (v128.load (i32.const 3)) + ) + ) + ) + ) + ) + (func (export "as-param") + (drop + (i16x8.ge_u + (i16x8.eq + (i16x8.lt_s + (v128.load (i32.const 0)) + (v128.load (i32.const 1)) + ) + (i16x8.le_u + (v128.load (i32.const 2)) + (v128.load (i32.const 3)) + ) + ) + (i16x8.ne + (i16x8.gt_s + (v128.load (i32.const 0)) + (v128.load (i32.const 1)) + ) + (i16x8.lt_u + (v128.load (i32.const 2)) + (v128.load (i32.const 3)) + ) + ) + ) + ) + ) +) +(assert_return (invoke "eq-in-block")) +(assert_return (invoke "ne-in-block")) +(assert_return (invoke "lt_s-in-block")) +(assert_return (invoke "le_u-in-block")) +(assert_return (invoke "gt_u-in-block")) +(assert_return (invoke "ge_s-in-block")) +(assert_return (invoke "nested-eq")) +(assert_return (invoke "nested-ne")) +(assert_return (invoke "nested-lt_s")) +(assert_return (invoke "nested-le_u")) +(assert_return (invoke "nested-gt_u")) +(assert_return (invoke "nested-ge_s")) +(assert_return (invoke "as-param")) + + +;; Test operation with empty argument + +(assert_invalid + (module + (func $i16x8.eq-1st-arg-empty (result v128) + (i16x8.eq (v128.const i16x8 0 0 0 0 0 0 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i16x8.eq-arg-empty (result v128) + (i16x8.eq) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i16x8.ne-1st-arg-empty (result v128) + (i16x8.ne (v128.const i16x8 0 0 0 0 0 0 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i16x8.ne-arg-empty (result v128) + (i16x8.ne) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i16x8.lt_s-1st-arg-empty (result v128) + (i16x8.lt_s (v128.const i16x8 0 0 0 0 0 0 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i16x8.lt_s-arg-empty (result v128) + (i16x8.lt_s) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i16x8.lt_u-1st-arg-empty (result v128) + (i16x8.lt_u (v128.const i16x8 0 0 0 0 0 0 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i16x8.lt_u-arg-empty (result v128) + (i16x8.lt_u) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i16x8.le_s-1st-arg-empty (result v128) + (i16x8.le_s (v128.const i16x8 0 0 0 0 0 0 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i16x8.le_s-arg-empty (result v128) + (i16x8.le_s) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i16x8.le_u-1st-arg-empty (result v128) + (i16x8.le_u (v128.const i16x8 0 0 0 0 0 0 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i16x8.le_u-arg-empty (result v128) + (i16x8.le_u) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i16x8.gt_s-1st-arg-empty (result v128) + (i16x8.gt_s (v128.const i16x8 0 0 0 0 0 0 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i16x8.gt_s-arg-empty (result v128) + (i16x8.gt_s) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i16x8.gt_u-1st-arg-empty (result v128) + (i16x8.gt_u (v128.const i16x8 0 0 0 0 0 0 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i16x8.gt_u-arg-empty (result v128) + (i16x8.gt_u) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i16x8.ge_s-1st-arg-empty (result v128) + (i16x8.ge_s (v128.const i16x8 0 0 0 0 0 0 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i16x8.ge_s-arg-empty (result v128) + (i16x8.ge_s) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i16x8.ge_u-1st-arg-empty (result v128) + (i16x8.ge_u (v128.const i16x8 0 0 0 0 0 0 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i16x8.ge_u-arg-empty (result v128) + (i16x8.ge_u) + ) + ) + "type mismatch" +) \ No newline at end of file diff --git a/runtime/near-vm/tests/wast/spec/proposals/simd/simd_i16x8_extadd_pairwise_i8x16.wast b/runtime/near-vm/tests/wast/spec/proposals/simd/simd_i16x8_extadd_pairwise_i8x16.wast new file mode 100644 index 00000000000..c2267de9c3e --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/proposals/simd/simd_i16x8_extadd_pairwise_i8x16.wast @@ -0,0 +1,68 @@ +;; Tests for i16x8 arithmetic operations on major boundary values and all special values. + + +(module + (func (export "i16x8.extadd_pairwise_i8x16_s") (param v128) (result v128) (i16x8.extadd_pairwise_i8x16_s (local.get 0))) + (func (export "i16x8.extadd_pairwise_i8x16_u") (param v128) (result v128) (i16x8.extadd_pairwise_i8x16_u (local.get 0))) +) + + +;; i16x8.extadd_pairwise_i8x16_s +(assert_return (invoke "i16x8.extadd_pairwise_i8x16_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.extadd_pairwise_i8x16_s" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) + (v128.const i16x8 2 2 2 2 2 2 2 2)) +(assert_return (invoke "i16x8.extadd_pairwise_i8x16_s" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i16x8 -2 -2 -2 -2 -2 -2 -2 -2)) +(assert_return (invoke "i16x8.extadd_pairwise_i8x16_s" (v128.const i8x16 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126)) + (v128.const i16x8 252 252 252 252 252 252 252 252)) +(assert_return (invoke "i16x8.extadd_pairwise_i8x16_s" (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127)) + (v128.const i16x8 -254 -254 -254 -254 -254 -254 -254 -254)) +(assert_return (invoke "i16x8.extadd_pairwise_i8x16_s" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)) + (v128.const i16x8 -256 -256 -256 -256 -256 -256 -256 -256)) +(assert_return (invoke "i16x8.extadd_pairwise_i8x16_s" (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127)) + (v128.const i16x8 254 254 254 254 254 254 254 254)) +(assert_return (invoke "i16x8.extadd_pairwise_i8x16_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)) + (v128.const i16x8 -2 -2 -2 -2 -2 -2 -2 -2)) + +;; i16x8.extadd_pairwise_i8x16_u +(assert_return (invoke "i16x8.extadd_pairwise_i8x16_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.extadd_pairwise_i8x16_u" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) + (v128.const i16x8 2 2 2 2 2 2 2 2)) +(assert_return (invoke "i16x8.extadd_pairwise_i8x16_u" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i16x8 510 510 510 510 510 510 510 510)) +(assert_return (invoke "i16x8.extadd_pairwise_i8x16_u" (v128.const i8x16 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126)) + (v128.const i16x8 252 252 252 252 252 252 252 252)) +(assert_return (invoke "i16x8.extadd_pairwise_i8x16_u" (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127)) + (v128.const i16x8 258 258 258 258 258 258 258 258)) +(assert_return (invoke "i16x8.extadd_pairwise_i8x16_u" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)) + (v128.const i16x8 256 256 256 256 256 256 256 256)) +(assert_return (invoke "i16x8.extadd_pairwise_i8x16_u" (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127)) + (v128.const i16x8 254 254 254 254 254 254 254 254)) +(assert_return (invoke "i16x8.extadd_pairwise_i8x16_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)) + (v128.const i16x8 510 510 510 510 510 510 510 510)) + +;; type check +(assert_invalid (module (func (result v128) (i16x8.extadd_pairwise_i8x16_s (i32.const 0)))) "type mismatch") +(assert_invalid (module (func (result v128) (i16x8.extadd_pairwise_i8x16_u (i32.const 0)))) "type mismatch") + +;; Test operation with empty argument + +(assert_invalid + (module + (func $i16x8.extadd_pairwise_i8x16_s-arg-empty (result v128) + (i16x8.extadd_pairwise_i8x16_s) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i16x8.extadd_pairwise_i8x16_u-arg-empty (result v128) + (i16x8.extadd_pairwise_i8x16_u) + ) + ) + "type mismatch" +) + diff --git a/runtime/near-vm/tests/wast/spec/proposals/simd/simd_i16x8_extmul_i8x16.wast b/runtime/near-vm/tests/wast/spec/proposals/simd/simd_i16x8_extmul_i8x16.wast new file mode 100644 index 00000000000..cc8cf8f4020 --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/proposals/simd/simd_i16x8_extmul_i8x16.wast @@ -0,0 +1,404 @@ +;; Tests for i16x8 arithmetic operations on major boundary values and all special values. + + +(module + (func (export "i16x8.extmul_low_i8x16_s") (param v128 v128) (result v128) (i16x8.extmul_low_i8x16_s (local.get 0) (local.get 1))) + (func (export "i16x8.extmul_high_i8x16_s") (param v128 v128) (result v128) (i16x8.extmul_high_i8x16_s (local.get 0) (local.get 1))) + (func (export "i16x8.extmul_low_i8x16_u") (param v128 v128) (result v128) (i16x8.extmul_low_i8x16_u (local.get 0) (local.get 1))) + (func (export "i16x8.extmul_high_i8x16_u") (param v128 v128) (result v128) (i16x8.extmul_high_i8x16_u (local.get 0) (local.get 1))) +) + + +;; i16x8.extmul_low_i8x16_s +(assert_return (invoke "i16x8.extmul_low_i8x16_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.extmul_low_i8x16_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.extmul_low_i8x16_s" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) + (v128.const i16x8 1 1 1 1 1 1 1 1)) +(assert_return (invoke "i16x8.extmul_low_i8x16_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.extmul_low_i8x16_s" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "i16x8.extmul_low_i8x16_s" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i16x8 1 1 1 1 1 1 1 1)) +(assert_return (invoke "i16x8.extmul_low_i8x16_s" (v128.const i8x16 63 63 63 63 63 63 63 63 63 63 63 63 63 63 63 63) + (v128.const i8x16 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64)) + (v128.const i16x8 4032 4032 4032 4032 4032 4032 4032 4032)) +(assert_return (invoke "i16x8.extmul_low_i8x16_s" (v128.const i8x16 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64) + (v128.const i8x16 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64)) + (v128.const i16x8 4096 4096 4096 4096 4096 4096 4096 4096)) +(assert_return (invoke "i16x8.extmul_low_i8x16_s" (v128.const i8x16 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63) + (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64)) + (v128.const i16x8 4032 4032 4032 4032 4032 4032 4032 4032)) +(assert_return (invoke "i16x8.extmul_low_i8x16_s" (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64) + (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64)) + (v128.const i16x8 4096 4096 4096 4096 4096 4096 4096 4096)) +(assert_return (invoke "i16x8.extmul_low_i8x16_s" (v128.const i8x16 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65) + (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64)) + (v128.const i16x8 4160 4160 4160 4160 4160 4160 4160 4160)) +(assert_return (invoke "i16x8.extmul_low_i8x16_s" (v128.const i8x16 125 125 125 125 125 125 125 125 125 125 125 125 125 125 125 125) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) + (v128.const i16x8 125 125 125 125 125 125 125 125)) +(assert_return (invoke "i16x8.extmul_low_i8x16_s" (v128.const i8x16 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) + (v128.const i16x8 126 126 126 126 126 126 126 126)) +(assert_return (invoke "i16x8.extmul_low_i8x16_s" (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) + (v128.const i16x8 -128 -128 -128 -128 -128 -128 -128 -128)) +(assert_return (invoke "i16x8.extmul_low_i8x16_s" (v128.const i8x16 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i16x8 126 126 126 126 126 126 126 126)) +(assert_return (invoke "i16x8.extmul_low_i8x16_s" (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i16x8 127 127 127 127 127 127 127 127)) +(assert_return (invoke "i16x8.extmul_low_i8x16_s" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i16x8 128 128 128 128 128 128 128 128)) +(assert_return (invoke "i16x8.extmul_low_i8x16_s" (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127) + (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127)) + (v128.const i16x8 16129 16129 16129 16129 16129 16129 16129 16129)) +(assert_return (invoke "i16x8.extmul_low_i8x16_s" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128) + (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)) + (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384)) +(assert_return (invoke "i16x8.extmul_low_i8x16_s" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128) + (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127)) + (v128.const i16x8 16256 16256 16256 16256 16256 16256 16256 16256)) +(assert_return (invoke "i16x8.extmul_low_i8x16_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.extmul_low_i8x16_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "i16x8.extmul_low_i8x16_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i16x8 1 1 1 1 1 1 1 1)) +(assert_return (invoke "i16x8.extmul_low_i8x16_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255) + (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127)) + (v128.const i16x8 -127 -127 -127 -127 -127 -127 -127 -127)) +(assert_return (invoke "i16x8.extmul_low_i8x16_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255) + (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)) + (v128.const i16x8 128 128 128 128 128 128 128 128)) +(assert_return (invoke "i16x8.extmul_low_i8x16_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255) + (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)) + (v128.const i16x8 1 1 1 1 1 1 1 1)) + +;; i16x8.extmul_high_i8x16_s +(assert_return (invoke "i16x8.extmul_high_i8x16_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.extmul_high_i8x16_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.extmul_high_i8x16_s" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) + (v128.const i16x8 1 1 1 1 1 1 1 1)) +(assert_return (invoke "i16x8.extmul_high_i8x16_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.extmul_high_i8x16_s" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "i16x8.extmul_high_i8x16_s" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i16x8 1 1 1 1 1 1 1 1)) +(assert_return (invoke "i16x8.extmul_high_i8x16_s" (v128.const i8x16 63 63 63 63 63 63 63 63 63 63 63 63 63 63 63 63) + (v128.const i8x16 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64)) + (v128.const i16x8 4032 4032 4032 4032 4032 4032 4032 4032)) +(assert_return (invoke "i16x8.extmul_high_i8x16_s" (v128.const i8x16 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64) + (v128.const i8x16 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64)) + (v128.const i16x8 4096 4096 4096 4096 4096 4096 4096 4096)) +(assert_return (invoke "i16x8.extmul_high_i8x16_s" (v128.const i8x16 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63) + (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64)) + (v128.const i16x8 4032 4032 4032 4032 4032 4032 4032 4032)) +(assert_return (invoke "i16x8.extmul_high_i8x16_s" (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64) + (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64)) + (v128.const i16x8 4096 4096 4096 4096 4096 4096 4096 4096)) +(assert_return (invoke "i16x8.extmul_high_i8x16_s" (v128.const i8x16 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65) + (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64)) + (v128.const i16x8 4160 4160 4160 4160 4160 4160 4160 4160)) +(assert_return (invoke "i16x8.extmul_high_i8x16_s" (v128.const i8x16 125 125 125 125 125 125 125 125 125 125 125 125 125 125 125 125) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) + (v128.const i16x8 125 125 125 125 125 125 125 125)) +(assert_return (invoke "i16x8.extmul_high_i8x16_s" (v128.const i8x16 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) + (v128.const i16x8 126 126 126 126 126 126 126 126)) +(assert_return (invoke "i16x8.extmul_high_i8x16_s" (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) + (v128.const i16x8 -128 -128 -128 -128 -128 -128 -128 -128)) +(assert_return (invoke "i16x8.extmul_high_i8x16_s" (v128.const i8x16 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i16x8 126 126 126 126 126 126 126 126)) +(assert_return (invoke "i16x8.extmul_high_i8x16_s" (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i16x8 127 127 127 127 127 127 127 127)) +(assert_return (invoke "i16x8.extmul_high_i8x16_s" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i16x8 128 128 128 128 128 128 128 128)) +(assert_return (invoke "i16x8.extmul_high_i8x16_s" (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127) + (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127)) + (v128.const i16x8 16129 16129 16129 16129 16129 16129 16129 16129)) +(assert_return (invoke "i16x8.extmul_high_i8x16_s" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128) + (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)) + (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384)) +(assert_return (invoke "i16x8.extmul_high_i8x16_s" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128) + (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127)) + (v128.const i16x8 16256 16256 16256 16256 16256 16256 16256 16256)) +(assert_return (invoke "i16x8.extmul_high_i8x16_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.extmul_high_i8x16_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "i16x8.extmul_high_i8x16_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i16x8 1 1 1 1 1 1 1 1)) +(assert_return (invoke "i16x8.extmul_high_i8x16_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255) + (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127)) + (v128.const i16x8 -127 -127 -127 -127 -127 -127 -127 -127)) +(assert_return (invoke "i16x8.extmul_high_i8x16_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255) + (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)) + (v128.const i16x8 128 128 128 128 128 128 128 128)) +(assert_return (invoke "i16x8.extmul_high_i8x16_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255) + (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)) + (v128.const i16x8 1 1 1 1 1 1 1 1)) + +;; i16x8.extmul_low_i8x16_u +(assert_return (invoke "i16x8.extmul_low_i8x16_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.extmul_low_i8x16_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.extmul_low_i8x16_u" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) + (v128.const i16x8 1 1 1 1 1 1 1 1)) +(assert_return (invoke "i16x8.extmul_low_i8x16_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.extmul_low_i8x16_u" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i16x8 255 255 255 255 255 255 255 255)) +(assert_return (invoke "i16x8.extmul_low_i8x16_u" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i16x8 -511 -511 -511 -511 -511 -511 -511 -511)) +(assert_return (invoke "i16x8.extmul_low_i8x16_u" (v128.const i8x16 63 63 63 63 63 63 63 63 63 63 63 63 63 63 63 63) + (v128.const i8x16 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64)) + (v128.const i16x8 4032 4032 4032 4032 4032 4032 4032 4032)) +(assert_return (invoke "i16x8.extmul_low_i8x16_u" (v128.const i8x16 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64) + (v128.const i8x16 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64)) + (v128.const i16x8 4096 4096 4096 4096 4096 4096 4096 4096)) +(assert_return (invoke "i16x8.extmul_low_i8x16_u" (v128.const i8x16 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63) + (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64)) + (v128.const i16x8 -28480 -28480 -28480 -28480 -28480 -28480 -28480 -28480)) +(assert_return (invoke "i16x8.extmul_low_i8x16_u" (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64) + (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64)) + (v128.const i16x8 -28672 -28672 -28672 -28672 -28672 -28672 -28672 -28672)) +(assert_return (invoke "i16x8.extmul_low_i8x16_u" (v128.const i8x16 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65) + (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64)) + (v128.const i16x8 -28864 -28864 -28864 -28864 -28864 -28864 -28864 -28864)) +(assert_return (invoke "i16x8.extmul_low_i8x16_u" (v128.const i8x16 125 125 125 125 125 125 125 125 125 125 125 125 125 125 125 125) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) + (v128.const i16x8 125 125 125 125 125 125 125 125)) +(assert_return (invoke "i16x8.extmul_low_i8x16_u" (v128.const i8x16 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) + (v128.const i16x8 126 126 126 126 126 126 126 126)) +(assert_return (invoke "i16x8.extmul_low_i8x16_u" (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) + (v128.const i16x8 128 128 128 128 128 128 128 128)) +(assert_return (invoke "i16x8.extmul_low_i8x16_u" (v128.const i8x16 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i16x8 -32386 -32386 -32386 -32386 -32386 -32386 -32386 -32386)) +(assert_return (invoke "i16x8.extmul_low_i8x16_u" (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i16x8 -32641 -32641 -32641 -32641 -32641 -32641 -32641 -32641)) +(assert_return (invoke "i16x8.extmul_low_i8x16_u" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i16x8 32640 32640 32640 32640 32640 32640 32640 32640)) +(assert_return (invoke "i16x8.extmul_low_i8x16_u" (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127) + (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127)) + (v128.const i16x8 16129 16129 16129 16129 16129 16129 16129 16129)) +(assert_return (invoke "i16x8.extmul_low_i8x16_u" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128) + (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)) + (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384)) +(assert_return (invoke "i16x8.extmul_low_i8x16_u" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128) + (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127)) + (v128.const i16x8 16512 16512 16512 16512 16512 16512 16512 16512)) +(assert_return (invoke "i16x8.extmul_low_i8x16_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.extmul_low_i8x16_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) + (v128.const i16x8 255 255 255 255 255 255 255 255)) +(assert_return (invoke "i16x8.extmul_low_i8x16_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i16x8 -511 -511 -511 -511 -511 -511 -511 -511)) +(assert_return (invoke "i16x8.extmul_low_i8x16_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255) + (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127)) + (v128.const i16x8 32385 32385 32385 32385 32385 32385 32385 32385)) +(assert_return (invoke "i16x8.extmul_low_i8x16_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255) + (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)) + (v128.const i16x8 32640 32640 32640 32640 32640 32640 32640 32640)) +(assert_return (invoke "i16x8.extmul_low_i8x16_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255) + (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)) + (v128.const i16x8 -511 -511 -511 -511 -511 -511 -511 -511)) + +;; i16x8.extmul_high_i8x16_u +(assert_return (invoke "i16x8.extmul_high_i8x16_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.extmul_high_i8x16_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.extmul_high_i8x16_u" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) + (v128.const i16x8 1 1 1 1 1 1 1 1)) +(assert_return (invoke "i16x8.extmul_high_i8x16_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.extmul_high_i8x16_u" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i16x8 255 255 255 255 255 255 255 255)) +(assert_return (invoke "i16x8.extmul_high_i8x16_u" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i16x8 -511 -511 -511 -511 -511 -511 -511 -511)) +(assert_return (invoke "i16x8.extmul_high_i8x16_u" (v128.const i8x16 63 63 63 63 63 63 63 63 63 63 63 63 63 63 63 63) + (v128.const i8x16 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64)) + (v128.const i16x8 4032 4032 4032 4032 4032 4032 4032 4032)) +(assert_return (invoke "i16x8.extmul_high_i8x16_u" (v128.const i8x16 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64) + (v128.const i8x16 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64)) + (v128.const i16x8 4096 4096 4096 4096 4096 4096 4096 4096)) +(assert_return (invoke "i16x8.extmul_high_i8x16_u" (v128.const i8x16 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63) + (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64)) + (v128.const i16x8 -28480 -28480 -28480 -28480 -28480 -28480 -28480 -28480)) +(assert_return (invoke "i16x8.extmul_high_i8x16_u" (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64) + (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64)) + (v128.const i16x8 -28672 -28672 -28672 -28672 -28672 -28672 -28672 -28672)) +(assert_return (invoke "i16x8.extmul_high_i8x16_u" (v128.const i8x16 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65) + (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64)) + (v128.const i16x8 -28864 -28864 -28864 -28864 -28864 -28864 -28864 -28864)) +(assert_return (invoke "i16x8.extmul_high_i8x16_u" (v128.const i8x16 125 125 125 125 125 125 125 125 125 125 125 125 125 125 125 125) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) + (v128.const i16x8 125 125 125 125 125 125 125 125)) +(assert_return (invoke "i16x8.extmul_high_i8x16_u" (v128.const i8x16 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) + (v128.const i16x8 126 126 126 126 126 126 126 126)) +(assert_return (invoke "i16x8.extmul_high_i8x16_u" (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) + (v128.const i16x8 128 128 128 128 128 128 128 128)) +(assert_return (invoke "i16x8.extmul_high_i8x16_u" (v128.const i8x16 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i16x8 -32386 -32386 -32386 -32386 -32386 -32386 -32386 -32386)) +(assert_return (invoke "i16x8.extmul_high_i8x16_u" (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i16x8 -32641 -32641 -32641 -32641 -32641 -32641 -32641 -32641)) +(assert_return (invoke "i16x8.extmul_high_i8x16_u" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i16x8 32640 32640 32640 32640 32640 32640 32640 32640)) +(assert_return (invoke "i16x8.extmul_high_i8x16_u" (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127) + (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127)) + (v128.const i16x8 16129 16129 16129 16129 16129 16129 16129 16129)) +(assert_return (invoke "i16x8.extmul_high_i8x16_u" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128) + (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)) + (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384)) +(assert_return (invoke "i16x8.extmul_high_i8x16_u" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128) + (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127)) + (v128.const i16x8 16512 16512 16512 16512 16512 16512 16512 16512)) +(assert_return (invoke "i16x8.extmul_high_i8x16_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.extmul_high_i8x16_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) + (v128.const i16x8 255 255 255 255 255 255 255 255)) +(assert_return (invoke "i16x8.extmul_high_i8x16_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i16x8 -511 -511 -511 -511 -511 -511 -511 -511)) +(assert_return (invoke "i16x8.extmul_high_i8x16_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255) + (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127)) + (v128.const i16x8 32385 32385 32385 32385 32385 32385 32385 32385)) +(assert_return (invoke "i16x8.extmul_high_i8x16_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255) + (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)) + (v128.const i16x8 32640 32640 32640 32640 32640 32640 32640 32640)) +(assert_return (invoke "i16x8.extmul_high_i8x16_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255) + (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)) + (v128.const i16x8 -511 -511 -511 -511 -511 -511 -511 -511)) + +;; type check +(assert_invalid (module (func (result v128) (i16x8.extmul_low_i8x16_s (i32.const 0) (f32.const 0.0)))) "type mismatch") +(assert_invalid (module (func (result v128) (i16x8.extmul_high_i8x16_s (i32.const 0) (f32.const 0.0)))) "type mismatch") +(assert_invalid (module (func (result v128) (i16x8.extmul_low_i8x16_u (i32.const 0) (f32.const 0.0)))) "type mismatch") +(assert_invalid (module (func (result v128) (i16x8.extmul_high_i8x16_u (i32.const 0) (f32.const 0.0)))) "type mismatch") + +;; Test operation with empty argument + +(assert_invalid + (module + (func $i16x8.extmul_low_i8x16_s-1st-arg-empty (result v128) + (i16x8.extmul_low_i8x16_s (v128.const i16x8 0 0 0 0 0 0 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i16x8.extmul_low_i8x16_s-arg-empty (result v128) + (i16x8.extmul_low_i8x16_s) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i16x8.extmul_high_i8x16_s-1st-arg-empty (result v128) + (i16x8.extmul_high_i8x16_s (v128.const i16x8 0 0 0 0 0 0 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i16x8.extmul_high_i8x16_s-arg-empty (result v128) + (i16x8.extmul_high_i8x16_s) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i16x8.extmul_low_i8x16_u-1st-arg-empty (result v128) + (i16x8.extmul_low_i8x16_u (v128.const i16x8 0 0 0 0 0 0 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i16x8.extmul_low_i8x16_u-arg-empty (result v128) + (i16x8.extmul_low_i8x16_u) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i16x8.extmul_high_i8x16_u-1st-arg-empty (result v128) + (i16x8.extmul_high_i8x16_u (v128.const i16x8 0 0 0 0 0 0 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i16x8.extmul_high_i8x16_u-arg-empty (result v128) + (i16x8.extmul_high_i8x16_u) + ) + ) + "type mismatch" +) + diff --git a/runtime/near-vm/tests/wast/spec/proposals/simd/simd_i16x8_q15mulr_sat_s.wast b/runtime/near-vm/tests/wast/spec/proposals/simd/simd_i16x8_q15mulr_sat_s.wast new file mode 100644 index 00000000000..2cea8cc7488 --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/proposals/simd/simd_i16x8_q15mulr_sat_s.wast @@ -0,0 +1,110 @@ +;; Tests for i16x8 arithmetic operations on major boundary values and all special values. + + +(module + (func (export "i16x8.q15mulr_sat_s") (param v128 v128) (result v128) (i16x8.q15mulr_sat_s (local.get 0) (local.get 1))) +) + + +;; i16x8.q15mulr_sat_s +(assert_return (invoke "i16x8.q15mulr_sat_s" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i16x8 0 0 0 0 0 0 0 0)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.q15mulr_sat_s" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i16x8 1 1 1 1 1 1 1 1)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.q15mulr_sat_s" (v128.const i16x8 1 1 1 1 1 1 1 1) + (v128.const i16x8 1 1 1 1 1 1 1 1)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.q15mulr_sat_s" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.q15mulr_sat_s" (v128.const i16x8 1 1 1 1 1 1 1 1) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.q15mulr_sat_s" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.q15mulr_sat_s" (v128.const i16x8 16383 16383 16383 16383 16383 16383 16383 16383) + (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384)) + (v128.const i16x8 8192 8192 8192 8192 8192 8192 8192 8192)) +(assert_return (invoke "i16x8.q15mulr_sat_s" (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384) + (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384)) + (v128.const i16x8 8192 8192 8192 8192 8192 8192 8192 8192)) +(assert_return (invoke "i16x8.q15mulr_sat_s" (v128.const i16x8 -16383 -16383 -16383 -16383 -16383 -16383 -16383 -16383) + (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384)) + (v128.const i16x8 8192 8192 8192 8192 8192 8192 8192 8192)) +(assert_return (invoke "i16x8.q15mulr_sat_s" (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384) + (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384)) + (v128.const i16x8 8192 8192 8192 8192 8192 8192 8192 8192)) +(assert_return (invoke "i16x8.q15mulr_sat_s" (v128.const i16x8 -16385 -16385 -16385 -16385 -16385 -16385 -16385 -16385) + (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384)) + (v128.const i16x8 8193 8193 8193 8193 8193 8193 8193 8193)) +(assert_return (invoke "i16x8.q15mulr_sat_s" (v128.const i16x8 32765 32765 32765 32765 32765 32765 32765 32765) + (v128.const i16x8 1 1 1 1 1 1 1 1)) + (v128.const i16x8 1 1 1 1 1 1 1 1)) +(assert_return (invoke "i16x8.q15mulr_sat_s" (v128.const i16x8 32766 32766 32766 32766 32766 32766 32766 32766) + (v128.const i16x8 1 1 1 1 1 1 1 1)) + (v128.const i16x8 1 1 1 1 1 1 1 1)) +(assert_return (invoke "i16x8.q15mulr_sat_s" (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768) + (v128.const i16x8 1 1 1 1 1 1 1 1)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "i16x8.q15mulr_sat_s" (v128.const i16x8 -32766 -32766 -32766 -32766 -32766 -32766 -32766 -32766) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i16x8 1 1 1 1 1 1 1 1)) +(assert_return (invoke "i16x8.q15mulr_sat_s" (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i16x8 1 1 1 1 1 1 1 1)) +(assert_return (invoke "i16x8.q15mulr_sat_s" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i16x8 1 1 1 1 1 1 1 1)) +(assert_return (invoke "i16x8.q15mulr_sat_s" (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767) + (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767)) + (v128.const i16x8 32766 32766 32766 32766 32766 32766 32766 32766)) +(assert_return (invoke "i16x8.q15mulr_sat_s" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768) + (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)) + (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767)) +(assert_return (invoke "i16x8.q15mulr_sat_s" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768) + (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767)) + (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767)) +(assert_return (invoke "i16x8.q15mulr_sat_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535) + (v128.const i16x8 0 0 0 0 0 0 0 0)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.q15mulr_sat_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535) + (v128.const i16x8 1 1 1 1 1 1 1 1)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.q15mulr_sat_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.q15mulr_sat_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535) + (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "i16x8.q15mulr_sat_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535) + (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)) + (v128.const i16x8 1 1 1 1 1 1 1 1)) +(assert_return (invoke "i16x8.q15mulr_sat_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535) + (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) + +;; type check +(assert_invalid (module (func (result v128) (i16x8.q15mulr_sat_s (i32.const 0) (f32.const 0.0)))) "type mismatch") + +;; Test operation with empty argument + +(assert_invalid + (module + (func $i16x8.q15mulr_sat_s-1st-arg-empty (result v128) + (i16x8.q15mulr_sat_s (v128.const i16x8 0 0 0 0 0 0 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i16x8.q15mulr_sat_s-arg-empty (result v128) + (i16x8.q15mulr_sat_s) + ) + ) + "type mismatch" +) + diff --git a/runtime/near-vm/tests/wast/spec/proposals/simd/simd_i16x8_sat_arith.wast b/runtime/near-vm/tests/wast/spec/proposals/simd/simd_i16x8_sat_arith.wast new file mode 100644 index 00000000000..cea4ebbc7f9 --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/proposals/simd/simd_i16x8_sat_arith.wast @@ -0,0 +1,742 @@ +;; Tests for i16x8 arithmetic operations on major boundary values and all special values. + + +(module + (func (export "i16x8.add_sat_s") (param v128 v128) (result v128) (i16x8.add_sat_s (local.get 0) (local.get 1))) + (func (export "i16x8.add_sat_u") (param v128 v128) (result v128) (i16x8.add_sat_u (local.get 0) (local.get 1))) + (func (export "i16x8.sub_sat_s") (param v128 v128) (result v128) (i16x8.sub_sat_s (local.get 0) (local.get 1))) + (func (export "i16x8.sub_sat_u") (param v128 v128) (result v128) (i16x8.sub_sat_u (local.get 0) (local.get 1))) +) + + +;; i16x8.add_sat_s +(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i16x8 0 0 0 0 0 0 0 0)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i16x8 1 1 1 1 1 1 1 1)) + (v128.const i16x8 1 1 1 1 1 1 1 1)) +(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 1 1 1 1 1 1 1 1) + (v128.const i16x8 1 1 1 1 1 1 1 1)) + (v128.const i16x8 2 2 2 2 2 2 2 2)) +(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 1 1 1 1 1 1 1 1) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i16x8 -2 -2 -2 -2 -2 -2 -2 -2)) +(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 16383 16383 16383 16383 16383 16383 16383 16383) + (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384)) + (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767)) +(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384) + (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384)) + (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767)) +(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 -16383 -16383 -16383 -16383 -16383 -16383 -16383 -16383) + (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384)) + (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767)) +(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384) + (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384)) + (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)) +(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 -16385 -16385 -16385 -16385 -16385 -16385 -16385 -16385) + (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384)) + (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)) +(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 32765 32765 32765 32765 32765 32765 32765 32765) + (v128.const i16x8 1 1 1 1 1 1 1 1)) + (v128.const i16x8 32766 32766 32766 32766 32766 32766 32766 32766)) +(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 32766 32766 32766 32766 32766 32766 32766 32766) + (v128.const i16x8 1 1 1 1 1 1 1 1)) + (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767)) +(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768) + (v128.const i16x8 1 1 1 1 1 1 1 1)) + (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767)) +(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 -32766 -32766 -32766 -32766 -32766 -32766 -32766 -32766) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767)) +(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)) +(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)) +(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767) + (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767)) + (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767)) +(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768) + (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)) + (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)) +(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768) + (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767)) + (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)) +(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535) + (v128.const i16x8 0 0 0 0 0 0 0 0)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535) + (v128.const i16x8 1 1 1 1 1 1 1 1)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i16x8 -2 -2 -2 -2 -2 -2 -2 -2)) +(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535) + (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767)) + (v128.const i16x8 32766 32766 32766 32766 32766 32766 32766 32766)) +(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535) + (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)) + (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)) +(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535) + (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)) + (v128.const i16x8 -2 -2 -2 -2 -2 -2 -2 -2)) +(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 0x3fff 0x3fff 0x3fff 0x3fff 0x3fff 0x3fff 0x3fff 0x3fff) + (v128.const i16x8 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000)) + (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767)) +(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000) + (v128.const i16x8 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000)) + (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767)) +(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 -0x3fff -0x3fff -0x3fff -0x3fff -0x3fff -0x3fff -0x3fff -0x3fff) + (v128.const i16x8 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000)) + (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767)) +(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000) + (v128.const i16x8 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000)) + (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)) +(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000) + (v128.const i16x8 -0x4001 -0x4001 -0x4001 -0x4001 -0x4001 -0x4001 -0x4001 -0x4001)) + (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)) +(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff) + (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff)) + (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767)) +(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff) + (v128.const i16x8 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01)) + (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767)) +(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000) + (v128.const i16x8 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01)) + (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)) +(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff) + (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000) + (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)) + (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)) +(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff) + (v128.const i16x8 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff) + (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff)) + (v128.const i16x8 -2 -2 -2 -2 -2 -2 -2 -2)) +(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000) + (v128.const f32x4 -0.0 -0.0 -0.0 -0.0)) + (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)) +(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 1 1 1 1 1 1 1 1) + (v128.const f32x4 +inf +inf +inf +inf)) + (v128.const i16x8 0x01 0x7f81 0x01 0x7f81 0x01 0x7f81 0x01 0x7f81)) +(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 1 1 1 1 1 1 1 1) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const i16x8 0x01 0xff81 0x01 0xff81 0x01 0xff81 0x01 0xff81)) +(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 1 1 1 1 1 1 1 1) + (v128.const f32x4 nan nan nan nan)) + (v128.const i16x8 0x01 0x7fc1 0x01 0x7fc1 0x01 0x7fc1 0x01 0x7fc1)) +(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 1 1 1 1 1 1 1 1) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const i16x8 0x01 0xffc1 0x01 0xffc1 0x01 0xffc1 0x01 0xffc1)) +(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 0 1 2 3 4 5 6 7) + (v128.const i16x8 0 0xffff 0xfffe 0xfffd 0xfffc 0xfffb 0xfffa 0xfff9)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 0 1 2 3 4 5 6 7) + (v128.const i16x8 0 2 4 6 8 10 12 14)) + (v128.const i16x8 0 3 6 9 12 15 18 21)) +(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 012_345 012_345 012_345 012_345 012_345 012_345 012_345 012_345) + (v128.const i16x8 032_123 032_123 032_123 032_123 032_123 032_123 032_123 032_123)) + (v128.const i16x8 032_767 032_767 032_767 032_767 032_767 032_767 032_767 032_767)) +(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 012_345 012_345 012_345 012_345 012_345 012_345 012_345 012_345) + (v128.const i16x8 056_789 056_789 056_789 056_789 056_789 056_789 056_789 056_789)) + (v128.const i16x8 03_598 03_598 03_598 03_598 03_598 03_598 03_598 03_598)) +(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234) + (v128.const i16x8 0x0_5678 0x0_5678 0x0_5678 0x0_5678 0x0_5678 0x0_5678 0x0_5678 0x0_5678)) + (v128.const i16x8 0x0_68ac 0x0_68ac 0x0_68ac 0x0_68ac 0x0_68ac 0x0_68ac 0x0_68ac 0x0_68ac)) +(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB) + (v128.const i16x8 0x0_cdef 0x0_cdef 0x0_cdef 0x0_cdef 0x0_cdef 0x0_cdef 0x0_cdef 0x0_cdef)) + (v128.const i16x8 -0x0_8000 -0x0_8000 -0x0_8000 -0x0_8000 -0x0_8000 -0x0_8000 -0x0_8000 -0x0_8000)) + +;; i16x8.add_sat_u +(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i16x8 0 0 0 0 0 0 0 0)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i16x8 1 1 1 1 1 1 1 1)) + (v128.const i16x8 1 1 1 1 1 1 1 1)) +(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 1 1 1 1 1 1 1 1) + (v128.const i16x8 1 1 1 1 1 1 1 1)) + (v128.const i16x8 2 2 2 2 2 2 2 2)) +(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)) +(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 1 1 1 1 1 1 1 1) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)) +(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)) +(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 16383 16383 16383 16383 16383 16383 16383 16383) + (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384)) + (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767)) +(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384) + (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384)) + (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768)) +(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 -16383 -16383 -16383 -16383 -16383 -16383 -16383 -16383) + (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384)) + (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)) +(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384) + (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384)) + (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)) +(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 -16385 -16385 -16385 -16385 -16385 -16385 -16385 -16385) + (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384)) + (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)) +(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 32765 32765 32765 32765 32765 32765 32765 32765) + (v128.const i16x8 1 1 1 1 1 1 1 1)) + (v128.const i16x8 32766 32766 32766 32766 32766 32766 32766 32766)) +(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 32766 32766 32766 32766 32766 32766 32766 32766) + (v128.const i16x8 1 1 1 1 1 1 1 1)) + (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767)) +(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768) + (v128.const i16x8 1 1 1 1 1 1 1 1)) + (v128.const i16x8 32769 32769 32769 32769 32769 32769 32769 32769)) +(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 -32766 -32766 -32766 -32766 -32766 -32766 -32766 -32766) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)) +(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)) +(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)) +(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767) + (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767)) + (v128.const i16x8 65534 65534 65534 65534 65534 65534 65534 65534)) +(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768) + (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)) + (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)) +(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768) + (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767)) + (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)) +(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535) + (v128.const i16x8 0 0 0 0 0 0 0 0)) + (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)) +(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535) + (v128.const i16x8 1 1 1 1 1 1 1 1)) + (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)) +(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)) +(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535) + (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767)) + (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)) +(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535) + (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)) + (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)) +(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535) + (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)) + (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)) +(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 0x3fff 0x3fff 0x3fff 0x3fff 0x3fff 0x3fff 0x3fff 0x3fff) + (v128.const i16x8 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000)) + (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767)) +(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000) + (v128.const i16x8 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000)) + (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768)) +(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 -0x3fff -0x3fff -0x3fff -0x3fff -0x3fff -0x3fff -0x3fff -0x3fff) + (v128.const i16x8 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000)) + (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)) +(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000) + (v128.const i16x8 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000)) + (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)) +(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000) + (v128.const i16x8 -0x4001 -0x4001 -0x4001 -0x4001 -0x4001 -0x4001 -0x4001 -0x4001)) + (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)) +(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff) + (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff)) + (v128.const i16x8 65534 65534 65534 65534 65534 65534 65534 65534)) +(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff) + (v128.const i16x8 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01)) + (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768)) +(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000) + (v128.const i16x8 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01)) + (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)) +(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff) + (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)) + (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)) +(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000) + (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)) + (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)) +(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff) + (v128.const i16x8 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01)) + (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)) +(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff) + (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff)) + (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)) +(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000) + (v128.const f32x4 -0.0 -0.0 -0.0 -0.0)) + (v128.const i16x8 0x8000 0xffff 0x8000 0xffff 0x8000 0xffff 0x8000 0xffff)) +(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 1 1 1 1 1 1 1 1) + (v128.const f32x4 +inf +inf +inf +inf)) + (v128.const i16x8 0x01 0x7f81 0x01 0x7f81 0x01 0x7f81 0x01 0x7f81)) +(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 1 1 1 1 1 1 1 1) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const i16x8 0x01 0xff81 0x01 0xff81 0x01 0xff81 0x01 0xff81)) +(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 1 1 1 1 1 1 1 1) + (v128.const f32x4 nan nan nan nan)) + (v128.const i16x8 0x01 0x7fc1 0x01 0x7fc1 0x01 0x7fc1 0x01 0x7fc1)) +(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 1 1 1 1 1 1 1 1) + (v128.const f32x4 nan nan nan nan)) + (v128.const i16x8 0x01 0x7fc1 0x01 0x7fc1 0x01 0x7fc1 0x01 0x7fc1)) +(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 0 1 2 3 4 5 6 7) + (v128.const i16x8 0 0xffff 0xfffe 0xfffd 0xfffc 0xfffb 0xfffa 0xfff9)) + (v128.const i16x8 0 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff)) +(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 0 1 2 3 4 5 6 7) + (v128.const i16x8 0 2 4 6 8 10 12 14)) + (v128.const i16x8 0 3 6 9 12 15 18 21)) +(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 012_345 012_345 012_345 012_345 012_345 012_345 012_345 012_345) + (v128.const i16x8 056_789 056_789 056_789 056_789 056_789 056_789 056_789 056_789)) + (v128.const i16x8 065_535 065_535 065_535 065_535 065_535 065_535 065_535 065_535)) +(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 012_345 012_345 012_345 012_345 012_345 012_345 012_345 012_345) + (v128.const i16x8 -012_345 -012_345 -012_345 -012_345 -012_345 -012_345 -012_345 -012_345)) + (v128.const i16x8 065_535 065_535 065_535 065_535 065_535 065_535 065_535 065_535)) +(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234) + (v128.const i16x8 0x0_5678 0x0_5678 0x0_5678 0x0_5678 0x0_5678 0x0_5678 0x0_5678 0x0_5678)) + (v128.const i16x8 0x0_68ac 0x0_68ac 0x0_68ac 0x0_68ac 0x0_68ac 0x0_68ac 0x0_68ac 0x0_68ac)) +(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB) + (v128.const i16x8 0x0_cdef 0x0_cdef 0x0_cdef 0x0_cdef 0x0_cdef 0x0_cdef 0x0_cdef 0x0_cdef)) + (v128.const i16x8 0x0_ffff 0x0_ffff 0x0_ffff 0x0_ffff 0x0_ffff 0x0_ffff 0x0_ffff 0x0_ffff)) + +;; i16x8.sub_sat_s +(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i16x8 0 0 0 0 0 0 0 0)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i16x8 1 1 1 1 1 1 1 1)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 1 1 1 1 1 1 1 1) + (v128.const i16x8 1 1 1 1 1 1 1 1)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i16x8 1 1 1 1 1 1 1 1)) +(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 1 1 1 1 1 1 1 1) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i16x8 2 2 2 2 2 2 2 2)) +(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 16383 16383 16383 16383 16383 16383 16383 16383) + (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384) + (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 -16383 -16383 -16383 -16383 -16383 -16383 -16383 -16383) + (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384)) + (v128.const i16x8 1 1 1 1 1 1 1 1)) +(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384) + (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 -16385 -16385 -16385 -16385 -16385 -16385 -16385 -16385) + (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 32765 32765 32765 32765 32765 32765 32765 32765) + (v128.const i16x8 1 1 1 1 1 1 1 1)) + (v128.const i16x8 32764 32764 32764 32764 32764 32764 32764 32764)) +(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 32766 32766 32766 32766 32766 32766 32766 32766) + (v128.const i16x8 1 1 1 1 1 1 1 1)) + (v128.const i16x8 32765 32765 32765 32765 32765 32765 32765 32765)) +(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768) + (v128.const i16x8 1 1 1 1 1 1 1 1)) + (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)) +(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 -32766 -32766 -32766 -32766 -32766 -32766 -32766 -32766) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i16x8 -32765 -32765 -32765 -32765 -32765 -32765 -32765 -32765)) +(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i16x8 -32766 -32766 -32766 -32766 -32766 -32766 -32766 -32766)) +(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767)) +(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767) + (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768) + (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768) + (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535) + (v128.const i16x8 0 0 0 0 0 0 0 0)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535) + (v128.const i16x8 1 1 1 1 1 1 1 1)) + (v128.const i16x8 -2 -2 -2 -2 -2 -2 -2 -2)) +(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535) + (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767)) + (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)) +(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535) + (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)) + (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767)) +(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535) + (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 0x3fff 0x3fff 0x3fff 0x3fff 0x3fff 0x3fff 0x3fff 0x3fff) + (v128.const i16x8 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000) + (v128.const i16x8 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 -0x3fff -0x3fff -0x3fff -0x3fff -0x3fff -0x3fff -0x3fff -0x3fff) + (v128.const i16x8 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000)) + (v128.const i16x8 1 1 1 1 1 1 1 1)) +(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000) + (v128.const i16x8 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000) + (v128.const i16x8 -0x4001 -0x4001 -0x4001 -0x4001 -0x4001 -0x4001 -0x4001 -0x4001)) + (v128.const i16x8 1 1 1 1 1 1 1 1)) +(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff) + (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff) + (v128.const i16x8 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01)) + (v128.const i16x8 32766 32766 32766 32766 32766 32766 32766 32766)) +(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000) + (v128.const i16x8 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01)) + (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767)) +(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff) + (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)) + (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767)) +(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000) + (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff) + (v128.const i16x8 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01)) + (v128.const i16x8 -2 -2 -2 -2 -2 -2 -2 -2)) +(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff) + (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000) + (v128.const f32x4 -0.0 -0.0 -0.0 -0.0)) + (v128.const i16x8 0x8000 0 0x8000 0 0x8000 0 0x8000 0)) +(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 1 1 1 1 1 1 1 1) + (v128.const f32x4 +inf +inf +inf +inf)) + (v128.const i16x8 0x01 0x8081 0x01 0x8081 0x01 0x8081 0x01 0x8081)) +(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 1 1 1 1 1 1 1 1) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const i16x8 0x01 0x81 0x01 0x81 0x01 0x81 0x01 0x81)) +(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 1 1 1 1 1 1 1 1) + (v128.const f32x4 nan nan nan nan)) + (v128.const i16x8 0x01 0x8041 0x01 0x8041 0x01 0x8041 0x01 0x8041)) +(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 1 1 1 1 1 1 1 1) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const i16x8 0x01 0x41 0x01 0x41 0x01 0x41 0x01 0x41)) +(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 0 1 2 3 4 5 6 7) + (v128.const i16x8 0 0xffff 0xfffe 0xfffd 0xfffc 0xfffb 0xfffa 0xfff9)) + (v128.const i16x8 0 2 4 6 8 10 12 14)) +(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 0 1 2 3 4 5 6 7) + (v128.const i16x8 0 2 4 6 8 10 12 14)) + (v128.const i16x8 0 -1 -2 -3 -4 -5 -6 -7)) +(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 012_345 012_345 012_345 012_345 012_345 012_345 012_345 012_345) + (v128.const i16x8 056_789 056_789 056_789 056_789 056_789 056_789 056_789 056_789)) + (v128.const i16x8 021_092 021_092 021_092 021_092 021_092 021_092 021_092 021_092)) +(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 012_345 012_345 012_345 012_345 012_345 012_345 012_345 012_345) + (v128.const i16x8 -012_345 -012_345 -012_345 -012_345 -012_345 -012_345 -012_345 -012_345)) + (v128.const i16x8 024_690 024_690 024_690 024_690 024_690 024_690 024_690 024_690)) +(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234) + (v128.const i16x8 0x0_5678 0x0_5678 0x0_5678 0x0_5678 0x0_5678 0x0_5678 0x0_5678 0x0_5678)) + (v128.const i16x8 0x0_bbbc 0x0_bbbc 0x0_bbbc 0x0_bbbc 0x0_bbbc 0x0_bbbc 0x0_bbbc 0x0_bbbc)) +(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB) + (v128.const i16x8 -0x1234 -0x1234 -0x1234 -0x1234 -0x1234 -0x1234 -0x1234 -0x1234)) + (v128.const i16x8 0xa2df 0xa2df 0xa2df 0xa2df 0xa2df 0xa2df 0xa2df 0xa2df)) + +;; i16x8.sub_sat_u +(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i16x8 0 0 0 0 0 0 0 0)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i16x8 1 1 1 1 1 1 1 1)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 1 1 1 1 1 1 1 1) + (v128.const i16x8 1 1 1 1 1 1 1 1)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 1 1 1 1 1 1 1 1) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 16383 16383 16383 16383 16383 16383 16383 16383) + (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384) + (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 -16383 -16383 -16383 -16383 -16383 -16383 -16383 -16383) + (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384)) + (v128.const i16x8 1 1 1 1 1 1 1 1)) +(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384) + (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 -16385 -16385 -16385 -16385 -16385 -16385 -16385 -16385) + (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 32765 32765 32765 32765 32765 32765 32765 32765) + (v128.const i16x8 1 1 1 1 1 1 1 1)) + (v128.const i16x8 32764 32764 32764 32764 32764 32764 32764 32764)) +(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 32766 32766 32766 32766 32766 32766 32766 32766) + (v128.const i16x8 1 1 1 1 1 1 1 1)) + (v128.const i16x8 32765 32765 32765 32765 32765 32765 32765 32765)) +(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768) + (v128.const i16x8 1 1 1 1 1 1 1 1)) + (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767)) +(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 -32766 -32766 -32766 -32766 -32766 -32766 -32766 -32766) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767) + (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768) + (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768) + (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535) + (v128.const i16x8 0 0 0 0 0 0 0 0)) + (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)) +(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535) + (v128.const i16x8 1 1 1 1 1 1 1 1)) + (v128.const i16x8 65534 65534 65534 65534 65534 65534 65534 65534)) +(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535) + (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767)) + (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768)) +(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535) + (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)) + (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767)) +(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535) + (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 0x3fff 0x3fff 0x3fff 0x3fff 0x3fff 0x3fff 0x3fff 0x3fff) + (v128.const i16x8 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000) + (v128.const i16x8 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 -0x3fff -0x3fff -0x3fff -0x3fff -0x3fff -0x3fff -0x3fff -0x3fff) + (v128.const i16x8 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000)) + (v128.const i16x8 1 1 1 1 1 1 1 1)) +(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000) + (v128.const i16x8 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000) + (v128.const i16x8 -0x4001 -0x4001 -0x4001 -0x4001 -0x4001 -0x4001 -0x4001 -0x4001)) + (v128.const i16x8 1 1 1 1 1 1 1 1)) +(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff) + (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff) + (v128.const i16x8 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01)) + (v128.const i16x8 32766 32766 32766 32766 32766 32766 32766 32766)) +(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000) + (v128.const i16x8 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff) + (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000) + (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff) + (v128.const i16x8 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01)) + (v128.const i16x8 65534 65534 65534 65534 65534 65534 65534 65534)) +(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff) + (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000) + (v128.const f32x4 -0.0 -0.0 -0.0 -0.0)) + (v128.const i16x8 0x8000 0 0x8000 0 0x8000 0 0x8000 0)) +(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 1 1 1 1 1 1 1 1) + (v128.const f32x4 +inf +inf +inf +inf)) + (v128.const i16x8 0x01 0 0x01 0 0x01 0 0x01 0)) +(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 1 1 1 1 1 1 1 1) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const i16x8 0x01 0 0x01 0 0x01 0 0x01 0)) +(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 1 1 1 1 1 1 1 1) + (v128.const f32x4 nan nan nan nan)) + (v128.const i16x8 0x01 0 0x01 0 0x01 0 0x01 0)) +(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 1 1 1 1 1 1 1 1) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const i16x8 0x01 0 0x01 0 0x01 0 0x01 0)) +(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 0 1 2 3 4 5 6 7) + (v128.const i16x8 0 0xffff 0xfffe 0xfffd 0xfffc 0xfffb 0xfffa 0xfff9)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 0 1 2 3 4 5 6 7) + (v128.const i16x8 0 2 4 6 8 10 12 14)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 012_345 012_345 012_345 012_345 012_345 012_345 012_345 012_345) + (v128.const i16x8 056_789 056_789 056_789 056_789 056_789 056_789 056_789 056_789)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 056_789 056_789 056_789 056_789 056_789 056_789 056_789 056_789) + (v128.const i16x8 -12_345 -12_345 -12_345 -12_345 -12_345 -12_345 -12_345 -12_345)) + (v128.const i16x8 03_598 03_598 03_598 03_598 03_598 03_598 03_598 03_598)) +(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234) + (v128.const i16x8 -0x0_5678 -0x0_5678 -0x0_5678 -0x0_5678 -0x0_5678 -0x0_5678 -0x0_5678 -0x0_5678)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 0x0_cdef 0x0_cdef 0x0_cdef 0x0_cdef 0x0_cdef 0x0_cdef 0x0_cdef 0x0_cdef) + (v128.const i16x8 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB)) + (v128.const i16x8 0x0_3d44 0x0_3d44 0x0_3d44 0x0_3d44 0x0_3d44 0x0_3d44 0x0_3d44 0x0_3d44)) + +;; Malformed cases: non-existent op names +(assert_malformed (module quote + "(func (result v128) (i16x8.add_sat (v128.const i16x8 1 1 1 1 1 1 1 1) (v128.const i16x8 2 2 2 2 2 2 2 2)))") + "unknown operator") +(assert_malformed (module quote + "(func (result v128) (i16x8.sub_sat (v128.const i16x8 1 1 1 1 1 1 1 1) (v128.const i16x8 2 2 2 2 2 2 2 2)))") + "unknown operator") +(assert_malformed (module quote + "(func (result v128) (i16x8.mul_sat (v128.const i16x8 1 1 1 1 1 1 1 1) (v128.const i16x8 2 2 2 2 2 2 2 2)))") + "unknown operator") +(assert_malformed (module quote + "(func (result v128) (i16x8.div_sat (v128.const i16x8 1 1 1 1 1 1 1 1) (v128.const i16x8 2 2 2 2 2 2 2 2)))") + "unknown operator") + +;; type check +(assert_invalid (module (func (result v128) (i16x8.add_sat_s (i32.const 0) (f32.const 0.0)))) "type mismatch") +(assert_invalid (module (func (result v128) (i16x8.add_sat_u (i32.const 0) (f32.const 0.0)))) "type mismatch") +(assert_invalid (module (func (result v128) (i16x8.sub_sat_s (i32.const 0) (f32.const 0.0)))) "type mismatch") +(assert_invalid (module (func (result v128) (i16x8.sub_sat_u (i32.const 0) (f32.const 0.0)))) "type mismatch") + +;; Test operation with empty argument + +(assert_invalid + (module + (func $i16x8.add_sat_s-1st-arg-empty (result v128) + (i16x8.add_sat_s (v128.const i16x8 0 0 0 0 0 0 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i16x8.add_sat_s-arg-empty (result v128) + (i16x8.add_sat_s) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i16x8.add_sat_u-1st-arg-empty (result v128) + (i16x8.add_sat_u (v128.const i16x8 0 0 0 0 0 0 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i16x8.add_sat_u-arg-empty (result v128) + (i16x8.add_sat_u) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i16x8.sub_sat_s-1st-arg-empty (result v128) + (i16x8.sub_sat_s (v128.const i16x8 0 0 0 0 0 0 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i16x8.sub_sat_s-arg-empty (result v128) + (i16x8.sub_sat_s) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i16x8.sub_sat_u-1st-arg-empty (result v128) + (i16x8.sub_sat_u (v128.const i16x8 0 0 0 0 0 0 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i16x8.sub_sat_u-arg-empty (result v128) + (i16x8.sub_sat_u) + ) + ) + "type mismatch" +) + +;; combination +(module + (func (export "sat-add_s-sub_s") (param v128 v128 v128) (result v128) + (i16x8.add_sat_s (i16x8.sub_sat_s (local.get 0) (local.get 1))(local.get 2))) + (func (export "sat-add_s-sub_u") (param v128 v128 v128) (result v128) + (i16x8.add_sat_s (i16x8.sub_sat_u (local.get 0) (local.get 1))(local.get 2))) + (func (export "sat-add_u-sub_s") (param v128 v128 v128) (result v128) + (i16x8.add_sat_u (i16x8.sub_sat_s (local.get 0) (local.get 1))(local.get 2))) + (func (export "sat-add_u-sub_u") (param v128 v128 v128) (result v128) + (i16x8.add_sat_u (i16x8.sub_sat_u (local.get 0) (local.get 1))(local.get 2))) + (func (export "sat-add_s-neg") (param v128 v128) (result v128) + (i16x8.add_sat_s (i16x8.neg (local.get 0)) (local.get 1))) + (func (export "sat-add_u-neg") (param v128 v128) (result v128) + (i16x8.add_sat_u (i16x8.neg (local.get 0)) (local.get 1))) + (func (export "sat-sub_s-neg") (param v128 v128) (result v128) + (i16x8.sub_sat_s (i16x8.neg (local.get 0)) (local.get 1))) + (func (export "sat-sub_u-neg") (param v128 v128) (result v128) + (i16x8.sub_sat_u (i16x8.neg (local.get 0)) (local.get 1))) +) + +(assert_return (invoke "sat-add_s-sub_s" (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384) + (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767) + (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)) + (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)) +(assert_return (invoke "sat-add_s-sub_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535) + (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768) + (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "sat-add_u-sub_s" (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1) + (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767)) + (v128.const i16x8 65534 65534 65534 65534 65534 65534 65534 65534)) +(assert_return (invoke "sat-add_u-sub_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535) + (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i16x8 1 1 1 1 1 1 1 1)) + (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)) +(assert_return (invoke "sat-add_s-neg" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768) + (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "sat-add_u-neg" (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767) + (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)) + (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)) +(assert_return (invoke "sat-sub_s-neg" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768) + (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767)) + (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)) +(assert_return (invoke "sat-sub_u-neg" (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767) + (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)) + (v128.const i16x8 1 1 1 1 1 1 1 1)) \ No newline at end of file diff --git a/runtime/near-vm/tests/wast/spec/proposals/simd/simd_i32x4_arith.wast b/runtime/near-vm/tests/wast/spec/proposals/simd/simd_i32x4_arith.wast new file mode 100644 index 00000000000..f0e09b8bf76 --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/proposals/simd/simd_i32x4_arith.wast @@ -0,0 +1,634 @@ +;; Tests for i32x4 arithmetic operations on major boundary values and all special values. + + +(module + (func (export "i32x4.add") (param v128 v128) (result v128) (i32x4.add (local.get 0) (local.get 1))) + (func (export "i32x4.sub") (param v128 v128) (result v128) (i32x4.sub (local.get 0) (local.get 1))) + (func (export "i32x4.mul") (param v128 v128) (result v128) (i32x4.mul (local.get 0) (local.get 1))) + (func (export "i32x4.neg") (param v128) (result v128) (i32x4.neg (local.get 0))) +) + + +;; i32x4.add +(assert_return (invoke "i32x4.add" (v128.const i32x4 0 0 0 0) + (v128.const i32x4 0 0 0 0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.add" (v128.const i32x4 0 0 0 0) + (v128.const i32x4 1 1 1 1)) + (v128.const i32x4 1 1 1 1)) +(assert_return (invoke "i32x4.add" (v128.const i32x4 1 1 1 1) + (v128.const i32x4 1 1 1 1)) + (v128.const i32x4 2 2 2 2)) +(assert_return (invoke "i32x4.add" (v128.const i32x4 0 0 0 0) + (v128.const i32x4 -1 -1 -1 -1)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "i32x4.add" (v128.const i32x4 1 1 1 1) + (v128.const i32x4 -1 -1 -1 -1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.add" (v128.const i32x4 -1 -1 -1 -1) + (v128.const i32x4 -1 -1 -1 -1)) + (v128.const i32x4 -2 -2 -2 -2)) +(assert_return (invoke "i32x4.add" (v128.const i32x4 1073741823 1073741823 1073741823 1073741823) + (v128.const i32x4 1073741824 1073741824 1073741824 1073741824)) + (v128.const i32x4 2147483647 2147483647 2147483647 2147483647)) +(assert_return (invoke "i32x4.add" (v128.const i32x4 1073741824 1073741824 1073741824 1073741824) + (v128.const i32x4 1073741824 1073741824 1073741824 1073741824)) + (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648)) +(assert_return (invoke "i32x4.add" (v128.const i32x4 -1073741823 -1073741823 -1073741823 -1073741823) + (v128.const i32x4 -1073741824 -1073741824 -1073741824 -1073741824)) + (v128.const i32x4 -2147483647 -2147483647 -2147483647 -2147483647)) +(assert_return (invoke "i32x4.add" (v128.const i32x4 -1073741824 -1073741824 -1073741824 -1073741824) + (v128.const i32x4 -1073741824 -1073741824 -1073741824 -1073741824)) + (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648)) +(assert_return (invoke "i32x4.add" (v128.const i32x4 -1073741825 -1073741825 -1073741825 -1073741825) + (v128.const i32x4 -1073741824 -1073741824 -1073741824 -1073741824)) + (v128.const i32x4 2147483647 2147483647 2147483647 2147483647)) +(assert_return (invoke "i32x4.add" (v128.const i32x4 2147483645 2147483645 2147483645 2147483645) + (v128.const i32x4 1 1 1 1)) + (v128.const i32x4 2147483646 2147483646 2147483646 2147483646)) +(assert_return (invoke "i32x4.add" (v128.const i32x4 2147483646 2147483646 2147483646 2147483646) + (v128.const i32x4 1 1 1 1)) + (v128.const i32x4 2147483647 2147483647 2147483647 2147483647)) +(assert_return (invoke "i32x4.add" (v128.const i32x4 2147483648 2147483648 2147483648 2147483648) + (v128.const i32x4 1 1 1 1)) + (v128.const i32x4 -2147483647 -2147483647 -2147483647 -2147483647)) +(assert_return (invoke "i32x4.add" (v128.const i32x4 -2147483646 -2147483646 -2147483646 -2147483646) + (v128.const i32x4 -1 -1 -1 -1)) + (v128.const i32x4 -2147483647 -2147483647 -2147483647 -2147483647)) +(assert_return (invoke "i32x4.add" (v128.const i32x4 -2147483647 -2147483647 -2147483647 -2147483647) + (v128.const i32x4 -1 -1 -1 -1)) + (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648)) +(assert_return (invoke "i32x4.add" (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648) + (v128.const i32x4 -1 -1 -1 -1)) + (v128.const i32x4 2147483647 2147483647 2147483647 2147483647)) +(assert_return (invoke "i32x4.add" (v128.const i32x4 2147483647 2147483647 2147483647 2147483647) + (v128.const i32x4 2147483647 2147483647 2147483647 2147483647)) + (v128.const i32x4 -2 -2 -2 -2)) +(assert_return (invoke "i32x4.add" (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648) + (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.add" (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648) + (v128.const i32x4 -2147483647 -2147483647 -2147483647 -2147483647)) + (v128.const i32x4 1 1 1 1)) +(assert_return (invoke "i32x4.add" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295) + (v128.const i32x4 0 0 0 0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "i32x4.add" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295) + (v128.const i32x4 1 1 1 1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.add" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295) + (v128.const i32x4 -1 -1 -1 -1)) + (v128.const i32x4 -2 -2 -2 -2)) +(assert_return (invoke "i32x4.add" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295) + (v128.const i32x4 2147483647 2147483647 2147483647 2147483647)) + (v128.const i32x4 2147483646 2147483646 2147483646 2147483646)) +(assert_return (invoke "i32x4.add" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295) + (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648)) + (v128.const i32x4 2147483647 2147483647 2147483647 2147483647)) +(assert_return (invoke "i32x4.add" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295) + (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)) + (v128.const i32x4 -2 -2 -2 -2)) +(assert_return (invoke "i32x4.add" (v128.const i32x4 0x3fffffff 0x3fffffff 0x3fffffff 0x3fffffff) + (v128.const i32x4 0x40000000 0x40000000 0x40000000 0x40000000)) + (v128.const i32x4 2147483647 2147483647 2147483647 2147483647)) +(assert_return (invoke "i32x4.add" (v128.const i32x4 0x40000000 0x40000000 0x40000000 0x40000000) + (v128.const i32x4 0x40000000 0x40000000 0x40000000 0x40000000)) + (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648)) +(assert_return (invoke "i32x4.add" (v128.const i32x4 -0x3fffffff -0x3fffffff -0x3fffffff -0x3fffffff) + (v128.const i32x4 -0x40000000 -0x40000000 -0x40000000 -0x40000000)) + (v128.const i32x4 -2147483647 -2147483647 -2147483647 -2147483647)) +(assert_return (invoke "i32x4.add" (v128.const i32x4 -0x40000000 -0x40000000 -0x40000000 -0x40000000) + (v128.const i32x4 -0x40000000 -0x40000000 -0x40000000 -0x40000000)) + (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648)) +(assert_return (invoke "i32x4.add" (v128.const i32x4 -0x40000000 -0x40000000 -0x40000000 -0x40000000) + (v128.const i32x4 -0x40000001 -0x40000001 -0x40000001 -0x40000001)) + (v128.const i32x4 2147483647 2147483647 2147483647 2147483647)) +(assert_return (invoke "i32x4.add" (v128.const i32x4 0x7fffffff 0x7fffffff 0x7fffffff 0x7fffffff) + (v128.const i32x4 0x7fffffff 0x7fffffff 0x7fffffff 0x7fffffff)) + (v128.const i32x4 -2 -2 -2 -2)) +(assert_return (invoke "i32x4.add" (v128.const i32x4 0x7fffffff 0x7fffffff 0x7fffffff 0x7fffffff) + (v128.const i32x4 0x01 0x01 0x01 0x01)) + (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648)) +(assert_return (invoke "i32x4.add" (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000) + (v128.const i32x4 -0x01 -0x01 -0x01 -0x01)) + (v128.const i32x4 2147483647 2147483647 2147483647 2147483647)) +(assert_return (invoke "i32x4.add" (v128.const i32x4 0x7fffffff 0x7fffffff 0x7fffffff 0x7fffffff) + (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "i32x4.add" (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000) + (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.add" (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff) + (v128.const i32x4 0x01 0x01 0x01 0x01)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.add" (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff) + (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff)) + (v128.const i32x4 -2 -2 -2 -2)) +(assert_return (invoke "i32x4.add" (v128.const i32x4 0x7fffffff 0x7fffffff 0x7fffffff 0x7fffffff) + (v128.const i8x16 0 0 0 0x80 0 0 0 0x80 0 0 0 0x80 0 0 0 0x80)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "i32x4.add" (v128.const i32x4 1 1 1 1) + (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.add" (v128.const i32x4 0x7fffffff 0x7fffffff 0x7fffffff 0x7fffffff) + (v128.const i16x8 0 0x8000 0 0x8000 0 0x8000 0 0x8000)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "i32x4.add" (v128.const i32x4 1 1 1 1) + (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.add" (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000) + (v128.const f32x4 +0.0 +0.0 +0.0 +0.0)) + (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000)) +(assert_return (invoke "i32x4.add" (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000) + (v128.const f32x4 -0.0 -0.0 -0.0 -0.0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.add" (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000) + (v128.const f32x4 1.0 1.0 1.0 1.0)) + (v128.const i32x4 0xbf800000 0xbf800000 0xbf800000 0xbf800000)) +(assert_return (invoke "i32x4.add" (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000) + (v128.const f32x4 -1.0 -1.0 -1.0 -1.0)) + (v128.const i32x4 0x3f800000 0x3f800000 0x3f800000 0x3f800000)) +(assert_return (invoke "i32x4.add" (v128.const i32x4 1 1 1 1) + (v128.const f32x4 +inf +inf +inf +inf)) + (v128.const i32x4 0x7f800001 0x7f800001 0x7f800001 0x7f800001)) +(assert_return (invoke "i32x4.add" (v128.const i32x4 1 1 1 1) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const i32x4 0xff800001 0xff800001 0xff800001 0xff800001)) +(assert_return (invoke "i32x4.add" (v128.const i32x4 1 1 1 1) + (v128.const f32x4 nan nan nan nan)) + (v128.const i32x4 0x7fc00001 0x7fc00001 0x7fc00001 0x7fc00001)) +(assert_return (invoke "i32x4.add" (v128.const i32x4 0 1 2 3) + (v128.const i32x4 0 0xffffffff 0xfffffffe 0xfffffffd)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.add" (v128.const i32x4 0 1 2 3) + (v128.const i32x4 0 2 4 6)) + (v128.const i32x4 0 3 6 9)) +(assert_return (invoke "i32x4.add" (v128.const i32x4 01_234_567_890 01_234_567_890 01_234_567_890 01_234_567_890) + (v128.const i32x4 01_234_567_890 01_234_567_890 01_234_567_890 01_234_567_890)) + (v128.const i32x4 02_469_135_780 02_469_135_780 02_469_135_780 02_469_135_780)) +(assert_return (invoke "i32x4.add" (v128.const i32x4 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678) + (v128.const i32x4 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef)) + (v128.const i32x4 0x0_a2e0_2467 0x0_a2e0_2467 0x0_a2e0_2467 0x0_a2e0_2467)) + +;; i32x4.sub +(assert_return (invoke "i32x4.sub" (v128.const i32x4 0 0 0 0) + (v128.const i32x4 0 0 0 0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.sub" (v128.const i32x4 0 0 0 0) + (v128.const i32x4 1 1 1 1)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "i32x4.sub" (v128.const i32x4 1 1 1 1) + (v128.const i32x4 1 1 1 1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.sub" (v128.const i32x4 0 0 0 0) + (v128.const i32x4 -1 -1 -1 -1)) + (v128.const i32x4 1 1 1 1)) +(assert_return (invoke "i32x4.sub" (v128.const i32x4 1 1 1 1) + (v128.const i32x4 -1 -1 -1 -1)) + (v128.const i32x4 2 2 2 2)) +(assert_return (invoke "i32x4.sub" (v128.const i32x4 -1 -1 -1 -1) + (v128.const i32x4 -1 -1 -1 -1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.sub" (v128.const i32x4 1073741823 1073741823 1073741823 1073741823) + (v128.const i32x4 1073741824 1073741824 1073741824 1073741824)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "i32x4.sub" (v128.const i32x4 1073741824 1073741824 1073741824 1073741824) + (v128.const i32x4 1073741824 1073741824 1073741824 1073741824)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.sub" (v128.const i32x4 -1073741823 -1073741823 -1073741823 -1073741823) + (v128.const i32x4 -1073741824 -1073741824 -1073741824 -1073741824)) + (v128.const i32x4 1 1 1 1)) +(assert_return (invoke "i32x4.sub" (v128.const i32x4 -1073741824 -1073741824 -1073741824 -1073741824) + (v128.const i32x4 -1073741824 -1073741824 -1073741824 -1073741824)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.sub" (v128.const i32x4 -1073741825 -1073741825 -1073741825 -1073741825) + (v128.const i32x4 -1073741824 -1073741824 -1073741824 -1073741824)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "i32x4.sub" (v128.const i32x4 2147483645 2147483645 2147483645 2147483645) + (v128.const i32x4 1 1 1 1)) + (v128.const i32x4 2147483644 2147483644 2147483644 2147483644)) +(assert_return (invoke "i32x4.sub" (v128.const i32x4 2147483646 2147483646 2147483646 2147483646) + (v128.const i32x4 1 1 1 1)) + (v128.const i32x4 2147483645 2147483645 2147483645 2147483645)) +(assert_return (invoke "i32x4.sub" (v128.const i32x4 2147483648 2147483648 2147483648 2147483648) + (v128.const i32x4 1 1 1 1)) + (v128.const i32x4 2147483647 2147483647 2147483647 2147483647)) +(assert_return (invoke "i32x4.sub" (v128.const i32x4 -2147483646 -2147483646 -2147483646 -2147483646) + (v128.const i32x4 -1 -1 -1 -1)) + (v128.const i32x4 -2147483645 -2147483645 -2147483645 -2147483645)) +(assert_return (invoke "i32x4.sub" (v128.const i32x4 -2147483647 -2147483647 -2147483647 -2147483647) + (v128.const i32x4 -1 -1 -1 -1)) + (v128.const i32x4 -2147483646 -2147483646 -2147483646 -2147483646)) +(assert_return (invoke "i32x4.sub" (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648) + (v128.const i32x4 -1 -1 -1 -1)) + (v128.const i32x4 -2147483647 -2147483647 -2147483647 -2147483647)) +(assert_return (invoke "i32x4.sub" (v128.const i32x4 2147483647 2147483647 2147483647 2147483647) + (v128.const i32x4 2147483647 2147483647 2147483647 2147483647)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.sub" (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648) + (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.sub" (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648) + (v128.const i32x4 -2147483647 -2147483647 -2147483647 -2147483647)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "i32x4.sub" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295) + (v128.const i32x4 0 0 0 0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "i32x4.sub" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295) + (v128.const i32x4 1 1 1 1)) + (v128.const i32x4 -2 -2 -2 -2)) +(assert_return (invoke "i32x4.sub" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295) + (v128.const i32x4 -1 -1 -1 -1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.sub" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295) + (v128.const i32x4 2147483647 2147483647 2147483647 2147483647)) + (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648)) +(assert_return (invoke "i32x4.sub" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295) + (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648)) + (v128.const i32x4 2147483647 2147483647 2147483647 2147483647)) +(assert_return (invoke "i32x4.sub" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295) + (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.sub" (v128.const i32x4 0x3fffffff 0x3fffffff 0x3fffffff 0x3fffffff) + (v128.const i32x4 0x40000000 0x40000000 0x40000000 0x40000000)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "i32x4.sub" (v128.const i32x4 0x40000000 0x40000000 0x40000000 0x40000000) + (v128.const i32x4 0x40000000 0x40000000 0x40000000 0x40000000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.sub" (v128.const i32x4 -0x3fffffff -0x3fffffff -0x3fffffff -0x3fffffff) + (v128.const i32x4 -0x40000000 -0x40000000 -0x40000000 -0x40000000)) + (v128.const i32x4 1 1 1 1)) +(assert_return (invoke "i32x4.sub" (v128.const i32x4 -0x40000000 -0x40000000 -0x40000000 -0x40000000) + (v128.const i32x4 -0x40000000 -0x40000000 -0x40000000 -0x40000000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.sub" (v128.const i32x4 -0x40000000 -0x40000000 -0x40000000 -0x40000000) + (v128.const i32x4 -0x40000001 -0x40000001 -0x40000001 -0x40000001)) + (v128.const i32x4 1 1 1 1)) +(assert_return (invoke "i32x4.sub" (v128.const i32x4 0x7fffffff 0x7fffffff 0x7fffffff 0x7fffffff) + (v128.const i32x4 0x7fffffff 0x7fffffff 0x7fffffff 0x7fffffff)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.sub" (v128.const i32x4 0x7fffffff 0x7fffffff 0x7fffffff 0x7fffffff) + (v128.const i32x4 0x01 0x01 0x01 0x01)) + (v128.const i32x4 2147483646 2147483646 2147483646 2147483646)) +(assert_return (invoke "i32x4.sub" (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000) + (v128.const i32x4 -0x01 -0x01 -0x01 -0x01)) + (v128.const i32x4 -2147483647 -2147483647 -2147483647 -2147483647)) +(assert_return (invoke "i32x4.sub" (v128.const i32x4 0x7fffffff 0x7fffffff 0x7fffffff 0x7fffffff) + (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "i32x4.sub" (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000) + (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.sub" (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff) + (v128.const i32x4 0x01 0x01 0x01 0x01)) + (v128.const i32x4 -2 -2 -2 -2)) +(assert_return (invoke "i32x4.sub" (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff) + (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.sub" (v128.const i32x4 0x7fffffff 0x7fffffff 0x7fffffff 0x7fffffff) + (v128.const i8x16 0 0 0 0x80 0 0 0 0x80 0 0 0 0x80 0 0 0 0x80)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "i32x4.sub" (v128.const i32x4 1 1 1 1) + (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)) + (v128.const i32x4 2 2 2 2)) +(assert_return (invoke "i32x4.sub" (v128.const i32x4 0x7fffffff 0x7fffffff 0x7fffffff 0x7fffffff) + (v128.const i16x8 0 0x8000 0 0x8000 0 0x8000 0 0x8000)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "i32x4.sub" (v128.const i32x4 1 1 1 1) + (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff)) + (v128.const i32x4 0x02 0x02 0x02 0x02)) +(assert_return (invoke "i32x4.sub" (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000) + (v128.const f32x4 +0.0 +0.0 +0.0 +0.0)) + (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000)) +(assert_return (invoke "i32x4.sub" (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000) + (v128.const f32x4 -0.0 -0.0 -0.0 -0.0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.sub" (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000) + (v128.const f32x4 1.0 1.0 1.0 1.0)) + (v128.const i32x4 0x40800000 0x40800000 0x40800000 0x40800000)) +(assert_return (invoke "i32x4.sub" (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000) + (v128.const f32x4 -1.0 -1.0 -1.0 -1.0)) + (v128.const i32x4 0xc0800000 0xc0800000 0xc0800000 0xc0800000)) +(assert_return (invoke "i32x4.sub" (v128.const i32x4 0x1 0x1 0x1 0x1) + (v128.const f32x4 +inf +inf +inf +inf)) + (v128.const i32x4 0x80800001 0x80800001 0x80800001 0x80800001)) +(assert_return (invoke "i32x4.sub" (v128.const i32x4 0x1 0x1 0x1 0x1) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const i32x4 0x00800001 0x00800001 0x00800001 0x00800001)) +(assert_return (invoke "i32x4.sub" (v128.const i32x4 0x1 0x1 0x1 0x1) + (v128.const f32x4 nan nan nan nan)) + (v128.const i32x4 0x80400001 0x80400001 0x80400001 0x80400001)) +(assert_return (invoke "i32x4.sub" (v128.const i32x4 0 1 2 3) + (v128.const i32x4 0 0xffffffff 0xfffffffe 0xfffffffd)) + (v128.const i32x4 0 0x02 0x04 0x06)) +(assert_return (invoke "i32x4.sub" (v128.const i32x4 0 1 2 3) + (v128.const i32x4 0 2 4 6)) + (v128.const i32x4 0 -1 -2 -3)) +(assert_return (invoke "i32x4.sub" (v128.const i32x4 03_214_567_890 03_214_567_890 03_214_567_890 03_214_567_890 ) + (v128.const i32x4 01_234_567_890 01_234_567_890 01_234_567_890 01_234_567_890 )) + (v128.const i32x4 01_980_000_000 01_980_000_000 01_980_000_000 01_980_000_000)) +(assert_return (invoke "i32x4.sub" (v128.const i32x4 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef) + (v128.const i32x4 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678)) + (v128.const i32x4 0x0_7e77_7777 0x0_7e77_7777 0x0_7e77_7777 0x0_7e77_7777)) + +;; i32x4.mul +(assert_return (invoke "i32x4.mul" (v128.const i32x4 0 0 0 0) + (v128.const i32x4 0 0 0 0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.mul" (v128.const i32x4 0 0 0 0) + (v128.const i32x4 1 1 1 1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.mul" (v128.const i32x4 1 1 1 1) + (v128.const i32x4 1 1 1 1)) + (v128.const i32x4 1 1 1 1)) +(assert_return (invoke "i32x4.mul" (v128.const i32x4 0 0 0 0) + (v128.const i32x4 -1 -1 -1 -1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.mul" (v128.const i32x4 1 1 1 1) + (v128.const i32x4 -1 -1 -1 -1)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "i32x4.mul" (v128.const i32x4 -1 -1 -1 -1) + (v128.const i32x4 -1 -1 -1 -1)) + (v128.const i32x4 1 1 1 1)) +(assert_return (invoke "i32x4.mul" (v128.const i32x4 1073741823 1073741823 1073741823 1073741823) + (v128.const i32x4 1073741824 1073741824 1073741824 1073741824)) + (v128.const i32x4 -1073741824 -1073741824 -1073741824 -1073741824)) +(assert_return (invoke "i32x4.mul" (v128.const i32x4 1073741824 1073741824 1073741824 1073741824) + (v128.const i32x4 1073741824 1073741824 1073741824 1073741824)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.mul" (v128.const i32x4 -1073741823 -1073741823 -1073741823 -1073741823) + (v128.const i32x4 -1073741824 -1073741824 -1073741824 -1073741824)) + (v128.const i32x4 -1073741824 -1073741824 -1073741824 -1073741824)) +(assert_return (invoke "i32x4.mul" (v128.const i32x4 -1073741824 -1073741824 -1073741824 -1073741824) + (v128.const i32x4 -1073741824 -1073741824 -1073741824 -1073741824)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.mul" (v128.const i32x4 -1073741825 -1073741825 -1073741825 -1073741825) + (v128.const i32x4 -1073741824 -1073741824 -1073741824 -1073741824)) + (v128.const i32x4 1073741824 1073741824 1073741824 1073741824)) +(assert_return (invoke "i32x4.mul" (v128.const i32x4 2147483645 2147483645 2147483645 2147483645) + (v128.const i32x4 1 1 1 1)) + (v128.const i32x4 2147483645 2147483645 2147483645 2147483645)) +(assert_return (invoke "i32x4.mul" (v128.const i32x4 2147483646 2147483646 2147483646 2147483646) + (v128.const i32x4 1 1 1 1)) + (v128.const i32x4 2147483646 2147483646 2147483646 2147483646)) +(assert_return (invoke "i32x4.mul" (v128.const i32x4 2147483648 2147483648 2147483648 2147483648) + (v128.const i32x4 1 1 1 1)) + (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648)) +(assert_return (invoke "i32x4.mul" (v128.const i32x4 -2147483646 -2147483646 -2147483646 -2147483646) + (v128.const i32x4 -1 -1 -1 -1)) + (v128.const i32x4 2147483646 2147483646 2147483646 2147483646)) +(assert_return (invoke "i32x4.mul" (v128.const i32x4 -2147483647 -2147483647 -2147483647 -2147483647) + (v128.const i32x4 -1 -1 -1 -1)) + (v128.const i32x4 2147483647 2147483647 2147483647 2147483647)) +(assert_return (invoke "i32x4.mul" (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648) + (v128.const i32x4 -1 -1 -1 -1)) + (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648)) +(assert_return (invoke "i32x4.mul" (v128.const i32x4 2147483647 2147483647 2147483647 2147483647) + (v128.const i32x4 2147483647 2147483647 2147483647 2147483647)) + (v128.const i32x4 1 1 1 1)) +(assert_return (invoke "i32x4.mul" (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648) + (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.mul" (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648) + (v128.const i32x4 -2147483647 -2147483647 -2147483647 -2147483647)) + (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648)) +(assert_return (invoke "i32x4.mul" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295) + (v128.const i32x4 0 0 0 0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.mul" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295) + (v128.const i32x4 1 1 1 1)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "i32x4.mul" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295) + (v128.const i32x4 -1 -1 -1 -1)) + (v128.const i32x4 1 1 1 1)) +(assert_return (invoke "i32x4.mul" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295) + (v128.const i32x4 2147483647 2147483647 2147483647 2147483647)) + (v128.const i32x4 -2147483647 -2147483647 -2147483647 -2147483647)) +(assert_return (invoke "i32x4.mul" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295) + (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648)) + (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648)) +(assert_return (invoke "i32x4.mul" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295) + (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)) + (v128.const i32x4 1 1 1 1)) +(assert_return (invoke "i32x4.mul" (v128.const i32x4 0x3fffffff 0x3fffffff 0x3fffffff 0x3fffffff) + (v128.const i32x4 0x40000000 0x40000000 0x40000000 0x40000000)) + (v128.const i32x4 -1073741824 -1073741824 -1073741824 -1073741824)) +(assert_return (invoke "i32x4.mul" (v128.const i32x4 0x40000000 0x40000000 0x40000000 0x40000000) + (v128.const i32x4 0x40000000 0x40000000 0x40000000 0x40000000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.mul" (v128.const i32x4 -0x3fffffff -0x3fffffff -0x3fffffff -0x3fffffff) + (v128.const i32x4 -0x40000000 -0x40000000 -0x40000000 -0x40000000)) + (v128.const i32x4 -1073741824 -1073741824 -1073741824 -1073741824)) +(assert_return (invoke "i32x4.mul" (v128.const i32x4 -0x40000000 -0x40000000 -0x40000000 -0x40000000) + (v128.const i32x4 -0x40000000 -0x40000000 -0x40000000 -0x40000000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.mul" (v128.const i32x4 -0x40000000 -0x40000000 -0x40000000 -0x40000000) + (v128.const i32x4 -0x40000001 -0x40000001 -0x40000001 -0x40000001)) + (v128.const i32x4 1073741824 1073741824 1073741824 1073741824)) +(assert_return (invoke "i32x4.mul" (v128.const i32x4 0x7fffffff 0x7fffffff 0x7fffffff 0x7fffffff) + (v128.const i32x4 0x7fffffff 0x7fffffff 0x7fffffff 0x7fffffff)) + (v128.const i32x4 1 1 1 1)) +(assert_return (invoke "i32x4.mul" (v128.const i32x4 0x7fffffff 0x7fffffff 0x7fffffff 0x7fffffff) + (v128.const i32x4 0x01 0x01 0x01 0x01)) + (v128.const i32x4 2147483647 2147483647 2147483647 2147483647)) +(assert_return (invoke "i32x4.mul" (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000) + (v128.const i32x4 -0x01 -0x01 -0x01 -0x01)) + (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648)) +(assert_return (invoke "i32x4.mul" (v128.const i32x4 0x7fffffff 0x7fffffff 0x7fffffff 0x7fffffff) + (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000)) + (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648)) +(assert_return (invoke "i32x4.mul" (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000) + (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.mul" (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff) + (v128.const i32x4 0x01 0x01 0x01 0x01)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "i32x4.mul" (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff) + (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff)) + (v128.const i32x4 1 1 1 1)) +(assert_return (invoke "i32x4.mul" (v128.const i32x4 0x10000000 0x10000000 0x10000000 0x10000000) + (v128.const i8x16 0x10 0x10 0x10 0x10 0x10 0x10 0x10 0x10 0x10 0x10 0x10 0x10 0x10 0x10 0x10 0x10)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.mul" (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff) + (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)) + (v128.const i32x4 1 1 1 1)) +(assert_return (invoke "i32x4.mul" (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000) + (v128.const i16x8 0 0x02 0 0x02 0 0x02 0 0x02)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.mul" (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff) + (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff)) + (v128.const i32x4 1 1 1 1)) +(assert_return (invoke "i32x4.mul" (v128.const i32x4 0x8000 0x8000 0x8000 0x8000) + (v128.const f32x4 +0.0 +0.0 +0.0 +0.0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.mul" (v128.const i32x4 0x8000 0x8000 0x8000 0x8000) + (v128.const f32x4 -0.0 -0.0 -0.0 -0.0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.mul" (v128.const i32x4 0x8000 0x8000 0x8000 0x8000) + (v128.const f32x4 1.0 1.0 1.0 1.0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.mul" (v128.const i32x4 0x8000 0x8000 0x8000 0x8000) + (v128.const f32x4 -1.0 -1.0 -1.0 -1.0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.mul" (v128.const i32x4 0x1 0x1 0x1 0x1) + (v128.const f32x4 +inf +inf +inf +inf)) + (v128.const i32x4 0x7f800000 0x7f800000 0x7f800000 0x7f800000)) +(assert_return (invoke "i32x4.mul" (v128.const i32x4 0x1 0x1 0x1 0x1) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const i32x4 0xff800000 0xff800000 0xff800000 0xff800000)) +(assert_return (invoke "i32x4.mul" (v128.const i32x4 0x1 0x1 0x1 0x1) + (v128.const f32x4 nan nan nan nan)) + (v128.const i32x4 0x7fc00000 0x7fc00000 0x7fc00000 0x7fc00000)) +(assert_return (invoke "i32x4.mul" (v128.const i32x4 0 1 2 3) + (v128.const i32x4 0 0xffffffff 0xfffffffe 0xfffffffd)) + (v128.const i32x4 0 0xffffffff 0xfffffffc 0xfffffff7)) +(assert_return (invoke "i32x4.mul" (v128.const i32x4 0 1 2 3) + (v128.const i32x4 0 2 4 6)) + (v128.const i32x4 0 0x02 0x08 0x12)) +(assert_return (invoke "i32x4.mul" (v128.const i32x4 0_123_456_789 0_123_456_789 0_123_456_789 0_123_456_789) + (v128.const i32x4 0_987_654_321 0_987_654_321 0_987_654_321 0_987_654_321)) + (v128.const i32x4 04_227_814_277 04_227_814_277 04_227_814_277 04_227_814_277)) +(assert_return (invoke "i32x4.mul" (v128.const i32x4 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678) + (v128.const i32x4 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef)) + (v128.const i32x4 0x0_2a42_d208 0x0_2a42_d208 0x0_2a42_d208 0x0_2a42_d208)) + +;; i32x4.neg +(assert_return (invoke "i32x4.neg" (v128.const i32x4 0 0 0 0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.neg" (v128.const i32x4 1 1 1 1)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "i32x4.neg" (v128.const i32x4 -1 -1 -1 -1)) + (v128.const i32x4 1 1 1 1)) +(assert_return (invoke "i32x4.neg" (v128.const i32x4 2147483646 2147483646 2147483646 2147483646)) + (v128.const i32x4 -2147483646 -2147483646 -2147483646 -2147483646)) +(assert_return (invoke "i32x4.neg" (v128.const i32x4 -2147483647 -2147483647 -2147483647 -2147483647)) + (v128.const i32x4 2147483647 2147483647 2147483647 2147483647)) +(assert_return (invoke "i32x4.neg" (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648)) + (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648)) +(assert_return (invoke "i32x4.neg" (v128.const i32x4 2147483647 2147483647 2147483647 2147483647)) + (v128.const i32x4 -2147483647 -2147483647 -2147483647 -2147483647)) +(assert_return (invoke "i32x4.neg" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)) + (v128.const i32x4 1 1 1 1)) +(assert_return (invoke "i32x4.neg" (v128.const i32x4 0x01 0x01 0x01 0x01)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "i32x4.neg" (v128.const i32x4 -0x01 -0x01 -0x01 -0x01)) + (v128.const i32x4 1 1 1 1)) +(assert_return (invoke "i32x4.neg" (v128.const i32x4 -0x80000000 -0x80000000 -0x80000000 -0x80000000)) + (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648)) +(assert_return (invoke "i32x4.neg" (v128.const i32x4 -0x7fffffff -0x7fffffff -0x7fffffff -0x7fffffff)) + (v128.const i32x4 2147483647 2147483647 2147483647 2147483647)) +(assert_return (invoke "i32x4.neg" (v128.const i32x4 0x7fffffff 0x7fffffff 0x7fffffff 0x7fffffff)) + (v128.const i32x4 -2147483647 -2147483647 -2147483647 -2147483647)) +(assert_return (invoke "i32x4.neg" (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000)) + (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648)) +(assert_return (invoke "i32x4.neg" (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff)) + (v128.const i32x4 1 1 1 1)) + +;; type check +(assert_invalid (module (func (result v128) (i32x4.neg (i32.const 0)))) "type mismatch") +(assert_invalid (module (func (result v128) (i32x4.add (i32.const 0) (f32.const 0.0)))) "type mismatch") +(assert_invalid (module (func (result v128) (i32x4.sub (i32.const 0) (f32.const 0.0)))) "type mismatch") +(assert_invalid (module (func (result v128) (i32x4.mul (i32.const 0) (f32.const 0.0)))) "type mismatch") + +;; Test operation with empty argument + +(assert_invalid + (module + (func $i32x4.neg-arg-empty (result v128) + (i32x4.neg) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i32x4.add-1st-arg-empty (result v128) + (i32x4.add (v128.const i32x4 0 0 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i32x4.add-arg-empty (result v128) + (i32x4.add) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i32x4.sub-1st-arg-empty (result v128) + (i32x4.sub (v128.const i32x4 0 0 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i32x4.sub-arg-empty (result v128) + (i32x4.sub) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i32x4.mul-1st-arg-empty (result v128) + (i32x4.mul (v128.const i32x4 0 0 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i32x4.mul-arg-empty (result v128) + (i32x4.mul) + ) + ) + "type mismatch" +) + +;; combination +(module + (func (export "add-sub") (param v128 v128 v128) (result v128) + (i32x4.add (i32x4.sub (local.get 0) (local.get 1))(local.get 2))) + (func (export "mul-add") (param v128 v128 v128) (result v128) + (i32x4.mul (i32x4.add (local.get 0) (local.get 1))(local.get 2))) + (func (export "mul-sub") (param v128 v128 v128) (result v128) + (i32x4.mul (i32x4.sub (local.get 0) (local.get 1))(local.get 2))) + (func (export "sub-add") (param v128 v128 v128) (result v128) + (i32x4.sub (i32x4.add (local.get 0) (local.get 1))(local.get 2))) + (func (export "add-neg") (param v128 v128) (result v128) + (i32x4.add (i32x4.neg (local.get 0)) (local.get 1))) + (func (export "mul-neg") (param v128 v128) (result v128) + (i32x4.mul (i32x4.neg (local.get 0)) (local.get 1))) + (func (export "sub-neg") (param v128 v128) (result v128) + (i32x4.sub (i32x4.neg (local.get 0)) (local.get 1))) +) + +(assert_return (invoke "add-sub" (v128.const i32x4 0 1 2 3) + (v128.const i32x4 0 2 4 6) + (v128.const i32x4 0 2 4 6)) + (v128.const i32x4 0 1 2 3)) +(assert_return (invoke "mul-add" (v128.const i32x4 0 1 2 3) + (v128.const i32x4 0 1 2 3) + (v128.const i32x4 2 2 2 2)) + (v128.const i32x4 0 4 8 12)) +(assert_return (invoke "mul-sub" (v128.const i32x4 0 2 4 6) + (v128.const i32x4 0 1 2 3) + (v128.const i32x4 0 1 2 3)) + (v128.const i32x4 0 1 4 9)) +(assert_return (invoke "sub-add" (v128.const i32x4 0 1 2 3) + (v128.const i32x4 0 2 4 6) + (v128.const i32x4 0 2 4 6)) + (v128.const i32x4 0 1 2 3)) +(assert_return (invoke "add-neg" (v128.const i32x4 0 1 2 3) + (v128.const i32x4 0 1 2 3)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "mul-neg" (v128.const i32x4 0 1 2 3) + (v128.const i32x4 2 2 2 2)) + (v128.const i32x4 0 -2 -4 -6)) +(assert_return (invoke "sub-neg" (v128.const i32x4 0 1 2 3) + (v128.const i32x4 0 1 2 3)) + (v128.const i32x4 0 -2 -4 -6)) \ No newline at end of file diff --git a/runtime/near-vm/tests/wast/spec/proposals/simd/simd_i32x4_arith2.wast b/runtime/near-vm/tests/wast/spec/proposals/simd/simd_i32x4_arith2.wast new file mode 100644 index 00000000000..63c3f4a42c3 --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/proposals/simd/simd_i32x4_arith2.wast @@ -0,0 +1,494 @@ +;; Tests for i32x4 [min_s, min_u, max_s, max_u, abs] operations. + +(module + (func (export "i32x4.min_s") (param v128 v128) (result v128) (i32x4.min_s (local.get 0) (local.get 1))) + (func (export "i32x4.min_u") (param v128 v128) (result v128) (i32x4.min_u (local.get 0) (local.get 1))) + (func (export "i32x4.max_s") (param v128 v128) (result v128) (i32x4.max_s (local.get 0) (local.get 1))) + (func (export "i32x4.max_u") (param v128 v128) (result v128) (i32x4.max_u (local.get 0) (local.get 1))) + (func (export "i32x4.abs") (param v128) (result v128) (i32x4.abs (local.get 0))) + (func (export "i32x4.min_s_with_const_0") (result v128) (i32x4.min_s (v128.const i32x4 -2147483648 2147483647 1073741824 4294967295) (v128.const i32x4 4294967295 1073741824 2147483647 -2147483648))) + (func (export "i32x4.min_s_with_const_1") (result v128) (i32x4.min_s (v128.const i32x4 0 1 2 3) (v128.const i32x4 3 2 1 0))) + (func (export "i32x4.min_u_with_const_2") (result v128) (i32x4.min_u (v128.const i32x4 -2147483648 2147483647 1073741824 4294967295) (v128.const i32x4 4294967295 1073741824 2147483647 -2147483648))) + (func (export "i32x4.min_u_with_const_3") (result v128) (i32x4.min_u (v128.const i32x4 0 1 2 3) (v128.const i32x4 3 2 1 0))) + (func (export "i32x4.max_s_with_const_4") (result v128) (i32x4.max_s (v128.const i32x4 -2147483648 2147483647 1073741824 4294967295) (v128.const i32x4 4294967295 1073741824 2147483647 -2147483648))) + (func (export "i32x4.max_s_with_const_5") (result v128) (i32x4.max_s (v128.const i32x4 0 1 2 3) (v128.const i32x4 3 2 1 0))) + (func (export "i32x4.max_u_with_const_6") (result v128) (i32x4.max_u (v128.const i32x4 -2147483648 2147483647 1073741824 4294967295) (v128.const i32x4 4294967295 1073741824 2147483647 -2147483648))) + (func (export "i32x4.max_u_with_const_7") (result v128) (i32x4.max_u (v128.const i32x4 0 1 2 3) (v128.const i32x4 3 2 1 0))) + (func (export "i32x4.abs_with_const_8") (result v128) (i32x4.abs (v128.const i32x4 -2147483648 2147483647 1073741824 4294967295))) + (func (export "i32x4.min_s_with_const_9") (param v128) (result v128) (i32x4.min_s (local.get 0) (v128.const i32x4 -2147483648 2147483647 1073741824 4294967295))) + (func (export "i32x4.min_s_with_const_10") (param v128) (result v128) (i32x4.min_s (local.get 0) (v128.const i32x4 0 1 2 3))) + (func (export "i32x4.min_u_with_const_11") (param v128) (result v128) (i32x4.min_u (local.get 0) (v128.const i32x4 -2147483648 2147483647 1073741824 4294967295))) + (func (export "i32x4.min_u_with_const_12") (param v128) (result v128) (i32x4.min_u (local.get 0) (v128.const i32x4 0 1 2 3))) + (func (export "i32x4.max_s_with_const_13") (param v128) (result v128) (i32x4.max_s (local.get 0) (v128.const i32x4 -2147483648 2147483647 1073741824 4294967295))) + (func (export "i32x4.max_s_with_const_14") (param v128) (result v128) (i32x4.max_s (local.get 0) (v128.const i32x4 0 1 2 3))) + (func (export "i32x4.max_u_with_const_15") (param v128) (result v128) (i32x4.max_u (local.get 0) (v128.const i32x4 -2147483648 2147483647 1073741824 4294967295))) + (func (export "i32x4.max_u_with_const_16") (param v128) (result v128) (i32x4.max_u (local.get 0) (v128.const i32x4 0 1 2 3))) +) + +(assert_return (invoke "i32x4.min_s" (v128.const i32x4 0 0 0 0) + (v128.const i32x4 0 0 0 0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.min_s" (v128.const i32x4 0 0 0 0) + (v128.const i32x4 -1 -1 -1 -1)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "i32x4.min_s" (v128.const i32x4 0 0 -1 -1) + (v128.const i32x4 0 -1 0 -1)) + (v128.const i32x4 0 -1 -1 -1)) +(assert_return (invoke "i32x4.min_s" (v128.const i32x4 0 0 0 0) + (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff)) + (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff)) +(assert_return (invoke "i32x4.min_s" (v128.const i32x4 1 1 1 1) + (v128.const i32x4 1 1 1 1)) + (v128.const i32x4 1 1 1 1)) +(assert_return (invoke "i32x4.min_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295) + (v128.const i32x4 1 1 1 1)) + (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)) +(assert_return (invoke "i32x4.min_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295) + (v128.const i32x4 128 128 128 128)) + (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)) +(assert_return (invoke "i32x4.min_s" (v128.const i32x4 2147483648 2147483648 2147483648 2147483648) + (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648)) + (v128.const i32x4 2147483648 2147483648 2147483648 2147483648)) +(assert_return (invoke "i32x4.min_s" (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000) + (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648)) + (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000)) +(assert_return (invoke "i32x4.min_s" (v128.const i32x4 123 123 123 123) + (v128.const i32x4 01_2_3 01_2_3 01_2_3 01_2_3)) + (v128.const i32x4 123 123 123 123)) +(assert_return (invoke "i32x4.min_s" (v128.const i32x4 0x80 0x80 0x80 0x80) + (v128.const i32x4 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0)) + (v128.const i32x4 0x80 0x80 0x80 0x80)) +(assert_return (invoke "i32x4.min_u" (v128.const i32x4 0 0 0 0) + (v128.const i32x4 0 0 0 0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.min_u" (v128.const i32x4 0 0 0 0) + (v128.const i32x4 -1 -1 -1 -1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.min_u" (v128.const i32x4 0 0 -1 -1) + (v128.const i32x4 0 -1 0 -1)) + (v128.const i32x4 0 0 0 -1)) +(assert_return (invoke "i32x4.min_u" (v128.const i32x4 0 0 0 0) + (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.min_u" (v128.const i32x4 1 1 1 1) + (v128.const i32x4 1 1 1 1)) + (v128.const i32x4 1 1 1 1)) +(assert_return (invoke "i32x4.min_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295) + (v128.const i32x4 1 1 1 1)) + (v128.const i32x4 1 1 1 1)) +(assert_return (invoke "i32x4.min_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295) + (v128.const i32x4 128 128 128 128)) + (v128.const i32x4 128 128 128 128)) +(assert_return (invoke "i32x4.min_u" (v128.const i32x4 2147483648 2147483648 2147483648 2147483648) + (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648)) + (v128.const i32x4 2147483648 2147483648 2147483648 2147483648)) +(assert_return (invoke "i32x4.min_u" (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000) + (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648)) + (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000)) +(assert_return (invoke "i32x4.min_u" (v128.const i32x4 123 123 123 123) + (v128.const i32x4 01_2_3 01_2_3 01_2_3 01_2_3)) + (v128.const i32x4 123 123 123 123)) +(assert_return (invoke "i32x4.min_u" (v128.const i32x4 0x80 0x80 0x80 0x80) + (v128.const i32x4 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0)) + (v128.const i32x4 0x80 0x80 0x80 0x80)) +(assert_return (invoke "i32x4.max_s" (v128.const i32x4 0 0 0 0) + (v128.const i32x4 0 0 0 0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.max_s" (v128.const i32x4 0 0 0 0) + (v128.const i32x4 -1 -1 -1 -1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.max_s" (v128.const i32x4 0 0 -1 -1) + (v128.const i32x4 0 -1 0 -1)) + (v128.const i32x4 0 0 0 -1)) +(assert_return (invoke "i32x4.max_s" (v128.const i32x4 0 0 0 0) + (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.max_s" (v128.const i32x4 1 1 1 1) + (v128.const i32x4 1 1 1 1)) + (v128.const i32x4 1 1 1 1)) +(assert_return (invoke "i32x4.max_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295) + (v128.const i32x4 1 1 1 1)) + (v128.const i32x4 1 1 1 1)) +(assert_return (invoke "i32x4.max_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295) + (v128.const i32x4 128 128 128 128)) + (v128.const i32x4 128 128 128 128)) +(assert_return (invoke "i32x4.max_s" (v128.const i32x4 2147483648 2147483648 2147483648 2147483648) + (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648)) + (v128.const i32x4 2147483648 2147483648 2147483648 2147483648)) +(assert_return (invoke "i32x4.max_s" (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000) + (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648)) + (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000)) +(assert_return (invoke "i32x4.max_s" (v128.const i32x4 123 123 123 123) + (v128.const i32x4 01_2_3 01_2_3 01_2_3 01_2_3)) + (v128.const i32x4 123 123 123 123)) +(assert_return (invoke "i32x4.max_s" (v128.const i32x4 0x80 0x80 0x80 0x80) + (v128.const i32x4 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0)) + (v128.const i32x4 0x80 0x80 0x80 0x80)) +(assert_return (invoke "i32x4.max_u" (v128.const i32x4 0 0 0 0) + (v128.const i32x4 0 0 0 0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.max_u" (v128.const i32x4 0 0 0 0) + (v128.const i32x4 -1 -1 -1 -1)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "i32x4.max_u" (v128.const i32x4 0 0 -1 -1) + (v128.const i32x4 0 -1 0 -1)) + (v128.const i32x4 0 -1 -1 -1)) +(assert_return (invoke "i32x4.max_u" (v128.const i32x4 0 0 0 0) + (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff)) + (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff)) +(assert_return (invoke "i32x4.max_u" (v128.const i32x4 1 1 1 1) + (v128.const i32x4 1 1 1 1)) + (v128.const i32x4 1 1 1 1)) +(assert_return (invoke "i32x4.max_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295) + (v128.const i32x4 1 1 1 1)) + (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)) +(assert_return (invoke "i32x4.max_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295) + (v128.const i32x4 128 128 128 128)) + (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)) +(assert_return (invoke "i32x4.max_u" (v128.const i32x4 2147483648 2147483648 2147483648 2147483648) + (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648)) + (v128.const i32x4 2147483648 2147483648 2147483648 2147483648)) +(assert_return (invoke "i32x4.max_u" (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000) + (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648)) + (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000)) +(assert_return (invoke "i32x4.max_u" (v128.const i32x4 123 123 123 123) + (v128.const i32x4 01_2_3 01_2_3 01_2_3 01_2_3)) + (v128.const i32x4 123 123 123 123)) +(assert_return (invoke "i32x4.max_u" (v128.const i32x4 0x80 0x80 0x80 0x80) + (v128.const i32x4 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0)) + (v128.const i32x4 0x80 0x80 0x80 0x80)) +(assert_return (invoke "i32x4.abs" (v128.const i32x4 1 1 1 1)) + (v128.const i32x4 1 1 1 1)) +(assert_return (invoke "i32x4.abs" (v128.const i32x4 -1 -1 -1 -1)) + (v128.const i32x4 1 1 1 1)) +(assert_return (invoke "i32x4.abs" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)) + (v128.const i32x4 1 1 1 1)) +(assert_return (invoke "i32x4.abs" (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff)) + (v128.const i32x4 0x1 0x1 0x1 0x1)) +(assert_return (invoke "i32x4.abs" (v128.const i32x4 2147483648 2147483648 2147483648 2147483648)) + (v128.const i32x4 2147483648 2147483648 2147483648 2147483648)) +(assert_return (invoke "i32x4.abs" (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648)) + (v128.const i32x4 2147483648 2147483648 2147483648 2147483648)) +(assert_return (invoke "i32x4.abs" (v128.const i32x4 -0x80000000 -0x80000000 -0x80000000 -0x80000000)) + (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000)) +(assert_return (invoke "i32x4.abs" (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000)) + (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000)) +(assert_return (invoke "i32x4.abs" (v128.const i32x4 01_2_3 01_2_3 01_2_3 01_2_3)) + (v128.const i32x4 01_2_3 01_2_3 01_2_3 01_2_3)) +(assert_return (invoke "i32x4.abs" (v128.const i32x4 -01_2_3 -01_2_3 -01_2_3 -01_2_3)) + (v128.const i32x4 123 123 123 123)) +(assert_return (invoke "i32x4.abs" (v128.const i32x4 0x80 0x80 0x80 0x80)) + (v128.const i32x4 0x80 0x80 0x80 0x80)) +(assert_return (invoke "i32x4.abs" (v128.const i32x4 -0x80 -0x80 -0x80 -0x80)) + (v128.const i32x4 0x80 0x80 0x80 0x80)) +(assert_return (invoke "i32x4.abs" (v128.const i32x4 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0)) + (v128.const i32x4 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0)) +(assert_return (invoke "i32x4.abs" (v128.const i32x4 -0x0_8_0 -0x0_8_0 -0x0_8_0 -0x0_8_0)) + (v128.const i32x4 0x80 0x80 0x80 0x80)) + +;; Const vs const +(assert_return (invoke "i32x4.min_s_with_const_0") (v128.const i32x4 -2147483648 1073741824 1073741824 -2147483648)) +(assert_return (invoke "i32x4.min_s_with_const_1") (v128.const i32x4 0 1 1 0)) +(assert_return (invoke "i32x4.min_u_with_const_2") (v128.const i32x4 -2147483648 1073741824 1073741824 -2147483648)) +(assert_return (invoke "i32x4.min_u_with_const_3") (v128.const i32x4 0 1 1 0)) +(assert_return (invoke "i32x4.max_s_with_const_4") (v128.const i32x4 4294967295 2147483647 2147483647 4294967295)) +(assert_return (invoke "i32x4.max_s_with_const_5") (v128.const i32x4 3 2 2 3)) +(assert_return (invoke "i32x4.max_u_with_const_6") (v128.const i32x4 4294967295 2147483647 2147483647 4294967295)) +(assert_return (invoke "i32x4.max_u_with_const_7") (v128.const i32x4 3 2 2 3)) +(assert_return (invoke "i32x4.abs_with_const_8") (v128.const i32x4 2147483648 2147483647 1073741824 1)) + +;; Param vs const +(assert_return (invoke "i32x4.min_s_with_const_9" (v128.const i32x4 4294967295 1073741824 2147483647 -2147483648)) + (v128.const i32x4 -2147483648 1073741824 1073741824 -2147483648)) +(assert_return (invoke "i32x4.min_s_with_const_10" (v128.const i32x4 3 2 1 0)) + (v128.const i32x4 0 1 1 0)) +(assert_return (invoke "i32x4.min_u_with_const_11" (v128.const i32x4 4294967295 1073741824 2147483647 -2147483648)) + (v128.const i32x4 -2147483648 1073741824 1073741824 -2147483648)) +(assert_return (invoke "i32x4.min_u_with_const_12" (v128.const i32x4 3 2 1 0)) + (v128.const i32x4 0 1 1 0)) +(assert_return (invoke "i32x4.max_s_with_const_13" (v128.const i32x4 4294967295 1073741824 2147483647 -2147483648)) + (v128.const i32x4 4294967295 2147483647 2147483647 4294967295)) +(assert_return (invoke "i32x4.max_s_with_const_14" (v128.const i32x4 3 2 1 0)) + (v128.const i32x4 3 2 2 3)) +(assert_return (invoke "i32x4.max_u_with_const_15" (v128.const i32x4 4294967295 1073741824 2147483647 -2147483648)) + (v128.const i32x4 4294967295 2147483647 2147483647 4294967295)) +(assert_return (invoke "i32x4.max_u_with_const_16" (v128.const i32x4 3 2 1 0)) + (v128.const i32x4 3 2 2 3)) + +;; Test different lanes go through different if-then clauses +(assert_return (invoke "i32x4.min_s" (v128.const i32x4 -2147483648 2147483647 1073741824 4294967295) + (v128.const i32x4 4294967295 1073741824 2147483647 -2147483648)) + (v128.const i32x4 -2147483648 1073741824 1073741824 -2147483648)) +(assert_return (invoke "i32x4.min_s" (v128.const i32x4 0 1 2 128) + (v128.const i32x4 0 2 1 128)) + (v128.const i32x4 0 1 1 128)) +(assert_return (invoke "i32x4.min_u" (v128.const i32x4 -2147483648 2147483647 1073741824 4294967295) + (v128.const i32x4 4294967295 1073741824 2147483647 -2147483648)) + (v128.const i32x4 -2147483648 1073741824 1073741824 -2147483648)) +(assert_return (invoke "i32x4.min_u" (v128.const i32x4 0 1 2 128) + (v128.const i32x4 0 2 1 128)) + (v128.const i32x4 0 1 1 128)) +(assert_return (invoke "i32x4.max_s" (v128.const i32x4 -2147483648 2147483647 1073741824 4294967295) + (v128.const i32x4 4294967295 1073741824 2147483647 -2147483648)) + (v128.const i32x4 4294967295 2147483647 2147483647 4294967295)) +(assert_return (invoke "i32x4.max_s" (v128.const i32x4 0 1 2 128) + (v128.const i32x4 0 2 1 128)) + (v128.const i32x4 0 2 2 128)) +(assert_return (invoke "i32x4.max_u" (v128.const i32x4 -2147483648 2147483647 1073741824 4294967295) + (v128.const i32x4 4294967295 1073741824 2147483647 -2147483648)) + (v128.const i32x4 4294967295 2147483647 2147483647 4294967295)) +(assert_return (invoke "i32x4.max_u" (v128.const i32x4 0 1 2 128) + (v128.const i32x4 0 2 1 128)) + (v128.const i32x4 0 2 2 128)) +(assert_return (invoke "i32x4.abs" (v128.const i32x4 -2147483648 2147483647 1073741824 4294967295)) + (v128.const i32x4 2147483648 2147483647 1073741824 1)) + +;; Test opposite signs of zero +(assert_return (invoke "i32x4.min_s" (v128.const i32x4 -0 -0 +0 +0) + (v128.const i32x4 +0 0 -0 0)) + (v128.const i32x4 -0 -0 +0 +0)) +(assert_return (invoke "i32x4.min_s" (v128.const i32x4 -0 -0 -0 -0) + (v128.const i32x4 +0 +0 +0 +0)) + (v128.const i32x4 -0 -0 -0 -0)) +(assert_return (invoke "i32x4.min_u" (v128.const i32x4 -0 -0 +0 +0) + (v128.const i32x4 +0 0 -0 0)) + (v128.const i32x4 -0 -0 +0 +0)) +(assert_return (invoke "i32x4.min_u" (v128.const i32x4 -0 -0 -0 -0) + (v128.const i32x4 +0 +0 +0 +0)) + (v128.const i32x4 -0 -0 -0 -0)) +(assert_return (invoke "i32x4.max_s" (v128.const i32x4 -0 -0 +0 +0) + (v128.const i32x4 +0 0 -0 0)) + (v128.const i32x4 -0 -0 +0 +0)) +(assert_return (invoke "i32x4.max_s" (v128.const i32x4 -0 -0 -0 -0) + (v128.const i32x4 +0 +0 +0 +0)) + (v128.const i32x4 -0 -0 -0 -0)) +(assert_return (invoke "i32x4.max_u" (v128.const i32x4 -0 -0 +0 +0) + (v128.const i32x4 +0 0 -0 0)) + (v128.const i32x4 -0 -0 +0 +0)) +(assert_return (invoke "i32x4.max_u" (v128.const i32x4 -0 -0 -0 -0) + (v128.const i32x4 +0 +0 +0 +0)) + (v128.const i32x4 -0 -0 -0 -0)) +(assert_return (invoke "i32x4.abs" (v128.const i32x4 -0 -0 +0 +0)) + (v128.const i32x4 -0 -0 +0 +0)) +(assert_return (invoke "i32x4.abs" (v128.const i32x4 +0 0 -0 0)) + (v128.const i32x4 +0 0 -0 0)) +(assert_return (invoke "i32x4.abs" (v128.const i32x4 -0 -0 -0 -0)) + (v128.const i32x4 -0 -0 -0 -0)) +(assert_return (invoke "i32x4.abs" (v128.const i32x4 +0 +0 +0 +0)) + (v128.const i32x4 +0 +0 +0 +0)) + +;; Unknown operators +(assert_malformed (module quote "(memory 1) (func (result v128) (f32x4.min_s (v128.const i32x4 0 0 0 0) (v128.const i32x4 1 1 1 1)))") "unknown operator") +(assert_malformed (module quote "(memory 1) (func (result v128) (f32x4.min_u (v128.const i32x4 0 0 0 0) (v128.const i32x4 1 1 1 1)))") "unknown operator") +(assert_malformed (module quote "(memory 1) (func (result v128) (f32x4.max_s (v128.const i32x4 0 0 0 0) (v128.const i32x4 1 1 1 1)))") "unknown operator") +(assert_malformed (module quote "(memory 1) (func (result v128) (f32x4.max_u (v128.const i32x4 0 0 0 0) (v128.const i32x4 1 1 1 1)))") "unknown operator") +(assert_malformed (module quote "(memory 1) (func (result v128) (i64x2.min_s (v128.const i32x4 0 0 0 0) (v128.const i32x4 1 1 1 1)))") "unknown operator") +(assert_malformed (module quote "(memory 1) (func (result v128) (i64x2.min_u (v128.const i32x4 0 0 0 0) (v128.const i32x4 1 1 1 1)))") "unknown operator") +(assert_malformed (module quote "(memory 1) (func (result v128) (i64x2.max_s (v128.const i32x4 0 0 0 0) (v128.const i32x4 1 1 1 1)))") "unknown operator") +(assert_malformed (module quote "(memory 1) (func (result v128) (i64x2.max_u (v128.const i32x4 0 0 0 0) (v128.const i32x4 1 1 1 1)))") "unknown operator") +(assert_malformed (module quote "(memory 1) (func (result v128) (f64x2.min_s (v128.const i32x4 0 0 0 0) (v128.const i32x4 1 1 1 1)))") "unknown operator") +(assert_malformed (module quote "(memory 1) (func (result v128) (f64x2.min_u (v128.const i32x4 0 0 0 0) (v128.const i32x4 1 1 1 1)))") "unknown operator") +(assert_malformed (module quote "(memory 1) (func (result v128) (f64x2.max_s (v128.const i32x4 0 0 0 0) (v128.const i32x4 1 1 1 1)))") "unknown operator") +(assert_malformed (module quote "(memory 1) (func (result v128) (f64x2.max_u (v128.const i32x4 0 0 0 0) (v128.const i32x4 1 1 1 1)))") "unknown operator") + +;; Type check +(assert_invalid (module (func (result v128) (i32x4.min_s (i32.const 0) (f32.const 0.0)))) "type mismatch") +(assert_invalid (module (func (result v128) (i32x4.min_u (i32.const 0) (f32.const 0.0)))) "type mismatch") +(assert_invalid (module (func (result v128) (i32x4.max_s (i32.const 0) (f32.const 0.0)))) "type mismatch") +(assert_invalid (module (func (result v128) (i32x4.max_u (i32.const 0) (f32.const 0.0)))) "type mismatch") +(assert_invalid (module (func (result v128) (i32x4.abs (f32.const 0.0)))) "type mismatch") + +;; Test operation with empty argument + +(assert_invalid + (module + (func $i32x4.min_s-1st-arg-empty (result v128) + (i32x4.min_s (v128.const i32x4 0 0 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i32x4.min_s-arg-empty (result v128) + (i32x4.min_s) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i32x4.min_u-1st-arg-empty (result v128) + (i32x4.min_u (v128.const i32x4 0 0 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i32x4.min_u-arg-empty (result v128) + (i32x4.min_u) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i32x4.max_s-1st-arg-empty (result v128) + (i32x4.max_s (v128.const i32x4 0 0 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i32x4.max_s-arg-empty (result v128) + (i32x4.max_s) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i32x4.max_u-1st-arg-empty (result v128) + (i32x4.max_u (v128.const i32x4 0 0 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i32x4.max_u-arg-empty (result v128) + (i32x4.max_u) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i32x4.abs-arg-empty (result v128) + (i32x4.abs) + ) + ) + "type mismatch" +) + +;; Combination +(module + (func (export "i32x4.min_s-i32x4.max_u") (param v128 v128 v128) (result v128) (i32x4.min_s (i32x4.max_u (local.get 0) (local.get 1))(local.get 2))) + (func (export "i32x4.min_s-i32x4.max_s") (param v128 v128 v128) (result v128) (i32x4.min_s (i32x4.max_s (local.get 0) (local.get 1))(local.get 2))) + (func (export "i32x4.min_s-i32x4.min_u") (param v128 v128 v128) (result v128) (i32x4.min_s (i32x4.min_u (local.get 0) (local.get 1))(local.get 2))) + (func (export "i32x4.min_s-i32x4.min_s") (param v128 v128 v128) (result v128) (i32x4.min_s (i32x4.min_s (local.get 0) (local.get 1))(local.get 2))) + (func (export "i32x4.min_s-i32x4.abs") (param v128 v128) (result v128) (i32x4.min_s (i32x4.abs (local.get 0))(local.get 1))) + (func (export "i32x4.abs-i32x4.min_s") (param v128 v128) (result v128) (i32x4.abs (i32x4.min_s (local.get 0) (local.get 1)))) + (func (export "i32x4.min_u-i32x4.max_u") (param v128 v128 v128) (result v128) (i32x4.min_u (i32x4.max_u (local.get 0) (local.get 1))(local.get 2))) + (func (export "i32x4.min_u-i32x4.max_s") (param v128 v128 v128) (result v128) (i32x4.min_u (i32x4.max_s (local.get 0) (local.get 1))(local.get 2))) + (func (export "i32x4.min_u-i32x4.min_u") (param v128 v128 v128) (result v128) (i32x4.min_u (i32x4.min_u (local.get 0) (local.get 1))(local.get 2))) + (func (export "i32x4.min_u-i32x4.min_s") (param v128 v128 v128) (result v128) (i32x4.min_u (i32x4.min_s (local.get 0) (local.get 1))(local.get 2))) + (func (export "i32x4.min_u-i32x4.abs") (param v128 v128) (result v128) (i32x4.min_u (i32x4.abs (local.get 0))(local.get 1))) + (func (export "i32x4.abs-i32x4.min_u") (param v128 v128) (result v128) (i32x4.abs (i32x4.min_u (local.get 0) (local.get 1)))) + (func (export "i32x4.max_s-i32x4.max_u") (param v128 v128 v128) (result v128) (i32x4.max_s (i32x4.max_u (local.get 0) (local.get 1))(local.get 2))) + (func (export "i32x4.max_s-i32x4.max_s") (param v128 v128 v128) (result v128) (i32x4.max_s (i32x4.max_s (local.get 0) (local.get 1))(local.get 2))) + (func (export "i32x4.max_s-i32x4.min_u") (param v128 v128 v128) (result v128) (i32x4.max_s (i32x4.min_u (local.get 0) (local.get 1))(local.get 2))) + (func (export "i32x4.max_s-i32x4.min_s") (param v128 v128 v128) (result v128) (i32x4.max_s (i32x4.min_s (local.get 0) (local.get 1))(local.get 2))) + (func (export "i32x4.max_s-i32x4.abs") (param v128 v128) (result v128) (i32x4.max_s (i32x4.abs (local.get 0))(local.get 1))) + (func (export "i32x4.abs-i32x4.max_s") (param v128 v128) (result v128) (i32x4.abs (i32x4.max_s (local.get 0) (local.get 1)))) + (func (export "i32x4.max_u-i32x4.max_u") (param v128 v128 v128) (result v128) (i32x4.max_u (i32x4.max_u (local.get 0) (local.get 1))(local.get 2))) + (func (export "i32x4.max_u-i32x4.max_s") (param v128 v128 v128) (result v128) (i32x4.max_u (i32x4.max_s (local.get 0) (local.get 1))(local.get 2))) + (func (export "i32x4.max_u-i32x4.min_u") (param v128 v128 v128) (result v128) (i32x4.max_u (i32x4.min_u (local.get 0) (local.get 1))(local.get 2))) + (func (export "i32x4.max_u-i32x4.min_s") (param v128 v128 v128) (result v128) (i32x4.max_u (i32x4.min_s (local.get 0) (local.get 1))(local.get 2))) + (func (export "i32x4.max_u-i32x4.abs") (param v128 v128) (result v128) (i32x4.max_u (i32x4.abs (local.get 0))(local.get 1))) + (func (export "i32x4.abs-i32x4.max_u") (param v128 v128) (result v128) (i32x4.abs (i32x4.max_u (local.get 0) (local.get 1)))) + (func (export "i32x4.abs-i32x4.abs") (param v128) (result v128) (i32x4.abs (i32x4.abs (local.get 0)))) +) + +(assert_return (invoke "i32x4.min_s-i32x4.max_u" (v128.const i32x4 0 0 0 0) + (v128.const i32x4 1 1 1 1) + (v128.const i32x4 2 2 2 2)) + (v128.const i32x4 1 1 1 1)) +(assert_return (invoke "i32x4.min_s-i32x4.max_s" (v128.const i32x4 0 0 0 0) + (v128.const i32x4 1 1 1 1) + (v128.const i32x4 2 2 2 2)) + (v128.const i32x4 1 1 1 1)) +(assert_return (invoke "i32x4.min_s-i32x4.min_u" (v128.const i32x4 0 0 0 0) + (v128.const i32x4 1 1 1 1) + (v128.const i32x4 2 2 2 2)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.min_s-i32x4.min_s" (v128.const i32x4 0 0 0 0) + (v128.const i32x4 1 1 1 1) + (v128.const i32x4 2 2 2 2)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.min_s-i32x4.abs" (v128.const i32x4 -1 -1 -1 -1) + (v128.const i32x4 0 0 0 0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.abs-i32x4.min_s" (v128.const i32x4 0 0 0 0) + (v128.const i32x4 -1 -1 -1 -1)) + (v128.const i32x4 1 1 1 1)) +(assert_return (invoke "i32x4.min_u-i32x4.max_u" (v128.const i32x4 0 0 0 0) + (v128.const i32x4 1 1 1 1) + (v128.const i32x4 2 2 2 2)) + (v128.const i32x4 1 1 1 1)) +(assert_return (invoke "i32x4.min_u-i32x4.max_s" (v128.const i32x4 0 0 0 0) + (v128.const i32x4 1 1 1 1) + (v128.const i32x4 2 2 2 2)) + (v128.const i32x4 1 1 1 1)) +(assert_return (invoke "i32x4.min_u-i32x4.min_u" (v128.const i32x4 0 0 0 0) + (v128.const i32x4 1 1 1 1) + (v128.const i32x4 2 2 2 2)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.min_u-i32x4.min_s" (v128.const i32x4 0 0 0 0) + (v128.const i32x4 1 1 1 1) + (v128.const i32x4 2 2 2 2)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.min_u-i32x4.abs" (v128.const i32x4 -1 -1 -1 -1) + (v128.const i32x4 0 0 0 0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.abs-i32x4.min_u" (v128.const i32x4 0 0 0 0) + (v128.const i32x4 -1 -1 -1 -1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.max_s-i32x4.max_u" (v128.const i32x4 0 0 0 0) + (v128.const i32x4 1 1 1 1) + (v128.const i32x4 2 2 2 2)) + (v128.const i32x4 2 2 2 2)) +(assert_return (invoke "i32x4.max_s-i32x4.max_s" (v128.const i32x4 0 0 0 0) + (v128.const i32x4 1 1 1 1) + (v128.const i32x4 2 2 2 2)) + (v128.const i32x4 2 2 2 2)) +(assert_return (invoke "i32x4.max_s-i32x4.min_u" (v128.const i32x4 0 0 0 0) + (v128.const i32x4 1 1 1 1) + (v128.const i32x4 2 2 2 2)) + (v128.const i32x4 2 2 2 2)) +(assert_return (invoke "i32x4.max_s-i32x4.min_s" (v128.const i32x4 0 0 0 0) + (v128.const i32x4 1 1 1 1) + (v128.const i32x4 2 2 2 2)) + (v128.const i32x4 2 2 2 2)) +(assert_return (invoke "i32x4.max_s-i32x4.abs" (v128.const i32x4 -1 -1 -1 -1) + (v128.const i32x4 0 0 0 0)) + (v128.const i32x4 1 1 1 1)) +(assert_return (invoke "i32x4.abs-i32x4.max_s" (v128.const i32x4 0 0 0 0) + (v128.const i32x4 -1 -1 -1 -1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.max_u-i32x4.max_u" (v128.const i32x4 0 0 0 0) + (v128.const i32x4 1 1 1 1) + (v128.const i32x4 2 2 2 2)) + (v128.const i32x4 2 2 2 2)) +(assert_return (invoke "i32x4.max_u-i32x4.max_s" (v128.const i32x4 0 0 0 0) + (v128.const i32x4 1 1 1 1) + (v128.const i32x4 2 2 2 2)) + (v128.const i32x4 2 2 2 2)) +(assert_return (invoke "i32x4.max_u-i32x4.min_u" (v128.const i32x4 0 0 0 0) + (v128.const i32x4 1 1 1 1) + (v128.const i32x4 2 2 2 2)) + (v128.const i32x4 2 2 2 2)) +(assert_return (invoke "i32x4.max_u-i32x4.min_s" (v128.const i32x4 0 0 0 0) + (v128.const i32x4 1 1 1 1) + (v128.const i32x4 2 2 2 2)) + (v128.const i32x4 2 2 2 2)) +(assert_return (invoke "i32x4.max_u-i32x4.abs" (v128.const i32x4 -1 -1 -1 -1) + (v128.const i32x4 0 0 0 0)) + (v128.const i32x4 1 1 1 1)) +(assert_return (invoke "i32x4.abs-i32x4.max_u" (v128.const i32x4 0 0 0 0) + (v128.const i32x4 -1 -1 -1 -1)) + (v128.const i32x4 1 1 1 1)) +(assert_return (invoke "i32x4.abs-i32x4.abs" (v128.const i32x4 -1 -1 -1 -1)) + (v128.const i32x4 1 1 1 1)) diff --git a/runtime/near-vm/tests/wast/spec/proposals/simd/simd_i32x4_cmp.wast b/runtime/near-vm/tests/wast/spec/proposals/simd/simd_i32x4_cmp.wast new file mode 100644 index 00000000000..fca45ab96bd --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/proposals/simd/simd_i32x4_cmp.wast @@ -0,0 +1,1920 @@ + +;; Test all the i32x4 comparison operators on major boundary values and all special values. + +(module + (func (export "eq") (param $x v128) (param $y v128) (result v128) (i32x4.eq (local.get $x) (local.get $y))) + (func (export "ne") (param $x v128) (param $y v128) (result v128) (i32x4.ne (local.get $x) (local.get $y))) + (func (export "lt_s") (param $x v128) (param $y v128) (result v128) (i32x4.lt_s (local.get $x) (local.get $y))) + (func (export "lt_u") (param $x v128) (param $y v128) (result v128) (i32x4.lt_u (local.get $x) (local.get $y))) + (func (export "le_s") (param $x v128) (param $y v128) (result v128) (i32x4.le_s (local.get $x) (local.get $y))) + (func (export "le_u") (param $x v128) (param $y v128) (result v128) (i32x4.le_u (local.get $x) (local.get $y))) + (func (export "gt_s") (param $x v128) (param $y v128) (result v128) (i32x4.gt_s (local.get $x) (local.get $y))) + (func (export "gt_u") (param $x v128) (param $y v128) (result v128) (i32x4.gt_u (local.get $x) (local.get $y))) + (func (export "ge_s") (param $x v128) (param $y v128) (result v128) (i32x4.ge_s (local.get $x) (local.get $y))) + (func (export "ge_u") (param $x v128) (param $y v128) (result v128) (i32x4.ge_u (local.get $x) (local.get $y))) +) + + +;; eq + +;; i32x4.eq (i32x4) (i32x4) + +;; hex vs hex +(assert_return (invoke "eq" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF) + (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "eq" (v128.const i32x4 0x00000000 0x00000000 0x00000000 0x00000000) + (v128.const i32x4 0x00000000 0x00000000 0x00000000 0x00000000)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "eq" (v128.const i32x4 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0) + (v128.const i32x4 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "eq" (v128.const i32x4 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F) + (v128.const i32x4 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "eq" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0x00000000 0x00000000) + (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0x00000000 0x00000000)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "eq" (v128.const i32x4 0x00000000 0x00000000 0xFFFFFFFF 0xFFFFFFFF) + (v128.const i32x4 0x00000000 0x00000000 0xFFFFFFFF 0xFFFFFFFF)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "eq" (v128.const i32x4 0x03020100 0x11100904 0x1A0B0A12 0xFFABAA1B) + (v128.const i32x4 0x03020100 0x11100904 0x1A0B0A12 0xFFABAA1B)) + (v128.const i32x4 -1 -1 -1 -1)) + +;; hex vs dec +(assert_return (invoke "eq" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF) + (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "eq" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF) + (v128.const i32x4 -1 -1 -1 -1)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "eq" (v128.const i32x4 0x80808080 0x80808080 0x80808080 0x80808080) + (v128.const i32x4 2155905152 2155905152 2155905152 2155905152)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "eq" (v128.const i32x4 0x80808080 0x80808080 0x80808080 0x80808080) + (v128.const i32x4 -2139062144 -2139062144 -2139062144 -2139062144)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "eq" (v128.const i32x4 0x83828180 0x00FFFEFD 0x7F020100 0xFFFEFD80) + (v128.const i32x4 2206368128 16776957 2130837760 4294901120)) + (v128.const i32x4 -1 -1 -1 -1)) + +;; dec vs dec +(assert_return (invoke "eq" (v128.const i32x4 -1 -1 -1 -1) + (v128.const i32x4 -1 -1 -1 -1)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "eq" (v128.const i32x4 0 0 0 0) + (v128.const i32x4 0 0 0 0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "eq" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295) + (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "eq" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295) + (v128.const i32x4 -1 -1 -1 -1)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "eq" (v128.const i32x4 4294967295 4294967295 0 0) + (v128.const i32x4 4294967295 4294967295 0 0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "eq" (v128.const i32x4 0 0 4294967295 4294967295) + (v128.const i32x4 0 0 4294967295 4294967295)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "eq" (v128.const i32x4 -2147483647 4294967295 0 -1) + (v128.const i32x4 2147483649 -1 0 -1)) + (v128.const i32x4 -1 -1 -1 -1)) + +;; hex vs float +(assert_return (invoke "eq" (v128.const i32x4 0xc3000000 0xc2fe0000 0xbf800000 0x00000000) + (v128.const f32x4 -128.0 -127.0 -1.0 0.0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "eq" (v128.const i32x4 0x3f800000 0x42fe0000 0x43000000 0x437f0000) + (v128.const f32x4 1.0 127.0 128.0 255.0)) + (v128.const i32x4 -1 -1 -1 -1)) + +;; not equal +(assert_return (invoke "eq" (v128.const i32x4 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F) + (v128.const i32x4 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const i32x4 0x00000000 0x00000000 0xFFFFFFFF 0xFFFFFFFF) + (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0x00000000 0x00000000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const i32x4 0x02030001 0x10110409 0x0B1A120A 0xABFF1BAA) + (v128.const i32x4 0xAA1BFFAB 0x0A121A0B 0x09041110 0x01000302)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const i32x4 0x80018000 0x80038002 0x80058004 0x80078006) + (v128.const i32x4 2147975174 2147844100 2147713026 2147581952)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const i32x4 2147483648 2147483647 0 -1) + (v128.const i32x4 -2147483648 -2147483647 -1 0)) + (v128.const i32x4 -1 0 0 0)) + +;; i32x4.eq (i32x4) (i8x16) +(assert_return (invoke "eq" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF) + (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "eq" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295) + (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "eq" (v128.const i32x4 0 0 0 0) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "eq" (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C) + (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "eq" (v128.const i32x4 2206368128 16776957 2130837760 4294901120) + (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "eq" (v128.const i32x4 -8323200 0 1 4294967295) + (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255)) + (v128.const i32x4 0 -1 0 -1)) +(assert_return (invoke "eq" (v128.const i32x4 0x55555555 0x55555555 0x55555555 0x55555555) + (v128.const i8x16 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA)) + (v128.const i32x4 0 0 0 0)) + +;; i32x4.eq (i32x4) (i16x8) +(assert_return (invoke "eq" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF) + (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "eq" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295) + (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "eq" (v128.const i32x4 0 0 0 0) + (v128.const i16x8 0 0 0 0 0 0 0 0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "eq" (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C) + (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "eq" (v128.const i32x4 2206368128 16776957 2130837760 4294901120) + (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "eq" (v128.const i32x4 4294967295 0 1 65535) + (v128.const i16x8 65535 65535 0 0 1 0 65535 65535)) + (v128.const i32x4 -1 -1 -1 0)) +(assert_return (invoke "eq" (v128.const i32x4 0x55555555 0x55555555 0x55555555 0x55555555) + (v128.const i16x8 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "eq" (v128.const i32x4 0_123_456_789 0_123_456_789 0_123_456_789 0_123_456_789) + (v128.const i32x4 123456789 123456789 123456789 123456789)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "eq" (v128.const i32x4 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678) + (v128.const i32x4 0x12345678 0x12345678 0x12345678 0x12345678)) + (v128.const i32x4 -1 -1 -1 -1)) + +;; ne + +;; i32x4.ne (i32x4) (i32x4) + +;; hex vs hex +(assert_return (invoke "ne" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF) + (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ne" (v128.const i32x4 0x00000000 0x00000000 0x00000000 0x00000000) + (v128.const i32x4 0x00000000 0x00000000 0x00000000 0x00000000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ne" (v128.const i32x4 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0) + (v128.const i32x4 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ne" (v128.const i32x4 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F) + (v128.const i32x4 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ne" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0x00000000 0x00000000) + (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0x00000000 0x00000000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ne" (v128.const i32x4 0x00000000 0x00000000 0xFFFFFFFF 0xFFFFFFFF) + (v128.const i32x4 0x00000000 0x00000000 0xFFFFFFFF 0xFFFFFFFF)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ne" (v128.const i32x4 0x03020100 0x11100904 0x1A0B0A12 0xFFABAA1B) + (v128.const i32x4 0x03020100 0x11100904 0x1A0B0A12 0xFFABAA1B)) + (v128.const i32x4 0 0 0 0)) + +;; hex vs dec +(assert_return (invoke "ne" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF) + (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ne" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF) + (v128.const i32x4 -1 -1 -1 -1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ne" (v128.const i32x4 0x80808080 0x80808080 0x80808080 0x80808080) + (v128.const i32x4 2155905152 2155905152 2155905152 2155905152)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ne" (v128.const i32x4 0x80808080 0x80808080 0x80808080 0x80808080) + (v128.const i32x4 -2139062144 -2139062144 -2139062144 -2139062144)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ne" (v128.const i32x4 0x83828180 0x00FFFEFD 0x7F020100 0xFFFEFD80) + (v128.const i32x4 2206368128 16776957 2130837760 4294901120)) + (v128.const i32x4 0 0 0 0)) + +;; dec vs dec +(assert_return (invoke "ne" (v128.const i32x4 -1 -1 -1 -1) + (v128.const i32x4 -1 -1 -1 -1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ne" (v128.const i32x4 0 0 0 0) + (v128.const i32x4 0 0 0 0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ne" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295) + (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ne" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295) + (v128.const i32x4 -1 -1 -1 -1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ne" (v128.const i32x4 4294967295 4294967295 0 0) + (v128.const i32x4 4294967295 4294967295 0 0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ne" (v128.const i32x4 0 0 4294967295 4294967295) + (v128.const i32x4 0 0 4294967295 4294967295)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ne" (v128.const i32x4 -2147483647 4294967295 0 -1) + (v128.const i32x4 2147483649 -1 0 -1)) + (v128.const i32x4 0 0 0 0)) + +;; hex vs float +(assert_return (invoke "ne" (v128.const i32x4 0xc3000000 0xc2fe0000 0xbf800000 0x00000000) + (v128.const f32x4 -128.0 -127.0 -1.0 0.0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ne" (v128.const i32x4 0x3f800000 0x42fe0000 0x43000000 0x437f0000) + (v128.const f32x4 1.0 127.0 128.0 255.0)) + (v128.const i32x4 0 0 0 0)) + +;; not equal +(assert_return (invoke "ne" (v128.const i32x4 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F) + (v128.const i32x4 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const i32x4 0x00000000 0x00000000 0xFFFFFFFF 0xFFFFFFFF) + (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0x00000000 0x00000000)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const i32x4 0x02030001 0x10110409 0x0B1A120A 0xABFF1BAA) + (v128.const i32x4 0xAA1BFFAB 0x0A121A0B 0x09041110 0x01000302)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const i32x4 0x80018000 0x80038002 0x80058004 0x80078006) + (v128.const i32x4 2147975174 2147844100 2147713026 2147581952)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const i32x4 2147483648 2147483647 0 -1) + (v128.const i32x4 -2147483648 -2147483647 -1 0)) + (v128.const i32x4 0 -1 -1 -1)) + +;; i32x4.ne (i32x4) (i8x16) +(assert_return (invoke "ne" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF) + (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ne" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295) + (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ne" (v128.const i32x4 0 0 0 0) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ne" (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C) + (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ne" (v128.const i32x4 2206368128 16776957 2130837760 4294901120) + (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ne" (v128.const i32x4 -8323200 0 1 4294967295) + (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255)) + (v128.const i32x4 -1 0 -1 0)) +(assert_return (invoke "ne" (v128.const i32x4 0x55555555 0x55555555 0x55555555 0x55555555) + (v128.const i8x16 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA)) + (v128.const i32x4 -1 -1 -1 -1)) + +;; i32x4.ne (i32x4) (i16x8) +(assert_return (invoke "ne" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF) + (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ne" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295) + (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ne" (v128.const i32x4 0 0 0 0) + (v128.const i16x8 0 0 0 0 0 0 0 0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ne" (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C) + (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ne" (v128.const i32x4 2206368128 16776957 2130837760 4294901120) + (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ne" (v128.const i32x4 -128 0 1 255) + (v128.const i16x8 -128 -128 0 0 1 1 255 255)) + (v128.const i32x4 -1 0 -1 -1)) +(assert_return (invoke "ne" (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA) + (v128.const i16x8 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const i32x4 0_123_456_789 0_123_456_789 0_123_456_789 0_123_456_789) + (v128.const i32x4 123456789 123456789 123456789 123456789)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ne" (v128.const i32x4 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678) + (v128.const i32x4 0x12345678 0x12345678 0x12345678 0x12345678)) + (v128.const i32x4 0 0 0 0)) + +;; lt_s + +;; i32x4.lt_s (i32x4) (i32x4) + +;; hex vs hex +(assert_return (invoke "lt_s" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF) + (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt_s" (v128.const i32x4 0x00000000 0x00000000 0x00000000 0x00000000) + (v128.const i32x4 0x00000000 0x00000000 0x00000000 0x00000000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt_s" (v128.const i32x4 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0) + (v128.const i32x4 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt_s" (v128.const i32x4 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F) + (v128.const i32x4 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt_s" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0x00000000 0x00000000) + (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0x00000000 0x00000000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt_s" (v128.const i32x4 0x00000000 0x00000000 0xFFFFFFFF 0xFFFFFFFF) + (v128.const i32x4 0x00000000 0x00000000 0xFFFFFFFF 0xFFFFFFFF)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt_s" (v128.const i32x4 0x03020100 0x11100904 0x1A0B0A12 0xFFABAA1B) + (v128.const i32x4 0x03020100 0x11100904 0x1A0B0A12 0xFFABAA1B)) + (v128.const i32x4 0 0 0 0)) + +;; hex vs dec +(assert_return (invoke "lt_s" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF) + (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt_s" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF) + (v128.const i32x4 -1 -1 -1 -1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt_s" (v128.const i32x4 0x80808080 0x80808080 0x80808080 0x80808080) + (v128.const i32x4 2155905152 2155905152 2155905152 2155905152)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt_s" (v128.const i32x4 0x80808080 0x80808080 0x80808080 0x80808080) + (v128.const i32x4 -2139062144 -2139062144 -2139062144 -2139062144)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt_s" (v128.const i32x4 0x83828180 0x00FFFEFD 0x7F020100 0xFFFEFD80) + (v128.const i32x4 2206368128 16776957 2130837760 4294901120)) + (v128.const i32x4 0 0 0 0)) + +;; dec vs dec +(assert_return (invoke "lt_s" (v128.const i32x4 -1 -1 -1 -1) + (v128.const i32x4 -1 -1 -1 -1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt_s" (v128.const i32x4 0 0 0 0) + (v128.const i32x4 0 0 0 0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295) + (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295) + (v128.const i32x4 -1 -1 -1 -1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt_s" (v128.const i32x4 4294967295 4294967295 0 0) + (v128.const i32x4 4294967295 4294967295 0 0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt_s" (v128.const i32x4 0 0 4294967295 4294967295) + (v128.const i32x4 0 0 4294967295 4294967295)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt_s" (v128.const i32x4 -2147483647 4294967295 0 -1) + (v128.const i32x4 2147483649 -1 0 -1)) + (v128.const i32x4 0 0 0 0)) + +;; hex vs float +(assert_return (invoke "lt_s" (v128.const i32x4 0xc3000000 0xc2fe0000 0xbf800000 0x00000000) + (v128.const f32x4 -128.0 -127.0 -1.0 0.0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt_s" (v128.const i32x4 0x3f800000 0x42fe0000 0x43000000 0x437f0000) + (v128.const f32x4 1.0 127.0 128.0 255.0)) + (v128.const i32x4 0 0 0 0)) + +;; not equal +(assert_return (invoke "lt_s" (v128.const i32x4 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F) + (v128.const i32x4 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt_s" (v128.const i32x4 0x00000000 0x00000000 0xFFFFFFFF 0xFFFFFFFF) + (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0x00000000 0x00000000)) + (v128.const i32x4 0 0 -1 -1)) +(assert_return (invoke "lt_s" (v128.const i32x4 0x02030001 0x10110409 0x0B1A120A 0xABFF1BAA) + (v128.const i32x4 0xAA1BFFAB 0x0A121A0B 0x09041110 0x01000302)) + (v128.const i32x4 0 0 0 -1)) +(assert_return (invoke "lt_s" (v128.const i32x4 0x80018000 0x80038002 0x80058004 0x80078006) + (v128.const i32x4 2147975174 2147844100 2147713026 2147581952)) + (v128.const i32x4 -1 -1 0 0)) +(assert_return (invoke "lt_s" (v128.const i32x4 2147483648 2147483647 0 -1) + (v128.const i32x4 -2147483648 -2147483647 -1 0)) + (v128.const i32x4 0 0 0 -1)) + +;; i32x4.lt_s (i32x4) (i8x16) +(assert_return (invoke "lt_s" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF) + (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295) + (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt_s" (v128.const i32x4 0 0 0 0) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt_s" (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C) + (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt_s" (v128.const i32x4 2206368128 16776957 2130837760 4294901120) + (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt_s" (v128.const i32x4 -8323200 0 1 4294967295) + (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255)) + (v128.const i32x4 0 0 -1 0)) +(assert_return (invoke "lt_s" (v128.const i32x4 0x55555555 0x55555555 0x55555555 0x55555555) + (v128.const i8x16 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA)) + (v128.const i32x4 0 0 0 0)) + +;; i32x4.lt_s (i32x4) (i16x8) +(assert_return (invoke "lt_s" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF) + (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295) + (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt_s" (v128.const i32x4 0 0 0 0) + (v128.const i16x8 0 0 0 0 0 0 0 0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt_s" (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C) + (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt_s" (v128.const i32x4 2206368128 16776957 2130837760 4294901120) + (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt_s" (v128.const i32x4 -128 0 1 255) + (v128.const i16x8 -128 -128 0 0 1 1 255 255)) + (v128.const i32x4 0 0 -1 -1)) +(assert_return (invoke "lt_s" (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA) + (v128.const i16x8 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "lt_s" (v128.const i32x4 0_123_456_789 0_123_456_789 0_123_456_789 0_123_456_789) + (v128.const i32x4 123456789 123456789 123456789 123456789)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt_s" (v128.const i32x4 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef) + (v128.const i32x4 -0x6f543210 -0x6f543210 -0x6f543210 -0x6f543210)) + (v128.const i32x4 -1 -1 -1 -1)) + +;; lt_u + +;; i32x4.lt_u (i32x4) (i32x4) + +;; hex vs hex +(assert_return (invoke "lt_u" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF) + (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt_u" (v128.const i32x4 0x00000000 0x00000000 0x00000000 0x00000000) + (v128.const i32x4 0x00000000 0x00000000 0x00000000 0x00000000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt_u" (v128.const i32x4 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0) + (v128.const i32x4 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt_u" (v128.const i32x4 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F) + (v128.const i32x4 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt_u" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0x00000000 0x00000000) + (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0x00000000 0x00000000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt_u" (v128.const i32x4 0x00000000 0x00000000 0xFFFFFFFF 0xFFFFFFFF) + (v128.const i32x4 0x00000000 0x00000000 0xFFFFFFFF 0xFFFFFFFF)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt_u" (v128.const i32x4 0x03020100 0x11100904 0x1A0B0A12 0xFFABAA1B) + (v128.const i32x4 0x03020100 0x11100904 0x1A0B0A12 0xFFABAA1B)) + (v128.const i32x4 0 0 0 0)) + +;; hex vs dec +(assert_return (invoke "lt_u" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF) + (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt_u" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF) + (v128.const i32x4 -1 -1 -1 -1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt_u" (v128.const i32x4 0x80808080 0x80808080 0x80808080 0x80808080) + (v128.const i32x4 2155905152 2155905152 2155905152 2155905152)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt_u" (v128.const i32x4 0x80808080 0x80808080 0x80808080 0x80808080) + (v128.const i32x4 -2139062144 -2139062144 -2139062144 -2139062144)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt_u" (v128.const i32x4 0x83828180 0x00FFFEFD 0x7F020100 0xFFFEFD80) + (v128.const i32x4 2206368128 16776957 2130837760 4294901120)) + (v128.const i32x4 0 0 0 0)) + +;; dec vs dec +(assert_return (invoke "lt_u" (v128.const i32x4 -1 -1 -1 -1) + (v128.const i32x4 -1 -1 -1 -1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt_u" (v128.const i32x4 0 0 0 0) + (v128.const i32x4 0 0 0 0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295) + (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295) + (v128.const i32x4 -1 -1 -1 -1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt_u" (v128.const i32x4 4294967295 4294967295 0 0) + (v128.const i32x4 4294967295 4294967295 0 0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt_u" (v128.const i32x4 0 0 4294967295 4294967295) + (v128.const i32x4 0 0 4294967295 4294967295)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt_u" (v128.const i32x4 -2147483647 4294967295 0 -1) + (v128.const i32x4 2147483649 -1 0 -1)) + (v128.const i32x4 0 0 0 0)) + +;; hex vs float +(assert_return (invoke "lt_u" (v128.const i32x4 0xc3000000 0xc2fe0000 0xbf800000 0x00000000) + (v128.const f32x4 -128.0 -127.0 -1.0 0.0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt_u" (v128.const i32x4 0x3f800000 0x42fe0000 0x43000000 0x437f0000) + (v128.const f32x4 1.0 127.0 128.0 255.0)) + (v128.const i32x4 0 0 0 0)) + +;; not equal +(assert_return (invoke "lt_u" (v128.const i32x4 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F) + (v128.const i32x4 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "lt_u" (v128.const i32x4 0x00000000 0x00000000 0xFFFFFFFF 0xFFFFFFFF) + (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0x00000000 0x00000000)) + (v128.const i32x4 -1 -1 0 0)) +(assert_return (invoke "lt_u" (v128.const i32x4 0x02030001 0x10110409 0x0B1A120A 0xABFF1BAA) + (v128.const i32x4 0xAA1BFFAB 0x0A121A0B 0x09041110 0x01000302)) + (v128.const i32x4 -1 0 0 0)) +(assert_return (invoke "lt_u" (v128.const i32x4 0x80018000 0x80038002 0x80058004 0x80078006) + (v128.const i32x4 2147975174 2147844100 2147713026 2147581952)) + (v128.const i32x4 -1 -1 0 0)) +(assert_return (invoke "lt_u" (v128.const i32x4 2147483648 2147483647 0 -1) + (v128.const i32x4 -2147483648 -2147483647 -1 0)) + (v128.const i32x4 0 -1 -1 0)) + +;; i32x4.lt_u (i32x4) (i8x16) +(assert_return (invoke "lt_u" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF) + (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295) + (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt_u" (v128.const i32x4 0 0 0 0) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt_u" (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C) + (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt_u" (v128.const i32x4 2206368128 16776957 2130837760 4294901120) + (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt_u" (v128.const i32x4 -8323200 0 1 4294967295) + (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255)) + (v128.const i32x4 0 0 -1 0)) +(assert_return (invoke "lt_u" (v128.const i32x4 0x55555555 0x55555555 0x55555555 0x55555555) + (v128.const i8x16 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA)) + (v128.const i32x4 -1 -1 -1 -1)) + +;; i32x4.lt_u (i32x4) (i16x8) +(assert_return (invoke "lt_u" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF) + (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295) + (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt_u" (v128.const i32x4 0 0 0 0) + (v128.const i16x8 0 0 0 0 0 0 0 0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt_u" (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C) + (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt_u" (v128.const i32x4 2206368128 16776957 2130837760 4294901120) + (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt_u" (v128.const i32x4 -128 0 1 255) + (v128.const i16x8 -128 -128 0 0 1 1 255 255)) + (v128.const i32x4 0 0 -1 -1)) +(assert_return (invoke "lt_u" (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA) + (v128.const i16x8 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt_u" (v128.const i32x4 0_123_456_789 0_123_456_789 0_123_456_789 0_123_456_789) + (v128.const i32x4 123456789 123456789 123456789 123456789)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "lt_u" (v128.const i32x4 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef) + (v128.const i32x4 -0x6f543210 -0x6f543210 -0x6f543210 -0x6f543210)) + (v128.const i32x4 -1 -1 -1 -1)) + +;; le_s + +;; i32x4.le_s (i32x4) (i32x4) + +;; hex vs hex +(assert_return (invoke "le_s" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF) + (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le_s" (v128.const i32x4 0x00000000 0x00000000 0x00000000 0x00000000) + (v128.const i32x4 0x00000000 0x00000000 0x00000000 0x00000000)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le_s" (v128.const i32x4 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0) + (v128.const i32x4 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le_s" (v128.const i32x4 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F) + (v128.const i32x4 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le_s" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0x00000000 0x00000000) + (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0x00000000 0x00000000)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le_s" (v128.const i32x4 0x00000000 0x00000000 0xFFFFFFFF 0xFFFFFFFF) + (v128.const i32x4 0x00000000 0x00000000 0xFFFFFFFF 0xFFFFFFFF)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le_s" (v128.const i32x4 0x03020100 0x11100904 0x1A0B0A12 0xFFABAA1B) + (v128.const i32x4 0x03020100 0x11100904 0x1A0B0A12 0xFFABAA1B)) + (v128.const i32x4 -1 -1 -1 -1)) + +;; hex vs dec +(assert_return (invoke "le_s" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF) + (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le_s" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF) + (v128.const i32x4 -1 -1 -1 -1)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le_s" (v128.const i32x4 0x80808080 0x80808080 0x80808080 0x80808080) + (v128.const i32x4 2155905152 2155905152 2155905152 2155905152)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le_s" (v128.const i32x4 0x80808080 0x80808080 0x80808080 0x80808080) + (v128.const i32x4 -2139062144 -2139062144 -2139062144 -2139062144)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le_s" (v128.const i32x4 0x83828180 0x00FFFEFD 0x7F020100 0xFFFEFD80) + (v128.const i32x4 2206368128 16776957 2130837760 4294901120)) + (v128.const i32x4 -1 -1 -1 -1)) + +;; dec vs dec +(assert_return (invoke "le_s" (v128.const i32x4 -1 -1 -1 -1) + (v128.const i32x4 -1 -1 -1 -1)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le_s" (v128.const i32x4 0 0 0 0) + (v128.const i32x4 0 0 0 0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295) + (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295) + (v128.const i32x4 -1 -1 -1 -1)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le_s" (v128.const i32x4 4294967295 4294967295 0 0) + (v128.const i32x4 4294967295 4294967295 0 0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le_s" (v128.const i32x4 0 0 4294967295 4294967295) + (v128.const i32x4 0 0 4294967295 4294967295)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le_s" (v128.const i32x4 -2147483647 4294967295 0 -1) + (v128.const i32x4 2147483649 -1 0 -1)) + (v128.const i32x4 -1 -1 -1 -1)) + +;; hex vs float +(assert_return (invoke "le_s" (v128.const i32x4 0xc3000000 0xc2fe0000 0xbf800000 0x00000000) + (v128.const f32x4 -128.0 -127.0 -1.0 0.0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le_s" (v128.const i32x4 0x3f800000 0x42fe0000 0x43000000 0x437f0000) + (v128.const f32x4 1.0 127.0 128.0 255.0)) + (v128.const i32x4 -1 -1 -1 -1)) + +;; not equal +(assert_return (invoke "le_s" (v128.const i32x4 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F) + (v128.const i32x4 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le_s" (v128.const i32x4 0x00000000 0x00000000 0xFFFFFFFF 0xFFFFFFFF) + (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0x00000000 0x00000000)) + (v128.const i32x4 0 0 -1 -1)) +(assert_return (invoke "le_s" (v128.const i32x4 0x02030001 0x10110409 0x0B1A120A 0xABFF1BAA) + (v128.const i32x4 0xAA1BFFAB 0x0A121A0B 0x09041110 0x01000302)) + (v128.const i32x4 0 0 0 -1)) +(assert_return (invoke "le_s" (v128.const i32x4 0x80018000 0x80038002 0x80058004 0x80078006) + (v128.const i32x4 2147975174 2147844100 2147713026 2147581952)) + (v128.const i32x4 -1 -1 0 0)) +(assert_return (invoke "le_s" (v128.const i32x4 2147483648 2147483647 0 -1) + (v128.const i32x4 -2147483648 -2147483647 -1 0)) + (v128.const i32x4 -1 0 0 -1)) + +;; i32x4.le_s (i32x4)(i8x16) +(assert_return (invoke "le_s" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF) + (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295) + (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le_s" (v128.const i32x4 0 0 0 0) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le_s" (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C) + (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le_s" (v128.const i32x4 2206368128 16776957 2130837760 4294901120) + (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le_s" (v128.const i32x4 -8323200 0 1 4294967295) + (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255)) + (v128.const i32x4 0 -1 -1 -1)) +(assert_return (invoke "le_s" (v128.const i32x4 0x55555555 0x55555555 0x55555555 0x55555555) + (v128.const i8x16 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA)) + (v128.const i32x4 0 0 0 0)) + +;; i32x4.le_s (i32x4) (i16x8) +(assert_return (invoke "le_s" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF) + (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295) + (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le_s" (v128.const i32x4 0 0 0 0) + (v128.const i16x8 0 0 0 0 0 0 0 0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le_s" (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C) + (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le_s" (v128.const i32x4 2206368128 16776957 2130837760 4294901120) + (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le_s" (v128.const i32x4 -128 0 1 255) + (v128.const i16x8 -128 -128 0 0 1 1 255 255)) + (v128.const i32x4 0 -1 -1 -1)) +(assert_return (invoke "le_s" (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA) + (v128.const i16x8 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le_s" (v128.const i32x4 0_123_456_789 0_123_456_789 0_123_456_789 0_123_456_789) + (v128.const i32x4 123456789 123456789 123456789 123456789)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le_s" (v128.const i32x4 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678) + (v128.const i32x4 0x12345678 0x12345678 0x12345678 0x12345678)) + (v128.const i32x4 -1 -1 -1 -1)) + +;; le_u + +;; i32x4.le_u (i32x4) (i32x4) + +;; hex vs hex +(assert_return (invoke "le_u" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF) + (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le_u" (v128.const i32x4 0x00000000 0x00000000 0x00000000 0x00000000) + (v128.const i32x4 0x00000000 0x00000000 0x00000000 0x00000000)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le_u" (v128.const i32x4 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0) + (v128.const i32x4 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le_u" (v128.const i32x4 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F) + (v128.const i32x4 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le_u" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0x00000000 0x00000000) + (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0x00000000 0x00000000)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le_u" (v128.const i32x4 0x00000000 0x00000000 0xFFFFFFFF 0xFFFFFFFF) + (v128.const i32x4 0x00000000 0x00000000 0xFFFFFFFF 0xFFFFFFFF)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le_u" (v128.const i32x4 0x03020100 0x11100904 0x1A0B0A12 0xFFABAA1B) + (v128.const i32x4 0x03020100 0x11100904 0x1A0B0A12 0xFFABAA1B)) + (v128.const i32x4 -1 -1 -1 -1)) + +;; hex vs dec +(assert_return (invoke "le_u" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF) + (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le_u" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF) + (v128.const i32x4 -1 -1 -1 -1)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le_u" (v128.const i32x4 0x80808080 0x80808080 0x80808080 0x80808080) + (v128.const i32x4 2155905152 2155905152 2155905152 2155905152)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le_u" (v128.const i32x4 0x80808080 0x80808080 0x80808080 0x80808080) + (v128.const i32x4 -2139062144 -2139062144 -2139062144 -2139062144)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le_u" (v128.const i32x4 0x83828180 0x00FFFEFD 0x7F020100 0xFFFEFD80) + (v128.const i32x4 2206368128 16776957 2130837760 4294901120)) + (v128.const i32x4 -1 -1 -1 -1)) + +;; dec vs dec +(assert_return (invoke "le_u" (v128.const i32x4 -1 -1 -1 -1) + (v128.const i32x4 -1 -1 -1 -1)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le_u" (v128.const i32x4 0 0 0 0) + (v128.const i32x4 0 0 0 0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295) + (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295) + (v128.const i32x4 -1 -1 -1 -1)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le_u" (v128.const i32x4 4294967295 4294967295 0 0) + (v128.const i32x4 4294967295 4294967295 0 0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le_u" (v128.const i32x4 0 0 4294967295 4294967295) + (v128.const i32x4 0 0 4294967295 4294967295)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le_u" (v128.const i32x4 -2147483647 4294967295 0 -1) + (v128.const i32x4 2147483649 -1 0 -1)) + (v128.const i32x4 -1 -1 -1 -1)) + +;; hex vs float +(assert_return (invoke "le_u" (v128.const i32x4 0xc3000000 0xc2fe0000 0xbf800000 0x00000000) + (v128.const f32x4 -128.0 -127.0 -1.0 0.0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le_u" (v128.const i32x4 0x3f800000 0x42fe0000 0x43000000 0x437f0000) + (v128.const f32x4 1.0 127.0 128.0 255.0)) + (v128.const i32x4 -1 -1 -1 -1)) + +;; not equal +(assert_return (invoke "le_u" (v128.const i32x4 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F) + (v128.const i32x4 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le_u" (v128.const i32x4 0x00000000 0x00000000 0xFFFFFFFF 0xFFFFFFFF) + (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0x00000000 0x00000000)) + (v128.const i32x4 -1 -1 0 0)) +(assert_return (invoke "le_u" (v128.const i32x4 0x02030001 0x10110409 0x0B1A120A 0xABFF1BAA) + (v128.const i32x4 0xAA1BFFAB 0x0A121A0B 0x09041110 0x01000302)) + (v128.const i32x4 -1 0 0 0)) +(assert_return (invoke "le_u" (v128.const i32x4 0x80018000 0x80038002 0x80058004 0x80078006) + (v128.const i32x4 2147975174 2147844100 2147713026 2147581952)) + (v128.const i32x4 -1 -1 0 0)) +(assert_return (invoke "le_u" (v128.const i32x4 2147483648 2147483647 0 -1) + (v128.const i32x4 -2147483648 -2147483647 -1 0)) + (v128.const i32x4 -1 -1 -1 0)) + +;; i32x4.le_u (i32x4) (i8x16) +(assert_return (invoke "le_u" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF) + (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295) + (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le_u" (v128.const i32x4 0 0 0 0) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le_u" (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C) + (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le_u" (v128.const i32x4 2206368128 16776957 2130837760 4294901120) + (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le_u" (v128.const i32x4 -8323200 0 1 4294967295) + (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255)) + (v128.const i32x4 0 -1 -1 -1)) +(assert_return (invoke "le_u" (v128.const i32x4 0x55555555 0x55555555 0x55555555 0x55555555) + (v128.const i8x16 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA)) + (v128.const i32x4 -1 -1 -1 -1)) + +;; i32x4.le_u (i32x4) (i16x8) +(assert_return (invoke "le_u" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF) + (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295) + (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le_u" (v128.const i32x4 0 0 0 0) + (v128.const i16x8 0 0 0 0 0 0 0 0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le_u" (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C) + (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le_u" (v128.const i32x4 2206368128 16776957 2130837760 4294901120) + (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le_u" (v128.const i32x4 -128 0 1 255) + (v128.const i16x8 -128 -128 0 0 1 1 255 255)) + (v128.const i32x4 0 -1 -1 -1)) +(assert_return (invoke "le_u" (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA) + (v128.const i16x8 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "le_u" (v128.const i32x4 0_123_456_789 0_123_456_789 0_123_456_789 0_123_456_789) + (v128.const i32x4 123456789 123456789 123456789 123456789)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "le_u" (v128.const i32x4 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef) + (v128.const i32x4 0x90ABcdef 0x90ABcdef 0x90ABcdef 0x90ABcdef)) + (v128.const i32x4 -1 -1 -1 -1)) + +;; gt_s + +;; i32x4.gt_s (i32x4) (i32x4) + +;; hex vs hex +(assert_return (invoke "gt_s" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF) + (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt_s" (v128.const i32x4 0x00000000 0x00000000 0x00000000 0x00000000) + (v128.const i32x4 0x00000000 0x00000000 0x00000000 0x00000000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt_s" (v128.const i32x4 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0) + (v128.const i32x4 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt_s" (v128.const i32x4 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F) + (v128.const i32x4 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt_s" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0x00000000 0x00000000) + (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0x00000000 0x00000000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt_s" (v128.const i32x4 0x00000000 0x00000000 0xFFFFFFFF 0xFFFFFFFF) + (v128.const i32x4 0x00000000 0x00000000 0xFFFFFFFF 0xFFFFFFFF)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt_s" (v128.const i32x4 0x03020100 0x11100904 0x1A0B0A12 0xFFABAA1B) + (v128.const i32x4 0x03020100 0x11100904 0x1A0B0A12 0xFFABAA1B)) + (v128.const i32x4 0 0 0 0)) + +;; hex vs dec +(assert_return (invoke "gt_s" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF) + (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt_s" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF) + (v128.const i32x4 -1 -1 -1 -1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt_s" (v128.const i32x4 0x80808080 0x80808080 0x80808080 0x80808080) + (v128.const i32x4 2155905152 2155905152 2155905152 2155905152)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt_s" (v128.const i32x4 0x80808080 0x80808080 0x80808080 0x80808080) + (v128.const i32x4 -2139062144 -2139062144 -2139062144 -2139062144)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt_s" (v128.const i32x4 0x83828180 0x00FFFEFD 0x7F020100 0xFFFEFD80) + (v128.const i32x4 2206368128 16776957 2130837760 4294901120)) + (v128.const i32x4 0 0 0 0)) + +;; dec vs dec +(assert_return (invoke "gt_s" (v128.const i32x4 -1 -1 -1 -1) + (v128.const i32x4 -1 -1 -1 -1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt_s" (v128.const i32x4 0 0 0 0) + (v128.const i32x4 0 0 0 0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295) + (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295) + (v128.const i32x4 -1 -1 -1 -1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt_s" (v128.const i32x4 4294967295 4294967295 0 0) + (v128.const i32x4 4294967295 4294967295 0 0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt_s" (v128.const i32x4 0 0 4294967295 4294967295) + (v128.const i32x4 0 0 4294967295 4294967295)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt_s" (v128.const i32x4 -2147483647 4294967295 0 -1) + (v128.const i32x4 2147483649 -1 0 -1)) + (v128.const i32x4 0 0 0 0)) + +;; hex vs float +(assert_return (invoke "gt_s" (v128.const i32x4 0xc3000000 0xc2fe0000 0xbf800000 0x00000000) + (v128.const f32x4 -128.0 -127.0 -1.0 0.0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt_s" (v128.const i32x4 0x3f800000 0x42fe0000 0x43000000 0x437f0000) + (v128.const f32x4 1.0 127.0 128.0 255.0)) + (v128.const i32x4 0 0 0 0)) + +;; not equal +(assert_return (invoke "gt_s" (v128.const i32x4 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F) + (v128.const i32x4 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "gt_s" (v128.const i32x4 0x00000000 0x00000000 0xFFFFFFFF 0xFFFFFFFF) + (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0x00000000 0x00000000)) + (v128.const i32x4 -1 -1 0 0)) +(assert_return (invoke "gt_s" (v128.const i32x4 0x02030001 0x10110409 0x0B1A120A 0xABFF1BAA) + (v128.const i32x4 0xAA1BFFAB 0x0A121A0B 0x09041110 0x01000302)) + (v128.const i32x4 -1 -1 -1 0)) +(assert_return (invoke "gt_s" (v128.const i32x4 0x80018000 0x80038002 0x80058004 0x80078006) + (v128.const i32x4 2147975174 2147844100 2147713026 2147581952)) + (v128.const i32x4 0 0 -1 -1)) +(assert_return (invoke "gt_s" (v128.const i32x4 2147483648 2147483647 0 -1) + (v128.const i32x4 -2147483648 -2147483647 -1 0)) + (v128.const i32x4 0 -1 -1 0)) + +;; i32x4.gt_s (i32x4) (i8x16) +(assert_return (invoke "gt_s" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF) + (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295) + (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt_s" (v128.const i32x4 0 0 0 0) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt_s" (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C) + (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt_s" (v128.const i32x4 2206368128 16776957 2130837760 4294901120) + (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt_s" (v128.const i32x4 -8323200 0 1 4294967295) + (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255)) + (v128.const i32x4 -1 0 0 0)) +(assert_return (invoke "gt_s" (v128.const i32x4 0x55555555 0x55555555 0x55555555 0x55555555) + (v128.const i8x16 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA)) + (v128.const i32x4 -1 -1 -1 -1)) + +;; i32x4.gt_s (i32x4) (i16x8) +(assert_return (invoke "gt_s" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF) + (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295) + (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt_s" (v128.const i32x4 0 0 0 0) + (v128.const i16x8 0 0 0 0 0 0 0 0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt_s" (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C) + (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt_s" (v128.const i32x4 2206368128 16776957 2130837760 4294901120) + (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt_s" (v128.const i32x4 65535 0 1 32768) + (v128.const i16x8 65535 65535 0 0 1 1 32768 32768)) + (v128.const i32x4 -1 0 0 -1)) +(assert_return (invoke "gt_s" (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA) + (v128.const i16x8 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt_s" (v128.const i32x4 0_123_456_789 0_123_456_789 0_123_456_789 0_123_456_789) + (v128.const i32x4 123456789 123456789 123456789 123456789)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt_s" (v128.const i32x4 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef) + (v128.const i32x4 -0x6f543211 -0x6f543211 -0x6f543211 -0x6f543211)) + (v128.const i32x4 0 0 0 0)) + +;; gt_u + +;; i32x4.gt_u (i32x4) (i32x4) + +;; hex vs hex +(assert_return (invoke "gt_u" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF) + (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt_u" (v128.const i32x4 0x00000000 0x00000000 0x00000000 0x00000000) + (v128.const i32x4 0x00000000 0x00000000 0x00000000 0x00000000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt_u" (v128.const i32x4 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0) + (v128.const i32x4 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt_u" (v128.const i32x4 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F) + (v128.const i32x4 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt_u" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0x00000000 0x00000000) + (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0x00000000 0x00000000)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt_u" (v128.const i32x4 0x00000000 0x00000000 0xFFFFFFFF 0xFFFFFFFF) + (v128.const i32x4 0x00000000 0x00000000 0xFFFFFFFF 0xFFFFFFFF)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt_u" (v128.const i32x4 0x03020100 0x11100904 0x1A0B0A12 0xFFABAA1B) + (v128.const i32x4 0x03020100 0x11100904 0x1A0B0A12 0xFFABAA1B)) + (v128.const i32x4 0 0 0 0)) + +;; hex vs dec +(assert_return (invoke "gt_u" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF) + (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt_u" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF) + (v128.const i32x4 -1 -1 -1 -1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt_u" (v128.const i32x4 0x80808080 0x80808080 0x80808080 0x80808080) + (v128.const i32x4 2155905152 2155905152 2155905152 2155905152)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt_u" (v128.const i32x4 0x80808080 0x80808080 0x80808080 0x80808080) + (v128.const i32x4 -2139062144 -2139062144 -2139062144 -2139062144)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt_u" (v128.const i32x4 0x83828180 0x00FFFEFD 0x7F020100 0xFFFEFD80) + (v128.const i32x4 2206368128 16776957 2130837760 4294901120)) + (v128.const i32x4 0 0 0 0)) + +;; dec vs dec +(assert_return (invoke "gt_u" (v128.const i32x4 -1 -1 -1 -1) + (v128.const i32x4 -1 -1 -1 -1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt_u" (v128.const i32x4 0 0 0 0) + (v128.const i32x4 0 0 0 0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295) + (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295) + (v128.const i32x4 -1 -1 -1 -1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt_u" (v128.const i32x4 4294967295 4294967295 0 0) + (v128.const i32x4 4294967295 4294967295 0 0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt_u" (v128.const i32x4 0 0 4294967295 4294967295) + (v128.const i32x4 0 0 4294967295 4294967295)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt_u" (v128.const i32x4 -2147483647 4294967295 0 -1) + (v128.const i32x4 2147483649 -1 0 -1)) + (v128.const i32x4 0 0 0 0)) + +;; hex vs float +(assert_return (invoke "gt_u" (v128.const i32x4 0xc3000000 0xc2fe0000 0xbf800000 0x00000000) + (v128.const f32x4 -128.0 -127.0 -1.0 0.0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt_u" (v128.const i32x4 0x3f800000 0x42fe0000 0x43000000 0x437f0000) + (v128.const f32x4 1.0 127.0 128.0 255.0)) + (v128.const i32x4 0 0 0 0)) + +;; not equal +(assert_return (invoke "gt_u" (v128.const i32x4 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F) + (v128.const i32x4 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt_u" (v128.const i32x4 0x00000000 0x00000000 0xFFFFFFFF 0xFFFFFFFF) + (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0x00000000 0x00000000)) + (v128.const i32x4 0 0 -1 -1)) +(assert_return (invoke "gt_u" (v128.const i32x4 0x02030001 0x10110409 0x0B1A120A 0xABFF1BAA) + (v128.const i32x4 0xAA1BFFAB 0x0A121A0B 0x09041110 0x01000302)) + (v128.const i32x4 0 -1 -1 -1)) +(assert_return (invoke "gt_u" (v128.const i32x4 0x80018000 0x80038002 0x80058004 0x80078006) + (v128.const i32x4 2147975174 2147844100 2147713026 2147581952)) + (v128.const i32x4 0 0 -1 -1)) +(assert_return (invoke "gt_u" (v128.const i32x4 2147483648 2147483647 0 -1) + (v128.const i32x4 -2147483648 -2147483647 -1 0)) + (v128.const i32x4 0 0 0 -1)) + +;; i32x4.gt_u (i32x4) (i8x16) +(assert_return (invoke "gt_u" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF) + (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295) + (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt_u" (v128.const i32x4 0 0 0 0) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt_u" (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C) + (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt_u" (v128.const i32x4 2206368128 16776957 2130837760 4294901120) + (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt_u" (v128.const i32x4 -8323200 0 1 4294967295) + (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255)) + (v128.const i32x4 -1 0 0 0)) +(assert_return (invoke "gt_u" (v128.const i32x4 0x55555555 0x55555555 0x55555555 0x55555555) + (v128.const i8x16 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA)) + (v128.const i32x4 0 0 0 0)) + +;; i32x4.gt_u (i32x4) (i16x8) +(assert_return (invoke "gt_u" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF) + (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295) + (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt_u" (v128.const i32x4 0 0 0 0) + (v128.const i16x8 0 0 0 0 0 0 0 0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt_u" (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C) + (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt_u" (v128.const i32x4 2206368128 16776957 2130837760 4294901120) + (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt_u" (v128.const i32x4 -128 0 1 255) + (v128.const i16x8 -128 -128 0 0 1 1 255 255)) + (v128.const i32x4 -1 0 0 0)) +(assert_return (invoke "gt_u" (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA) + (v128.const i16x8 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "gt_u" (v128.const i32x4 0_123_456_789 0_123_456_789 0_123_456_789 0_123_456_789) + (v128.const i32x4 123456789 123456789 123456789 123456789)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "gt_u" (v128.const i32x4 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678) + (v128.const i32x4 0x12345678 0x12345678 0x12345678 0x12345678)) + (v128.const i32x4 0 0 0 0)) + +;; ge_s + +;; i32x4.ge_s (i32x4) (i32x4) + +;; hex vs hex +(assert_return (invoke "ge_s" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF) + (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge_s" (v128.const i32x4 0x00000000 0x00000000 0x00000000 0x00000000) + (v128.const i32x4 0x00000000 0x00000000 0x00000000 0x00000000)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge_s" (v128.const i32x4 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0) + (v128.const i32x4 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge_s" (v128.const i32x4 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F) + (v128.const i32x4 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge_s" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0x00000000 0x00000000) + (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0x00000000 0x00000000)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge_s" (v128.const i32x4 0x00000000 0x00000000 0xFFFFFFFF 0xFFFFFFFF) + (v128.const i32x4 0x00000000 0x00000000 0xFFFFFFFF 0xFFFFFFFF)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge_s" (v128.const i32x4 0x03020100 0x11100904 0x1A0B0A12 0xFFABAA1B) + (v128.const i32x4 0x03020100 0x11100904 0x1A0B0A12 0xFFABAA1B)) + (v128.const i32x4 -1 -1 -1 -1)) + +;; hex vs dec +(assert_return (invoke "ge_s" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF) + (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge_s" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF) + (v128.const i32x4 -1 -1 -1 -1)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge_s" (v128.const i32x4 0x80808080 0x80808080 0x80808080 0x80808080) + (v128.const i32x4 2155905152 2155905152 2155905152 2155905152)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge_s" (v128.const i32x4 0x80808080 0x80808080 0x80808080 0x80808080) + (v128.const i32x4 -2139062144 -2139062144 -2139062144 -2139062144)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge_s" (v128.const i32x4 0x83828180 0x00FFFEFD 0x7F020100 0xFFFEFD80) + (v128.const i32x4 2206368128 16776957 2130837760 4294901120)) + (v128.const i32x4 -1 -1 -1 -1)) + +;; dec vs dec +(assert_return (invoke "ge_s" (v128.const i32x4 -1 -1 -1 -1) + (v128.const i32x4 -1 -1 -1 -1)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge_s" (v128.const i32x4 0 0 0 0) + (v128.const i32x4 0 0 0 0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295) + (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295) + (v128.const i32x4 -1 -1 -1 -1)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge_s" (v128.const i32x4 4294967295 4294967295 0 0) + (v128.const i32x4 4294967295 4294967295 0 0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge_s" (v128.const i32x4 0 0 4294967295 4294967295) + (v128.const i32x4 0 0 4294967295 4294967295)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge_s" (v128.const i32x4 -2147483647 4294967295 0 -1) + (v128.const i32x4 2147483649 -1 0 -1)) + (v128.const i32x4 -1 -1 -1 -1)) + +;; hex vs float +(assert_return (invoke "ge_s" (v128.const i32x4 0xc3000000 0xc2fe0000 0xbf800000 0x00000000) + (v128.const f32x4 -128.0 -127.0 -1.0 0.0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge_s" (v128.const i32x4 0x3f800000 0x42fe0000 0x43000000 0x437f0000) + (v128.const f32x4 1.0 127.0 128.0 255.0)) + (v128.const i32x4 -1 -1 -1 -1)) + +;; not equal +(assert_return (invoke "ge_s" (v128.const i32x4 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F) + (v128.const i32x4 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge_s" (v128.const i32x4 0x00000000 0x00000000 0xFFFFFFFF 0xFFFFFFFF) + (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0x00000000 0x00000000)) + (v128.const i32x4 -1 -1 0 0)) +(assert_return (invoke "ge_s" (v128.const i32x4 0x02030001 0x10110409 0x0B1A120A 0xABFF1BAA) + (v128.const i32x4 0xAA1BFFAB 0x0A121A0B 0x09041110 0x01000302)) + (v128.const i32x4 -1 -1 -1 0)) +(assert_return (invoke "ge_s" (v128.const i32x4 0x80018000 0x80038002 0x80058004 0x80078006) + (v128.const i32x4 2147975174 2147844100 2147713026 2147581952)) + (v128.const i32x4 0 0 -1 -1)) +(assert_return (invoke "ge_s" (v128.const i32x4 2147483648 2147483647 0 -1) + (v128.const i32x4 -2147483648 -2147483647 -1 0)) + (v128.const i32x4 -1 -1 -1 0)) + +;; i32x4.ge_s (i32x4) (i8x16) +(assert_return (invoke "ge_s" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF) + (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295) + (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge_s" (v128.const i32x4 0 0 0 0) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge_s" (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C) + (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge_s" (v128.const i32x4 2206368128 16776957 2130837760 4294901120) + (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge_s" (v128.const i32x4 -8323200 0 1 4294967295) + (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255)) + (v128.const i32x4 -1 -1 0 -1)) +(assert_return (invoke "ge_s" (v128.const i32x4 0x55555555 0x55555555 0x55555555 0x55555555) + (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55)) + (v128.const i32x4 -1 -1 -1 -1)) + +;; i32x4.ge_s (i32x4) (i16x8) +(assert_return (invoke "ge_s" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF) + (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295) + (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge_s" (v128.const i32x4 0 0 0 0) + (v128.const i16x8 0 0 0 0 0 0 0 0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge_s" (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C) + (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge_s" (v128.const i32x4 2206368128 16776957 2130837760 4294901120) + (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge_s" (v128.const i32x4 65535 0 1 32768) + (v128.const i16x8 65535 65535 0 0 1 1 32768 32768)) + (v128.const i32x4 -1 -1 0 -1)) +(assert_return (invoke "ge_s" (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA) + (v128.const i16x8 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge_s" (v128.const i32x4 0_123_456_789 0_123_456_789 0_123_456_789 0_123_456_789) + (v128.const i32x4 123456789 123456789 123456789 123456789)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge_s" (v128.const i32x4 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678) + (v128.const i32x4 0x12345678 0x12345678 0x12345678 0x12345678)) + (v128.const i32x4 -1 -1 -1 -1)) + +;; ge_u + +;; i32x4.ge_u (i32x4) (i32x4) + +;; hex vs hex +(assert_return (invoke "ge_u" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF) + (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge_u" (v128.const i32x4 0x00000000 0x00000000 0x00000000 0x00000000) + (v128.const i32x4 0x00000000 0x00000000 0x00000000 0x00000000)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge_u" (v128.const i32x4 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0) + (v128.const i32x4 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge_u" (v128.const i32x4 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F) + (v128.const i32x4 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge_u" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0x00000000 0x00000000) + (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0x00000000 0x00000000)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge_u" (v128.const i32x4 0x00000000 0x00000000 0xFFFFFFFF 0xFFFFFFFF) + (v128.const i32x4 0x00000000 0x00000000 0xFFFFFFFF 0xFFFFFFFF)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge_u" (v128.const i32x4 0x03020100 0x11100904 0x1A0B0A12 0xFFABAA1B) + (v128.const i32x4 0x03020100 0x11100904 0x1A0B0A12 0xFFABAA1B)) + (v128.const i32x4 -1 -1 -1 -1)) + +;; hex vs dec +(assert_return (invoke "ge_u" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF) + (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge_u" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF) + (v128.const i32x4 -1 -1 -1 -1)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge_u" (v128.const i32x4 0x80808080 0x80808080 0x80808080 0x80808080) + (v128.const i32x4 2155905152 2155905152 2155905152 2155905152)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge_u" (v128.const i32x4 0x80808080 0x80808080 0x80808080 0x80808080) + (v128.const i32x4 -2139062144 -2139062144 -2139062144 -2139062144)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge_u" (v128.const i32x4 0x83828180 0x00FFFEFD 0x7F020100 0xFFFEFD80) + (v128.const i32x4 2206368128 16776957 2130837760 4294901120)) + (v128.const i32x4 -1 -1 -1 -1)) + +;; dec vs dec +(assert_return (invoke "ge_u" (v128.const i32x4 -1 -1 -1 -1) + (v128.const i32x4 -1 -1 -1 -1)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge_u" (v128.const i32x4 0 0 0 0) + (v128.const i32x4 0 0 0 0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295) + (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295) + (v128.const i32x4 -1 -1 -1 -1)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge_u" (v128.const i32x4 4294967295 4294967295 0 0) + (v128.const i32x4 4294967295 4294967295 0 0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge_u" (v128.const i32x4 0 0 4294967295 4294967295) + (v128.const i32x4 0 0 4294967295 4294967295)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge_u" (v128.const i32x4 -2147483647 4294967295 0 -1) + (v128.const i32x4 2147483649 -1 0 -1)) + (v128.const i32x4 -1 -1 -1 -1)) + +;; hex vs float +(assert_return (invoke "ge_u" (v128.const i32x4 0xc3000000 0xc2fe0000 0xbf800000 0x00000000) + (v128.const f32x4 -128.0 -127.0 -1.0 0.0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge_u" (v128.const i32x4 0x3f800000 0x42fe0000 0x43000000 0x437f0000) + (v128.const f32x4 1.0 127.0 128.0 255.0)) + (v128.const i32x4 -1 -1 -1 -1)) + +;; not equal +(assert_return (invoke "ge_u" (v128.const i32x4 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F) + (v128.const i32x4 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "ge_u" (v128.const i32x4 0x00000000 0x00000000 0xFFFFFFFF 0xFFFFFFFF) + (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0x00000000 0x00000000)) + (v128.const i32x4 0 0 -1 -1)) +(assert_return (invoke "ge_u" (v128.const i32x4 0x02030001 0x10110409 0x0B1A120A 0xABFF1BAA) + (v128.const i32x4 0xAA1BFFAB 0x0A121A0B 0x09041110 0x01000302)) + (v128.const i32x4 0 -1 -1 -1)) +(assert_return (invoke "ge_u" (v128.const i32x4 0x80018000 0x80038002 0x80058004 0x80078006) + (v128.const i32x4 2147975174 2147844100 2147713026 2147581952)) + (v128.const i32x4 0 0 -1 -1)) +(assert_return (invoke "ge_u" (v128.const i32x4 2147483648 2147483647 0 -1) + (v128.const i32x4 -2147483648 -2147483647 -1 0)) + (v128.const i32x4 -1 0 0 -1)) + +;; i32x4.ge_u (i32x4) (i8x16) +(assert_return (invoke "ge_u" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF) + (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295) + (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge_u" (v128.const i32x4 0 0 0 0) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge_u" (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C) + (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge_u" (v128.const i32x4 2206368128 16776957 2130837760 4294901120) + (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge_u" (v128.const i32x4 -8323200 0 1 4294967295) + (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255)) + (v128.const i32x4 -1 -1 0 -1)) +(assert_return (invoke "ge_u" (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA) + (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55)) + (v128.const i32x4 -1 -1 -1 -1)) + +;; i32x4.ge_u (i32x4) (i16x8) +(assert_return (invoke "ge_u" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF) + (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295) + (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge_u" (v128.const i32x4 0 0 0 0) + (v128.const i16x8 0 0 0 0 0 0 0 0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge_u" (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C) + (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge_u" (v128.const i32x4 2206368128 16776957 2130837760 4294901120) + (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge_u" (v128.const i32x4 -128 0 1 255) + (v128.const i16x8 65535 65535 0 0 1 1 32768 32768)) + (v128.const i32x4 0 -1 0 0)) +(assert_return (invoke "ge_u" (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA) + (v128.const i16x8 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge_u" (v128.const i32x4 0_123_456_789 0_123_456_789 0_123_456_789 0_123_456_789) + (v128.const i32x4 123456789 123456789 123456789 123456789)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "ge_u" (v128.const i32x4 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678) + (v128.const i32x4 0x12345678 0x12345678 0x12345678 0x12345678)) + (v128.const i32x4 -1 -1 -1 -1)) + + +;; Type check + +(assert_invalid (module (func (result v128) (i32x4.eq (i32.const 0) (f32.const 0)))) "type mismatch") +(assert_invalid (module (func (result v128) (i32x4.ge_s (i32.const 0) (f32.const 0)))) "type mismatch") +(assert_invalid (module (func (result v128) (i32x4.ge_u (i32.const 0) (f32.const 0)))) "type mismatch") +(assert_invalid (module (func (result v128) (i32x4.gt_s (i32.const 0) (f32.const 0)))) "type mismatch") +(assert_invalid (module (func (result v128) (i32x4.gt_u (i32.const 0) (f32.const 0)))) "type mismatch") +(assert_invalid (module (func (result v128) (i32x4.le_s (i32.const 0) (f32.const 0)))) "type mismatch") +(assert_invalid (module (func (result v128) (i32x4.le_u (i32.const 0) (f32.const 0)))) "type mismatch") +(assert_invalid (module (func (result v128) (i32x4.lt_s (i32.const 0) (f32.const 0)))) "type mismatch") +(assert_invalid (module (func (result v128) (i32x4.lt_u (i32.const 0) (f32.const 0)))) "type mismatch") +(assert_invalid (module (func (result v128) (i32x4.ne (i32.const 0) (f32.const 0)))) "type mismatch") + + +;; combination + +(module (memory 1) + (func (export "eq-in-block") + (block + (drop + (block (result v128) + (i32x4.eq + (block (result v128) (v128.load (i32.const 0))) + (block (result v128) (v128.load (i32.const 1))) + ) + ) + ) + ) + ) + (func (export "ne-in-block") + (block + (drop + (block (result v128) + (i32x4.ne + (block (result v128) (v128.load (i32.const 0))) + (block (result v128) (v128.load (i32.const 1))) + ) + ) + ) + ) + ) + (func (export "lt_s-in-block") + (block + (drop + (block (result v128) + (i32x4.lt_s + (block (result v128) (v128.load (i32.const 0))) + (block (result v128) (v128.load (i32.const 1))) + ) + ) + ) + ) + ) + (func (export "le_u-in-block") + (block + (drop + (block (result v128) + (i32x4.le_u + (block (result v128) (v128.load (i32.const 0))) + (block (result v128) (v128.load (i32.const 1))) + ) + ) + ) + ) + ) + (func (export "gt_u-in-block") + (block + (drop + (block (result v128) + (i32x4.gt_u + (block (result v128) (v128.load (i32.const 0))) + (block (result v128) (v128.load (i32.const 1))) + ) + ) + ) + ) + ) + (func (export "ge_s-in-block") + (block + (drop + (block (result v128) + (i32x4.ge_s + (block (result v128) (v128.load (i32.const 0))) + (block (result v128) (v128.load (i32.const 1))) + ) + ) + ) + ) + ) + (func (export "nested-eq") + (drop + (i32x4.eq + (i32x4.eq + (i32x4.eq + (v128.load (i32.const 0)) + (v128.load (i32.const 1)) + ) + (i32x4.eq + (v128.load (i32.const 2)) + (v128.load (i32.const 3)) + ) + ) + (i32x4.eq + (i32x4.eq + (v128.load (i32.const 0)) + (v128.load (i32.const 1)) + ) + (i32x4.eq + (v128.load (i32.const 2)) + (v128.load (i32.const 3)) + ) + ) + ) + ) + ) + (func (export "nested-ne") + (drop + (i32x4.ne + (i32x4.ne + (i32x4.ne + (v128.load (i32.const 0)) + (v128.load (i32.const 1)) + ) + (i32x4.ne + (v128.load (i32.const 2)) + (v128.load (i32.const 3)) + ) + ) + (i32x4.ne + (i32x4.ne + (v128.load (i32.const 0)) + (v128.load (i32.const 1)) + ) + (i32x4.ne + (v128.load (i32.const 2)) + (v128.load (i32.const 3)) + ) + ) + ) + ) + ) + (func (export "nested-lt_s") + (drop + (i32x4.lt_s + (i32x4.lt_s + (i32x4.lt_s + (v128.load (i32.const 0)) + (v128.load (i32.const 1)) + ) + (i32x4.lt_s + (v128.load (i32.const 2)) + (v128.load (i32.const 3)) + ) + ) + (i32x4.lt_s + (i32x4.lt_s + (v128.load (i32.const 0)) + (v128.load (i32.const 1)) + ) + (i32x4.lt_s + (v128.load (i32.const 2)) + (v128.load (i32.const 3)) + ) + ) + ) + ) + ) + (func (export "nested-le_u") + (drop + (i32x4.le_u + (i32x4.le_u + (i32x4.le_u + (v128.load (i32.const 0)) + (v128.load (i32.const 1)) + ) + (i32x4.le_u + (v128.load (i32.const 2)) + (v128.load (i32.const 3)) + ) + ) + (i32x4.le_u + (i32x4.le_u + (v128.load (i32.const 0)) + (v128.load (i32.const 1)) + ) + (i32x4.le_u + (v128.load (i32.const 2)) + (v128.load (i32.const 3)) + ) + ) + ) + ) + ) + (func (export "nested-gt_u") + (drop + (i32x4.gt_u + (i32x4.gt_u + (i32x4.gt_u + (v128.load (i32.const 0)) + (v128.load (i32.const 1)) + ) + (i32x4.gt_u + (v128.load (i32.const 2)) + (v128.load (i32.const 3)) + ) + ) + (i32x4.gt_u + (i32x4.gt_u + (v128.load (i32.const 0)) + (v128.load (i32.const 1)) + ) + (i32x4.gt_u + (v128.load (i32.const 2)) + (v128.load (i32.const 3)) + ) + ) + ) + ) + ) + (func (export "nested-ge_s") + (drop + (i32x4.ge_s + (i32x4.ge_s + (i32x4.ge_s + (v128.load (i32.const 0)) + (v128.load (i32.const 1)) + ) + (i32x4.ge_s + (v128.load (i32.const 2)) + (v128.load (i32.const 3)) + ) + ) + (i32x4.ge_s + (i32x4.ge_s + (v128.load (i32.const 0)) + (v128.load (i32.const 1)) + ) + (i32x4.ge_s + (v128.load (i32.const 2)) + (v128.load (i32.const 3)) + ) + ) + ) + ) + ) + (func (export "as-param") + (drop + (i32x4.ge_u + (i32x4.eq + (i32x4.lt_s + (v128.load (i32.const 0)) + (v128.load (i32.const 1)) + ) + (i32x4.le_u + (v128.load (i32.const 2)) + (v128.load (i32.const 3)) + ) + ) + (i32x4.ne + (i32x4.gt_s + (v128.load (i32.const 0)) + (v128.load (i32.const 1)) + ) + (i32x4.lt_u + (v128.load (i32.const 2)) + (v128.load (i32.const 3)) + ) + ) + ) + ) + ) +) +(assert_return (invoke "eq-in-block")) +(assert_return (invoke "ne-in-block")) +(assert_return (invoke "lt_s-in-block")) +(assert_return (invoke "le_u-in-block")) +(assert_return (invoke "gt_u-in-block")) +(assert_return (invoke "ge_s-in-block")) +(assert_return (invoke "nested-eq")) +(assert_return (invoke "nested-ne")) +(assert_return (invoke "nested-lt_s")) +(assert_return (invoke "nested-le_u")) +(assert_return (invoke "nested-gt_u")) +(assert_return (invoke "nested-ge_s")) +(assert_return (invoke "as-param")) + + +;; Test operation with empty argument + +(assert_invalid + (module + (func $i32x4.eq-1st-arg-empty (result v128) + (i32x4.eq (v128.const i32x4 0 0 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i32x4.eq-arg-empty (result v128) + (i32x4.eq) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i32x4.ne-1st-arg-empty (result v128) + (i32x4.ne (v128.const i32x4 0 0 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i32x4.ne-arg-empty (result v128) + (i32x4.ne) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i32x4.lt_s-1st-arg-empty (result v128) + (i32x4.lt_s (v128.const i32x4 0 0 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i32x4.lt_s-arg-empty (result v128) + (i32x4.lt_s) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i32x4.lt_u-1st-arg-empty (result v128) + (i32x4.lt_u (v128.const i32x4 0 0 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i32x4.lt_u-arg-empty (result v128) + (i32x4.lt_u) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i32x4.le_s-1st-arg-empty (result v128) + (i32x4.le_s (v128.const i32x4 0 0 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i32x4.le_s-arg-empty (result v128) + (i32x4.le_s) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i32x4.le_u-1st-arg-empty (result v128) + (i32x4.le_u (v128.const i32x4 0 0 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i32x4.le_u-arg-empty (result v128) + (i32x4.le_u) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i32x4.gt_s-1st-arg-empty (result v128) + (i32x4.gt_s (v128.const i32x4 0 0 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i32x4.gt_s-arg-empty (result v128) + (i32x4.gt_s) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i32x4.gt_u-1st-arg-empty (result v128) + (i32x4.gt_u (v128.const i32x4 0 0 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i32x4.gt_u-arg-empty (result v128) + (i32x4.gt_u) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i32x4.ge_s-1st-arg-empty (result v128) + (i32x4.ge_s (v128.const i32x4 0 0 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i32x4.ge_s-arg-empty (result v128) + (i32x4.ge_s) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i32x4.ge_u-1st-arg-empty (result v128) + (i32x4.ge_u (v128.const i32x4 0 0 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i32x4.ge_u-arg-empty (result v128) + (i32x4.ge_u) + ) + ) + "type mismatch" +) +;; Unknown operators + +(assert_malformed (module quote "(memory 1) (func (param $x v128) (param $y v128) (result v128) (i4x32.eq (local.get $x) (local.get $y)))") "unknown operator") +(assert_malformed (module quote "(memory 1) (func (param $x v128) (param $y v128) (result v128) (i4x32.ne (local.get $x) (local.get $y)))") "unknown operator") +(assert_malformed (module quote "(memory 1) (func (param $x v128) (param $y v128) (result v128) (i4x32.lt_s (local.get $x) (local.get $y)))") "unknown operator") +(assert_malformed (module quote "(memory 1) (func (param $x v128) (param $y v128) (result v128) (i4x32.lt_u (local.get $x) (local.get $y)))") "unknown operator") +(assert_malformed (module quote "(memory 1) (func (param $x v128) (param $y v128) (result v128) (i4x32.le_s (local.get $x) (local.get $y)))") "unknown operator") +(assert_malformed (module quote "(memory 1) (func (param $x v128) (param $y v128) (result v128) (i4x32.le_u (local.get $x) (local.get $y)))") "unknown operator") +(assert_malformed (module quote "(memory 1) (func (param $x v128) (param $y v128) (result v128) (i4x32.gt_s (local.get $x) (local.get $y)))") "unknown operator") +(assert_malformed (module quote "(memory 1) (func (param $x v128) (param $y v128) (result v128) (i4x32.gt_u (local.get $x) (local.get $y)))") "unknown operator") +(assert_malformed (module quote "(memory 1) (func (param $x v128) (param $y v128) (result v128) (i4x32.ge_s (local.get $x) (local.get $y)))") "unknown operator") +(assert_malformed (module quote "(memory 1) (func (param $x v128) (param $y v128) (result v128) (i4x32.ge_u (local.get $x) (local.get $y)))") "unknown operator") + diff --git a/runtime/near-vm/tests/wast/spec/proposals/simd/simd_i32x4_dot_i16x8.wast b/runtime/near-vm/tests/wast/spec/proposals/simd/simd_i32x4_dot_i16x8.wast new file mode 100644 index 00000000000..b41de74d00b --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/proposals/simd/simd_i32x4_dot_i16x8.wast @@ -0,0 +1,110 @@ +;; Tests for i32x4 arithmetic operations on major boundary values and all special values. + + +(module + (func (export "i32x4.dot_i16x8_s") (param v128 v128) (result v128) (i32x4.dot_i16x8_s (local.get 0) (local.get 1))) +) + + +;; i32x4.dot_i16x8_s +(assert_return (invoke "i32x4.dot_i16x8_s" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i16x8 0 0 0 0 0 0 0 0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.dot_i16x8_s" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i16x8 1 1 1 1 1 1 1 1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.dot_i16x8_s" (v128.const i16x8 1 1 1 1 1 1 1 1) + (v128.const i16x8 1 1 1 1 1 1 1 1)) + (v128.const i32x4 2 2 2 2)) +(assert_return (invoke "i32x4.dot_i16x8_s" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.dot_i16x8_s" (v128.const i16x8 1 1 1 1 1 1 1 1) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i32x4 -2 -2 -2 -2)) +(assert_return (invoke "i32x4.dot_i16x8_s" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i32x4 2 2 2 2)) +(assert_return (invoke "i32x4.dot_i16x8_s" (v128.const i16x8 16383 16383 16383 16383 16383 16383 16383 16383) + (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384)) + (v128.const i32x4 536838144 536838144 536838144 536838144)) +(assert_return (invoke "i32x4.dot_i16x8_s" (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384) + (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384)) + (v128.const i32x4 536870912 536870912 536870912 536870912)) +(assert_return (invoke "i32x4.dot_i16x8_s" (v128.const i16x8 -16383 -16383 -16383 -16383 -16383 -16383 -16383 -16383) + (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384)) + (v128.const i32x4 536838144 536838144 536838144 536838144)) +(assert_return (invoke "i32x4.dot_i16x8_s" (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384) + (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384)) + (v128.const i32x4 536870912 536870912 536870912 536870912)) +(assert_return (invoke "i32x4.dot_i16x8_s" (v128.const i16x8 -16385 -16385 -16385 -16385 -16385 -16385 -16385 -16385) + (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384)) + (v128.const i32x4 536903680 536903680 536903680 536903680)) +(assert_return (invoke "i32x4.dot_i16x8_s" (v128.const i16x8 32765 32765 32765 32765 32765 32765 32765 32765) + (v128.const i16x8 1 1 1 1 1 1 1 1)) + (v128.const i32x4 65530 65530 65530 65530)) +(assert_return (invoke "i32x4.dot_i16x8_s" (v128.const i16x8 32766 32766 32766 32766 32766 32766 32766 32766) + (v128.const i16x8 1 1 1 1 1 1 1 1)) + (v128.const i32x4 65532 65532 65532 65532)) +(assert_return (invoke "i32x4.dot_i16x8_s" (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768) + (v128.const i16x8 1 1 1 1 1 1 1 1)) + (v128.const i32x4 -65536 -65536 -65536 -65536)) +(assert_return (invoke "i32x4.dot_i16x8_s" (v128.const i16x8 -32766 -32766 -32766 -32766 -32766 -32766 -32766 -32766) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i32x4 65532 65532 65532 65532)) +(assert_return (invoke "i32x4.dot_i16x8_s" (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i32x4 65534 65534 65534 65534)) +(assert_return (invoke "i32x4.dot_i16x8_s" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i32x4 65536 65536 65536 65536)) +(assert_return (invoke "i32x4.dot_i16x8_s" (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767) + (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767)) + (v128.const i32x4 2147352578 2147352578 2147352578 2147352578)) +(assert_return (invoke "i32x4.dot_i16x8_s" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768) + (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)) + (v128.const i32x4 2147483648 2147483648 2147483648 2147483648)) +(assert_return (invoke "i32x4.dot_i16x8_s" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768) + (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767)) + (v128.const i32x4 2147418112 2147418112 2147418112 2147418112)) +(assert_return (invoke "i32x4.dot_i16x8_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535) + (v128.const i16x8 0 0 0 0 0 0 0 0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.dot_i16x8_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535) + (v128.const i16x8 1 1 1 1 1 1 1 1)) + (v128.const i32x4 -2 -2 -2 -2)) +(assert_return (invoke "i32x4.dot_i16x8_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i32x4 2 2 2 2)) +(assert_return (invoke "i32x4.dot_i16x8_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535) + (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767)) + (v128.const i32x4 -65534 -65534 -65534 -65534)) +(assert_return (invoke "i32x4.dot_i16x8_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535) + (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)) + (v128.const i32x4 65536 65536 65536 65536)) +(assert_return (invoke "i32x4.dot_i16x8_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535) + (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)) + (v128.const i32x4 2 2 2 2)) + +;; type check +(assert_invalid (module (func (result v128) (i32x4.dot_i16x8_s (i32.const 0) (f32.const 0.0)))) "type mismatch") + +;; Test operation with empty argument + +(assert_invalid + (module + (func $i32x4.dot_i16x8_s-1st-arg-empty (result v128) + (i32x4.dot_i16x8_s (v128.const i32x4 0 0 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i32x4.dot_i16x8_s-arg-empty (result v128) + (i32x4.dot_i16x8_s) + ) + ) + "type mismatch" +) + diff --git a/runtime/near-vm/tests/wast/spec/proposals/simd/simd_i32x4_extadd_pairwise_i16x8.wast b/runtime/near-vm/tests/wast/spec/proposals/simd/simd_i32x4_extadd_pairwise_i16x8.wast new file mode 100644 index 00000000000..2d1682d40e7 --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/proposals/simd/simd_i32x4_extadd_pairwise_i16x8.wast @@ -0,0 +1,68 @@ +;; Tests for i32x4 arithmetic operations on major boundary values and all special values. + + +(module + (func (export "i32x4.extadd_pairwise_i16x8_s") (param v128) (result v128) (i32x4.extadd_pairwise_i16x8_s (local.get 0))) + (func (export "i32x4.extadd_pairwise_i16x8_u") (param v128) (result v128) (i32x4.extadd_pairwise_i16x8_u (local.get 0))) +) + + +;; i32x4.extadd_pairwise_i16x8_s +(assert_return (invoke "i32x4.extadd_pairwise_i16x8_s" (v128.const i16x8 0 0 0 0 0 0 0 0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.extadd_pairwise_i16x8_s" (v128.const i16x8 1 1 1 1 1 1 1 1)) + (v128.const i32x4 2 2 2 2)) +(assert_return (invoke "i32x4.extadd_pairwise_i16x8_s" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i32x4 -2 -2 -2 -2)) +(assert_return (invoke "i32x4.extadd_pairwise_i16x8_s" (v128.const i16x8 32766 32766 32766 32766 32766 32766 32766 32766)) + (v128.const i32x4 65532 65532 65532 65532)) +(assert_return (invoke "i32x4.extadd_pairwise_i16x8_s" (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767)) + (v128.const i32x4 -65534 -65534 -65534 -65534)) +(assert_return (invoke "i32x4.extadd_pairwise_i16x8_s" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)) + (v128.const i32x4 -65536 -65536 -65536 -65536)) +(assert_return (invoke "i32x4.extadd_pairwise_i16x8_s" (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767)) + (v128.const i32x4 65534 65534 65534 65534)) +(assert_return (invoke "i32x4.extadd_pairwise_i16x8_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)) + (v128.const i32x4 -2 -2 -2 -2)) + +;; i32x4.extadd_pairwise_i16x8_u +(assert_return (invoke "i32x4.extadd_pairwise_i16x8_u" (v128.const i16x8 0 0 0 0 0 0 0 0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.extadd_pairwise_i16x8_u" (v128.const i16x8 1 1 1 1 1 1 1 1)) + (v128.const i32x4 2 2 2 2)) +(assert_return (invoke "i32x4.extadd_pairwise_i16x8_u" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i32x4 131070 131070 131070 131070)) +(assert_return (invoke "i32x4.extadd_pairwise_i16x8_u" (v128.const i16x8 32766 32766 32766 32766 32766 32766 32766 32766)) + (v128.const i32x4 65532 65532 65532 65532)) +(assert_return (invoke "i32x4.extadd_pairwise_i16x8_u" (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767)) + (v128.const i32x4 65538 65538 65538 65538)) +(assert_return (invoke "i32x4.extadd_pairwise_i16x8_u" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)) + (v128.const i32x4 65536 65536 65536 65536)) +(assert_return (invoke "i32x4.extadd_pairwise_i16x8_u" (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767)) + (v128.const i32x4 65534 65534 65534 65534)) +(assert_return (invoke "i32x4.extadd_pairwise_i16x8_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)) + (v128.const i32x4 131070 131070 131070 131070)) + +;; type check +(assert_invalid (module (func (result v128) (i32x4.extadd_pairwise_i16x8_s (i32.const 0)))) "type mismatch") +(assert_invalid (module (func (result v128) (i32x4.extadd_pairwise_i16x8_u (i32.const 0)))) "type mismatch") + +;; Test operation with empty argument + +(assert_invalid + (module + (func $i32x4.extadd_pairwise_i16x8_s-arg-empty (result v128) + (i32x4.extadd_pairwise_i16x8_s) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i32x4.extadd_pairwise_i16x8_u-arg-empty (result v128) + (i32x4.extadd_pairwise_i16x8_u) + ) + ) + "type mismatch" +) + diff --git a/runtime/near-vm/tests/wast/spec/proposals/simd/simd_i32x4_extmul_i16x8.wast b/runtime/near-vm/tests/wast/spec/proposals/simd/simd_i32x4_extmul_i16x8.wast new file mode 100644 index 00000000000..f04db6770f7 --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/proposals/simd/simd_i32x4_extmul_i16x8.wast @@ -0,0 +1,404 @@ +;; Tests for i32x4 arithmetic operations on major boundary values and all special values. + + +(module + (func (export "i32x4.extmul_low_i16x8_s") (param v128 v128) (result v128) (i32x4.extmul_low_i16x8_s (local.get 0) (local.get 1))) + (func (export "i32x4.extmul_high_i16x8_s") (param v128 v128) (result v128) (i32x4.extmul_high_i16x8_s (local.get 0) (local.get 1))) + (func (export "i32x4.extmul_low_i16x8_u") (param v128 v128) (result v128) (i32x4.extmul_low_i16x8_u (local.get 0) (local.get 1))) + (func (export "i32x4.extmul_high_i16x8_u") (param v128 v128) (result v128) (i32x4.extmul_high_i16x8_u (local.get 0) (local.get 1))) +) + + +;; i32x4.extmul_low_i16x8_s +(assert_return (invoke "i32x4.extmul_low_i16x8_s" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i16x8 0 0 0 0 0 0 0 0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.extmul_low_i16x8_s" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i16x8 1 1 1 1 1 1 1 1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.extmul_low_i16x8_s" (v128.const i16x8 1 1 1 1 1 1 1 1) + (v128.const i16x8 1 1 1 1 1 1 1 1)) + (v128.const i32x4 1 1 1 1)) +(assert_return (invoke "i32x4.extmul_low_i16x8_s" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.extmul_low_i16x8_s" (v128.const i16x8 1 1 1 1 1 1 1 1) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "i32x4.extmul_low_i16x8_s" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i32x4 1 1 1 1)) +(assert_return (invoke "i32x4.extmul_low_i16x8_s" (v128.const i16x8 16383 16383 16383 16383 16383 16383 16383 16383) + (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384)) + (v128.const i32x4 268419072 268419072 268419072 268419072)) +(assert_return (invoke "i32x4.extmul_low_i16x8_s" (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384) + (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384)) + (v128.const i32x4 268435456 268435456 268435456 268435456)) +(assert_return (invoke "i32x4.extmul_low_i16x8_s" (v128.const i16x8 -16383 -16383 -16383 -16383 -16383 -16383 -16383 -16383) + (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384)) + (v128.const i32x4 268419072 268419072 268419072 268419072)) +(assert_return (invoke "i32x4.extmul_low_i16x8_s" (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384) + (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384)) + (v128.const i32x4 268435456 268435456 268435456 268435456)) +(assert_return (invoke "i32x4.extmul_low_i16x8_s" (v128.const i16x8 -16385 -16385 -16385 -16385 -16385 -16385 -16385 -16385) + (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384)) + (v128.const i32x4 268451840 268451840 268451840 268451840)) +(assert_return (invoke "i32x4.extmul_low_i16x8_s" (v128.const i16x8 32765 32765 32765 32765 32765 32765 32765 32765) + (v128.const i16x8 1 1 1 1 1 1 1 1)) + (v128.const i32x4 32765 32765 32765 32765)) +(assert_return (invoke "i32x4.extmul_low_i16x8_s" (v128.const i16x8 32766 32766 32766 32766 32766 32766 32766 32766) + (v128.const i16x8 1 1 1 1 1 1 1 1)) + (v128.const i32x4 32766 32766 32766 32766)) +(assert_return (invoke "i32x4.extmul_low_i16x8_s" (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768) + (v128.const i16x8 1 1 1 1 1 1 1 1)) + (v128.const i32x4 -32768 -32768 -32768 -32768)) +(assert_return (invoke "i32x4.extmul_low_i16x8_s" (v128.const i16x8 -32766 -32766 -32766 -32766 -32766 -32766 -32766 -32766) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i32x4 32766 32766 32766 32766)) +(assert_return (invoke "i32x4.extmul_low_i16x8_s" (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i32x4 32767 32767 32767 32767)) +(assert_return (invoke "i32x4.extmul_low_i16x8_s" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i32x4 32768 32768 32768 32768)) +(assert_return (invoke "i32x4.extmul_low_i16x8_s" (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767) + (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767)) + (v128.const i32x4 1073676289 1073676289 1073676289 1073676289)) +(assert_return (invoke "i32x4.extmul_low_i16x8_s" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768) + (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)) + (v128.const i32x4 1073741824 1073741824 1073741824 1073741824)) +(assert_return (invoke "i32x4.extmul_low_i16x8_s" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768) + (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767)) + (v128.const i32x4 1073709056 1073709056 1073709056 1073709056)) +(assert_return (invoke "i32x4.extmul_low_i16x8_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535) + (v128.const i16x8 0 0 0 0 0 0 0 0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.extmul_low_i16x8_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535) + (v128.const i16x8 1 1 1 1 1 1 1 1)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "i32x4.extmul_low_i16x8_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i32x4 1 1 1 1)) +(assert_return (invoke "i32x4.extmul_low_i16x8_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535) + (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767)) + (v128.const i32x4 -32767 -32767 -32767 -32767)) +(assert_return (invoke "i32x4.extmul_low_i16x8_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535) + (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)) + (v128.const i32x4 32768 32768 32768 32768)) +(assert_return (invoke "i32x4.extmul_low_i16x8_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535) + (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)) + (v128.const i32x4 1 1 1 1)) + +;; i32x4.extmul_high_i16x8_s +(assert_return (invoke "i32x4.extmul_high_i16x8_s" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i16x8 0 0 0 0 0 0 0 0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.extmul_high_i16x8_s" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i16x8 1 1 1 1 1 1 1 1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.extmul_high_i16x8_s" (v128.const i16x8 1 1 1 1 1 1 1 1) + (v128.const i16x8 1 1 1 1 1 1 1 1)) + (v128.const i32x4 1 1 1 1)) +(assert_return (invoke "i32x4.extmul_high_i16x8_s" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.extmul_high_i16x8_s" (v128.const i16x8 1 1 1 1 1 1 1 1) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "i32x4.extmul_high_i16x8_s" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i32x4 1 1 1 1)) +(assert_return (invoke "i32x4.extmul_high_i16x8_s" (v128.const i16x8 16383 16383 16383 16383 16383 16383 16383 16383) + (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384)) + (v128.const i32x4 268419072 268419072 268419072 268419072)) +(assert_return (invoke "i32x4.extmul_high_i16x8_s" (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384) + (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384)) + (v128.const i32x4 268435456 268435456 268435456 268435456)) +(assert_return (invoke "i32x4.extmul_high_i16x8_s" (v128.const i16x8 -16383 -16383 -16383 -16383 -16383 -16383 -16383 -16383) + (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384)) + (v128.const i32x4 268419072 268419072 268419072 268419072)) +(assert_return (invoke "i32x4.extmul_high_i16x8_s" (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384) + (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384)) + (v128.const i32x4 268435456 268435456 268435456 268435456)) +(assert_return (invoke "i32x4.extmul_high_i16x8_s" (v128.const i16x8 -16385 -16385 -16385 -16385 -16385 -16385 -16385 -16385) + (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384)) + (v128.const i32x4 268451840 268451840 268451840 268451840)) +(assert_return (invoke "i32x4.extmul_high_i16x8_s" (v128.const i16x8 32765 32765 32765 32765 32765 32765 32765 32765) + (v128.const i16x8 1 1 1 1 1 1 1 1)) + (v128.const i32x4 32765 32765 32765 32765)) +(assert_return (invoke "i32x4.extmul_high_i16x8_s" (v128.const i16x8 32766 32766 32766 32766 32766 32766 32766 32766) + (v128.const i16x8 1 1 1 1 1 1 1 1)) + (v128.const i32x4 32766 32766 32766 32766)) +(assert_return (invoke "i32x4.extmul_high_i16x8_s" (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768) + (v128.const i16x8 1 1 1 1 1 1 1 1)) + (v128.const i32x4 -32768 -32768 -32768 -32768)) +(assert_return (invoke "i32x4.extmul_high_i16x8_s" (v128.const i16x8 -32766 -32766 -32766 -32766 -32766 -32766 -32766 -32766) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i32x4 32766 32766 32766 32766)) +(assert_return (invoke "i32x4.extmul_high_i16x8_s" (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i32x4 32767 32767 32767 32767)) +(assert_return (invoke "i32x4.extmul_high_i16x8_s" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i32x4 32768 32768 32768 32768)) +(assert_return (invoke "i32x4.extmul_high_i16x8_s" (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767) + (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767)) + (v128.const i32x4 1073676289 1073676289 1073676289 1073676289)) +(assert_return (invoke "i32x4.extmul_high_i16x8_s" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768) + (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)) + (v128.const i32x4 1073741824 1073741824 1073741824 1073741824)) +(assert_return (invoke "i32x4.extmul_high_i16x8_s" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768) + (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767)) + (v128.const i32x4 1073709056 1073709056 1073709056 1073709056)) +(assert_return (invoke "i32x4.extmul_high_i16x8_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535) + (v128.const i16x8 0 0 0 0 0 0 0 0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.extmul_high_i16x8_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535) + (v128.const i16x8 1 1 1 1 1 1 1 1)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "i32x4.extmul_high_i16x8_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i32x4 1 1 1 1)) +(assert_return (invoke "i32x4.extmul_high_i16x8_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535) + (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767)) + (v128.const i32x4 -32767 -32767 -32767 -32767)) +(assert_return (invoke "i32x4.extmul_high_i16x8_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535) + (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)) + (v128.const i32x4 32768 32768 32768 32768)) +(assert_return (invoke "i32x4.extmul_high_i16x8_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535) + (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)) + (v128.const i32x4 1 1 1 1)) + +;; i32x4.extmul_low_i16x8_u +(assert_return (invoke "i32x4.extmul_low_i16x8_u" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i16x8 0 0 0 0 0 0 0 0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.extmul_low_i16x8_u" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i16x8 1 1 1 1 1 1 1 1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.extmul_low_i16x8_u" (v128.const i16x8 1 1 1 1 1 1 1 1) + (v128.const i16x8 1 1 1 1 1 1 1 1)) + (v128.const i32x4 1 1 1 1)) +(assert_return (invoke "i32x4.extmul_low_i16x8_u" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.extmul_low_i16x8_u" (v128.const i16x8 1 1 1 1 1 1 1 1) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i32x4 65535 65535 65535 65535)) +(assert_return (invoke "i32x4.extmul_low_i16x8_u" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i32x4 -131071 -131071 -131071 -131071)) +(assert_return (invoke "i32x4.extmul_low_i16x8_u" (v128.const i16x8 16383 16383 16383 16383 16383 16383 16383 16383) + (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384)) + (v128.const i32x4 268419072 268419072 268419072 268419072)) +(assert_return (invoke "i32x4.extmul_low_i16x8_u" (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384) + (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384)) + (v128.const i32x4 268435456 268435456 268435456 268435456)) +(assert_return (invoke "i32x4.extmul_low_i16x8_u" (v128.const i16x8 -16383 -16383 -16383 -16383 -16383 -16383 -16383 -16383) + (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384)) + (v128.const i32x4 -1878999040 -1878999040 -1878999040 -1878999040)) +(assert_return (invoke "i32x4.extmul_low_i16x8_u" (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384) + (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384)) + (v128.const i32x4 -1879048192 -1879048192 -1879048192 -1879048192)) +(assert_return (invoke "i32x4.extmul_low_i16x8_u" (v128.const i16x8 -16385 -16385 -16385 -16385 -16385 -16385 -16385 -16385) + (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384)) + (v128.const i32x4 -1879097344 -1879097344 -1879097344 -1879097344)) +(assert_return (invoke "i32x4.extmul_low_i16x8_u" (v128.const i16x8 32765 32765 32765 32765 32765 32765 32765 32765) + (v128.const i16x8 1 1 1 1 1 1 1 1)) + (v128.const i32x4 32765 32765 32765 32765)) +(assert_return (invoke "i32x4.extmul_low_i16x8_u" (v128.const i16x8 32766 32766 32766 32766 32766 32766 32766 32766) + (v128.const i16x8 1 1 1 1 1 1 1 1)) + (v128.const i32x4 32766 32766 32766 32766)) +(assert_return (invoke "i32x4.extmul_low_i16x8_u" (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768) + (v128.const i16x8 1 1 1 1 1 1 1 1)) + (v128.const i32x4 32768 32768 32768 32768)) +(assert_return (invoke "i32x4.extmul_low_i16x8_u" (v128.const i16x8 -32766 -32766 -32766 -32766 -32766 -32766 -32766 -32766) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i32x4 -2147385346 -2147385346 -2147385346 -2147385346)) +(assert_return (invoke "i32x4.extmul_low_i16x8_u" (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i32x4 -2147450881 -2147450881 -2147450881 -2147450881)) +(assert_return (invoke "i32x4.extmul_low_i16x8_u" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i32x4 2147450880 2147450880 2147450880 2147450880)) +(assert_return (invoke "i32x4.extmul_low_i16x8_u" (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767) + (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767)) + (v128.const i32x4 1073676289 1073676289 1073676289 1073676289)) +(assert_return (invoke "i32x4.extmul_low_i16x8_u" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768) + (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)) + (v128.const i32x4 1073741824 1073741824 1073741824 1073741824)) +(assert_return (invoke "i32x4.extmul_low_i16x8_u" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768) + (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767)) + (v128.const i32x4 1073774592 1073774592 1073774592 1073774592)) +(assert_return (invoke "i32x4.extmul_low_i16x8_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535) + (v128.const i16x8 0 0 0 0 0 0 0 0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.extmul_low_i16x8_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535) + (v128.const i16x8 1 1 1 1 1 1 1 1)) + (v128.const i32x4 65535 65535 65535 65535)) +(assert_return (invoke "i32x4.extmul_low_i16x8_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i32x4 -131071 -131071 -131071 -131071)) +(assert_return (invoke "i32x4.extmul_low_i16x8_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535) + (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767)) + (v128.const i32x4 2147385345 2147385345 2147385345 2147385345)) +(assert_return (invoke "i32x4.extmul_low_i16x8_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535) + (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)) + (v128.const i32x4 2147450880 2147450880 2147450880 2147450880)) +(assert_return (invoke "i32x4.extmul_low_i16x8_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535) + (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)) + (v128.const i32x4 -131071 -131071 -131071 -131071)) + +;; i32x4.extmul_high_i16x8_u +(assert_return (invoke "i32x4.extmul_high_i16x8_u" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i16x8 0 0 0 0 0 0 0 0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.extmul_high_i16x8_u" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i16x8 1 1 1 1 1 1 1 1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.extmul_high_i16x8_u" (v128.const i16x8 1 1 1 1 1 1 1 1) + (v128.const i16x8 1 1 1 1 1 1 1 1)) + (v128.const i32x4 1 1 1 1)) +(assert_return (invoke "i32x4.extmul_high_i16x8_u" (v128.const i16x8 0 0 0 0 0 0 0 0) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.extmul_high_i16x8_u" (v128.const i16x8 1 1 1 1 1 1 1 1) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i32x4 65535 65535 65535 65535)) +(assert_return (invoke "i32x4.extmul_high_i16x8_u" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i32x4 -131071 -131071 -131071 -131071)) +(assert_return (invoke "i32x4.extmul_high_i16x8_u" (v128.const i16x8 16383 16383 16383 16383 16383 16383 16383 16383) + (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384)) + (v128.const i32x4 268419072 268419072 268419072 268419072)) +(assert_return (invoke "i32x4.extmul_high_i16x8_u" (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384) + (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384)) + (v128.const i32x4 268435456 268435456 268435456 268435456)) +(assert_return (invoke "i32x4.extmul_high_i16x8_u" (v128.const i16x8 -16383 -16383 -16383 -16383 -16383 -16383 -16383 -16383) + (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384)) + (v128.const i32x4 -1878999040 -1878999040 -1878999040 -1878999040)) +(assert_return (invoke "i32x4.extmul_high_i16x8_u" (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384) + (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384)) + (v128.const i32x4 -1879048192 -1879048192 -1879048192 -1879048192)) +(assert_return (invoke "i32x4.extmul_high_i16x8_u" (v128.const i16x8 -16385 -16385 -16385 -16385 -16385 -16385 -16385 -16385) + (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384)) + (v128.const i32x4 -1879097344 -1879097344 -1879097344 -1879097344)) +(assert_return (invoke "i32x4.extmul_high_i16x8_u" (v128.const i16x8 32765 32765 32765 32765 32765 32765 32765 32765) + (v128.const i16x8 1 1 1 1 1 1 1 1)) + (v128.const i32x4 32765 32765 32765 32765)) +(assert_return (invoke "i32x4.extmul_high_i16x8_u" (v128.const i16x8 32766 32766 32766 32766 32766 32766 32766 32766) + (v128.const i16x8 1 1 1 1 1 1 1 1)) + (v128.const i32x4 32766 32766 32766 32766)) +(assert_return (invoke "i32x4.extmul_high_i16x8_u" (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768) + (v128.const i16x8 1 1 1 1 1 1 1 1)) + (v128.const i32x4 32768 32768 32768 32768)) +(assert_return (invoke "i32x4.extmul_high_i16x8_u" (v128.const i16x8 -32766 -32766 -32766 -32766 -32766 -32766 -32766 -32766) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i32x4 -2147385346 -2147385346 -2147385346 -2147385346)) +(assert_return (invoke "i32x4.extmul_high_i16x8_u" (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i32x4 -2147450881 -2147450881 -2147450881 -2147450881)) +(assert_return (invoke "i32x4.extmul_high_i16x8_u" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i32x4 2147450880 2147450880 2147450880 2147450880)) +(assert_return (invoke "i32x4.extmul_high_i16x8_u" (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767) + (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767)) + (v128.const i32x4 1073676289 1073676289 1073676289 1073676289)) +(assert_return (invoke "i32x4.extmul_high_i16x8_u" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768) + (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)) + (v128.const i32x4 1073741824 1073741824 1073741824 1073741824)) +(assert_return (invoke "i32x4.extmul_high_i16x8_u" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768) + (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767)) + (v128.const i32x4 1073774592 1073774592 1073774592 1073774592)) +(assert_return (invoke "i32x4.extmul_high_i16x8_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535) + (v128.const i16x8 0 0 0 0 0 0 0 0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.extmul_high_i16x8_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535) + (v128.const i16x8 1 1 1 1 1 1 1 1)) + (v128.const i32x4 65535 65535 65535 65535)) +(assert_return (invoke "i32x4.extmul_high_i16x8_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i32x4 -131071 -131071 -131071 -131071)) +(assert_return (invoke "i32x4.extmul_high_i16x8_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535) + (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767)) + (v128.const i32x4 2147385345 2147385345 2147385345 2147385345)) +(assert_return (invoke "i32x4.extmul_high_i16x8_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535) + (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)) + (v128.const i32x4 2147450880 2147450880 2147450880 2147450880)) +(assert_return (invoke "i32x4.extmul_high_i16x8_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535) + (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)) + (v128.const i32x4 -131071 -131071 -131071 -131071)) + +;; type check +(assert_invalid (module (func (result v128) (i32x4.extmul_low_i16x8_s (i32.const 0) (f32.const 0.0)))) "type mismatch") +(assert_invalid (module (func (result v128) (i32x4.extmul_high_i16x8_s (i32.const 0) (f32.const 0.0)))) "type mismatch") +(assert_invalid (module (func (result v128) (i32x4.extmul_low_i16x8_u (i32.const 0) (f32.const 0.0)))) "type mismatch") +(assert_invalid (module (func (result v128) (i32x4.extmul_high_i16x8_u (i32.const 0) (f32.const 0.0)))) "type mismatch") + +;; Test operation with empty argument + +(assert_invalid + (module + (func $i32x4.extmul_low_i16x8_s-1st-arg-empty (result v128) + (i32x4.extmul_low_i16x8_s (v128.const i32x4 0 0 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i32x4.extmul_low_i16x8_s-arg-empty (result v128) + (i32x4.extmul_low_i16x8_s) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i32x4.extmul_high_i16x8_s-1st-arg-empty (result v128) + (i32x4.extmul_high_i16x8_s (v128.const i32x4 0 0 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i32x4.extmul_high_i16x8_s-arg-empty (result v128) + (i32x4.extmul_high_i16x8_s) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i32x4.extmul_low_i16x8_u-1st-arg-empty (result v128) + (i32x4.extmul_low_i16x8_u (v128.const i32x4 0 0 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i32x4.extmul_low_i16x8_u-arg-empty (result v128) + (i32x4.extmul_low_i16x8_u) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i32x4.extmul_high_i16x8_u-1st-arg-empty (result v128) + (i32x4.extmul_high_i16x8_u (v128.const i32x4 0 0 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i32x4.extmul_high_i16x8_u-arg-empty (result v128) + (i32x4.extmul_high_i16x8_u) + ) + ) + "type mismatch" +) + diff --git a/runtime/near-vm/tests/wast/spec/proposals/simd/simd_i32x4_trunc_sat_f32x4.wast b/runtime/near-vm/tests/wast/spec/proposals/simd/simd_i32x4_trunc_sat_f32x4.wast new file mode 100644 index 00000000000..40af590f52a --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/proposals/simd/simd_i32x4_trunc_sat_f32x4.wast @@ -0,0 +1,239 @@ +;; Tests for i32x4 trunc sat conversions from float. + +(module + (func (export "i32x4.trunc_sat_f32x4_s") (param v128) (result v128) (i32x4.trunc_sat_f32x4_s (local.get 0))) + (func (export "i32x4.trunc_sat_f32x4_u") (param v128) (result v128) (i32x4.trunc_sat_f32x4_u (local.get 0))) +) + + +;; i32x4.trunc_sat_f32x4_s +(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 0.0 0.0 0.0 0.0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 -0.0 -0.0 -0.0 -0.0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 1.5 1.5 1.5 1.5)) + (v128.const i32x4 1 1 1 1)) +(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 -1.5 -1.5 -1.5 -1.5)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 1.9 1.9 1.9 1.9)) + (v128.const i32x4 1 1 1 1)) +(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 2.0 2.0 2.0 2.0)) + (v128.const i32x4 2 2 2 2)) +(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 -1.9 -1.9 -1.9 -1.9)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 -2.0 -2.0 -2.0 -2.0)) + (v128.const i32x4 -2 -2 -2 -2)) +(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 2147483520.0 2147483520.0 2147483520.0 2147483520.0)) + (v128.const i32x4 2147483520 2147483520 2147483520 2147483520)) +(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 -2147483520.0 -2147483520.0 -2147483520.0 -2147483520.0)) + (v128.const i32x4 -2147483520 -2147483520 -2147483520 -2147483520)) +(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 2147483648.0 2147483648.0 2147483648.0 2147483648.0)) + (v128.const i32x4 2147483647 2147483647 2147483647 2147483647)) +(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 -2147483648.0 -2147483648.0 -2147483648.0 -2147483648.0)) + (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648)) +(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 4294967294.0 4294967294.0 4294967294.0 4294967294.0)) + (v128.const i32x4 2147483647 2147483647 2147483647 2147483647)) +(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 -4294967294.0 -4294967294.0 -4294967294.0 -4294967294.0)) + (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648)) +(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 2147483647.0 2147483647.0 2147483647.0 2147483647.0)) + (v128.const i32x4 2147483647 2147483647 2147483647 2147483647)) +(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 -2147483647.0 -2147483647.0 -2147483647.0 -2147483647.0)) + (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648)) +(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 4294967294.0 4294967294.0 4294967294.0 4294967294.0)) + (v128.const i32x4 2147483647 2147483647 2147483647 2147483647)) +(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 4294967295.0 4294967295.0 4294967295.0 4294967295.0)) + (v128.const i32x4 2147483647 2147483647 2147483647 2147483647)) +(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 4294967296.0 4294967296.0 4294967296.0 4294967296.0)) + (v128.const i32x4 2147483647 2147483647 2147483647 2147483647)) +(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const i32x4 1 1 1 1)) +(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 0x1.19999ap+0 0x1.19999ap+0 0x1.19999ap+0 0x1.19999ap+0)) + (v128.const i32x4 1 1 1 1)) +(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 -0x1.19999ap+0 -0x1.19999ap+0 -0x1.19999ap+0 -0x1.19999ap+0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const i32x4 6 6 6 6)) +(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const i32x4 -6 -6 -6 -6)) +(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const i32x4 2147483647 2147483647 2147483647 2147483647)) +(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648)) +(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 0x1.ccccccp-1 0x1.ccccccp-1 0x1.ccccccp-1 0x1.ccccccp-1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 -0x1.ccccccp-1 -0x1.ccccccp-1 -0x1.ccccccp-1 -0x1.ccccccp-1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 0x1.fffffep-1 0x1.fffffep-1 0x1.fffffep-1 0x1.fffffep-1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 -0x1.fffffep-1 -0x1.fffffep-1 -0x1.fffffep-1 -0x1.fffffep-1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const i32x4 6 6 6 6)) +(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const i32x4 -6 -6 -6 -6)) +(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const i32x4 2147483647 2147483647 2147483647 2147483647)) +(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648)) +(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 +inf +inf +inf +inf)) + (v128.const i32x4 2147483647 2147483647 2147483647 2147483647)) +(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648)) +(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 +nan +nan +nan +nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 nan:0x444444 nan:0x444444 nan:0x444444 nan:0x444444)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 -nan:0x444444 -nan:0x444444 -nan:0x444444 -nan:0x444444)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 42 42 42 42)) + (v128.const i32x4 42 42 42 42)) +(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 -42 -42 -42 -42)) + (v128.const i32x4 -42 -42 -42 -42)) +(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 0123456792.0 0123456792.0 0123456792.0 0123456792.0)) + (v128.const i32x4 123456792 123456792 123456792 123456792)) +(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 01234567890.0 01234567890.0 01234567890.0 01234567890.0)) + (v128.const i32x4 1234567936 1234567936 1234567936 1234567936)) + +;; i32x4.trunc_sat_f32x4_u +(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 0.0 0.0 0.0 0.0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 -0.0 -0.0 -0.0 -0.0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 1.5 1.5 1.5 1.5)) + (v128.const i32x4 1 1 1 1)) +(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 -1.5 -1.5 -1.5 -1.5)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 1.9 1.9 1.9 1.9)) + (v128.const i32x4 1 1 1 1)) +(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 2.0 2.0 2.0 2.0)) + (v128.const i32x4 2 2 2 2)) +(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 -1.9 -1.9 -1.9 -1.9)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 -2.0 -2.0 -2.0 -2.0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 2147483520.0 2147483520.0 2147483520.0 2147483520.0)) + (v128.const i32x4 2147483520 2147483520 2147483520 2147483520)) +(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 -2147483520.0 -2147483520.0 -2147483520.0 -2147483520.0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 2147483648.0 2147483648.0 2147483648.0 2147483648.0)) + (v128.const i32x4 2147483648 2147483648 2147483648 2147483648)) +(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 -2147483648.0 -2147483648.0 -2147483648.0 -2147483648.0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 4294967294.0 4294967294.0 4294967294.0 4294967294.0)) + (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)) +(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 -4294967294.0 -4294967294.0 -4294967294.0 -4294967294.0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 2147483647.0 2147483647.0 2147483647.0 2147483647.0)) + (v128.const i32x4 2147483648 2147483648 2147483648 2147483648)) +(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 -2147483647.0 -2147483647.0 -2147483647.0 -2147483647.0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 4294967294.0 4294967294.0 4294967294.0 4294967294.0)) + (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)) +(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 4294967295.0 4294967295.0 4294967295.0 4294967295.0)) + (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)) +(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 4294967296.0 4294967296.0 4294967296.0 4294967296.0)) + (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)) +(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)) + (v128.const i32x4 1 1 1 1)) +(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 0x1.19999ap+0 0x1.19999ap+0 0x1.19999ap+0 0x1.19999ap+0)) + (v128.const i32x4 1 1 1 1)) +(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 -0x1.19999ap+0 -0x1.19999ap+0 -0x1.19999ap+0 -0x1.19999ap+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const i32x4 6 6 6 6)) +(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)) +(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 0x1.ccccccp-1 0x1.ccccccp-1 0x1.ccccccp-1 0x1.ccccccp-1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 -0x1.ccccccp-1 -0x1.ccccccp-1 -0x1.ccccccp-1 -0x1.ccccccp-1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 0x1.fffffep-1 0x1.fffffep-1 0x1.fffffep-1 0x1.fffffep-1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 -0x1.fffffep-1 -0x1.fffffep-1 -0x1.fffffep-1 -0x1.fffffep-1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const i32x4 6 6 6 6)) +(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)) +(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 +inf +inf +inf +inf)) + (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)) +(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 +nan +nan +nan +nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 nan:0x444444 nan:0x444444 nan:0x444444 nan:0x444444)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 -nan:0x444444 -nan:0x444444 -nan:0x444444 -nan:0x444444)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 42 42 42 42)) + (v128.const i32x4 42 42 42 42)) +(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 -42 -42 -42 -42)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 0123456792.0 0123456792.0 0123456792.0 0123456792.0)) + (v128.const i32x4 123456792 123456792 123456792 123456792)) +(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 01234567890.0 01234567890.0 01234567890.0 01234567890.0)) + (v128.const i32x4 1234567936 1234567936 1234567936 1234567936)) + +;; type check +(assert_invalid (module (func (result v128) (i32x4.trunc_sat_f32x4_s (i32.const 0)))) "type mismatch") +(assert_invalid (module (func (result v128) (i32x4.trunc_sat_f32x4_u (i32.const 0)))) "type mismatch") + +;; Test operation with empty argument + +(assert_invalid + (module + (func $i32x4.trunc_sat_f32x4_s-arg-empty (result v128) + (i32x4.trunc_sat_f32x4_s) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i32x4.trunc_sat_f32x4_u-arg-empty (result v128) + (i32x4.trunc_sat_f32x4_u) + ) + ) + "type mismatch" +) + diff --git a/runtime/near-vm/tests/wast/spec/proposals/simd/simd_i32x4_trunc_sat_f64x2.wast b/runtime/near-vm/tests/wast/spec/proposals/simd/simd_i32x4_trunc_sat_f64x2.wast new file mode 100644 index 00000000000..9bf507d77fb --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/proposals/simd/simd_i32x4_trunc_sat_f64x2.wast @@ -0,0 +1,239 @@ +;; Tests for i32x4 trunc sat conversions from float. + +(module + (func (export "i32x4.trunc_sat_f64x2_s_zero") (param v128) (result v128) (i32x4.trunc_sat_f64x2_s_zero (local.get 0))) + (func (export "i32x4.trunc_sat_f64x2_u_zero") (param v128) (result v128) (i32x4.trunc_sat_f64x2_u_zero (local.get 0))) +) + + +;; i32x4.trunc_sat_f64x2_s_zero +(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 0.0 0.0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 -0.0 -0.0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 1.5 1.5)) + (v128.const i32x4 1 1 0 0)) +(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 -1.5 -1.5)) + (v128.const i32x4 -1 -1 0 0)) +(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 1.9 1.9)) + (v128.const i32x4 1 1 0 0)) +(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 2.0 2.0)) + (v128.const i32x4 2 2 0 0)) +(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 -1.9 -1.9)) + (v128.const i32x4 -1 -1 0 0)) +(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 -2.0 -2.0)) + (v128.const i32x4 -2 -2 0 0)) +(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 2147483520.0 2147483520.0)) + (v128.const i32x4 2147483520 2147483520 0 0)) +(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 -2147483520.0 -2147483520.0)) + (v128.const i32x4 -2147483520 -2147483520 0 0)) +(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 2147483648.0 2147483648.0)) + (v128.const i32x4 2147483647 2147483647 0 0)) +(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 -2147483648.0 -2147483648.0)) + (v128.const i32x4 -2147483648 -2147483648 0 0)) +(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 4294967294.0 4294967294.0)) + (v128.const i32x4 2147483647 2147483647 0 0)) +(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 -4294967294.0 -4294967294.0)) + (v128.const i32x4 -2147483648 -2147483648 0 0)) +(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 2147483647.0 2147483647.0)) + (v128.const i32x4 2147483647 2147483647 0 0)) +(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 -2147483647.0 -2147483647.0)) + (v128.const i32x4 -2147483647 -2147483647 0 0)) +(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 4294967294.0 4294967294.0)) + (v128.const i32x4 2147483647 2147483647 0 0)) +(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 4294967295.0 4294967295.0)) + (v128.const i32x4 2147483647 2147483647 0 0)) +(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 4294967296.0 4294967296.0)) + (v128.const i32x4 2147483647 2147483647 0 0)) +(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 0x1p-149 0x1p-149)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 -0x1p-149 -0x1p-149)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 0x1p-126 0x1p-126)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 -0x1p-126 -0x1p-126)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const i32x4 1 1 0 0)) +(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const i32x4 -1 -1 0 0)) +(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 0x1.19999ap+0 0x1.19999ap+0)) + (v128.const i32x4 1 1 0 0)) +(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 -0x1.19999ap+0 -0x1.19999ap+0)) + (v128.const i32x4 -1 -1 0 0)) +(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const i32x4 6 6 0 0)) +(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const i32x4 -6 -6 0 0)) +(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const i32x4 2147483647 2147483647 0 0)) +(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const i32x4 -2147483648 -2147483648 0 0)) +(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 0x1.ccccccp-1 0x1.ccccccp-1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 -0x1.ccccccp-1 -0x1.ccccccp-1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 0x1.fffffep-1 0x1.fffffep-1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 -0x1.fffffep-1 -0x1.fffffep-1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const i32x4 6 6 0 0)) +(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const i32x4 -6 -6 0 0)) +(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const i32x4 2147483647 2147483647 0 0)) +(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const i32x4 -2147483648 -2147483648 0 0)) +(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 +inf +inf)) + (v128.const i32x4 2147483647 2147483647 0 0)) +(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 -inf -inf)) + (v128.const i32x4 -2147483648 -2147483648 0 0)) +(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 +nan +nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 -nan -nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 nan:0x444444 nan:0x444444)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 -nan:0x444444 -nan:0x444444)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 42 42)) + (v128.const i32x4 42 42 0 0)) +(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 -42 -42)) + (v128.const i32x4 -42 -42 0 0)) +(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 0123456792.0 0123456792.0)) + (v128.const i32x4 123456792 123456792 0 0)) +(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 01234567890.0 01234567890.0)) + (v128.const i32x4 1234567890 1234567890 0 0)) + +;; i32x4.trunc_sat_f64x2_u_zero +(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 0.0 0.0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 -0.0 -0.0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 1.5 1.5)) + (v128.const i32x4 1 1 0 0)) +(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 -1.5 -1.5)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 1.9 1.9)) + (v128.const i32x4 1 1 0 0)) +(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 2.0 2.0)) + (v128.const i32x4 2 2 0 0)) +(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 -1.9 -1.9)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 -2.0 -2.0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 2147483520.0 2147483520.0)) + (v128.const i32x4 2147483520 2147483520 0 0)) +(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 -2147483520.0 -2147483520.0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 2147483648.0 2147483648.0)) + (v128.const i32x4 2147483648 2147483648 0 0)) +(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 -2147483648.0 -2147483648.0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 4294967294.0 4294967294.0)) + (v128.const i32x4 4294967294 4294967294 0 0)) +(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 -4294967294.0 -4294967294.0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 2147483647.0 2147483647.0)) + (v128.const i32x4 2147483647 2147483647 0 0)) +(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 -2147483647.0 -2147483647.0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 4294967294.0 4294967294.0)) + (v128.const i32x4 4294967294 4294967294 0 0)) +(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 4294967295.0 4294967295.0)) + (v128.const i32x4 4294967295 4294967295 0 0)) +(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 4294967296.0 4294967296.0)) + (v128.const i32x4 4294967295 4294967295 0 0)) +(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 0x1p-149 0x1p-149)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 -0x1p-149 -0x1p-149)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 0x1p-126 0x1p-126)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 -0x1p-126 -0x1p-126)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 0x1p-1 0x1p-1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 -0x1p-1 -0x1p-1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 0x1p+0 0x1p+0)) + (v128.const i32x4 1 1 0 0)) +(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 -0x1p+0 -0x1p+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 0x1.19999ap+0 0x1.19999ap+0)) + (v128.const i32x4 1 1 0 0)) +(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 -0x1.19999ap+0 -0x1.19999ap+0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const i32x4 6 6 0 0)) +(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const i32x4 4294967295 4294967295 0 0)) +(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 0x1.ccccccp-1 0x1.ccccccp-1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 -0x1.ccccccp-1 -0x1.ccccccp-1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 0x1.fffffep-1 0x1.fffffep-1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 -0x1.fffffep-1 -0x1.fffffep-1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 0x1.921fb6p+2 0x1.921fb6p+2)) + (v128.const i32x4 6 6 0 0)) +(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 -0x1.921fb6p+2 -0x1.921fb6p+2)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 0x1.fffffep+127 0x1.fffffep+127)) + (v128.const i32x4 4294967295 4294967295 0 0)) +(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 -0x1.fffffep+127 -0x1.fffffep+127)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 +inf +inf)) + (v128.const i32x4 4294967295 4294967295 0 0)) +(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 -inf -inf)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 +nan +nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 -nan -nan)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 nan:0x444444 nan:0x444444)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 -nan:0x444444 -nan:0x444444)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 42 42)) + (v128.const i32x4 42 42 0 0)) +(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 -42 -42)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 0123456792.0 0123456792.0)) + (v128.const i32x4 123456792 123456792 0 0)) +(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 01234567890.0 01234567890.0)) + (v128.const i32x4 1234567890 1234567890 0 0)) + +;; type check +(assert_invalid (module (func (result v128) (i32x4.trunc_sat_f64x2_s_zero (i32.const 0)))) "type mismatch") +(assert_invalid (module (func (result v128) (i32x4.trunc_sat_f64x2_u_zero (i32.const 0)))) "type mismatch") + +;; Test operation with empty argument + +(assert_invalid + (module + (func $i32x4.trunc_sat_f64x2_s_zero-arg-empty (result v128) + (i32x4.trunc_sat_f64x2_s_zero) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i32x4.trunc_sat_f64x2_u_zero-arg-empty (result v128) + (i32x4.trunc_sat_f64x2_u_zero) + ) + ) + "type mismatch" +) + diff --git a/runtime/near-vm/tests/wast/spec/proposals/simd/simd_i64x2_arith.wast b/runtime/near-vm/tests/wast/spec/proposals/simd/simd_i64x2_arith.wast new file mode 100644 index 00000000000..00963a0d032 --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/proposals/simd/simd_i64x2_arith.wast @@ -0,0 +1,652 @@ +;; Tests for i64x2 arithmetic operations on major boundary values and all special values. + + +(module + (func (export "i64x2.add") (param v128 v128) (result v128) (i64x2.add (local.get 0) (local.get 1))) + (func (export "i64x2.sub") (param v128 v128) (result v128) (i64x2.sub (local.get 0) (local.get 1))) + (func (export "i64x2.mul") (param v128 v128) (result v128) (i64x2.mul (local.get 0) (local.get 1))) + (func (export "i64x2.neg") (param v128) (result v128) (i64x2.neg (local.get 0))) +) + + +;; i64x2.add +(assert_return (invoke "i64x2.add" (v128.const i64x2 0 0) + (v128.const i64x2 0 0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "i64x2.add" (v128.const i64x2 0 0) + (v128.const i64x2 1 1)) + (v128.const i64x2 1 1)) +(assert_return (invoke "i64x2.add" (v128.const i64x2 1 1) + (v128.const i64x2 1 1)) + (v128.const i64x2 2 2)) +(assert_return (invoke "i64x2.add" (v128.const i64x2 0 0) + (v128.const i64x2 -1 -1)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "i64x2.add" (v128.const i64x2 1 1) + (v128.const i64x2 -1 -1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "i64x2.add" (v128.const i64x2 -1 -1) + (v128.const i64x2 -1 -1)) + (v128.const i64x2 -2 -2)) +(assert_return (invoke "i64x2.add" (v128.const i64x2 4611686018427387903 4611686018427387903) + (v128.const i64x2 4611686018427387904 4611686018427387904)) + (v128.const i64x2 9223372036854775807 9223372036854775807)) +(assert_return (invoke "i64x2.add" (v128.const i64x2 4611686018427387904 4611686018427387904) + (v128.const i64x2 4611686018427387904 4611686018427387904)) + (v128.const i64x2 -9223372036854775808 -9223372036854775808)) +(assert_return (invoke "i64x2.add" (v128.const i64x2 -4611686018427387903 -4611686018427387903) + (v128.const i64x2 -4611686018427387904 -4611686018427387904)) + (v128.const i64x2 -9223372036854775807 -9223372036854775807)) +(assert_return (invoke "i64x2.add" (v128.const i64x2 -4611686018427387904 -4611686018427387904) + (v128.const i64x2 -4611686018427387904 -4611686018427387904)) + (v128.const i64x2 -9223372036854775808 -9223372036854775808)) +(assert_return (invoke "i64x2.add" (v128.const i64x2 -4611686018427387905 -4611686018427387905) + (v128.const i64x2 -4611686018427387904 -4611686018427387904)) + (v128.const i64x2 9223372036854775807 9223372036854775807)) +(assert_return (invoke "i64x2.add" (v128.const i64x2 9223372036854775805 9223372036854775805) + (v128.const i64x2 1 1)) + (v128.const i64x2 9223372036854775806 9223372036854775806)) +(assert_return (invoke "i64x2.add" (v128.const i64x2 9223372036854775806 9223372036854775806) + (v128.const i64x2 1 1)) + (v128.const i64x2 9223372036854775807 9223372036854775807)) +(assert_return (invoke "i64x2.add" (v128.const i64x2 9223372036854775808 9223372036854775808) + (v128.const i64x2 1 1)) + (v128.const i64x2 -9223372036854775807 -9223372036854775807)) +(assert_return (invoke "i64x2.add" (v128.const i64x2 -9223372036854775806 -9223372036854775806) + (v128.const i64x2 -1 -1)) + (v128.const i64x2 -9223372036854775807 -9223372036854775807)) +(assert_return (invoke "i64x2.add" (v128.const i64x2 -9223372036854775807 -9223372036854775807) + (v128.const i64x2 -1 -1)) + (v128.const i64x2 -9223372036854775808 -9223372036854775808)) +(assert_return (invoke "i64x2.add" (v128.const i64x2 -9223372036854775808 -9223372036854775808) + (v128.const i64x2 -1 -1)) + (v128.const i64x2 9223372036854775807 9223372036854775807)) +(assert_return (invoke "i64x2.add" (v128.const i64x2 9223372036854775807 9223372036854775807) + (v128.const i64x2 9223372036854775807 9223372036854775807)) + (v128.const i64x2 -2 -2)) +(assert_return (invoke "i64x2.add" (v128.const i64x2 -9223372036854775808 -9223372036854775808) + (v128.const i64x2 -9223372036854775808 -9223372036854775808)) + (v128.const i64x2 0 0)) +(assert_return (invoke "i64x2.add" (v128.const i64x2 -9223372036854775808 -9223372036854775808) + (v128.const i64x2 -9223372036854775807 -9223372036854775807)) + (v128.const i64x2 1 1)) +(assert_return (invoke "i64x2.add" (v128.const i64x2 18446744073709551615 18446744073709551615) + (v128.const i64x2 0 0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "i64x2.add" (v128.const i64x2 18446744073709551615 18446744073709551615) + (v128.const i64x2 1 1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "i64x2.add" (v128.const i64x2 18446744073709551615 18446744073709551615) + (v128.const i64x2 -1 -1)) + (v128.const i64x2 -2 -2)) +(assert_return (invoke "i64x2.add" (v128.const i64x2 18446744073709551615 18446744073709551615) + (v128.const i64x2 9223372036854775807 9223372036854775807)) + (v128.const i64x2 9223372036854775806 9223372036854775806)) +(assert_return (invoke "i64x2.add" (v128.const i64x2 18446744073709551615 18446744073709551615) + (v128.const i64x2 -9223372036854775808 -9223372036854775808)) + (v128.const i64x2 9223372036854775807 9223372036854775807)) +(assert_return (invoke "i64x2.add" (v128.const i64x2 18446744073709551615 18446744073709551615) + (v128.const i64x2 18446744073709551615 18446744073709551615)) + (v128.const i64x2 -2 -2)) +(assert_return (invoke "i64x2.add" (v128.const i64x2 0x3fffffffffffffff 0x3fffffffffffffff) + (v128.const i64x2 0x4000000000000000 0x4000000000000000)) + (v128.const i64x2 9223372036854775807 9223372036854775807)) +(assert_return (invoke "i64x2.add" (v128.const i64x2 0x4000000000000000 0x4000000000000000) + (v128.const i64x2 0x4000000000000000 0x4000000000000000)) + (v128.const i64x2 -9223372036854775808 -9223372036854775808)) +(assert_return (invoke "i64x2.add" (v128.const i64x2 -0x3fffffffffffffff -0x3fffffffffffffff) + (v128.const i64x2 -0x40000000fffffff -0x40000000fffffff)) + (v128.const i64x2 -4899916394847535102 -4899916394847535102)) +(assert_return (invoke "i64x2.add" (v128.const i64x2 -0x4000000000000000 -0x4000000000000000) + (v128.const i64x2 -0x400000000000000 -0x400000000000000)) + (v128.const i64x2 -4899916394579099648 -4899916394579099648)) +(assert_return (invoke "i64x2.add" (v128.const i64x2 -0x4000000000000000 -0x4000000000000000) + (v128.const i64x2 -0x400000000000001 -0x400000000000001)) + (v128.const i64x2 -4899916394579099649 -4899916394579099649)) +(assert_return (invoke "i64x2.add" (v128.const i64x2 0x7fffffffffffffff 0x7fffffffffffffff) + (v128.const i64x2 0x7ffffffffffffff 0x7ffffffffffffff)) + (v128.const i64x2 -8646911284551352322 -8646911284551352322)) +(assert_return (invoke "i64x2.add" (v128.const i64x2 0x7fffffffffffffff 0x7fffffffffffffff) + (v128.const i64x2 0x01 0x01)) + (v128.const i64x2 -9223372036854775808 -9223372036854775808)) +(assert_return (invoke "i64x2.add" (v128.const i64x2 0x8000000000000000 0x8000000000000000) + (v128.const i64x2 -0x01 -0x01)) + (v128.const i64x2 9223372036854775807 9223372036854775807)) +(assert_return (invoke "i64x2.add" (v128.const i64x2 0x7fffffffffffffff 0x7fffffffffffffff) + (v128.const i64x2 0x8000000000000000 0x8000000000000000)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "i64x2.add" (v128.const i64x2 0x8000000000000000 0x8000000000000000) + (v128.const i64x2 0x8000000000000000 0x8000000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "i64x2.add" (v128.const i64x2 0xffffffffffffffff 0xffffffffffffffff) + (v128.const i64x2 0x01 0x01)) + (v128.const i64x2 0 0)) +(assert_return (invoke "i64x2.add" (v128.const i64x2 0xffffffffffffffff 0xffffffffffffffff) + (v128.const i64x2 0xffffffffffffffff 0xffffffffffffffff)) + (v128.const i64x2 -2 -2)) +(assert_return (invoke "i64x2.add" (v128.const i64x2 0x7fffffffffffffff 0x7fffffffffffffff) + (v128.const i8x16 0 0 0 0 0 0 0 0x80 0 0 0 0 0 0 0 0x80)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "i64x2.add" (v128.const i64x2 1 1) + (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)) + (v128.const i64x2 0 0)) +(assert_return (invoke "i64x2.add" (v128.const i64x2 0x7fffffffffffffff 0x7fffffffffffffff) + (v128.const i16x8 0 0 0 0x8000 0 0 0 0x8000)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "i64x2.add" (v128.const i64x2 1 1) + (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff)) + (v128.const i64x2 0 0)) +(assert_return (invoke "i64x2.add" (v128.const i64x2 0x7fffffffffffffff 0x7fffffffffffffff) + (v128.const i32x4 0 0x80000000 0 0x80000000)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "i64x2.add" (v128.const i64x2 1 1) + (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff)) + (v128.const i64x2 0 0)) +(assert_return (invoke "i64x2.add" (v128.const i64x2 0x8000000000000000 0x8000000000000000) + (v128.const f64x2 +0.0 +0.0)) + (v128.const i64x2 0x8000000000000000 0x8000000000000000)) +(assert_return (invoke "i64x2.add" (v128.const i64x2 0x8000000000000000 0x8000000000000000) + (v128.const f64x2 -0.0 -0.0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "i64x2.add" (v128.const i64x2 0x8000000000000000 0x8000000000000000) + (v128.const f64x2 1.0 1.0)) + (v128.const i64x2 0xbff0000000000000 0xbff0000000000000)) +(assert_return (invoke "i64x2.add" (v128.const i64x2 0x8000000000000000 0x8000000000000000) + (v128.const f64x2 -1.0 -1.0)) + (v128.const i64x2 0x3ff0000000000000 0x3ff0000000000000)) +(assert_return (invoke "i64x2.add" (v128.const i64x2 1 1) + (v128.const f64x2 +inf +inf)) + (v128.const i64x2 0x7ff0000000000001 0x7ff0000000000001)) +(assert_return (invoke "i64x2.add" (v128.const i64x2 1 1) + (v128.const f64x2 -inf -inf)) + (v128.const i64x2 0xfff0000000000001 0xfff0000000000001)) +(assert_return (invoke "i64x2.add" (v128.const i64x2 1 1) + (v128.const f64x2 nan nan)) + (v128.const i64x2 0x7ff8000000000001 0x7ff8000000000001)) +(assert_return (invoke "i64x2.add" (v128.const i64x2 0 1) + (v128.const i64x2 0 0xffffffffffffffff)) + (v128.const i64x2 0 0)) +(assert_return (invoke "i64x2.add" (v128.const i64x2 0 1) + (v128.const i64x2 0 2)) + (v128.const i64x2 0 3)) +(assert_return (invoke "i64x2.add" (v128.const i64x2 01_234_567_890_123_456_789 01_234_567_890_123_456_789) + (v128.const i64x2 01_234_567_890_123_456_789 01_234_567_890_123_456_789)) + (v128.const i64x2 02_469_135_780_246_913_578 02_469_135_780_246_913_578)) +(assert_return (invoke "i64x2.add" (v128.const i64x2 0x0_1234_5678_90AB_cdef 0x0_1234_5678_90AB_cdef) + (v128.const i64x2 0x0_90AB_cdef_1234_5678 0x0_90AB_cdef_1234_5678)) + (v128.const i64x2 0x0_a2e0_2467_a2e0_2467 0x0_a2e0_2467_a2e0_2467)) + +;; i64x2.sub +(assert_return (invoke "i64x2.sub" (v128.const i64x2 0 0) + (v128.const i64x2 0 0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "i64x2.sub" (v128.const i64x2 0 0) + (v128.const i64x2 1 1)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "i64x2.sub" (v128.const i64x2 1 1) + (v128.const i64x2 1 1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "i64x2.sub" (v128.const i64x2 0 0) + (v128.const i64x2 -1 -1)) + (v128.const i64x2 1 1)) +(assert_return (invoke "i64x2.sub" (v128.const i64x2 1 1) + (v128.const i64x2 -1 -1)) + (v128.const i64x2 2 2)) +(assert_return (invoke "i64x2.sub" (v128.const i64x2 -1 -1) + (v128.const i64x2 -1 -1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "i64x2.sub" (v128.const i64x2 4611686018427387903 4611686018427387903) + (v128.const i64x2 4611686018427387904 4611686018427387904)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "i64x2.sub" (v128.const i64x2 4611686018427387904 4611686018427387904) + (v128.const i64x2 4611686018427387904 4611686018427387904)) + (v128.const i64x2 0 0)) +(assert_return (invoke "i64x2.sub" (v128.const i64x2 -4611686018427387903 -4611686018427387903) + (v128.const i64x2 -4611686018427387904 -4611686018427387904)) + (v128.const i64x2 1 1)) +(assert_return (invoke "i64x2.sub" (v128.const i64x2 -4611686018427387904 -4611686018427387904) + (v128.const i64x2 -4611686018427387904 -4611686018427387904)) + (v128.const i64x2 0 0)) +(assert_return (invoke "i64x2.sub" (v128.const i64x2 -4611686018427387905 -4611686018427387905) + (v128.const i64x2 -4611686018427387904 -4611686018427387904)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "i64x2.sub" (v128.const i64x2 9223372036854775805 9223372036854775805) + (v128.const i64x2 1 1)) + (v128.const i64x2 9223372036854775804 9223372036854775804)) +(assert_return (invoke "i64x2.sub" (v128.const i64x2 9223372036854775806 9223372036854775806) + (v128.const i64x2 1 1)) + (v128.const i64x2 9223372036854775805 9223372036854775805)) +(assert_return (invoke "i64x2.sub" (v128.const i64x2 9223372036854775808 9223372036854775808) + (v128.const i64x2 1 1)) + (v128.const i64x2 9223372036854775807 9223372036854775807)) +(assert_return (invoke "i64x2.sub" (v128.const i64x2 -9223372036854775806 -9223372036854775806) + (v128.const i64x2 -1 -1)) + (v128.const i64x2 -9223372036854775805 -9223372036854775805)) +(assert_return (invoke "i64x2.sub" (v128.const i64x2 -9223372036854775807 -9223372036854775807) + (v128.const i64x2 -1 -1)) + (v128.const i64x2 -9223372036854775806 -9223372036854775806)) +(assert_return (invoke "i64x2.sub" (v128.const i64x2 -9223372036854775808 -9223372036854775808) + (v128.const i64x2 -1 -1)) + (v128.const i64x2 -9223372036854775807 -9223372036854775807)) +(assert_return (invoke "i64x2.sub" (v128.const i64x2 9223372036854775807 9223372036854775807) + (v128.const i64x2 9223372036854775807 9223372036854775807)) + (v128.const i64x2 0 0)) +(assert_return (invoke "i64x2.sub" (v128.const i64x2 -9223372036854775808 -9223372036854775808) + (v128.const i64x2 -9223372036854775808 -9223372036854775808)) + (v128.const i64x2 0 0)) +(assert_return (invoke "i64x2.sub" (v128.const i64x2 -9223372036854775808 -9223372036854775808) + (v128.const i64x2 -9223372036854775807 -9223372036854775807)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "i64x2.sub" (v128.const i64x2 18446744073709551615 18446744073709551615) + (v128.const i64x2 0 0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "i64x2.sub" (v128.const i64x2 18446744073709551615 18446744073709551615) + (v128.const i64x2 1 1)) + (v128.const i64x2 -2 -2)) +(assert_return (invoke "i64x2.sub" (v128.const i64x2 18446744073709551615 18446744073709551615) + (v128.const i64x2 -1 -1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "i64x2.sub" (v128.const i64x2 18446744073709551615 18446744073709551615) + (v128.const i64x2 9223372036854775807 9223372036854775807)) + (v128.const i64x2 -9223372036854775808 -9223372036854775808)) +(assert_return (invoke "i64x2.sub" (v128.const i64x2 18446744073709551615 18446744073709551615) + (v128.const i64x2 -9223372036854775808 -9223372036854775808)) + (v128.const i64x2 9223372036854775807 9223372036854775807)) +(assert_return (invoke "i64x2.sub" (v128.const i64x2 18446744073709551615 18446744073709551615) + (v128.const i64x2 18446744073709551615 18446744073709551615)) + (v128.const i64x2 0 0)) +(assert_return (invoke "i64x2.sub" (v128.const i64x2 0x3fffffffffffffff 0x3fffffffffffffff) + (v128.const i64x2 0x4000000000000000 0x4000000000000000)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "i64x2.sub" (v128.const i64x2 0x4000000000000000 0x4000000000000000) + (v128.const i64x2 0x4000000000000000 0x4000000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "i64x2.sub" (v128.const i64x2 -0x3fffffffffffffff -0x3fffffffffffffff) + (v128.const i64x2 -0x40000000fffffff -0x40000000fffffff)) + (v128.const i64x2 -4323455642007240704 -4323455642007240704)) +(assert_return (invoke "i64x2.sub" (v128.const i64x2 -0x4000000000000000 -0x4000000000000000) + (v128.const i64x2 -0x400000000000000 -0x400000000000000)) + (v128.const i64x2 -4323455642275676160 -4323455642275676160)) +(assert_return (invoke "i64x2.sub" (v128.const i64x2 -0x4000000000000000 -0x4000000000000000) + (v128.const i64x2 -0x400000000000001 -0x400000000000001)) + (v128.const i64x2 -4323455642275676159 -4323455642275676159)) +(assert_return (invoke "i64x2.sub" (v128.const i64x2 0x7fffffffffffffff 0x7fffffffffffffff) + (v128.const i64x2 0x7ffffffffffffff 0x7ffffffffffffff)) + (v128.const i64x2 8646911284551352320 8646911284551352320)) +(assert_return (invoke "i64x2.sub" (v128.const i64x2 0x7fffffffffffffff 0x7fffffffffffffff) + (v128.const i64x2 0x01 0x01)) + (v128.const i64x2 9223372036854775806 9223372036854775806)) +(assert_return (invoke "i64x2.sub" (v128.const i64x2 0x8000000000000000 0x8000000000000000) + (v128.const i64x2 -0x01 -0x01)) + (v128.const i64x2 -9223372036854775807 -9223372036854775807)) +(assert_return (invoke "i64x2.sub" (v128.const i64x2 0x7fffffffffffffff 0x7fffffffffffffff) + (v128.const i64x2 0x8000000000000000 0x8000000000000000)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "i64x2.sub" (v128.const i64x2 0x8000000000000000 0x8000000000000000) + (v128.const i64x2 0x8000000000000000 0x8000000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "i64x2.sub" (v128.const i64x2 0xffffffffffffffff 0xffffffffffffffff) + (v128.const i64x2 0x01 0x01)) + (v128.const i64x2 -2 -2)) +(assert_return (invoke "i64x2.sub" (v128.const i64x2 0xffffffffffffffff 0xffffffffffffffff) + (v128.const i64x2 0xffffffffffffffff 0xffffffffffffffff)) + (v128.const i64x2 0 0)) +(assert_return (invoke "i64x2.sub" (v128.const i64x2 0x7fffffffffffffff 0x7fffffffffffffff) + (v128.const i8x16 0 0 0 0 0 0 0 0x80 0 0 0 0 0 0 0 0x80)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "i64x2.sub" (v128.const i64x2 1 1) + (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)) + (v128.const i64x2 2 2)) +(assert_return (invoke "i64x2.sub" (v128.const i64x2 0x7fffffffffffffff 0x7fffffffffffffff) + (v128.const i16x8 0 0 0 0x8000 0 0 0 0x8000)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "i64x2.sub" (v128.const i64x2 1 1) + (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff)) + (v128.const i64x2 2 2)) +(assert_return (invoke "i64x2.sub" (v128.const i64x2 0x7fffffffffffffff 0x7fffffffffffffff) + (v128.const i32x4 0 0x80000000 0 0x80000000)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "i64x2.sub" (v128.const i64x2 1 1) + (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff)) + (v128.const i64x2 2 2)) +(assert_return (invoke "i64x2.sub" (v128.const i64x2 0x8000000000000000 0x8000000000000000) + (v128.const f64x2 +0.0 +0.0)) + (v128.const i64x2 0x8000000000000000 0x8000000000000000)) +(assert_return (invoke "i64x2.sub" (v128.const i64x2 0x8000000000000000 0x8000000000000000) + (v128.const f64x2 -0.0 -0.0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "i64x2.sub" (v128.const i64x2 0x8000000000000000 0x8000000000000000) + (v128.const f64x2 1.0 1.0)) + (v128.const i64x2 0x4010000000000000 0x4010000000000000)) +(assert_return (invoke "i64x2.sub" (v128.const i64x2 0x8000000000000000 0x8000000000000000) + (v128.const f64x2 -1.0 -1.0)) + (v128.const i64x2 0xc010000000000000 0xc010000000000000)) +(assert_return (invoke "i64x2.sub" (v128.const i64x2 0x1 0x1) + (v128.const f64x2 +inf +inf)) + (v128.const i64x2 0x8010000000000001 0x8010000000000001)) +(assert_return (invoke "i64x2.sub" (v128.const i64x2 0x1 0x1) + (v128.const f64x2 -inf -inf)) + (v128.const i64x2 0x0010000000000001 0x0010000000000001)) +(assert_return (invoke "i64x2.sub" (v128.const i64x2 0x1 0x1) + (v128.const f64x2 nan nan)) + (v128.const i64x2 0x8008000000000001 0x8008000000000001)) +(assert_return (invoke "i64x2.sub" (v128.const i64x2 0 1) + (v128.const i64x2 0 0xffffffffffffffff)) + (v128.const i64x2 0 0x02)) +(assert_return (invoke "i64x2.sub" (v128.const i64x2 0 1) + (v128.const i64x2 0 2)) + (v128.const i64x2 0 -1)) +(assert_return (invoke "i64x2.sub" (v128.const i64x2 03_214_567_890_123_456_789 03_214_567_890_123_456_789) + (v128.const i64x2 01_234_567_890_123_456_789 01_234_567_890_123_456_789)) + (v128.const i64x2 01_980_000_000_000_000_000 01_980_000_000_000_000_000)) +(assert_return (invoke "i64x2.sub" (v128.const i64x2 0x0_90AB_cdef_8765_4321 0x0_90AB_cdef_8765_4321) + (v128.const i64x2 0x0_1234_5678_90AB_cdef 0x0_1234_5678_90AB_cdef)) + (v128.const i64x2 0x0_7e77_7776_f6b9_7532 0x0_7e77_7776_f6b9_7532)) + +;; i64x2.mul +(assert_return (invoke "i64x2.mul" (v128.const i64x2 0 0) + (v128.const i64x2 0 0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "i64x2.mul" (v128.const i64x2 0 0) + (v128.const i64x2 1 1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "i64x2.mul" (v128.const i64x2 1 1) + (v128.const i64x2 1 1)) + (v128.const i64x2 1 1)) +(assert_return (invoke "i64x2.mul" (v128.const i64x2 0 0) + (v128.const i64x2 -1 -1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "i64x2.mul" (v128.const i64x2 1 1) + (v128.const i64x2 -1 -1)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "i64x2.mul" (v128.const i64x2 -1 -1) + (v128.const i64x2 -1 -1)) + (v128.const i64x2 1 1)) +(assert_return (invoke "i64x2.mul" (v128.const i64x2 4611686018427387903 4611686018427387903) + (v128.const i64x2 4611686018427387904 4611686018427387904)) + (v128.const i64x2 -4611686018427387904 -4611686018427387904)) +(assert_return (invoke "i64x2.mul" (v128.const i64x2 4611686018427387904 4611686018427387904) + (v128.const i64x2 4611686018427387904 4611686018427387904)) + (v128.const i64x2 0 0)) +(assert_return (invoke "i64x2.mul" (v128.const i64x2 -4611686018427387903 -4611686018427387903) + (v128.const i64x2 -4611686018427387904 -4611686018427387904)) + (v128.const i64x2 -4611686018427387904 -4611686018427387904)) +(assert_return (invoke "i64x2.mul" (v128.const i64x2 -4611686018427387904 -4611686018427387904) + (v128.const i64x2 -4611686018427387904 -4611686018427387904)) + (v128.const i64x2 0 0)) +(assert_return (invoke "i64x2.mul" (v128.const i64x2 -4611686018427387905 -4611686018427387905) + (v128.const i64x2 -4611686018427387904 -4611686018427387904)) + (v128.const i64x2 4611686018427387904 4611686018427387904)) +(assert_return (invoke "i64x2.mul" (v128.const i64x2 9223372036854775805 9223372036854775805) + (v128.const i64x2 1 1)) + (v128.const i64x2 9223372036854775805 9223372036854775805)) +(assert_return (invoke "i64x2.mul" (v128.const i64x2 9223372036854775806 9223372036854775806) + (v128.const i64x2 1 1)) + (v128.const i64x2 9223372036854775806 9223372036854775806)) +(assert_return (invoke "i64x2.mul" (v128.const i64x2 9223372036854775808 9223372036854775808) + (v128.const i64x2 1 1)) + (v128.const i64x2 -9223372036854775808 -9223372036854775808)) +(assert_return (invoke "i64x2.mul" (v128.const i64x2 -9223372036854775806 -9223372036854775806) + (v128.const i64x2 -1 -1)) + (v128.const i64x2 9223372036854775806 9223372036854775806)) +(assert_return (invoke "i64x2.mul" (v128.const i64x2 -9223372036854775807 -9223372036854775807) + (v128.const i64x2 -1 -1)) + (v128.const i64x2 9223372036854775807 9223372036854775807)) +(assert_return (invoke "i64x2.mul" (v128.const i64x2 -9223372036854775808 -9223372036854775808) + (v128.const i64x2 -1 -1)) + (v128.const i64x2 -9223372036854775808 -9223372036854775808)) +(assert_return (invoke "i64x2.mul" (v128.const i64x2 9223372036854775807 9223372036854775807) + (v128.const i64x2 9223372036854775807 9223372036854775807)) + (v128.const i64x2 1 1)) +(assert_return (invoke "i64x2.mul" (v128.const i64x2 -9223372036854775808 -9223372036854775808) + (v128.const i64x2 -9223372036854775808 -9223372036854775808)) + (v128.const i64x2 0 0)) +(assert_return (invoke "i64x2.mul" (v128.const i64x2 -9223372036854775808 -9223372036854775808) + (v128.const i64x2 -9223372036854775807 -9223372036854775807)) + (v128.const i64x2 -9223372036854775808 -9223372036854775808)) +(assert_return (invoke "i64x2.mul" (v128.const i64x2 18446744073709551615 18446744073709551615) + (v128.const i64x2 0 0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "i64x2.mul" (v128.const i64x2 18446744073709551615 18446744073709551615) + (v128.const i64x2 1 1)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "i64x2.mul" (v128.const i64x2 18446744073709551615 18446744073709551615) + (v128.const i64x2 -1 -1)) + (v128.const i64x2 1 1)) +(assert_return (invoke "i64x2.mul" (v128.const i64x2 18446744073709551615 18446744073709551615) + (v128.const i64x2 9223372036854775807 9223372036854775807)) + (v128.const i64x2 -9223372036854775807 -9223372036854775807)) +(assert_return (invoke "i64x2.mul" (v128.const i64x2 18446744073709551615 18446744073709551615) + (v128.const i64x2 -9223372036854775808 -9223372036854775808)) + (v128.const i64x2 -9223372036854775808 -9223372036854775808)) +(assert_return (invoke "i64x2.mul" (v128.const i64x2 18446744073709551615 18446744073709551615) + (v128.const i64x2 18446744073709551615 18446744073709551615)) + (v128.const i64x2 1 1)) +(assert_return (invoke "i64x2.mul" (v128.const i64x2 0x3fffffffffffffff 0x3fffffffffffffff) + (v128.const i64x2 0x4000000000000000 0x4000000000000000)) + (v128.const i64x2 -4611686018427387904 -4611686018427387904)) +(assert_return (invoke "i64x2.mul" (v128.const i64x2 0x4000000000000000 0x4000000000000000) + (v128.const i64x2 0x4000000000000000 0x4000000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "i64x2.mul" (v128.const i64x2 -0x3fffffffffffffff -0x3fffffffffffffff) + (v128.const i64x2 -0x40000000fffffff -0x40000000fffffff)) + (v128.const i64x2 -4899916394847535103 -4899916394847535103)) +(assert_return (invoke "i64x2.mul" (v128.const i64x2 -0x4000000000000000 -0x4000000000000000) + (v128.const i64x2 -0x400000000000000 -0x400000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "i64x2.mul" (v128.const i64x2 -0x4000000000000000 -0x4000000000000000) + (v128.const i64x2 -0x400000000000001 -0x400000000000001)) + (v128.const i64x2 4611686018427387904 4611686018427387904)) +(assert_return (invoke "i64x2.mul" (v128.const i64x2 0x7fffffffffffffff 0x7fffffffffffffff) + (v128.const i64x2 0x7ffffffffffffff 0x7ffffffffffffff)) + (v128.const i64x2 8646911284551352321 8646911284551352321)) +(assert_return (invoke "i64x2.mul" (v128.const i64x2 0x7fffffffffffffff 0x7fffffffffffffff) + (v128.const i64x2 0x01 0x01)) + (v128.const i64x2 9223372036854775807 9223372036854775807)) +(assert_return (invoke "i64x2.mul" (v128.const i64x2 0x8000000000000000 0x8000000000000000) + (v128.const i64x2 -0x01 -0x01)) + (v128.const i64x2 -9223372036854775808 -9223372036854775808)) +(assert_return (invoke "i64x2.mul" (v128.const i64x2 0x7fffffffffffffff 0x7fffffffffffffff) + (v128.const i64x2 0x8000000000000000 0x8000000000000000)) + (v128.const i64x2 -9223372036854775808 -9223372036854775808)) +(assert_return (invoke "i64x2.mul" (v128.const i64x2 0x8000000000000000 0x8000000000000000) + (v128.const i64x2 0x8000000000000000 0x8000000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "i64x2.mul" (v128.const i64x2 0xffffffffffffffff 0xffffffffffffffff) + (v128.const i64x2 0x01 0x01)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "i64x2.mul" (v128.const i64x2 0xffffffffffffffff 0xffffffffffffffff) + (v128.const i64x2 0xffffffffffffffff 0xffffffffffffffff)) + (v128.const i64x2 1 1)) +(assert_return (invoke "i64x2.mul" (v128.const i64x2 0x8000000000000000 0x8000000000000000) + (v128.const i8x16 0x2 0x2 0x2 0x2 0x2 0x2 0x2 0x2 0x2 0x2 0x2 0x2 0x2 0x2 0x2 0x2)) + (v128.const i64x2 0 0)) +(assert_return (invoke "i64x2.mul" (v128.const i64x2 0xffffffffffffffff 0xffffffffffffffff) + (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)) + (v128.const i64x2 1 1)) +(assert_return (invoke "i64x2.mul" (v128.const i64x2 0x8000000000000000 0x8000000000000000) + (v128.const i16x8 0 0 0 0x02 0 0 0 0x02)) + (v128.const i64x2 0 0)) +(assert_return (invoke "i64x2.mul" (v128.const i64x2 0xffffffffffffffff 0xffffffffffffffff) + (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff)) + (v128.const i64x2 1 1)) +(assert_return (invoke "i64x2.mul" (v128.const i64x2 0x8000000000000000 0x8000000000000000) + (v128.const i32x4 0 0x02 0 0x02)) + (v128.const i64x2 0 0)) +(assert_return (invoke "i64x2.mul" (v128.const i64x2 0xffffffffffffffff 0xffffffffffffffff) + (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff)) + (v128.const i64x2 1 1)) +(assert_return (invoke "i64x2.mul" (v128.const i64x2 0x80000000 0x80000000) + (v128.const f64x2 +0.0 +0.0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "i64x2.mul" (v128.const i64x2 0x80000000 0x80000000) + (v128.const f64x2 -0.0 -0.0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "i64x2.mul" (v128.const i64x2 0x80000000 0x80000000) + (v128.const f64x2 1.0 1.0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "i64x2.mul" (v128.const i64x2 0x80000000 0x80000000) + (v128.const f64x2 -1.0 -1.0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "i64x2.mul" (v128.const i64x2 0x1 0x1) + (v128.const f64x2 +inf +inf)) + (v128.const i64x2 0x7ff0000000000000 0x7ff0000000000000)) +(assert_return (invoke "i64x2.mul" (v128.const i64x2 0x1 0x1) + (v128.const f64x2 -inf -inf)) + (v128.const i64x2 0xfff0000000000000 0xfff0000000000000)) +(assert_return (invoke "i64x2.mul" (v128.const i64x2 0x1 0x1) + (v128.const f64x2 nan nan)) + (v128.const i64x2 0x7ff8000000000000 0x7ff8000000000000)) +(assert_return (invoke "i64x2.mul" (v128.const i64x2 0 1) + (v128.const i64x2 0 0xffffffffffffffff)) + (v128.const i64x2 0 0xffffffffffffffff)) +(assert_return (invoke "i64x2.mul" (v128.const i64x2 0 1) + (v128.const i64x2 0 2)) + (v128.const i64x2 0 0x02)) +(assert_return (invoke "i64x2.mul" (v128.const i64x2 01_234_567_890_123_456_789 01_234_567_890_123_456_789) + (v128.const i64x2 01_234_567_890_123_456_789 01_234_567_890_123_456_789)) + (v128.const i64x2 09_710_478_858_155_731_897 09_710_478_858_155_731_897)) +(assert_return (invoke "i64x2.mul" (v128.const i64x2 0x0_1234_5678_90AB_cdef 0x0_1234_5678_90AB_cdef) + (v128.const i64x2 0x0_90AB_cdef_8765_4321 0x0_90AB_cdef_8765_4321)) + (v128.const i64x2 0x0_602f_05e9_e556_18cf 0x0_602f_05e9_e556_18cf)) + +;; i64x2.neg +(assert_return (invoke "i64x2.neg" (v128.const i64x2 0 0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "i64x2.neg" (v128.const i64x2 1 1)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "i64x2.neg" (v128.const i64x2 -1 -1)) + (v128.const i64x2 1 1)) +(assert_return (invoke "i64x2.neg" (v128.const i64x2 9223372036854775806 9223372036854775806)) + (v128.const i64x2 -9223372036854775806 -9223372036854775806)) +(assert_return (invoke "i64x2.neg" (v128.const i64x2 -9223372036854775807 -9223372036854775807)) + (v128.const i64x2 9223372036854775807 9223372036854775807)) +(assert_return (invoke "i64x2.neg" (v128.const i64x2 -9223372036854775808 -9223372036854775808)) + (v128.const i64x2 -9223372036854775808 -9223372036854775808)) +(assert_return (invoke "i64x2.neg" (v128.const i64x2 9223372036854775807 9223372036854775807)) + (v128.const i64x2 -9223372036854775807 -9223372036854775807)) +(assert_return (invoke "i64x2.neg" (v128.const i64x2 18446744073709551615 18446744073709551615)) + (v128.const i64x2 1 1)) +(assert_return (invoke "i64x2.neg" (v128.const i64x2 0x01 0x01)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "i64x2.neg" (v128.const i64x2 -0x01 -0x01)) + (v128.const i64x2 1 1)) +(assert_return (invoke "i64x2.neg" (v128.const i64x2 -0x8000000000000000 -0x8000000000000000)) + (v128.const i64x2 -9223372036854775808 -9223372036854775808)) +(assert_return (invoke "i64x2.neg" (v128.const i64x2 -0x7fffffffffffffff -0x7fffffffffffffff)) + (v128.const i64x2 9223372036854775807 9223372036854775807)) +(assert_return (invoke "i64x2.neg" (v128.const i64x2 0x7fffffffffffffff 0x7fffffffffffffff)) + (v128.const i64x2 -9223372036854775807 -9223372036854775807)) +(assert_return (invoke "i64x2.neg" (v128.const i64x2 0x8000000000000000 0x8000000000000000)) + (v128.const i64x2 -9223372036854775808 -9223372036854775808)) +(assert_return (invoke "i64x2.neg" (v128.const i64x2 0xffffffffffffffff 0xffffffffffffffff)) + (v128.const i64x2 1 1)) + +;; type check +(assert_invalid (module (func (result v128) (i64x2.neg (i32.const 0)))) "type mismatch") +(assert_invalid (module (func (result v128) (i64x2.add (i32.const 0) (f32.const 0.0)))) "type mismatch") +(assert_invalid (module (func (result v128) (i64x2.sub (i32.const 0) (f32.const 0.0)))) "type mismatch") +(assert_invalid (module (func (result v128) (i64x2.mul (i32.const 0) (f32.const 0.0)))) "type mismatch") + +;; Test operation with empty argument + +(assert_invalid + (module + (func $i64x2.neg-arg-empty (result v128) + (i64x2.neg) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i64x2.add-1st-arg-empty (result v128) + (i64x2.add (v128.const i64x2 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i64x2.add-arg-empty (result v128) + (i64x2.add) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i64x2.sub-1st-arg-empty (result v128) + (i64x2.sub (v128.const i64x2 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i64x2.sub-arg-empty (result v128) + (i64x2.sub) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i64x2.mul-1st-arg-empty (result v128) + (i64x2.mul (v128.const i64x2 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i64x2.mul-arg-empty (result v128) + (i64x2.mul) + ) + ) + "type mismatch" +) + +;; combination +(module + (func (export "add-sub") (param v128 v128 v128) (result v128) + (i64x2.add (i64x2.sub (local.get 0) (local.get 1))(local.get 2))) + (func (export "mul-add") (param v128 v128 v128) (result v128) + (i64x2.mul (i64x2.add (local.get 0) (local.get 1))(local.get 2))) + (func (export "mul-sub") (param v128 v128 v128) (result v128) + (i64x2.mul (i64x2.sub (local.get 0) (local.get 1))(local.get 2))) + (func (export "sub-add") (param v128 v128 v128) (result v128) + (i64x2.sub (i64x2.add (local.get 0) (local.get 1))(local.get 2))) + (func (export "add-neg") (param v128 v128) (result v128) + (i64x2.add (i64x2.neg (local.get 0)) (local.get 1))) + (func (export "mul-neg") (param v128 v128) (result v128) + (i64x2.mul (i64x2.neg (local.get 0)) (local.get 1))) + (func (export "sub-neg") (param v128 v128) (result v128) + (i64x2.sub (i64x2.neg (local.get 0)) (local.get 1))) +) + +(assert_return (invoke "add-sub" (v128.const i64x2 0 1) + (v128.const i64x2 0 2) + (v128.const i64x2 0 2)) + (v128.const i64x2 0 1)) +(assert_return (invoke "mul-add" (v128.const i64x2 0 1) + (v128.const i64x2 0 1) + (v128.const i64x2 2 2)) + (v128.const i64x2 0 4)) +(assert_return (invoke "mul-sub" (v128.const i64x2 0 2) + (v128.const i64x2 0 1) + (v128.const i64x2 0 1)) + (v128.const i64x2 0 1)) +(assert_return (invoke "sub-add" (v128.const i64x2 0 1) + (v128.const i64x2 0 2) + (v128.const i64x2 0 2)) + (v128.const i64x2 0 1)) +(assert_return (invoke "add-neg" (v128.const i64x2 0 1) + (v128.const i64x2 0 1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "mul-neg" (v128.const i64x2 0 1) + (v128.const i64x2 2 2)) + (v128.const i64x2 0 -2)) +(assert_return (invoke "sub-neg" (v128.const i64x2 0 1) + (v128.const i64x2 0 1)) + (v128.const i64x2 0 -2)) \ No newline at end of file diff --git a/runtime/near-vm/tests/wast/spec/proposals/simd/simd_i64x2_arith2.wast b/runtime/near-vm/tests/wast/spec/proposals/simd/simd_i64x2_arith2.wast new file mode 100644 index 00000000000..14398d8a46a --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/proposals/simd/simd_i64x2_arith2.wast @@ -0,0 +1,78 @@ +;; Tests for i64x2 [abs] operations. + +(module + (func (export "i64x2.abs") (param v128) (result v128) (i64x2.abs (local.get 0))) + (func (export "i64x2.abs_with_const_0") (result v128) (i64x2.abs (v128.const i64x2 -9223372036854775808 9223372036854775807))) +) + +(assert_return (invoke "i64x2.abs" (v128.const i64x2 1 1)) + (v128.const i64x2 1 1)) +(assert_return (invoke "i64x2.abs" (v128.const i64x2 -1 -1)) + (v128.const i64x2 1 1)) +(assert_return (invoke "i64x2.abs" (v128.const i64x2 18446744073709551615 18446744073709551615)) + (v128.const i64x2 1 1)) +(assert_return (invoke "i64x2.abs" (v128.const i64x2 0xffffffffffffffff 0xffffffffffffffff)) + (v128.const i64x2 0x1 0x1)) +(assert_return (invoke "i64x2.abs" (v128.const i64x2 9223372036854775808 9223372036854775808)) + (v128.const i64x2 9223372036854775808 9223372036854775808)) +(assert_return (invoke "i64x2.abs" (v128.const i64x2 -9223372036854775808 -9223372036854775808)) + (v128.const i64x2 9223372036854775808 9223372036854775808)) +(assert_return (invoke "i64x2.abs" (v128.const i64x2 -0x8000000000000000 -0x8000000000000000)) + (v128.const i64x2 0x8000000000000000 0x8000000000000000)) +(assert_return (invoke "i64x2.abs" (v128.const i64x2 0x8000000000000000 0x8000000000000000)) + (v128.const i64x2 0x8000000000000000 0x8000000000000000)) +(assert_return (invoke "i64x2.abs" (v128.const i64x2 01_2_3 01_2_3)) + (v128.const i64x2 01_2_3 01_2_3)) +(assert_return (invoke "i64x2.abs" (v128.const i64x2 -01_2_3 -01_2_3)) + (v128.const i64x2 123 123)) +(assert_return (invoke "i64x2.abs" (v128.const i64x2 0x80 0x80)) + (v128.const i64x2 0x80 0x80)) +(assert_return (invoke "i64x2.abs" (v128.const i64x2 -0x80 -0x80)) + (v128.const i64x2 0x80 0x80)) +(assert_return (invoke "i64x2.abs" (v128.const i64x2 0x0_8_0 0x0_8_0)) + (v128.const i64x2 0x0_8_0 0x0_8_0)) +(assert_return (invoke "i64x2.abs" (v128.const i64x2 -0x0_8_0 -0x0_8_0)) + (v128.const i64x2 0x80 0x80)) + +;; Const vs const +(assert_return (invoke "i64x2.abs_with_const_0") (v128.const i64x2 9223372036854775808 9223372036854775807)) + +;; Param vs const + +;; Test different lanes go through different if-then clauses +(assert_return (invoke "i64x2.abs" (v128.const i64x2 -9223372036854775808 9223372036854775807)) + (v128.const i64x2 9223372036854775808 9223372036854775807)) + +;; Test opposite signs of zero +(assert_return (invoke "i64x2.abs" (v128.const i64x2 -0 -0)) + (v128.const i64x2 -0 -0)) +(assert_return (invoke "i64x2.abs" (v128.const i64x2 +0 0)) + (v128.const i64x2 +0 0)) +(assert_return (invoke "i64x2.abs" (v128.const i64x2 -0 -0)) + (v128.const i64x2 -0 -0)) +(assert_return (invoke "i64x2.abs" (v128.const i64x2 +0 +0)) + (v128.const i64x2 +0 +0)) + +;; Unknown operators + +;; Type check +(assert_invalid (module (func (result v128) (i64x2.abs (f32.const 0.0)))) "type mismatch") + +;; Test operation with empty argument + +(assert_invalid + (module + (func $i64x2.abs-arg-empty (result v128) + (i64x2.abs) + ) + ) + "type mismatch" +) + +;; Combination +(module + (func (export "i64x2.abs-i64x2.abs") (param v128) (result v128) (i64x2.abs (i64x2.abs (local.get 0)))) +) + +(assert_return (invoke "i64x2.abs-i64x2.abs" (v128.const i64x2 -1 -1)) + (v128.const i64x2 1 1)) diff --git a/runtime/near-vm/tests/wast/spec/proposals/simd/simd_i64x2_cmp.wast b/runtime/near-vm/tests/wast/spec/proposals/simd/simd_i64x2_cmp.wast new file mode 100644 index 00000000000..50e58b64b11 --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/proposals/simd/simd_i64x2_cmp.wast @@ -0,0 +1,420 @@ + +;; Test all the i64x2 comparison operators on major boundary values and all special values. + +(module + (func (export "eq") (param $x v128) (param $y v128) (result v128) (i64x2.eq (local.get $x) (local.get $y))) + (func (export "ne") (param $x v128) (param $y v128) (result v128) (i64x2.ne (local.get $x) (local.get $y))) + (func (export "lt_s") (param $x v128) (param $y v128) (result v128) (i64x2.lt_s (local.get $x) (local.get $y))) + (func (export "le_s") (param $x v128) (param $y v128) (result v128) (i64x2.le_s (local.get $x) (local.get $y))) + (func (export "gt_s") (param $x v128) (param $y v128) (result v128) (i64x2.gt_s (local.get $x) (local.get $y))) + (func (export "ge_s") (param $x v128) (param $y v128) (result v128) (i64x2.ge_s (local.get $x) (local.get $y))) +) + + +;; eq + +;; i64x2.eq (i64x2) (i64x2) +(assert_return (invoke "eq" (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0xFFFFFFFFFFFFFFFF) + (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0xFFFFFFFFFFFFFFFF)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "eq" (v128.const i64x2 0x0000000000000000 0x0000000000000000) + (v128.const i64x2 0x0000000000000000 0x0000000000000000)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "eq" (v128.const i64x2 0xF0F0F0F0F0F0F0F0 0xF0F0F0F0F0F0F0F0) + (v128.const i64x2 0xF0F0F0F0F0F0F0F0 0xF0F0F0F0F0F0F0F0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "eq" (v128.const i64x2 0x0F0F0F0F0F0F0F0F 0x0F0F0F0F0F0F0F0F) + (v128.const i64x2 0x0F0F0F0F0F0F0F0F 0x0F0F0F0F0F0F0F0F)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "eq" (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0x0000000000000000) + (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0x0000000000000000)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "eq" (v128.const i64x2 0x0000000000000000 0xFFFFFFFFFFFFFFFF) + (v128.const i64x2 0x0000000000000000 0xFFFFFFFFFFFFFFFF)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "eq" (v128.const i64x2 0x03020100 0x11100904) + (v128.const i64x2 0x03020100 0x11100904)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "eq" (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0xFFFFFFFFFFFFFFFF) + (v128.const i64x2 0x0FFFFFFFFFFFFFFF 0x0FFFFFFFFFFFFFFF)) + (v128.const i64x2 0 0)) +(assert_return (invoke "eq" (v128.const i64x2 0x1 0x1) + (v128.const i64x2 0x2 0x2)) + (v128.const i64x2 0 0)) + +;; ne + +;; i64x2.ne (i64x2) (i64x2) + +;; hex vs hex +(assert_return (invoke "ne" (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0xFFFFFFFFFFFFFFFF) + (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0xFFFFFFFFFFFFFFFF)) + (v128.const i64x2 0 0)) +(assert_return (invoke "ne" (v128.const i64x2 0x0000000000000000 0x0000000000000000) + (v128.const i64x2 0x0000000000000000 0x0000000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "ne" (v128.const i64x2 0xF0F0F0F0F0F0F0F0 0xF0F0F0F0F0F0F0F0) + (v128.const i64x2 0xF0F0F0F0F0F0F0F0 0xF0F0F0F0F0F0F0F0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "ne" (v128.const i64x2 0x0F0F0F0F0F0F0F0F 0x0F0F0F0F0F0F0F0F) + (v128.const i64x2 0x0F0F0F0F0F0F0F0F 0x0F0F0F0F0F0F0F0F)) + (v128.const i64x2 0 0)) +(assert_return (invoke "ne" (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0x0000000000000000) + (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0x0000000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "ne" (v128.const i64x2 0x0000000000000000 0xFFFFFFFFFFFFFFFF) + (v128.const i64x2 0x0000000000000000 0xFFFFFFFFFFFFFFFF)) + (v128.const i64x2 0 0)) +(assert_return (invoke "ne" (v128.const i64x2 0x03020100 0x11100904) + (v128.const i64x2 0x03020100 0x11100904)) + (v128.const i64x2 0 0)) + +;; lt_s + +;; i64x2.lt_s (i64x2) (i64x2) + +;; hex vs hex +(assert_return (invoke "lt_s" (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0xFFFFFFFFFFFFFFFF) + (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0xFFFFFFFFFFFFFFFF)) + (v128.const i64x2 0 0)) +(assert_return (invoke "lt_s" (v128.const i64x2 0x0000000000000000 0x0000000000000000) + (v128.const i64x2 0x0000000000000000 0x0000000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "lt_s" (v128.const i64x2 0xF0F0F0F0F0F0F0F0 0xF0F0F0F0F0F0F0F0) + (v128.const i64x2 0xF0F0F0F0F0F0F0F0 0xF0F0F0F0F0F0F0F0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "lt_s" (v128.const i64x2 0x0F0F0F0F0F0F0F0F 0x0F0F0F0F0F0F0F0F) + (v128.const i64x2 0x0F0F0F0F0F0F0F0F 0x0F0F0F0F0F0F0F0F)) + (v128.const i64x2 0 0)) +(assert_return (invoke "lt_s" (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0x0000000000000000) + (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0x0000000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "lt_s" (v128.const i64x2 0x0000000000000000 0xFFFFFFFFFFFFFFFF) + (v128.const i64x2 0x0000000000000000 0xFFFFFFFFFFFFFFFF)) + (v128.const i64x2 0 0)) +(assert_return (invoke "lt_s" (v128.const i64x2 0x0302010011100904 0x1A0B0A12FFABAA1B) + (v128.const i64x2 0x0302010011100904 0x1A0B0A12FFABAA1B)) + (v128.const i64x2 0 0)) + +;; hex vs dec +(assert_return (invoke "lt_s" (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0xFFFFFFFFFFFFFFFF) + (v128.const i64x2 18446744073709551615 18446744073709551615)) + (v128.const i64x2 0 0)) +(assert_return (invoke "lt_s" (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0xFFFFFFFFFFFFFFFF) + (v128.const i64x2 -1 -1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "lt_s" (v128.const i64x2 0x8080808080808080 0x8080808080808080) + (v128.const i64x2 9259542123273814144 9259542123273814144)) + (v128.const i64x2 0 0)) +(assert_return (invoke "lt_s" (v128.const i64x2 0x8080808080808080 0x8080808080808080) + (v128.const i64x2 -9187201950435737472 -9187201950435737472)) + (v128.const i64x2 0 0)) +(assert_return (invoke "lt_s" (v128.const i64x2 0x8382818000FFFEFD 0x7F020100FFFEFD80) + (v128.const i64x2 -8970465120996032771 9151878496576798080)) + (v128.const i64x2 0 0)) + +;; dec vs dec +(assert_return (invoke "lt_s" (v128.const i64x2 -1 -1) + (v128.const i64x2 -1 -1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "lt_s" (v128.const i64x2 0 0) + (v128.const i64x2 0 0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "lt_s" (v128.const i64x2 18446744073709551615 18446744073709551615) + (v128.const i64x2 18446744073709551615 18446744073709551615)) + (v128.const i64x2 0 0)) +(assert_return (invoke "lt_s" (v128.const i64x2 18446744073709551615 18446744073709551615) + (v128.const i64x2 -1 -1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "lt_s" (v128.const i64x2 18446744073709551615 0) + (v128.const i64x2 18446744073709551615 0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "lt_s" (v128.const i64x2 0 18446744073709551615) + (v128.const i64x2 0 18446744073709551615)) + (v128.const i64x2 0 0)) +(assert_return (invoke "lt_s" (v128.const i64x2 -9223372036854775807 18446744073709551615) + (v128.const i64x2 9223372036854775809 -1)) + (v128.const i64x2 0 0)) + +;; hex vs float +(assert_return (invoke "lt_s" (v128.const i64x2 0xc060000000000000 0xc05fc00000000000) + (v128.const f64x2 -128.0 -127.0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "lt_s" (v128.const i64x2 0x3ff0000000000000 0x405fc00000000000) + (v128.const f64x2 1.0 127.0)) + (v128.const i64x2 0 0)) + +;; le_s + +;; i64x2.le_s (i64x2) (i64x2) + +;; hex vs hex +(assert_return (invoke "le_s" (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0xFFFFFFFFFFFFFFFF) + (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0xFFFFFFFFFFFFFFFF)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "le_s" (v128.const i64x2 0x0000000000000000 0x0000000000000000) + (v128.const i64x2 0x0000000000000000 0x0000000000000000)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "le_s" (v128.const i64x2 0xF0F0F0F0F0F0F0F0 0xF0F0F0F0F0F0F0F0) + (v128.const i64x2 0xF0F0F0F0F0F0F0F0 0xF0F0F0F0F0F0F0F0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "le_s" (v128.const i64x2 0x0F0F0F0F0F0F0F0F 0x0F0F0F0F0F0F0F0F) + (v128.const i64x2 0x0F0F0F0F0F0F0F0F 0x0F0F0F0F0F0F0F0F)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "le_s" (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0x0000000000000000) + (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0x0000000000000000)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "le_s" (v128.const i64x2 0x0000000000000000 0xFFFFFFFFFFFFFFFF) + (v128.const i64x2 0x0000000000000000 0xFFFFFFFFFFFFFFFF)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "le_s" (v128.const i64x2 0x0302010011100904 0x1A0B0A12FFABAA1B) + (v128.const i64x2 0x0302010011100904 0x1A0B0A12FFABAA1B)) + (v128.const i64x2 -1 -1)) + +;; hex vs dec +(assert_return (invoke "le_s" (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0xFFFFFFFFFFFFFFFF) + (v128.const i64x2 18446744073709551615 18446744073709551615)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "le_s" (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0xFFFFFFFFFFFFFFFF) + (v128.const i64x2 -1 -1)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "le_s" (v128.const i64x2 0x8080808080808080 0x8080808080808080) + (v128.const i64x2 9259542123273814144 9259542123273814144)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "le_s" (v128.const i64x2 0x8080808080808080 0x8080808080808080) + (v128.const i64x2 -9187201950435737472 -9187201950435737472)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "le_s" (v128.const i64x2 0x8382818000FFFEFD 0x7F020100FFFEFD80) + (v128.const i64x2 -8970465120996032771 9151878496576798080)) + (v128.const i64x2 -1 -1)) + +;; dec vs dec +(assert_return (invoke "le_s" (v128.const i64x2 -1 -1) + (v128.const i64x2 -1 -1)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "le_s" (v128.const i64x2 0 0) + (v128.const i64x2 0 -1)) + (v128.const i64x2 -1 0)) +(assert_return (invoke "le_s" (v128.const i64x2 0 0) + (v128.const i64x2 0 0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "le_s" (v128.const i64x2 18446744073709551615 18446744073709551615) + (v128.const i64x2 18446744073709551615 18446744073709551615)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "le_s" (v128.const i64x2 18446744073709551615 18446744073709551615) + (v128.const i64x2 -1 -1)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "le_s" (v128.const i64x2 18446744073709551615 0) + (v128.const i64x2 18446744073709551615 0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "le_s" (v128.const i64x2 0 18446744073709551615) + (v128.const i64x2 0 18446744073709551615)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "le_s" (v128.const i64x2 -9223372036854775807 18446744073709551615) + (v128.const i64x2 9223372036854775809 -1)) + (v128.const i64x2 -1 -1)) + +;; hex vs float +(assert_return (invoke "le_s" (v128.const i64x2 0xc060000000000000 0xc05fc00000000000) + (v128.const f64x2 -128.0 -127.0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "le_s" (v128.const i64x2 0x3ff0000000000000 0x405fc00000000000) + (v128.const f64x2 1.0 127.0)) + (v128.const i64x2 -1 -1)) + +;; gt_s + +;; i64x2.gt_s (i64x2) (i64x2) + +;; hex vs hex +(assert_return (invoke "gt_s" (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0xFFFFFFFFFFFFFFFF) + (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0xFFFFFFFFFFFFFFFF)) + (v128.const i64x2 0 0)) +(assert_return (invoke "gt_s" (v128.const i64x2 0x0000000000000000 0x0000000000000000) + (v128.const i64x2 0x0000000000000000 0x0000000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "gt_s" (v128.const i64x2 0xF0F0F0F0F0F0F0F0 0xF0F0F0F0F0F0F0F0) + (v128.const i64x2 0xF0F0F0F0F0F0F0F0 0xF0F0F0F0F0F0F0F0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "gt_s" (v128.const i64x2 0x0F0F0F0F0F0F0F0F 0x0F0F0F0F0F0F0F0F) + (v128.const i64x2 0x0F0F0F0F0F0F0F0F 0x0F0F0F0F0F0F0F0F)) + (v128.const i64x2 0 0)) +(assert_return (invoke "gt_s" (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0x0000000000000000) + (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0x0000000000000000)) + (v128.const i64x2 0 0)) +(assert_return (invoke "gt_s" (v128.const i64x2 0x0000000000000000 0xFFFFFFFFFFFFFFFF) + (v128.const i64x2 0x0000000000000000 0xFFFFFFFFFFFFFFFF)) + (v128.const i64x2 0 0)) +(assert_return (invoke "gt_s" (v128.const i64x2 0x0302010011100904 0x1A0B0A12FFABAA1B) + (v128.const i64x2 0x0302010011100904 0x1A0B0A12FFABAA1B)) + (v128.const i64x2 0 0)) + +;; hex vs dec +(assert_return (invoke "gt_s" (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0xFFFFFFFFFFFFFFFF) + (v128.const i64x2 18446744073709551615 18446744073709551615)) + (v128.const i64x2 0 0)) +(assert_return (invoke "gt_s" (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0xFFFFFFFFFFFFFFFF) + (v128.const i64x2 -1 -1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "gt_s" (v128.const i64x2 0x8080808080808080 0x8080808080808080) + (v128.const i64x2 9259542123273814144 9259542123273814144)) + (v128.const i64x2 0 0)) +(assert_return (invoke "gt_s" (v128.const i64x2 0x8080808080808080 0x8080808080808080) + (v128.const i64x2 -9187201950435737472 -9187201950435737472)) + (v128.const i64x2 0 0)) +(assert_return (invoke "gt_s" (v128.const i64x2 0x8382818000FFFEFD 0x7F020100FFFEFD80) + (v128.const i64x2 -8970465120996032771 9151878496576798080)) + (v128.const i64x2 0 0)) + +;; dec vs dec +(assert_return (invoke "gt_s" (v128.const i64x2 -1 -1) + (v128.const i64x2 -1 -1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "gt_s" (v128.const i64x2 0 0) + (v128.const i64x2 0 0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "gt_s" (v128.const i64x2 18446744073709551615 18446744073709551615) + (v128.const i64x2 18446744073709551615 18446744073709551615)) + (v128.const i64x2 0 0)) +(assert_return (invoke "gt_s" (v128.const i64x2 18446744073709551615 18446744073709551615) + (v128.const i64x2 -1 -1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "gt_s" (v128.const i64x2 18446744073709551615 0) + (v128.const i64x2 18446744073709551615 0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "gt_s" (v128.const i64x2 0 18446744073709551615) + (v128.const i64x2 0 18446744073709551615)) + (v128.const i64x2 0 0)) +(assert_return (invoke "gt_s" (v128.const i64x2 -9223372036854775807 18446744073709551615) + (v128.const i64x2 9223372036854775809 -1)) + (v128.const i64x2 0 0)) + +;; hex vs float +(assert_return (invoke "gt_s" (v128.const i64x2 0xc060000000000000 0xc05fc00000000000) + (v128.const f64x2 -128.0 -127.0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "gt_s" (v128.const i64x2 0x3ff0000000000000 0x405fc00000000000) + (v128.const f64x2 1.0 127.0)) + (v128.const i64x2 0 0)) + +;; ge_s + +;; i64x2.ge_s (i64x2) (i64x2) + +;; hex vs hex +(assert_return (invoke "ge_s" (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0xFFFFFFFFFFFFFFFF) + (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0xFFFFFFFFFFFFFFFF)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "ge_s" (v128.const i64x2 0x0000000000000000 0x0000000000000000) + (v128.const i64x2 0x0000000000000000 0x0000000000000000)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "ge_s" (v128.const i64x2 0xF0F0F0F0F0F0F0F0 0xF0F0F0F0F0F0F0F0) + (v128.const i64x2 0xF0F0F0F0F0F0F0F0 0xF0F0F0F0F0F0F0F0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "ge_s" (v128.const i64x2 0x0F0F0F0F0F0F0F0F 0x0F0F0F0F0F0F0F0F) + (v128.const i64x2 0x0F0F0F0F0F0F0F0F 0x0F0F0F0F0F0F0F0F)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "ge_s" (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0x0000000000000000) + (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0x0000000000000000)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "ge_s" (v128.const i64x2 0x0000000000000000 0xFFFFFFFFFFFFFFFF) + (v128.const i64x2 0x0000000000000000 0xFFFFFFFFFFFFFFFF)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "ge_s" (v128.const i64x2 0x0302010011100904 0x1A0B0A12FFABAA1B) + (v128.const i64x2 0x0302010011100904 0x1A0B0A12FFABAA1B)) + (v128.const i64x2 -1 -1)) + +;; hex vs dec +(assert_return (invoke "ge_s" (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0xFFFFFFFFFFFFFFFF) + (v128.const i64x2 18446744073709551615 18446744073709551615)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "ge_s" (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0xFFFFFFFFFFFFFFFF) + (v128.const i64x2 -1 -1)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "ge_s" (v128.const i64x2 0x8080808080808080 0x8080808080808080) + (v128.const i64x2 9259542123273814144 9259542123273814144)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "ge_s" (v128.const i64x2 0x8080808080808080 0x8080808080808080) + (v128.const i64x2 -9187201950435737472 -9187201950435737472)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "ge_s" (v128.const i64x2 0x8382818000FFFEFD 0x7F020100FFFEFD80) + (v128.const i64x2 -8970465120996032771 9151878496576798080)) + (v128.const i64x2 -1 -1)) + +;; dec vs dec +(assert_return (invoke "ge_s" (v128.const i64x2 -1 -1) + (v128.const i64x2 -1 -1)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "ge_s" (v128.const i64x2 -1 -1) + (v128.const i64x2 0 -1)) + (v128.const i64x2 0 -1)) +(assert_return (invoke "ge_s" (v128.const i64x2 0 0) + (v128.const i64x2 0 0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "ge_s" (v128.const i64x2 18446744073709551615 18446744073709551615) + (v128.const i64x2 18446744073709551615 18446744073709551615)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "ge_s" (v128.const i64x2 18446744073709551615 18446744073709551615) + (v128.const i64x2 -1 -1)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "ge_s" (v128.const i64x2 18446744073709551615 0) + (v128.const i64x2 18446744073709551615 0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "ge_s" (v128.const i64x2 0 18446744073709551615) + (v128.const i64x2 0 18446744073709551615)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "ge_s" (v128.const i64x2 -9223372036854775807 18446744073709551615) + (v128.const i64x2 9223372036854775809 -1)) + (v128.const i64x2 -1 -1)) + +;; hex vs float +(assert_return (invoke "ge_s" (v128.const i64x2 0xc060000000000000 0xc05fc00000000000) + (v128.const f64x2 -128.0 -127.0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "ge_s" (v128.const i64x2 0x3ff0000000000000 0x405fc00000000000) + (v128.const f64x2 1.0 127.0)) + (v128.const i64x2 -1 -1)) + +;; Type check + +(assert_invalid (module (func (result v128) (i64x2.eq (i32.const 0) (f32.const 0)))) "type mismatch") +(assert_invalid (module (func (result v128) (i64x2.ne (i32.const 0) (f32.const 0)))) "type mismatch") +(assert_invalid (module (func (result v128) (i64x2.ge_s (i32.const 0) (f32.const 0)))) "type mismatch") +(assert_invalid (module (func (result v128) (i64x2.gt_s (i32.const 0) (f32.const 0)))) "type mismatch") +(assert_invalid (module (func (result v128) (i64x2.le_s (i32.const 0) (f32.const 0)))) "type mismatch") +(assert_invalid (module (func (result v128) (i64x2.lt_s (i32.const 0) (f32.const 0)))) "type mismatch") + +;; Test operation with empty argument + +(assert_invalid + (module + (func $i64x2.eq-1st-arg-empty (result v128) + (i64x2.eq (v128.const i64x2 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i64x2.eq-arg-empty (result v128) + (i64x2.eq) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i64x2.ne-1st-arg-empty (result v128) + (i64x2.ne (v128.const i64x2 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i64x2.ne-arg-empty (result v128) + (i64x2.ne) + ) + ) + "type mismatch" +) \ No newline at end of file diff --git a/runtime/near-vm/tests/wast/spec/proposals/simd/simd_i64x2_extmul_i32x4.wast b/runtime/near-vm/tests/wast/spec/proposals/simd/simd_i64x2_extmul_i32x4.wast new file mode 100644 index 00000000000..9259279c927 --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/proposals/simd/simd_i64x2_extmul_i32x4.wast @@ -0,0 +1,404 @@ +;; Tests for i64x2 arithmetic operations on major boundary values and all special values. + + +(module + (func (export "i64x2.extmul_low_i32x4_s") (param v128 v128) (result v128) (i64x2.extmul_low_i32x4_s (local.get 0) (local.get 1))) + (func (export "i64x2.extmul_high_i32x4_s") (param v128 v128) (result v128) (i64x2.extmul_high_i32x4_s (local.get 0) (local.get 1))) + (func (export "i64x2.extmul_low_i32x4_u") (param v128 v128) (result v128) (i64x2.extmul_low_i32x4_u (local.get 0) (local.get 1))) + (func (export "i64x2.extmul_high_i32x4_u") (param v128 v128) (result v128) (i64x2.extmul_high_i32x4_u (local.get 0) (local.get 1))) +) + + +;; i64x2.extmul_low_i32x4_s +(assert_return (invoke "i64x2.extmul_low_i32x4_s" (v128.const i32x4 0 0 0 0) + (v128.const i32x4 0 0 0 0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "i64x2.extmul_low_i32x4_s" (v128.const i32x4 0 0 0 0) + (v128.const i32x4 1 1 1 1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "i64x2.extmul_low_i32x4_s" (v128.const i32x4 1 1 1 1) + (v128.const i32x4 1 1 1 1)) + (v128.const i64x2 1 1)) +(assert_return (invoke "i64x2.extmul_low_i32x4_s" (v128.const i32x4 0 0 0 0) + (v128.const i32x4 -1 -1 -1 -1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "i64x2.extmul_low_i32x4_s" (v128.const i32x4 1 1 1 1) + (v128.const i32x4 -1 -1 -1 -1)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "i64x2.extmul_low_i32x4_s" (v128.const i32x4 -1 -1 -1 -1) + (v128.const i32x4 -1 -1 -1 -1)) + (v128.const i64x2 1 1)) +(assert_return (invoke "i64x2.extmul_low_i32x4_s" (v128.const i32x4 1073741823 1073741823 1073741823 1073741823) + (v128.const i32x4 1073741824 1073741824 1073741824 1073741824)) + (v128.const i64x2 1152921503533105152 1152921503533105152)) +(assert_return (invoke "i64x2.extmul_low_i32x4_s" (v128.const i32x4 1073741824 1073741824 1073741824 1073741824) + (v128.const i32x4 1073741824 1073741824 1073741824 1073741824)) + (v128.const i64x2 1152921504606846976 1152921504606846976)) +(assert_return (invoke "i64x2.extmul_low_i32x4_s" (v128.const i32x4 -1073741823 -1073741823 -1073741823 -1073741823) + (v128.const i32x4 -1073741824 -1073741824 -1073741824 -1073741824)) + (v128.const i64x2 1152921503533105152 1152921503533105152)) +(assert_return (invoke "i64x2.extmul_low_i32x4_s" (v128.const i32x4 -1073741824 -1073741824 -1073741824 -1073741824) + (v128.const i32x4 -1073741824 -1073741824 -1073741824 -1073741824)) + (v128.const i64x2 1152921504606846976 1152921504606846976)) +(assert_return (invoke "i64x2.extmul_low_i32x4_s" (v128.const i32x4 -1073741825 -1073741825 -1073741825 -1073741825) + (v128.const i32x4 -1073741824 -1073741824 -1073741824 -1073741824)) + (v128.const i64x2 1152921505680588800 1152921505680588800)) +(assert_return (invoke "i64x2.extmul_low_i32x4_s" (v128.const i32x4 2147483645 2147483645 2147483645 2147483645) + (v128.const i32x4 1 1 1 1)) + (v128.const i64x2 2147483645 2147483645)) +(assert_return (invoke "i64x2.extmul_low_i32x4_s" (v128.const i32x4 2147483646 2147483646 2147483646 2147483646) + (v128.const i32x4 1 1 1 1)) + (v128.const i64x2 2147483646 2147483646)) +(assert_return (invoke "i64x2.extmul_low_i32x4_s" (v128.const i32x4 2147483648 2147483648 2147483648 2147483648) + (v128.const i32x4 1 1 1 1)) + (v128.const i64x2 -2147483648 -2147483648)) +(assert_return (invoke "i64x2.extmul_low_i32x4_s" (v128.const i32x4 -2147483646 -2147483646 -2147483646 -2147483646) + (v128.const i32x4 -1 -1 -1 -1)) + (v128.const i64x2 2147483646 2147483646)) +(assert_return (invoke "i64x2.extmul_low_i32x4_s" (v128.const i32x4 -2147483647 -2147483647 -2147483647 -2147483647) + (v128.const i32x4 -1 -1 -1 -1)) + (v128.const i64x2 2147483647 2147483647)) +(assert_return (invoke "i64x2.extmul_low_i32x4_s" (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648) + (v128.const i32x4 -1 -1 -1 -1)) + (v128.const i64x2 2147483648 2147483648)) +(assert_return (invoke "i64x2.extmul_low_i32x4_s" (v128.const i32x4 2147483647 2147483647 2147483647 2147483647) + (v128.const i32x4 2147483647 2147483647 2147483647 2147483647)) + (v128.const i64x2 4611686014132420609 4611686014132420609)) +(assert_return (invoke "i64x2.extmul_low_i32x4_s" (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648) + (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648)) + (v128.const i64x2 4611686018427387904 4611686018427387904)) +(assert_return (invoke "i64x2.extmul_low_i32x4_s" (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648) + (v128.const i32x4 -2147483647 -2147483647 -2147483647 -2147483647)) + (v128.const i64x2 4611686016279904256 4611686016279904256)) +(assert_return (invoke "i64x2.extmul_low_i32x4_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295) + (v128.const i32x4 0 0 0 0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "i64x2.extmul_low_i32x4_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295) + (v128.const i32x4 1 1 1 1)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "i64x2.extmul_low_i32x4_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295) + (v128.const i32x4 -1 -1 -1 -1)) + (v128.const i64x2 1 1)) +(assert_return (invoke "i64x2.extmul_low_i32x4_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295) + (v128.const i32x4 2147483647 2147483647 2147483647 2147483647)) + (v128.const i64x2 -2147483647 -2147483647)) +(assert_return (invoke "i64x2.extmul_low_i32x4_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295) + (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648)) + (v128.const i64x2 2147483648 2147483648)) +(assert_return (invoke "i64x2.extmul_low_i32x4_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295) + (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)) + (v128.const i64x2 1 1)) + +;; i64x2.extmul_high_i32x4_s +(assert_return (invoke "i64x2.extmul_high_i32x4_s" (v128.const i32x4 0 0 0 0) + (v128.const i32x4 0 0 0 0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "i64x2.extmul_high_i32x4_s" (v128.const i32x4 0 0 0 0) + (v128.const i32x4 1 1 1 1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "i64x2.extmul_high_i32x4_s" (v128.const i32x4 1 1 1 1) + (v128.const i32x4 1 1 1 1)) + (v128.const i64x2 1 1)) +(assert_return (invoke "i64x2.extmul_high_i32x4_s" (v128.const i32x4 0 0 0 0) + (v128.const i32x4 -1 -1 -1 -1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "i64x2.extmul_high_i32x4_s" (v128.const i32x4 1 1 1 1) + (v128.const i32x4 -1 -1 -1 -1)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "i64x2.extmul_high_i32x4_s" (v128.const i32x4 -1 -1 -1 -1) + (v128.const i32x4 -1 -1 -1 -1)) + (v128.const i64x2 1 1)) +(assert_return (invoke "i64x2.extmul_high_i32x4_s" (v128.const i32x4 1073741823 1073741823 1073741823 1073741823) + (v128.const i32x4 1073741824 1073741824 1073741824 1073741824)) + (v128.const i64x2 1152921503533105152 1152921503533105152)) +(assert_return (invoke "i64x2.extmul_high_i32x4_s" (v128.const i32x4 1073741824 1073741824 1073741824 1073741824) + (v128.const i32x4 1073741824 1073741824 1073741824 1073741824)) + (v128.const i64x2 1152921504606846976 1152921504606846976)) +(assert_return (invoke "i64x2.extmul_high_i32x4_s" (v128.const i32x4 -1073741823 -1073741823 -1073741823 -1073741823) + (v128.const i32x4 -1073741824 -1073741824 -1073741824 -1073741824)) + (v128.const i64x2 1152921503533105152 1152921503533105152)) +(assert_return (invoke "i64x2.extmul_high_i32x4_s" (v128.const i32x4 -1073741824 -1073741824 -1073741824 -1073741824) + (v128.const i32x4 -1073741824 -1073741824 -1073741824 -1073741824)) + (v128.const i64x2 1152921504606846976 1152921504606846976)) +(assert_return (invoke "i64x2.extmul_high_i32x4_s" (v128.const i32x4 -1073741825 -1073741825 -1073741825 -1073741825) + (v128.const i32x4 -1073741824 -1073741824 -1073741824 -1073741824)) + (v128.const i64x2 1152921505680588800 1152921505680588800)) +(assert_return (invoke "i64x2.extmul_high_i32x4_s" (v128.const i32x4 2147483645 2147483645 2147483645 2147483645) + (v128.const i32x4 1 1 1 1)) + (v128.const i64x2 2147483645 2147483645)) +(assert_return (invoke "i64x2.extmul_high_i32x4_s" (v128.const i32x4 2147483646 2147483646 2147483646 2147483646) + (v128.const i32x4 1 1 1 1)) + (v128.const i64x2 2147483646 2147483646)) +(assert_return (invoke "i64x2.extmul_high_i32x4_s" (v128.const i32x4 2147483648 2147483648 2147483648 2147483648) + (v128.const i32x4 1 1 1 1)) + (v128.const i64x2 -2147483648 -2147483648)) +(assert_return (invoke "i64x2.extmul_high_i32x4_s" (v128.const i32x4 -2147483646 -2147483646 -2147483646 -2147483646) + (v128.const i32x4 -1 -1 -1 -1)) + (v128.const i64x2 2147483646 2147483646)) +(assert_return (invoke "i64x2.extmul_high_i32x4_s" (v128.const i32x4 -2147483647 -2147483647 -2147483647 -2147483647) + (v128.const i32x4 -1 -1 -1 -1)) + (v128.const i64x2 2147483647 2147483647)) +(assert_return (invoke "i64x2.extmul_high_i32x4_s" (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648) + (v128.const i32x4 -1 -1 -1 -1)) + (v128.const i64x2 2147483648 2147483648)) +(assert_return (invoke "i64x2.extmul_high_i32x4_s" (v128.const i32x4 2147483647 2147483647 2147483647 2147483647) + (v128.const i32x4 2147483647 2147483647 2147483647 2147483647)) + (v128.const i64x2 4611686014132420609 4611686014132420609)) +(assert_return (invoke "i64x2.extmul_high_i32x4_s" (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648) + (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648)) + (v128.const i64x2 4611686018427387904 4611686018427387904)) +(assert_return (invoke "i64x2.extmul_high_i32x4_s" (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648) + (v128.const i32x4 -2147483647 -2147483647 -2147483647 -2147483647)) + (v128.const i64x2 4611686016279904256 4611686016279904256)) +(assert_return (invoke "i64x2.extmul_high_i32x4_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295) + (v128.const i32x4 0 0 0 0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "i64x2.extmul_high_i32x4_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295) + (v128.const i32x4 1 1 1 1)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "i64x2.extmul_high_i32x4_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295) + (v128.const i32x4 -1 -1 -1 -1)) + (v128.const i64x2 1 1)) +(assert_return (invoke "i64x2.extmul_high_i32x4_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295) + (v128.const i32x4 2147483647 2147483647 2147483647 2147483647)) + (v128.const i64x2 -2147483647 -2147483647)) +(assert_return (invoke "i64x2.extmul_high_i32x4_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295) + (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648)) + (v128.const i64x2 2147483648 2147483648)) +(assert_return (invoke "i64x2.extmul_high_i32x4_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295) + (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)) + (v128.const i64x2 1 1)) + +;; i64x2.extmul_low_i32x4_u +(assert_return (invoke "i64x2.extmul_low_i32x4_u" (v128.const i32x4 0 0 0 0) + (v128.const i32x4 0 0 0 0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "i64x2.extmul_low_i32x4_u" (v128.const i32x4 0 0 0 0) + (v128.const i32x4 1 1 1 1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "i64x2.extmul_low_i32x4_u" (v128.const i32x4 1 1 1 1) + (v128.const i32x4 1 1 1 1)) + (v128.const i64x2 1 1)) +(assert_return (invoke "i64x2.extmul_low_i32x4_u" (v128.const i32x4 0 0 0 0) + (v128.const i32x4 -1 -1 -1 -1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "i64x2.extmul_low_i32x4_u" (v128.const i32x4 1 1 1 1) + (v128.const i32x4 -1 -1 -1 -1)) + (v128.const i64x2 4294967295 4294967295)) +(assert_return (invoke "i64x2.extmul_low_i32x4_u" (v128.const i32x4 -1 -1 -1 -1) + (v128.const i32x4 -1 -1 -1 -1)) + (v128.const i64x2 -8589934591 -8589934591)) +(assert_return (invoke "i64x2.extmul_low_i32x4_u" (v128.const i32x4 1073741823 1073741823 1073741823 1073741823) + (v128.const i32x4 1073741824 1073741824 1073741824 1073741824)) + (v128.const i64x2 1152921503533105152 1152921503533105152)) +(assert_return (invoke "i64x2.extmul_low_i32x4_u" (v128.const i32x4 1073741824 1073741824 1073741824 1073741824) + (v128.const i32x4 1073741824 1073741824 1073741824 1073741824)) + (v128.const i64x2 1152921504606846976 1152921504606846976)) +(assert_return (invoke "i64x2.extmul_low_i32x4_u" (v128.const i32x4 -1073741823 -1073741823 -1073741823 -1073741823) + (v128.const i32x4 -1073741824 -1073741824 -1073741824 -1073741824)) + (v128.const i64x2 -8070450529026703360 -8070450529026703360)) +(assert_return (invoke "i64x2.extmul_low_i32x4_u" (v128.const i32x4 -1073741824 -1073741824 -1073741824 -1073741824) + (v128.const i32x4 -1073741824 -1073741824 -1073741824 -1073741824)) + (v128.const i64x2 -8070450532247928832 -8070450532247928832)) +(assert_return (invoke "i64x2.extmul_low_i32x4_u" (v128.const i32x4 -1073741825 -1073741825 -1073741825 -1073741825) + (v128.const i32x4 -1073741824 -1073741824 -1073741824 -1073741824)) + (v128.const i64x2 -8070450535469154304 -8070450535469154304)) +(assert_return (invoke "i64x2.extmul_low_i32x4_u" (v128.const i32x4 2147483645 2147483645 2147483645 2147483645) + (v128.const i32x4 1 1 1 1)) + (v128.const i64x2 2147483645 2147483645)) +(assert_return (invoke "i64x2.extmul_low_i32x4_u" (v128.const i32x4 2147483646 2147483646 2147483646 2147483646) + (v128.const i32x4 1 1 1 1)) + (v128.const i64x2 2147483646 2147483646)) +(assert_return (invoke "i64x2.extmul_low_i32x4_u" (v128.const i32x4 2147483648 2147483648 2147483648 2147483648) + (v128.const i32x4 1 1 1 1)) + (v128.const i64x2 2147483648 2147483648)) +(assert_return (invoke "i64x2.extmul_low_i32x4_u" (v128.const i32x4 -2147483646 -2147483646 -2147483646 -2147483646) + (v128.const i32x4 -1 -1 -1 -1)) + (v128.const i64x2 -9223372030412324866 -9223372030412324866)) +(assert_return (invoke "i64x2.extmul_low_i32x4_u" (v128.const i32x4 -2147483647 -2147483647 -2147483647 -2147483647) + (v128.const i32x4 -1 -1 -1 -1)) + (v128.const i64x2 -9223372034707292161 -9223372034707292161)) +(assert_return (invoke "i64x2.extmul_low_i32x4_u" (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648) + (v128.const i32x4 -1 -1 -1 -1)) + (v128.const i64x2 9223372034707292160 9223372034707292160)) +(assert_return (invoke "i64x2.extmul_low_i32x4_u" (v128.const i32x4 2147483647 2147483647 2147483647 2147483647) + (v128.const i32x4 2147483647 2147483647 2147483647 2147483647)) + (v128.const i64x2 4611686014132420609 4611686014132420609)) +(assert_return (invoke "i64x2.extmul_low_i32x4_u" (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648) + (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648)) + (v128.const i64x2 4611686018427387904 4611686018427387904)) +(assert_return (invoke "i64x2.extmul_low_i32x4_u" (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648) + (v128.const i32x4 -2147483647 -2147483647 -2147483647 -2147483647)) + (v128.const i64x2 4611686020574871552 4611686020574871552)) +(assert_return (invoke "i64x2.extmul_low_i32x4_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295) + (v128.const i32x4 0 0 0 0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "i64x2.extmul_low_i32x4_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295) + (v128.const i32x4 1 1 1 1)) + (v128.const i64x2 4294967295 4294967295)) +(assert_return (invoke "i64x2.extmul_low_i32x4_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295) + (v128.const i32x4 -1 -1 -1 -1)) + (v128.const i64x2 -8589934591 -8589934591)) +(assert_return (invoke "i64x2.extmul_low_i32x4_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295) + (v128.const i32x4 2147483647 2147483647 2147483647 2147483647)) + (v128.const i64x2 9223372030412324865 9223372030412324865)) +(assert_return (invoke "i64x2.extmul_low_i32x4_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295) + (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648)) + (v128.const i64x2 9223372034707292160 9223372034707292160)) +(assert_return (invoke "i64x2.extmul_low_i32x4_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295) + (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)) + (v128.const i64x2 -8589934591 -8589934591)) + +;; i64x2.extmul_high_i32x4_u +(assert_return (invoke "i64x2.extmul_high_i32x4_u" (v128.const i32x4 0 0 0 0) + (v128.const i32x4 0 0 0 0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "i64x2.extmul_high_i32x4_u" (v128.const i32x4 0 0 0 0) + (v128.const i32x4 1 1 1 1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "i64x2.extmul_high_i32x4_u" (v128.const i32x4 1 1 1 1) + (v128.const i32x4 1 1 1 1)) + (v128.const i64x2 1 1)) +(assert_return (invoke "i64x2.extmul_high_i32x4_u" (v128.const i32x4 0 0 0 0) + (v128.const i32x4 -1 -1 -1 -1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "i64x2.extmul_high_i32x4_u" (v128.const i32x4 1 1 1 1) + (v128.const i32x4 -1 -1 -1 -1)) + (v128.const i64x2 4294967295 4294967295)) +(assert_return (invoke "i64x2.extmul_high_i32x4_u" (v128.const i32x4 -1 -1 -1 -1) + (v128.const i32x4 -1 -1 -1 -1)) + (v128.const i64x2 -8589934591 -8589934591)) +(assert_return (invoke "i64x2.extmul_high_i32x4_u" (v128.const i32x4 1073741823 1073741823 1073741823 1073741823) + (v128.const i32x4 1073741824 1073741824 1073741824 1073741824)) + (v128.const i64x2 1152921503533105152 1152921503533105152)) +(assert_return (invoke "i64x2.extmul_high_i32x4_u" (v128.const i32x4 1073741824 1073741824 1073741824 1073741824) + (v128.const i32x4 1073741824 1073741824 1073741824 1073741824)) + (v128.const i64x2 1152921504606846976 1152921504606846976)) +(assert_return (invoke "i64x2.extmul_high_i32x4_u" (v128.const i32x4 -1073741823 -1073741823 -1073741823 -1073741823) + (v128.const i32x4 -1073741824 -1073741824 -1073741824 -1073741824)) + (v128.const i64x2 -8070450529026703360 -8070450529026703360)) +(assert_return (invoke "i64x2.extmul_high_i32x4_u" (v128.const i32x4 -1073741824 -1073741824 -1073741824 -1073741824) + (v128.const i32x4 -1073741824 -1073741824 -1073741824 -1073741824)) + (v128.const i64x2 -8070450532247928832 -8070450532247928832)) +(assert_return (invoke "i64x2.extmul_high_i32x4_u" (v128.const i32x4 -1073741825 -1073741825 -1073741825 -1073741825) + (v128.const i32x4 -1073741824 -1073741824 -1073741824 -1073741824)) + (v128.const i64x2 -8070450535469154304 -8070450535469154304)) +(assert_return (invoke "i64x2.extmul_high_i32x4_u" (v128.const i32x4 2147483645 2147483645 2147483645 2147483645) + (v128.const i32x4 1 1 1 1)) + (v128.const i64x2 2147483645 2147483645)) +(assert_return (invoke "i64x2.extmul_high_i32x4_u" (v128.const i32x4 2147483646 2147483646 2147483646 2147483646) + (v128.const i32x4 1 1 1 1)) + (v128.const i64x2 2147483646 2147483646)) +(assert_return (invoke "i64x2.extmul_high_i32x4_u" (v128.const i32x4 2147483648 2147483648 2147483648 2147483648) + (v128.const i32x4 1 1 1 1)) + (v128.const i64x2 2147483648 2147483648)) +(assert_return (invoke "i64x2.extmul_high_i32x4_u" (v128.const i32x4 -2147483646 -2147483646 -2147483646 -2147483646) + (v128.const i32x4 -1 -1 -1 -1)) + (v128.const i64x2 -9223372030412324866 -9223372030412324866)) +(assert_return (invoke "i64x2.extmul_high_i32x4_u" (v128.const i32x4 -2147483647 -2147483647 -2147483647 -2147483647) + (v128.const i32x4 -1 -1 -1 -1)) + (v128.const i64x2 -9223372034707292161 -9223372034707292161)) +(assert_return (invoke "i64x2.extmul_high_i32x4_u" (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648) + (v128.const i32x4 -1 -1 -1 -1)) + (v128.const i64x2 9223372034707292160 9223372034707292160)) +(assert_return (invoke "i64x2.extmul_high_i32x4_u" (v128.const i32x4 2147483647 2147483647 2147483647 2147483647) + (v128.const i32x4 2147483647 2147483647 2147483647 2147483647)) + (v128.const i64x2 4611686014132420609 4611686014132420609)) +(assert_return (invoke "i64x2.extmul_high_i32x4_u" (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648) + (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648)) + (v128.const i64x2 4611686018427387904 4611686018427387904)) +(assert_return (invoke "i64x2.extmul_high_i32x4_u" (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648) + (v128.const i32x4 -2147483647 -2147483647 -2147483647 -2147483647)) + (v128.const i64x2 4611686020574871552 4611686020574871552)) +(assert_return (invoke "i64x2.extmul_high_i32x4_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295) + (v128.const i32x4 0 0 0 0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "i64x2.extmul_high_i32x4_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295) + (v128.const i32x4 1 1 1 1)) + (v128.const i64x2 4294967295 4294967295)) +(assert_return (invoke "i64x2.extmul_high_i32x4_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295) + (v128.const i32x4 -1 -1 -1 -1)) + (v128.const i64x2 -8589934591 -8589934591)) +(assert_return (invoke "i64x2.extmul_high_i32x4_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295) + (v128.const i32x4 2147483647 2147483647 2147483647 2147483647)) + (v128.const i64x2 9223372030412324865 9223372030412324865)) +(assert_return (invoke "i64x2.extmul_high_i32x4_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295) + (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648)) + (v128.const i64x2 9223372034707292160 9223372034707292160)) +(assert_return (invoke "i64x2.extmul_high_i32x4_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295) + (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)) + (v128.const i64x2 -8589934591 -8589934591)) + +;; type check +(assert_invalid (module (func (result v128) (i64x2.extmul_low_i32x4_s (i32.const 0) (f32.const 0.0)))) "type mismatch") +(assert_invalid (module (func (result v128) (i64x2.extmul_high_i32x4_s (i32.const 0) (f32.const 0.0)))) "type mismatch") +(assert_invalid (module (func (result v128) (i64x2.extmul_low_i32x4_u (i32.const 0) (f32.const 0.0)))) "type mismatch") +(assert_invalid (module (func (result v128) (i64x2.extmul_high_i32x4_u (i32.const 0) (f32.const 0.0)))) "type mismatch") + +;; Test operation with empty argument + +(assert_invalid + (module + (func $i64x2.extmul_low_i32x4_s-1st-arg-empty (result v128) + (i64x2.extmul_low_i32x4_s (v128.const i64x2 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i64x2.extmul_low_i32x4_s-arg-empty (result v128) + (i64x2.extmul_low_i32x4_s) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i64x2.extmul_high_i32x4_s-1st-arg-empty (result v128) + (i64x2.extmul_high_i32x4_s (v128.const i64x2 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i64x2.extmul_high_i32x4_s-arg-empty (result v128) + (i64x2.extmul_high_i32x4_s) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i64x2.extmul_low_i32x4_u-1st-arg-empty (result v128) + (i64x2.extmul_low_i32x4_u (v128.const i64x2 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i64x2.extmul_low_i32x4_u-arg-empty (result v128) + (i64x2.extmul_low_i32x4_u) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i64x2.extmul_high_i32x4_u-1st-arg-empty (result v128) + (i64x2.extmul_high_i32x4_u (v128.const i64x2 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i64x2.extmul_high_i32x4_u-arg-empty (result v128) + (i64x2.extmul_high_i32x4_u) + ) + ) + "type mismatch" +) + diff --git a/runtime/near-vm/tests/wast/spec/proposals/simd/simd_i8x16_arith.wast b/runtime/near-vm/tests/wast/spec/proposals/simd/simd_i8x16_arith.wast new file mode 100644 index 00000000000..1e56b4c00f4 --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/proposals/simd/simd_i8x16_arith.wast @@ -0,0 +1,426 @@ +;; Tests for i8x16 arithmetic operations on major boundary values and all special values. + + +(module + (func (export "i8x16.add") (param v128 v128) (result v128) (i8x16.add (local.get 0) (local.get 1))) + (func (export "i8x16.sub") (param v128 v128) (result v128) (i8x16.sub (local.get 0) (local.get 1))) + (func (export "i8x16.neg") (param v128) (result v128) (i8x16.neg (local.get 0))) +) + + +;; i8x16.add +(assert_return (invoke "i8x16.add" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i8x16.add" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) +(assert_return (invoke "i8x16.add" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) + (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2)) +(assert_return (invoke "i8x16.add" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "i8x16.add" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i8x16.add" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i8x16 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2)) +(assert_return (invoke "i8x16.add" (v128.const i8x16 63 63 63 63 63 63 63 63 63 63 63 63 63 63 63 63) + (v128.const i8x16 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64)) + (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127)) +(assert_return (invoke "i8x16.add" (v128.const i8x16 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64) + (v128.const i8x16 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64)) + (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)) +(assert_return (invoke "i8x16.add" (v128.const i8x16 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63) + (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64)) + (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127)) +(assert_return (invoke "i8x16.add" (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64) + (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64)) + (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)) +(assert_return (invoke "i8x16.add" (v128.const i8x16 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65) + (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64)) + (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127)) +(assert_return (invoke "i8x16.add" (v128.const i8x16 125 125 125 125 125 125 125 125 125 125 125 125 125 125 125 125) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) + (v128.const i8x16 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126)) +(assert_return (invoke "i8x16.add" (v128.const i8x16 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) + (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127)) +(assert_return (invoke "i8x16.add" (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) + (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127)) +(assert_return (invoke "i8x16.add" (v128.const i8x16 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127)) +(assert_return (invoke "i8x16.add" (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)) +(assert_return (invoke "i8x16.add" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127)) +(assert_return (invoke "i8x16.add" (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127) + (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127)) + (v128.const i8x16 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2)) +(assert_return (invoke "i8x16.add" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128) + (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i8x16.add" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128) + (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127)) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) +(assert_return (invoke "i8x16.add" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "i8x16.add" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i8x16.add" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i8x16 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2)) +(assert_return (invoke "i8x16.add" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255) + (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127)) + (v128.const i8x16 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126)) +(assert_return (invoke "i8x16.add" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255) + (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)) + (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127)) +(assert_return (invoke "i8x16.add" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255) + (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)) + (v128.const i8x16 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2)) +(assert_return (invoke "i8x16.add" (v128.const i8x16 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f) + (v128.const i8x16 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40)) + (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127)) +(assert_return (invoke "i8x16.add" (v128.const i8x16 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40) + (v128.const i8x16 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40)) + (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)) +(assert_return (invoke "i8x16.add" (v128.const i8x16 -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f) + (v128.const i8x16 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40)) + (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127)) +(assert_return (invoke "i8x16.add" (v128.const i8x16 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40) + (v128.const i8x16 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40)) + (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)) +(assert_return (invoke "i8x16.add" (v128.const i8x16 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40) + (v128.const i8x16 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41)) + (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127)) +(assert_return (invoke "i8x16.add" (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f) + (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f)) + (v128.const i8x16 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2)) +(assert_return (invoke "i8x16.add" (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f) + (v128.const i8x16 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01)) + (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)) +(assert_return (invoke "i8x16.add" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80) + (v128.const i8x16 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01)) + (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127)) +(assert_return (invoke "i8x16.add" (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f) + (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "i8x16.add" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80) + (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i8x16.add" (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff) + (v128.const i8x16 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i8x16.add" (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff) + (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff)) + (v128.const i8x16 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2)) +(assert_return (invoke "i8x16.add" (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f) + (v128.const i16x8 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "i8x16.add" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1) + (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i8x16.add" (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f) + (v128.const i32x4 0x80808080 0x80808080 0x80808080 0x80808080)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "i8x16.add" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1) + (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i8x16.add" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80) + (v128.const f32x4 +0.0 +0.0 +0.0 +0.0)) + (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)) +(assert_return (invoke "i8x16.add" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80) + (v128.const f32x4 -0.0 -0.0 -0.0 -0.0)) + (v128.const i8x16 0x80 0x80 0x80 0 0x80 0x80 0x80 0 0x80 0x80 0x80 0 0x80 0x80 0x80 0)) +(assert_return (invoke "i8x16.add" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80) + (v128.const f32x4 1.0 1.0 1.0 1.0)) + (v128.const i8x16 0x80 0x80 0 0xbf 0x80 0x80 0 0xbf 0x80 0x80 0 0xbf 0x80 0x80 0 0xbf)) +(assert_return (invoke "i8x16.add" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80) + (v128.const f32x4 -1.0 -1.0 -1.0 -1.0)) + (v128.const i8x16 0x80 0x80 0 0x3f 0x80 0x80 0 0x3f 0x80 0x80 0 0x3f 0x80 0x80 0 0x3f)) +(assert_return (invoke "i8x16.add" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1) + (v128.const f32x4 +inf +inf +inf +inf)) + (v128.const i8x16 0x01 0x01 0x81 0x80 0x01 0x01 0x81 0x80 0x01 0x01 0x81 0x80 0x01 0x01 0x81 0x80)) +(assert_return (invoke "i8x16.add" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const i8x16 0x01 0x01 0x81 0 0x01 0x01 0x81 0 0x01 0x01 0x81 0 0x01 0x01 0x81 0)) +(assert_return (invoke "i8x16.add" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1) + (v128.const f32x4 nan nan nan nan)) + (v128.const i8x16 0x01 0x01 0xc1 0x80 0x01 0x01 0xc1 0x80 0x01 0x01 0xc1 0x80 0x01 0x01 0xc1 0x80)) +(assert_return (invoke "i8x16.add" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15) + (v128.const i8x16 0 0xff 0xfe 0xfd 0xfc 0xfb 0xfa 0xf9 0xf8 0xf7 0xf6 0xf5 0xf4 0xf3 0xf2 0xf1)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i8x16.add" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15) + (v128.const i8x16 0 2 4 6 8 10 12 14 16 18 20 22 24 26 28 30)) + (v128.const i8x16 0 3 6 9 12 15 18 21 24 27 30 33 36 39 42 45)) + +;; i8x16.sub +(assert_return (invoke "i8x16.sub" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i8x16.sub" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "i8x16.sub" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i8x16.sub" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) +(assert_return (invoke "i8x16.sub" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2)) +(assert_return (invoke "i8x16.sub" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i8x16.sub" (v128.const i8x16 63 63 63 63 63 63 63 63 63 63 63 63 63 63 63 63) + (v128.const i8x16 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "i8x16.sub" (v128.const i8x16 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64) + (v128.const i8x16 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i8x16.sub" (v128.const i8x16 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63) + (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64)) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) +(assert_return (invoke "i8x16.sub" (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64) + (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i8x16.sub" (v128.const i8x16 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65) + (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "i8x16.sub" (v128.const i8x16 125 125 125 125 125 125 125 125 125 125 125 125 125 125 125 125) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) + (v128.const i8x16 124 124 124 124 124 124 124 124 124 124 124 124 124 124 124 124)) +(assert_return (invoke "i8x16.sub" (v128.const i8x16 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) + (v128.const i8x16 125 125 125 125 125 125 125 125 125 125 125 125 125 125 125 125)) +(assert_return (invoke "i8x16.sub" (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) + (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127)) +(assert_return (invoke "i8x16.sub" (v128.const i8x16 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i8x16 -125 -125 -125 -125 -125 -125 -125 -125 -125 -125 -125 -125 -125 -125 -125 -125)) +(assert_return (invoke "i8x16.sub" (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i8x16 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126)) +(assert_return (invoke "i8x16.sub" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127)) +(assert_return (invoke "i8x16.sub" (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127) + (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i8x16.sub" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128) + (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i8x16.sub" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128) + (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "i8x16.sub" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "i8x16.sub" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) + (v128.const i8x16 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2)) +(assert_return (invoke "i8x16.sub" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i8x16.sub" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255) + (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127)) + (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)) +(assert_return (invoke "i8x16.sub" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255) + (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)) + (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127)) +(assert_return (invoke "i8x16.sub" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255) + (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i8x16.sub" (v128.const i8x16 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f) + (v128.const i8x16 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "i8x16.sub" (v128.const i8x16 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40) + (v128.const i8x16 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i8x16.sub" (v128.const i8x16 -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f) + (v128.const i8x16 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40)) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) +(assert_return (invoke "i8x16.sub" (v128.const i8x16 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40) + (v128.const i8x16 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i8x16.sub" (v128.const i8x16 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40) + (v128.const i8x16 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41)) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) +(assert_return (invoke "i8x16.sub" (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f) + (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i8x16.sub" (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f) + (v128.const i8x16 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01)) + (v128.const i8x16 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126)) +(assert_return (invoke "i8x16.sub" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80) + (v128.const i8x16 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01)) + (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127)) +(assert_return (invoke "i8x16.sub" (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f) + (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "i8x16.sub" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80) + (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i8x16.sub" (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff) + (v128.const i8x16 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01)) + (v128.const i8x16 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2)) +(assert_return (invoke "i8x16.sub" (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff) + (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i8x16.sub" (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f) + (v128.const i16x8 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "i8x16.sub" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1) + (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)) + (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2)) +(assert_return (invoke "i8x16.sub" (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f) + (v128.const i32x4 0x80808080 0x80808080 0x80808080 0x80808080)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "i8x16.sub" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1) + (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff)) + (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2)) +(assert_return (invoke "i8x16.sub" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80) + (v128.const f32x4 +0.0 +0.0 +0.0 +0.0)) + (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)) +(assert_return (invoke "i8x16.sub" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80) + (v128.const f32x4 -0.0 -0.0 -0.0 -0.0)) + (v128.const i8x16 0x80 0x80 0x80 0 0x80 0x80 0x80 0 0x80 0x80 0x80 0 0x80 0x80 0x80 0)) +(assert_return (invoke "i8x16.sub" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80) + (v128.const f32x4 1.0 1.0 1.0 1.0)) + (v128.const i8x16 0x80 0x80 0 0x41 0x80 0x80 0 0x41 0x80 0x80 0 0x41 0x80 0x80 0 0x41)) +(assert_return (invoke "i8x16.sub" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80) + (v128.const f32x4 -1.0 -1.0 -1.0 -1.0)) + (v128.const i8x16 0x80 0x80 0 0xc1 0x80 0x80 0 0xc1 0x80 0x80 0 0xc1 0x80 0x80 0 0xc1)) +(assert_return (invoke "i8x16.sub" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1) + (v128.const f32x4 +inf +inf +inf +inf)) + (v128.const i8x16 0x01 0x01 0x81 0x82 0x01 0x01 0x81 0x82 0x01 0x01 0x81 0x82 0x01 0x01 0x81 0x82)) +(assert_return (invoke "i8x16.sub" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const i8x16 0x01 0x01 0x81 0x02 0x01 0x01 0x81 0x02 0x01 0x01 0x81 0x02 0x01 0x01 0x81 0x02)) +(assert_return (invoke "i8x16.sub" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1) + (v128.const f32x4 nan nan nan nan)) + (v128.const i8x16 0x01 0x01 0x41 0x82 0x01 0x01 0x41 0x82 0x01 0x01 0x41 0x82 0x01 0x01 0x41 0x82)) +(assert_return (invoke "i8x16.sub" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15) + (v128.const i8x16 0 0xff 0xfe 0xfd 0xfc 0xfb 0xfa 0xf9 0xf8 0xf7 0xf6 0xf5 0xf4 0xf3 0xf2 0xf1)) + (v128.const i8x16 0 0x02 0x04 0x06 0x08 0x0a 0x0c 0x0e 0x10 0x12 0x14 0x16 0x18 0x1a 0x1c 0x1e)) +(assert_return (invoke "i8x16.sub" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15) + (v128.const i8x16 0 2 4 6 8 10 12 14 16 18 20 22 24 26 28 30)) + (v128.const i8x16 0 -1 -2 -3 -4 -5 -6 -7 -8 -9 -10 -11 -12 -13 -14 -15)) + +;; i8x16.neg +(assert_return (invoke "i8x16.neg" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i8x16.neg" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "i8x16.neg" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) +(assert_return (invoke "i8x16.neg" (v128.const i8x16 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126)) + (v128.const i8x16 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126)) +(assert_return (invoke "i8x16.neg" (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127)) + (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127)) +(assert_return (invoke "i8x16.neg" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)) + (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)) +(assert_return (invoke "i8x16.neg" (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127)) + (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127)) +(assert_return (invoke "i8x16.neg" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) +(assert_return (invoke "i8x16.neg" (v128.const i8x16 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "i8x16.neg" (v128.const i8x16 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01)) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) +(assert_return (invoke "i8x16.neg" (v128.const i8x16 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80)) + (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)) +(assert_return (invoke "i8x16.neg" (v128.const i8x16 -0x7f -0x7f -0x7f -0x7f -0x7f -0x7f -0x7f -0x7f -0x7f -0x7f -0x7f -0x7f -0x7f -0x7f -0x7f -0x7f)) + (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127)) +(assert_return (invoke "i8x16.neg" (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f)) + (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127)) +(assert_return (invoke "i8x16.neg" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)) + (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)) +(assert_return (invoke "i8x16.neg" (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff)) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) + +;; type check +(assert_invalid (module (func (result v128) (i8x16.neg (i32.const 0)))) "type mismatch") +(assert_invalid (module (func (result v128) (i8x16.add (i32.const 0) (f32.const 0.0)))) "type mismatch") +(assert_invalid (module (func (result v128) (i8x16.sub (i32.const 0) (f32.const 0.0)))) "type mismatch") + +;; Test operation with empty argument + +(assert_invalid + (module + (func $i8x16.neg-arg-empty (result v128) + (i8x16.neg) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i8x16.add-1st-arg-empty (result v128) + (i8x16.add (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i8x16.add-arg-empty (result v128) + (i8x16.add) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i8x16.sub-1st-arg-empty (result v128) + (i8x16.sub (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i8x16.sub-arg-empty (result v128) + (i8x16.sub) + ) + ) + "type mismatch" +) + +;; combination +(module + (func (export "add-sub") (param v128 v128 v128) (result v128) + (i8x16.add (i8x16.sub (local.get 0) (local.get 1))(local.get 2))) + (func (export "sub-add") (param v128 v128 v128) (result v128) + (i8x16.sub (i8x16.add (local.get 0) (local.get 1))(local.get 2))) + (func (export "add-neg") (param v128 v128) (result v128) + (i8x16.add (i8x16.neg (local.get 0)) (local.get 1))) + (func (export "sub-neg") (param v128 v128) (result v128) + (i8x16.sub (i8x16.neg (local.get 0)) (local.get 1))) +) + +(assert_return (invoke "add-sub" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15) + (v128.const i8x16 0 2 4 6 8 10 12 14 16 18 20 22 24 26 28 30) + (v128.const i8x16 0 2 4 6 8 10 12 14 16 18 20 22 24 26 28 30)) + (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)) +(assert_return (invoke "sub-add" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15) + (v128.const i8x16 0 2 4 6 8 10 12 14 16 18 20 22 24 26 28 30) + (v128.const i8x16 0 2 4 6 8 10 12 14 16 18 20 22 24 26 28 30)) + (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)) +(assert_return (invoke "add-neg" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15) + (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "sub-neg" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15) + (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)) + (v128.const i8x16 0 -2 -4 -6 -8 -10 -12 -14 -16 -18 -20 -22 -24 -26 -28 -30)) \ No newline at end of file diff --git a/runtime/near-vm/tests/wast/spec/proposals/simd/simd_i8x16_arith2.wast b/runtime/near-vm/tests/wast/spec/proposals/simd/simd_i8x16_arith2.wast new file mode 100644 index 00000000000..991ec14bb85 --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/proposals/simd/simd_i8x16_arith2.wast @@ -0,0 +1,713 @@ +;; Tests for i8x16 [min_s, min_u, max_s, max_u, avgr_u, abs] operations. + +(module + (func (export "i8x16.min_s") (param v128 v128) (result v128) (i8x16.min_s (local.get 0) (local.get 1))) + (func (export "i8x16.min_u") (param v128 v128) (result v128) (i8x16.min_u (local.get 0) (local.get 1))) + (func (export "i8x16.max_s") (param v128 v128) (result v128) (i8x16.max_s (local.get 0) (local.get 1))) + (func (export "i8x16.max_u") (param v128 v128) (result v128) (i8x16.max_u (local.get 0) (local.get 1))) + (func (export "i8x16.avgr_u") (param v128 v128) (result v128) (i8x16.avgr_u (local.get 0) (local.get 1))) + (func (export "i8x16.abs") (param v128) (result v128) (i8x16.abs (local.get 0))) + (func (export "i8x16.popcnt") (param v128) (result v128) (i8x16.popcnt (local.get 0))) + (func (export "i8x16.min_s_with_const_0") (result v128) (i8x16.min_s (v128.const i8x16 -128 -128 -128 -128 127 127 127 127 64 64 64 64 255 255 255 255) (v128.const i8x16 255 255 255 255 64 64 64 64 127 127 127 127 -128 -128 -128 -128))) + (func (export "i8x16.min_s_with_const_1") (result v128) (i8x16.min_s (v128.const i8x16 0 0 0 0 1 1 1 1 2 2 2 2 3 3 3 3) (v128.const i8x16 3 3 3 3 2 2 2 2 1 1 1 1 0 0 0 0))) + (func (export "i8x16.min_u_with_const_2") (result v128) (i8x16.min_u (v128.const i8x16 -128 -128 -128 -128 127 127 127 127 64 64 64 64 255 255 255 255) (v128.const i8x16 255 255 255 255 64 64 64 64 127 127 127 127 -128 -128 -128 -128))) + (func (export "i8x16.min_u_with_const_3") (result v128) (i8x16.min_u (v128.const i8x16 0 0 0 0 1 1 1 1 2 2 2 2 3 3 3 3) (v128.const i8x16 3 3 3 3 2 2 2 2 1 1 1 1 0 0 0 0))) + (func (export "i8x16.max_s_with_const_4") (result v128) (i8x16.max_s (v128.const i8x16 -128 -128 -128 -128 127 127 127 127 64 64 64 64 255 255 255 255) (v128.const i8x16 255 255 255 255 64 64 64 64 127 127 127 127 -128 -128 -128 -128))) + (func (export "i8x16.max_s_with_const_5") (result v128) (i8x16.max_s (v128.const i8x16 0 0 0 0 1 1 1 1 2 2 2 2 3 3 3 3) (v128.const i8x16 3 3 3 3 2 2 2 2 1 1 1 1 0 0 0 0))) + (func (export "i8x16.max_u_with_const_6") (result v128) (i8x16.max_u (v128.const i8x16 -128 -128 -128 -128 127 127 127 127 64 64 64 64 255 255 255 255) (v128.const i8x16 255 255 255 255 64 64 64 64 127 127 127 127 -128 -128 -128 -128))) + (func (export "i8x16.max_u_with_const_7") (result v128) (i8x16.max_u (v128.const i8x16 0 0 0 0 1 1 1 1 2 2 2 2 3 3 3 3) (v128.const i8x16 3 3 3 3 2 2 2 2 1 1 1 1 0 0 0 0))) + (func (export "i8x16.avgr_u_with_const_8") (result v128) (i8x16.avgr_u (v128.const i8x16 -128 -128 -128 -128 127 127 127 127 64 64 64 64 255 255 255 255) (v128.const i8x16 255 255 255 255 64 64 64 64 127 127 127 127 -128 -128 -128 -128))) + (func (export "i8x16.avgr_u_with_const_9") (result v128) (i8x16.avgr_u (v128.const i8x16 0 0 0 0 1 1 1 1 2 2 2 2 3 3 3 3) (v128.const i8x16 3 3 3 3 2 2 2 2 1 1 1 1 0 0 0 0))) + (func (export "i8x16.abs_with_const_10") (result v128) (i8x16.abs (v128.const i8x16 -128 -128 -128 -128 127 127 127 127 64 64 64 64 255 255 255 255))) + (func (export "i8x16.popcnt_with_const_11") (result v128) (i8x16.popcnt (v128.const i8x16 -128 -128 -128 -128 127 127 127 127 64 64 64 64 255 255 255 255))) + (func (export "i8x16.min_s_with_const_12") (param v128) (result v128) (i8x16.min_s (local.get 0) (v128.const i8x16 -128 -128 -128 -128 127 127 127 127 64 64 64 64 255 255 255 255))) + (func (export "i8x16.min_s_with_const_13") (param v128) (result v128) (i8x16.min_s (local.get 0) (v128.const i8x16 0 0 0 0 1 1 1 1 2 2 2 2 3 3 3 3))) + (func (export "i8x16.min_u_with_const_14") (param v128) (result v128) (i8x16.min_u (local.get 0) (v128.const i8x16 -128 -128 -128 -128 127 127 127 127 64 64 64 64 255 255 255 255))) + (func (export "i8x16.min_u_with_const_15") (param v128) (result v128) (i8x16.min_u (local.get 0) (v128.const i8x16 0 0 0 0 1 1 1 1 2 2 2 2 3 3 3 3))) + (func (export "i8x16.max_s_with_const_16") (param v128) (result v128) (i8x16.max_s (local.get 0) (v128.const i8x16 -128 -128 -128 -128 127 127 127 127 64 64 64 64 255 255 255 255))) + (func (export "i8x16.max_s_with_const_17") (param v128) (result v128) (i8x16.max_s (local.get 0) (v128.const i8x16 0 0 0 0 1 1 1 1 2 2 2 2 3 3 3 3))) + (func (export "i8x16.max_u_with_const_18") (param v128) (result v128) (i8x16.max_u (local.get 0) (v128.const i8x16 -128 -128 -128 -128 127 127 127 127 64 64 64 64 255 255 255 255))) + (func (export "i8x16.max_u_with_const_19") (param v128) (result v128) (i8x16.max_u (local.get 0) (v128.const i8x16 0 0 0 0 1 1 1 1 2 2 2 2 3 3 3 3))) + (func (export "i8x16.avgr_u_with_const_20") (param v128) (result v128) (i8x16.avgr_u (local.get 0) (v128.const i8x16 -128 -128 -128 -128 127 127 127 127 64 64 64 64 255 255 255 255))) + (func (export "i8x16.avgr_u_with_const_21") (param v128) (result v128) (i8x16.avgr_u (local.get 0) (v128.const i8x16 0 0 0 0 1 1 1 1 2 2 2 2 3 3 3 3))) +) + +(assert_return (invoke "i8x16.min_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i8x16.min_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "i8x16.min_s" (v128.const i8x16 0 0 0 0 0 0 0 0 -1 -1 -1 -1 -1 -1 -1 -1) + (v128.const i8x16 0 0 0 0 -1 -1 -1 -1 0 0 0 0 -1 -1 -1 -1)) + (v128.const i8x16 0 0 0 0 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "i8x16.min_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) + (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff)) + (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff)) +(assert_return (invoke "i8x16.min_s" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) +(assert_return (invoke "i8x16.min_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) + (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)) +(assert_return (invoke "i8x16.min_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255) + (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128)) + (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128)) +(assert_return (invoke "i8x16.min_s" (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128) + (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)) + (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128)) +(assert_return (invoke "i8x16.min_s" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80) + (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)) + (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)) +(assert_return (invoke "i8x16.min_s" (v128.const i8x16 123 123 123 123 123 123 123 123 123 123 123 123 123 123 123 123) + (v128.const i8x16 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3)) + (v128.const i8x16 123 123 123 123 123 123 123 123 123 123 123 123 123 123 123 123)) +(assert_return (invoke "i8x16.min_s" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80) + (v128.const i8x16 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0)) + (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)) +(assert_return (invoke "i8x16.min_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i8x16.min_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i8x16.min_u" (v128.const i8x16 0 0 0 0 0 0 0 0 -1 -1 -1 -1 -1 -1 -1 -1) + (v128.const i8x16 0 0 0 0 -1 -1 -1 -1 0 0 0 0 -1 -1 -1 -1)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 -1 -1 -1 -1)) +(assert_return (invoke "i8x16.min_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) + (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i8x16.min_u" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) +(assert_return (invoke "i8x16.min_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) +(assert_return (invoke "i8x16.min_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255) + (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128)) + (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128)) +(assert_return (invoke "i8x16.min_u" (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128) + (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)) + (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128)) +(assert_return (invoke "i8x16.min_u" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80) + (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)) + (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)) +(assert_return (invoke "i8x16.min_u" (v128.const i8x16 123 123 123 123 123 123 123 123 123 123 123 123 123 123 123 123) + (v128.const i8x16 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3)) + (v128.const i8x16 123 123 123 123 123 123 123 123 123 123 123 123 123 123 123 123)) +(assert_return (invoke "i8x16.min_u" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80) + (v128.const i8x16 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0)) + (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)) +(assert_return (invoke "i8x16.max_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i8x16.max_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i8x16.max_s" (v128.const i8x16 0 0 0 0 0 0 0 0 -1 -1 -1 -1 -1 -1 -1 -1) + (v128.const i8x16 0 0 0 0 -1 -1 -1 -1 0 0 0 0 -1 -1 -1 -1)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 -1 -1 -1 -1)) +(assert_return (invoke "i8x16.max_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) + (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i8x16.max_s" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) +(assert_return (invoke "i8x16.max_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) +(assert_return (invoke "i8x16.max_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255) + (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128)) + (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)) +(assert_return (invoke "i8x16.max_s" (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128) + (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)) + (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128)) +(assert_return (invoke "i8x16.max_s" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80) + (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)) + (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)) +(assert_return (invoke "i8x16.max_s" (v128.const i8x16 123 123 123 123 123 123 123 123 123 123 123 123 123 123 123 123) + (v128.const i8x16 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3)) + (v128.const i8x16 123 123 123 123 123 123 123 123 123 123 123 123 123 123 123 123)) +(assert_return (invoke "i8x16.max_s" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80) + (v128.const i8x16 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0)) + (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)) +(assert_return (invoke "i8x16.max_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i8x16.max_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "i8x16.max_u" (v128.const i8x16 0 0 0 0 0 0 0 0 -1 -1 -1 -1 -1 -1 -1 -1) + (v128.const i8x16 0 0 0 0 -1 -1 -1 -1 0 0 0 0 -1 -1 -1 -1)) + (v128.const i8x16 0 0 0 0 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "i8x16.max_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) + (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff)) + (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff)) +(assert_return (invoke "i8x16.max_u" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) +(assert_return (invoke "i8x16.max_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) + (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)) +(assert_return (invoke "i8x16.max_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255) + (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128)) + (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)) +(assert_return (invoke "i8x16.max_u" (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128) + (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)) + (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128)) +(assert_return (invoke "i8x16.max_u" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80) + (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)) + (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)) +(assert_return (invoke "i8x16.max_u" (v128.const i8x16 123 123 123 123 123 123 123 123 123 123 123 123 123 123 123 123) + (v128.const i8x16 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3)) + (v128.const i8x16 123 123 123 123 123 123 123 123 123 123 123 123 123 123 123 123)) +(assert_return (invoke "i8x16.max_u" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80) + (v128.const i8x16 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0)) + (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)) +(assert_return (invoke "i8x16.avgr_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i8x16.avgr_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128)) +(assert_return (invoke "i8x16.avgr_u" (v128.const i8x16 0 0 0 0 0 0 0 0 -1 -1 -1 -1 -1 -1 -1 -1) + (v128.const i8x16 0 0 0 0 -1 -1 -1 -1 0 0 0 0 -1 -1 -1 -1)) + (v128.const i8x16 0 0 0 0 128 128 128 128 128 128 128 128 255 255 255 255)) +(assert_return (invoke "i8x16.avgr_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) + (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff)) + (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)) +(assert_return (invoke "i8x16.avgr_u" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) +(assert_return (invoke "i8x16.avgr_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) + (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128)) +(assert_return (invoke "i8x16.avgr_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255) + (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128)) + (v128.const i8x16 192 192 192 192 192 192 192 192 192 192 192 192 192 192 192 192)) +(assert_return (invoke "i8x16.avgr_u" (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128) + (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)) + (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128)) +(assert_return (invoke "i8x16.avgr_u" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80) + (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)) + (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)) +(assert_return (invoke "i8x16.avgr_u" (v128.const i8x16 123 123 123 123 123 123 123 123 123 123 123 123 123 123 123 123) + (v128.const i8x16 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3)) + (v128.const i8x16 123 123 123 123 123 123 123 123 123 123 123 123 123 123 123 123)) +(assert_return (invoke "i8x16.avgr_u" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80) + (v128.const i8x16 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0)) + (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)) +(assert_return (invoke "i8x16.abs" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) +(assert_return (invoke "i8x16.abs" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) +(assert_return (invoke "i8x16.abs" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) +(assert_return (invoke "i8x16.abs" (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff)) + (v128.const i8x16 0x1 0x1 0x1 0x1 0x1 0x1 0x1 0x1 0x1 0x1 0x1 0x1 0x1 0x1 0x1 0x1)) +(assert_return (invoke "i8x16.abs" (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128)) + (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128)) +(assert_return (invoke "i8x16.abs" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)) + (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128)) +(assert_return (invoke "i8x16.abs" (v128.const i8x16 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80)) + (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)) +(assert_return (invoke "i8x16.abs" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)) + (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)) +(assert_return (invoke "i8x16.abs" (v128.const i8x16 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3)) + (v128.const i8x16 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3)) +(assert_return (invoke "i8x16.abs" (v128.const i8x16 -01_2_3 -01_2_3 -01_2_3 -01_2_3 -01_2_3 -01_2_3 -01_2_3 -01_2_3 -01_2_3 -01_2_3 -01_2_3 -01_2_3 -01_2_3 -01_2_3 -01_2_3 -01_2_3)) + (v128.const i8x16 123 123 123 123 123 123 123 123 123 123 123 123 123 123 123 123)) +(assert_return (invoke "i8x16.abs" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)) + (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)) +(assert_return (invoke "i8x16.abs" (v128.const i8x16 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80)) + (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)) +(assert_return (invoke "i8x16.abs" (v128.const i8x16 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0)) + (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)) +(assert_return (invoke "i8x16.abs" (v128.const i8x16 -0x0_8_0 -0x0_8_0 -0x0_8_0 -0x0_8_0 -0x0_8_0 -0x0_8_0 -0x0_8_0 -0x0_8_0 -0x0_8_0 -0x0_8_0 -0x0_8_0 -0x0_8_0 -0x0_8_0 -0x0_8_0 -0x0_8_0 -0x0_8_0)) + (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)) +(assert_return (invoke "i8x16.popcnt" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) +(assert_return (invoke "i8x16.popcnt" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i8x16 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8)) +(assert_return (invoke "i8x16.popcnt" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)) + (v128.const i8x16 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8)) +(assert_return (invoke "i8x16.popcnt" (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff)) + (v128.const i8x16 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8)) +(assert_return (invoke "i8x16.popcnt" (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128)) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) +(assert_return (invoke "i8x16.popcnt" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) +(assert_return (invoke "i8x16.popcnt" (v128.const i8x16 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80)) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) +(assert_return (invoke "i8x16.popcnt" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) +(assert_return (invoke "i8x16.popcnt" (v128.const i8x16 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3)) + (v128.const i8x16 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6)) +(assert_return (invoke "i8x16.popcnt" (v128.const i8x16 -01_2_3 -01_2_3 -01_2_3 -01_2_3 -01_2_3 -01_2_3 -01_2_3 -01_2_3 -01_2_3 -01_2_3 -01_2_3 -01_2_3 -01_2_3 -01_2_3 -01_2_3 -01_2_3)) + (v128.const i8x16 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3)) +(assert_return (invoke "i8x16.popcnt" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) +(assert_return (invoke "i8x16.popcnt" (v128.const i8x16 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80)) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) +(assert_return (invoke "i8x16.popcnt" (v128.const i8x16 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0)) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) +(assert_return (invoke "i8x16.popcnt" (v128.const i8x16 -0x0_8_0 -0x0_8_0 -0x0_8_0 -0x0_8_0 -0x0_8_0 -0x0_8_0 -0x0_8_0 -0x0_8_0 -0x0_8_0 -0x0_8_0 -0x0_8_0 -0x0_8_0 -0x0_8_0 -0x0_8_0 -0x0_8_0 -0x0_8_0)) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) + +;; Const vs const +(assert_return (invoke "i8x16.min_s_with_const_0") (v128.const i8x16 -128 -128 -128 -128 64 64 64 64 64 64 64 64 -128 -128 -128 -128)) +(assert_return (invoke "i8x16.min_s_with_const_1") (v128.const i8x16 0 0 0 0 1 1 1 1 1 1 1 1 0 0 0 0)) +(assert_return (invoke "i8x16.min_u_with_const_2") (v128.const i8x16 -128 -128 -128 -128 64 64 64 64 64 64 64 64 -128 -128 -128 -128)) +(assert_return (invoke "i8x16.min_u_with_const_3") (v128.const i8x16 0 0 0 0 1 1 1 1 1 1 1 1 0 0 0 0)) +(assert_return (invoke "i8x16.max_s_with_const_4") (v128.const i8x16 255 255 255 255 127 127 127 127 127 127 127 127 255 255 255 255)) +(assert_return (invoke "i8x16.max_s_with_const_5") (v128.const i8x16 3 3 3 3 2 2 2 2 2 2 2 2 3 3 3 3)) +(assert_return (invoke "i8x16.max_u_with_const_6") (v128.const i8x16 255 255 255 255 127 127 127 127 127 127 127 127 255 255 255 255)) +(assert_return (invoke "i8x16.max_u_with_const_7") (v128.const i8x16 3 3 3 3 2 2 2 2 2 2 2 2 3 3 3 3)) +(assert_return (invoke "i8x16.avgr_u_with_const_8") (v128.const i8x16 192 192 192 192 96 96 96 96 96 96 96 96 192 192 192 192)) +(assert_return (invoke "i8x16.avgr_u_with_const_9") (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2)) +(assert_return (invoke "i8x16.abs_with_const_10") (v128.const i8x16 128 128 128 128 127 127 127 127 64 64 64 64 1 1 1 1)) +(assert_return (invoke "i8x16.popcnt_with_const_11") (v128.const i8x16 1 1 1 1 7 7 7 7 1 1 1 1 8 8 8 8)) + +;; Param vs const +(assert_return (invoke "i8x16.min_s_with_const_12" (v128.const i8x16 255 255 255 255 64 64 64 64 127 127 127 127 -128 -128 -128 -128)) + (v128.const i8x16 -128 -128 -128 -128 64 64 64 64 64 64 64 64 -128 -128 -128 -128)) +(assert_return (invoke "i8x16.min_s_with_const_13" (v128.const i8x16 3 3 3 3 2 2 2 2 1 1 1 1 0 0 0 0)) + (v128.const i8x16 0 0 0 0 1 1 1 1 1 1 1 1 0 0 0 0)) +(assert_return (invoke "i8x16.min_u_with_const_14" (v128.const i8x16 255 255 255 255 64 64 64 64 127 127 127 127 -128 -128 -128 -128)) + (v128.const i8x16 -128 -128 -128 -128 64 64 64 64 64 64 64 64 -128 -128 -128 -128)) +(assert_return (invoke "i8x16.min_u_with_const_15" (v128.const i8x16 3 3 3 3 2 2 2 2 1 1 1 1 0 0 0 0)) + (v128.const i8x16 0 0 0 0 1 1 1 1 1 1 1 1 0 0 0 0)) +(assert_return (invoke "i8x16.max_s_with_const_16" (v128.const i8x16 255 255 255 255 64 64 64 64 127 127 127 127 -128 -128 -128 -128)) + (v128.const i8x16 255 255 255 255 127 127 127 127 127 127 127 127 255 255 255 255)) +(assert_return (invoke "i8x16.max_s_with_const_17" (v128.const i8x16 3 3 3 3 2 2 2 2 1 1 1 1 0 0 0 0)) + (v128.const i8x16 3 3 3 3 2 2 2 2 2 2 2 2 3 3 3 3)) +(assert_return (invoke "i8x16.max_u_with_const_18" (v128.const i8x16 255 255 255 255 64 64 64 64 127 127 127 127 -128 -128 -128 -128)) + (v128.const i8x16 255 255 255 255 127 127 127 127 127 127 127 127 255 255 255 255)) +(assert_return (invoke "i8x16.max_u_with_const_19" (v128.const i8x16 3 3 3 3 2 2 2 2 1 1 1 1 0 0 0 0)) + (v128.const i8x16 3 3 3 3 2 2 2 2 2 2 2 2 3 3 3 3)) +(assert_return (invoke "i8x16.avgr_u_with_const_20" (v128.const i8x16 255 255 255 255 64 64 64 64 127 127 127 127 -128 -128 -128 -128)) + (v128.const i8x16 192 192 192 192 96 96 96 96 96 96 96 96 192 192 192 192)) +(assert_return (invoke "i8x16.avgr_u_with_const_21" (v128.const i8x16 3 3 3 3 2 2 2 2 1 1 1 1 0 0 0 0)) + (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2)) + +;; Test different lanes go through different if-then clauses +(assert_return (invoke "i8x16.min_s" (v128.const i8x16 -128 -128 -128 -128 127 127 127 127 64 64 64 64 255 255 255 255) + (v128.const i8x16 255 255 255 255 64 64 64 64 127 127 127 127 -128 -128 -128 -128)) + (v128.const i8x16 -128 -128 -128 -128 64 64 64 64 64 64 64 64 -128 -128 -128 -128)) +(assert_return (invoke "i8x16.min_s" (v128.const i8x16 0 0 0 0 1 1 1 1 2 2 2 2 128 128 128 128) + (v128.const i8x16 0 0 0 0 2 2 2 2 1 1 1 1 128 128 128 128)) + (v128.const i8x16 0 0 0 0 1 1 1 1 1 1 1 1 128 128 128 128)) +(assert_return (invoke "i8x16.min_u" (v128.const i8x16 -128 -128 -128 -128 127 127 127 127 64 64 64 64 255 255 255 255) + (v128.const i8x16 255 255 255 255 64 64 64 64 127 127 127 127 -128 -128 -128 -128)) + (v128.const i8x16 -128 -128 -128 -128 64 64 64 64 64 64 64 64 -128 -128 -128 -128)) +(assert_return (invoke "i8x16.min_u" (v128.const i8x16 0 0 0 0 1 1 1 1 2 2 2 2 128 128 128 128) + (v128.const i8x16 0 0 0 0 2 2 2 2 1 1 1 1 128 128 128 128)) + (v128.const i8x16 0 0 0 0 1 1 1 1 1 1 1 1 128 128 128 128)) +(assert_return (invoke "i8x16.max_s" (v128.const i8x16 -128 -128 -128 -128 127 127 127 127 64 64 64 64 255 255 255 255) + (v128.const i8x16 255 255 255 255 64 64 64 64 127 127 127 127 -128 -128 -128 -128)) + (v128.const i8x16 255 255 255 255 127 127 127 127 127 127 127 127 255 255 255 255)) +(assert_return (invoke "i8x16.max_s" (v128.const i8x16 0 0 0 0 1 1 1 1 2 2 2 2 128 128 128 128) + (v128.const i8x16 0 0 0 0 2 2 2 2 1 1 1 1 128 128 128 128)) + (v128.const i8x16 0 0 0 0 2 2 2 2 2 2 2 2 128 128 128 128)) +(assert_return (invoke "i8x16.max_u" (v128.const i8x16 -128 -128 -128 -128 127 127 127 127 64 64 64 64 255 255 255 255) + (v128.const i8x16 255 255 255 255 64 64 64 64 127 127 127 127 -128 -128 -128 -128)) + (v128.const i8x16 255 255 255 255 127 127 127 127 127 127 127 127 255 255 255 255)) +(assert_return (invoke "i8x16.max_u" (v128.const i8x16 0 0 0 0 1 1 1 1 2 2 2 2 128 128 128 128) + (v128.const i8x16 0 0 0 0 2 2 2 2 1 1 1 1 128 128 128 128)) + (v128.const i8x16 0 0 0 0 2 2 2 2 2 2 2 2 128 128 128 128)) +(assert_return (invoke "i8x16.avgr_u" (v128.const i8x16 -128 -128 -128 -128 127 127 127 127 64 64 64 64 255 255 255 255) + (v128.const i8x16 255 255 255 255 64 64 64 64 127 127 127 127 -128 -128 -128 -128)) + (v128.const i8x16 192 192 192 192 96 96 96 96 96 96 96 96 192 192 192 192)) +(assert_return (invoke "i8x16.avgr_u" (v128.const i8x16 0 0 0 0 1 1 1 1 2 2 2 2 128 128 128 128) + (v128.const i8x16 0 0 0 0 2 2 2 2 1 1 1 1 128 128 128 128)) + (v128.const i8x16 0 0 0 0 2 2 2 2 2 2 2 2 128 128 128 128)) +(assert_return (invoke "i8x16.abs" (v128.const i8x16 -128 -128 -128 -128 127 127 127 127 64 64 64 64 255 255 255 255)) + (v128.const i8x16 128 128 128 128 127 127 127 127 64 64 64 64 1 1 1 1)) +(assert_return (invoke "i8x16.popcnt" (v128.const i8x16 -128 -128 -128 -128 127 127 127 127 64 64 64 64 255 255 255 255)) + (v128.const i8x16 1 1 1 1 7 7 7 7 1 1 1 1 8 8 8 8)) + +;; Test opposite signs of zero +(assert_return (invoke "i8x16.min_s" (v128.const i8x16 -0 -0 -0 -0 -0 -0 -0 -0 +0 +0 +0 +0 +0 +0 +0 +0) + (v128.const i8x16 +0 +0 +0 +0 0 0 0 0 -0 -0 -0 -0 0 0 0 0)) + (v128.const i8x16 -0 -0 -0 -0 -0 -0 -0 -0 +0 +0 +0 +0 +0 +0 +0 +0)) +(assert_return (invoke "i8x16.min_s" (v128.const i8x16 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0) + (v128.const i8x16 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0)) + (v128.const i8x16 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0)) +(assert_return (invoke "i8x16.min_u" (v128.const i8x16 -0 -0 -0 -0 -0 -0 -0 -0 +0 +0 +0 +0 +0 +0 +0 +0) + (v128.const i8x16 +0 +0 +0 +0 0 0 0 0 -0 -0 -0 -0 0 0 0 0)) + (v128.const i8x16 -0 -0 -0 -0 -0 -0 -0 -0 +0 +0 +0 +0 +0 +0 +0 +0)) +(assert_return (invoke "i8x16.min_u" (v128.const i8x16 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0) + (v128.const i8x16 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0)) + (v128.const i8x16 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0)) +(assert_return (invoke "i8x16.max_s" (v128.const i8x16 -0 -0 -0 -0 -0 -0 -0 -0 +0 +0 +0 +0 +0 +0 +0 +0) + (v128.const i8x16 +0 +0 +0 +0 0 0 0 0 -0 -0 -0 -0 0 0 0 0)) + (v128.const i8x16 -0 -0 -0 -0 -0 -0 -0 -0 +0 +0 +0 +0 +0 +0 +0 +0)) +(assert_return (invoke "i8x16.max_s" (v128.const i8x16 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0) + (v128.const i8x16 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0)) + (v128.const i8x16 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0)) +(assert_return (invoke "i8x16.max_u" (v128.const i8x16 -0 -0 -0 -0 -0 -0 -0 -0 +0 +0 +0 +0 +0 +0 +0 +0) + (v128.const i8x16 +0 +0 +0 +0 0 0 0 0 -0 -0 -0 -0 0 0 0 0)) + (v128.const i8x16 -0 -0 -0 -0 -0 -0 -0 -0 +0 +0 +0 +0 +0 +0 +0 +0)) +(assert_return (invoke "i8x16.max_u" (v128.const i8x16 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0) + (v128.const i8x16 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0)) + (v128.const i8x16 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0)) +(assert_return (invoke "i8x16.avgr_u" (v128.const i8x16 -0 -0 -0 -0 -0 -0 -0 -0 +0 +0 +0 +0 +0 +0 +0 +0) + (v128.const i8x16 +0 +0 +0 +0 0 0 0 0 -0 -0 -0 -0 0 0 0 0)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i8x16.avgr_u" (v128.const i8x16 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0) + (v128.const i8x16 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i8x16.abs" (v128.const i8x16 -0 -0 -0 -0 -0 -0 -0 -0 +0 +0 +0 +0 +0 +0 +0 +0)) + (v128.const i8x16 -0 -0 -0 -0 -0 -0 -0 -0 +0 +0 +0 +0 +0 +0 +0 +0)) +(assert_return (invoke "i8x16.abs" (v128.const i8x16 +0 +0 +0 +0 0 0 0 0 -0 -0 -0 -0 0 0 0 0)) + (v128.const i8x16 +0 +0 +0 +0 0 0 0 0 -0 -0 -0 -0 0 0 0 0)) +(assert_return (invoke "i8x16.abs" (v128.const i8x16 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0)) + (v128.const i8x16 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0)) +(assert_return (invoke "i8x16.abs" (v128.const i8x16 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0)) + (v128.const i8x16 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0)) +(assert_return (invoke "i8x16.popcnt" (v128.const i8x16 -0 -0 -0 -0 -0 -0 -0 -0 +0 +0 +0 +0 +0 +0 +0 +0)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i8x16.popcnt" (v128.const i8x16 +0 +0 +0 +0 0 0 0 0 -0 -0 -0 -0 0 0 0 0)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i8x16.popcnt" (v128.const i8x16 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i8x16.popcnt" (v128.const i8x16 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + +;; Unknown operators +(assert_malformed (module quote "(memory 1) (func (result v128) (i32x4.avgr_u (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)))") "unknown operator") +(assert_malformed (module quote "(memory 1) (func (result v128) (f32x4.avgr_u (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)))") "unknown operator") +(assert_malformed (module quote "(memory 1) (func (result v128) (i64x2.avgr_u (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)))") "unknown operator") +(assert_malformed (module quote "(memory 1) (func (result v128) (f64x2.avgr_u (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)))") "unknown operator") +(assert_malformed (module quote "(memory 1) (func (result v128) (i8x16.avgr (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)))") "unknown operator") +(assert_malformed (module quote "(memory 1) (func (result v128) (i8x16.avgr_s (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)))") "unknown operator") + +;; Type check +(assert_invalid (module (func (result v128) (i8x16.min_s (i32.const 0) (f32.const 0.0)))) "type mismatch") +(assert_invalid (module (func (result v128) (i8x16.min_u (i32.const 0) (f32.const 0.0)))) "type mismatch") +(assert_invalid (module (func (result v128) (i8x16.max_s (i32.const 0) (f32.const 0.0)))) "type mismatch") +(assert_invalid (module (func (result v128) (i8x16.max_u (i32.const 0) (f32.const 0.0)))) "type mismatch") +(assert_invalid (module (func (result v128) (i8x16.avgr_u (i32.const 0) (f32.const 0.0)))) "type mismatch") +(assert_invalid (module (func (result v128) (i8x16.abs (f32.const 0.0)))) "type mismatch") +(assert_invalid (module (func (result v128) (i8x16.popcnt (f32.const 0.0)))) "type mismatch") + +;; Test operation with empty argument + +(assert_invalid + (module + (func $i8x16.min_s-1st-arg-empty (result v128) + (i8x16.min_s (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i8x16.min_s-arg-empty (result v128) + (i8x16.min_s) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i8x16.min_u-1st-arg-empty (result v128) + (i8x16.min_u (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i8x16.min_u-arg-empty (result v128) + (i8x16.min_u) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i8x16.max_s-1st-arg-empty (result v128) + (i8x16.max_s (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i8x16.max_s-arg-empty (result v128) + (i8x16.max_s) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i8x16.max_u-1st-arg-empty (result v128) + (i8x16.max_u (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i8x16.max_u-arg-empty (result v128) + (i8x16.max_u) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i8x16.avgr_u-1st-arg-empty (result v128) + (i8x16.avgr_u (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i8x16.avgr_u-arg-empty (result v128) + (i8x16.avgr_u) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i8x16.abs-arg-empty (result v128) + (i8x16.abs) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i8x16.popcnt-arg-empty (result v128) + (i8x16.popcnt) + ) + ) + "type mismatch" +) + +;; Combination +(module + (func (export "i8x16.min_s-i8x16.avgr_u") (param v128 v128 v128) (result v128) (i8x16.min_s (i8x16.avgr_u (local.get 0) (local.get 1))(local.get 2))) + (func (export "i8x16.min_s-i8x16.max_u") (param v128 v128 v128) (result v128) (i8x16.min_s (i8x16.max_u (local.get 0) (local.get 1))(local.get 2))) + (func (export "i8x16.min_s-i8x16.max_s") (param v128 v128 v128) (result v128) (i8x16.min_s (i8x16.max_s (local.get 0) (local.get 1))(local.get 2))) + (func (export "i8x16.min_s-i8x16.min_u") (param v128 v128 v128) (result v128) (i8x16.min_s (i8x16.min_u (local.get 0) (local.get 1))(local.get 2))) + (func (export "i8x16.min_s-i8x16.min_s") (param v128 v128 v128) (result v128) (i8x16.min_s (i8x16.min_s (local.get 0) (local.get 1))(local.get 2))) + (func (export "i8x16.min_s-i8x16.abs") (param v128 v128) (result v128) (i8x16.min_s (i8x16.abs (local.get 0))(local.get 1))) + (func (export "i8x16.abs-i8x16.min_s") (param v128 v128) (result v128) (i8x16.abs (i8x16.min_s (local.get 0) (local.get 1)))) + (func (export "i8x16.min_s-i8x16.popcnt") (param v128 v128) (result v128) (i8x16.min_s (i8x16.popcnt (local.get 0))(local.get 1))) + (func (export "i8x16.popcnt-i8x16.min_s") (param v128 v128) (result v128) (i8x16.popcnt (i8x16.min_s (local.get 0) (local.get 1)))) + (func (export "i8x16.min_u-i8x16.avgr_u") (param v128 v128 v128) (result v128) (i8x16.min_u (i8x16.avgr_u (local.get 0) (local.get 1))(local.get 2))) + (func (export "i8x16.min_u-i8x16.max_u") (param v128 v128 v128) (result v128) (i8x16.min_u (i8x16.max_u (local.get 0) (local.get 1))(local.get 2))) + (func (export "i8x16.min_u-i8x16.max_s") (param v128 v128 v128) (result v128) (i8x16.min_u (i8x16.max_s (local.get 0) (local.get 1))(local.get 2))) + (func (export "i8x16.min_u-i8x16.min_u") (param v128 v128 v128) (result v128) (i8x16.min_u (i8x16.min_u (local.get 0) (local.get 1))(local.get 2))) + (func (export "i8x16.min_u-i8x16.min_s") (param v128 v128 v128) (result v128) (i8x16.min_u (i8x16.min_s (local.get 0) (local.get 1))(local.get 2))) + (func (export "i8x16.min_u-i8x16.abs") (param v128 v128) (result v128) (i8x16.min_u (i8x16.abs (local.get 0))(local.get 1))) + (func (export "i8x16.abs-i8x16.min_u") (param v128 v128) (result v128) (i8x16.abs (i8x16.min_u (local.get 0) (local.get 1)))) + (func (export "i8x16.min_u-i8x16.popcnt") (param v128 v128) (result v128) (i8x16.min_u (i8x16.popcnt (local.get 0))(local.get 1))) + (func (export "i8x16.popcnt-i8x16.min_u") (param v128 v128) (result v128) (i8x16.popcnt (i8x16.min_u (local.get 0) (local.get 1)))) + (func (export "i8x16.max_s-i8x16.avgr_u") (param v128 v128 v128) (result v128) (i8x16.max_s (i8x16.avgr_u (local.get 0) (local.get 1))(local.get 2))) + (func (export "i8x16.max_s-i8x16.max_u") (param v128 v128 v128) (result v128) (i8x16.max_s (i8x16.max_u (local.get 0) (local.get 1))(local.get 2))) + (func (export "i8x16.max_s-i8x16.max_s") (param v128 v128 v128) (result v128) (i8x16.max_s (i8x16.max_s (local.get 0) (local.get 1))(local.get 2))) + (func (export "i8x16.max_s-i8x16.min_u") (param v128 v128 v128) (result v128) (i8x16.max_s (i8x16.min_u (local.get 0) (local.get 1))(local.get 2))) + (func (export "i8x16.max_s-i8x16.min_s") (param v128 v128 v128) (result v128) (i8x16.max_s (i8x16.min_s (local.get 0) (local.get 1))(local.get 2))) + (func (export "i8x16.max_s-i8x16.abs") (param v128 v128) (result v128) (i8x16.max_s (i8x16.abs (local.get 0))(local.get 1))) + (func (export "i8x16.abs-i8x16.max_s") (param v128 v128) (result v128) (i8x16.abs (i8x16.max_s (local.get 0) (local.get 1)))) + (func (export "i8x16.max_s-i8x16.popcnt") (param v128 v128) (result v128) (i8x16.max_s (i8x16.popcnt (local.get 0))(local.get 1))) + (func (export "i8x16.popcnt-i8x16.max_s") (param v128 v128) (result v128) (i8x16.popcnt (i8x16.max_s (local.get 0) (local.get 1)))) + (func (export "i8x16.max_u-i8x16.avgr_u") (param v128 v128 v128) (result v128) (i8x16.max_u (i8x16.avgr_u (local.get 0) (local.get 1))(local.get 2))) + (func (export "i8x16.max_u-i8x16.max_u") (param v128 v128 v128) (result v128) (i8x16.max_u (i8x16.max_u (local.get 0) (local.get 1))(local.get 2))) + (func (export "i8x16.max_u-i8x16.max_s") (param v128 v128 v128) (result v128) (i8x16.max_u (i8x16.max_s (local.get 0) (local.get 1))(local.get 2))) + (func (export "i8x16.max_u-i8x16.min_u") (param v128 v128 v128) (result v128) (i8x16.max_u (i8x16.min_u (local.get 0) (local.get 1))(local.get 2))) + (func (export "i8x16.max_u-i8x16.min_s") (param v128 v128 v128) (result v128) (i8x16.max_u (i8x16.min_s (local.get 0) (local.get 1))(local.get 2))) + (func (export "i8x16.max_u-i8x16.abs") (param v128 v128) (result v128) (i8x16.max_u (i8x16.abs (local.get 0))(local.get 1))) + (func (export "i8x16.abs-i8x16.max_u") (param v128 v128) (result v128) (i8x16.abs (i8x16.max_u (local.get 0) (local.get 1)))) + (func (export "i8x16.max_u-i8x16.popcnt") (param v128 v128) (result v128) (i8x16.max_u (i8x16.popcnt (local.get 0))(local.get 1))) + (func (export "i8x16.popcnt-i8x16.max_u") (param v128 v128) (result v128) (i8x16.popcnt (i8x16.max_u (local.get 0) (local.get 1)))) + (func (export "i8x16.avgr_u-i8x16.avgr_u") (param v128 v128 v128) (result v128) (i8x16.avgr_u (i8x16.avgr_u (local.get 0) (local.get 1))(local.get 2))) + (func (export "i8x16.avgr_u-i8x16.max_u") (param v128 v128 v128) (result v128) (i8x16.avgr_u (i8x16.max_u (local.get 0) (local.get 1))(local.get 2))) + (func (export "i8x16.avgr_u-i8x16.max_s") (param v128 v128 v128) (result v128) (i8x16.avgr_u (i8x16.max_s (local.get 0) (local.get 1))(local.get 2))) + (func (export "i8x16.avgr_u-i8x16.min_u") (param v128 v128 v128) (result v128) (i8x16.avgr_u (i8x16.min_u (local.get 0) (local.get 1))(local.get 2))) + (func (export "i8x16.avgr_u-i8x16.min_s") (param v128 v128 v128) (result v128) (i8x16.avgr_u (i8x16.min_s (local.get 0) (local.get 1))(local.get 2))) + (func (export "i8x16.avgr_u-i8x16.abs") (param v128 v128) (result v128) (i8x16.avgr_u (i8x16.abs (local.get 0))(local.get 1))) + (func (export "i8x16.abs-i8x16.avgr_u") (param v128 v128) (result v128) (i8x16.abs (i8x16.avgr_u (local.get 0) (local.get 1)))) + (func (export "i8x16.avgr_u-i8x16.popcnt") (param v128 v128) (result v128) (i8x16.avgr_u (i8x16.popcnt (local.get 0))(local.get 1))) + (func (export "i8x16.popcnt-i8x16.avgr_u") (param v128 v128) (result v128) (i8x16.popcnt (i8x16.avgr_u (local.get 0) (local.get 1)))) + (func (export "i8x16.abs-i8x16.popcnt") (param v128) (result v128) (i8x16.abs (i8x16.popcnt (local.get 0)))) + (func (export "i8x16.abs-i8x16.abs") (param v128) (result v128) (i8x16.abs (i8x16.abs (local.get 0)))) + (func (export "i8x16.popcnt-i8x16.popcnt") (param v128) (result v128) (i8x16.popcnt (i8x16.popcnt (local.get 0)))) + (func (export "i8x16.popcnt-i8x16.abs") (param v128) (result v128) (i8x16.popcnt (i8x16.abs (local.get 0)))) +) + +(assert_return (invoke "i8x16.min_s-i8x16.avgr_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1) + (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2)) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) +(assert_return (invoke "i8x16.min_s-i8x16.max_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1) + (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2)) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) +(assert_return (invoke "i8x16.min_s-i8x16.max_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1) + (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2)) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) +(assert_return (invoke "i8x16.min_s-i8x16.min_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1) + (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i8x16.min_s-i8x16.min_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1) + (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i8x16.min_s-i8x16.abs" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i8x16.abs-i8x16.min_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) +(assert_return (invoke "i8x16.min_s-i8x16.popcnt" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i8x16.popcnt-i8x16.min_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i8x16 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8)) +(assert_return (invoke "i8x16.min_u-i8x16.avgr_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1) + (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2)) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) +(assert_return (invoke "i8x16.min_u-i8x16.max_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1) + (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2)) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) +(assert_return (invoke "i8x16.min_u-i8x16.max_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1) + (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2)) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) +(assert_return (invoke "i8x16.min_u-i8x16.min_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1) + (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i8x16.min_u-i8x16.min_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1) + (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i8x16.min_u-i8x16.abs" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i8x16.abs-i8x16.min_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i8x16.min_u-i8x16.popcnt" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i8x16.popcnt-i8x16.min_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i8x16.max_s-i8x16.avgr_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1) + (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2)) + (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2)) +(assert_return (invoke "i8x16.max_s-i8x16.max_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1) + (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2)) + (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2)) +(assert_return (invoke "i8x16.max_s-i8x16.max_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1) + (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2)) + (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2)) +(assert_return (invoke "i8x16.max_s-i8x16.min_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1) + (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2)) + (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2)) +(assert_return (invoke "i8x16.max_s-i8x16.min_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1) + (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2)) + (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2)) +(assert_return (invoke "i8x16.max_s-i8x16.abs" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) +(assert_return (invoke "i8x16.abs-i8x16.max_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i8x16.max_s-i8x16.popcnt" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + (v128.const i8x16 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8)) +(assert_return (invoke "i8x16.popcnt-i8x16.max_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i8x16.max_u-i8x16.avgr_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1) + (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2)) + (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2)) +(assert_return (invoke "i8x16.max_u-i8x16.max_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1) + (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2)) + (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2)) +(assert_return (invoke "i8x16.max_u-i8x16.max_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1) + (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2)) + (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2)) +(assert_return (invoke "i8x16.max_u-i8x16.min_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1) + (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2)) + (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2)) +(assert_return (invoke "i8x16.max_u-i8x16.min_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1) + (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2)) + (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2)) +(assert_return (invoke "i8x16.max_u-i8x16.abs" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) +(assert_return (invoke "i8x16.abs-i8x16.max_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) +(assert_return (invoke "i8x16.max_u-i8x16.popcnt" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + (v128.const i8x16 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8)) +(assert_return (invoke "i8x16.popcnt-i8x16.max_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i8x16 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8)) +(assert_return (invoke "i8x16.avgr_u-i8x16.avgr_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1) + (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2)) + (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2)) +(assert_return (invoke "i8x16.avgr_u-i8x16.max_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1) + (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2)) + (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2)) +(assert_return (invoke "i8x16.avgr_u-i8x16.max_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1) + (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2)) + (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2)) +(assert_return (invoke "i8x16.avgr_u-i8x16.min_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1) + (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2)) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) +(assert_return (invoke "i8x16.avgr_u-i8x16.min_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1) + (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2)) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) +(assert_return (invoke "i8x16.avgr_u-i8x16.abs" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) +(assert_return (invoke "i8x16.abs-i8x16.avgr_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128)) +(assert_return (invoke "i8x16.avgr_u-i8x16.popcnt" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + (v128.const i8x16 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4)) +(assert_return (invoke "i8x16.popcnt-i8x16.avgr_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) +(assert_return (invoke "i8x16.abs-i8x16.popcnt" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i8x16 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8)) +(assert_return (invoke "i8x16.abs-i8x16.abs" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) +(assert_return (invoke "i8x16.popcnt-i8x16.popcnt" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) +(assert_return (invoke "i8x16.popcnt-i8x16.abs" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) diff --git a/runtime/near-vm/tests/wast/spec/proposals/simd/simd_i8x16_cmp.wast b/runtime/near-vm/tests/wast/spec/proposals/simd/simd_i8x16_cmp.wast new file mode 100644 index 00000000000..8683accea43 --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/proposals/simd/simd_i8x16_cmp.wast @@ -0,0 +1,1847 @@ + +;; Test all the i8x16 comparison operators on major boundary values and all special values. + +(module + (func (export "eq") (param $x v128) (param $y v128) (result v128) (i8x16.eq (local.get $x) (local.get $y))) + (func (export "ne") (param $x v128) (param $y v128) (result v128) (i8x16.ne (local.get $x) (local.get $y))) + (func (export "lt_s") (param $x v128) (param $y v128) (result v128) (i8x16.lt_s (local.get $x) (local.get $y))) + (func (export "lt_u") (param $x v128) (param $y v128) (result v128) (i8x16.lt_u (local.get $x) (local.get $y))) + (func (export "le_s") (param $x v128) (param $y v128) (result v128) (i8x16.le_s (local.get $x) (local.get $y))) + (func (export "le_u") (param $x v128) (param $y v128) (result v128) (i8x16.le_u (local.get $x) (local.get $y))) + (func (export "gt_s") (param $x v128) (param $y v128) (result v128) (i8x16.gt_s (local.get $x) (local.get $y))) + (func (export "gt_u") (param $x v128) (param $y v128) (result v128) (i8x16.gt_u (local.get $x) (local.get $y))) + (func (export "ge_s") (param $x v128) (param $y v128) (result v128) (i8x16.ge_s (local.get $x) (local.get $y))) + (func (export "ge_u") (param $x v128) (param $y v128) (result v128) (i8x16.ge_u (local.get $x) (local.get $y))) +) + + +;; eq + +;; i8x16.eq (i8x16) (i8x16) + +;; hex vs hex +(assert_return (invoke "eq" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF) + (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "eq" (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00) + (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "eq" (v128.const i8x16 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0) + (v128.const i8x16 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "eq" (v128.const i8x16 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F) + (v128.const i8x16 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "eq" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00) + (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "eq" (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF) + (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "eq" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x09 0x10 0x11 0x12 0x0A 0x0B 0x1A 0x1B 0xAA 0xAB 0xFF) + (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x09 0x10 0x11 0x12 0x0A 0x0B 0x1A 0x1B 0xAA 0xAB 0xFF)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + +;; hex vs dec +(assert_return (invoke "eq" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF) + (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "eq" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "eq" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80) + (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "eq" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80) + (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "eq" (v128.const i8x16 0x80 0x81 0x82 0x83 0xFD 0xFE 0xFF 0x00 0x00 0x01 0x02 0x7F 0x80 0xFD 0xFE 0xFF) + (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + +;; dec vs dec +(assert_return (invoke "eq" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "eq" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "eq" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255) + (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "eq" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "eq" (v128.const i8x16 255 255 255 255 255 255 255 255 0 0 0 0 0 0 0 0) + (v128.const i8x16 255 255 255 255 255 255 255 255 0 0 0 0 0 0 0 0)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "eq" (v128.const i8x16 0 0 0 0 0 0 0 0 255 255 255 255 255 255 255 255) + (v128.const i8x16 0 0 0 0 0 0 0 0 255 255 255 255 255 255 255 255)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "eq" (v128.const i8x16 128 129 130 131 253 254 255 -0 0 1 2 127 128 253 254 255) + (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 -0 0 1 2 127 128 253 254 255)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + +;; hex vs float +(assert_return (invoke "eq" (v128.const i8x16 0x00 0x00 0x00 0xc3 0x00 0x00 0xfe 0xc2 0x00 0x00 0x80 0xbf 0x00 0x00 0x00 0x00) + (v128.const f32x4 -128.0 -127.0 -1.0 0.0)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "eq" (v128.const i8x16 0x00 0x00 0x80 0x3f 0x00 0x00 0xfe 0x42 0x00 0x00 0x00 0x43 0x00 0x00 0x7f 0x43) + (v128.const f32x4 1.0 127.0 128.0 255.0)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + +;; not equal +(assert_return (invoke "eq" (v128.const i8x16 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F) + (v128.const i8x16 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "eq" (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF) + (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "eq" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x09 0x10 0x11 0x12 0x0A 0x0B 0x1A 0x1B 0xAA 0xAB 0xFF) + (v128.const i8x16 0xFF 0xAB 0xAA 0x1B 0x1A 0x0B 0x0A 0x12 0x11 0x10 0x09 0x04 0x03 0x02 0x01 0x00)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "eq" (v128.const i8x16 0x80 0x81 0x82 0x83 0xFD 0xFE 0xFF 0x00 0x00 0x01 0x02 0x7F 0x80 0xFD 0xFE 0xFF) + (v128.const i8x16 255 254 253 128 127 2 1 0 0 -1 -2 -3 -125 -126 -127 -128)) + (v128.const i8x16 0 0 0 0 0 0 0 -1 -1 0 0 0 0 0 0 0)) +(assert_return (invoke "eq" (v128.const i8x16 128 129 130 131 253 254 255 -0 0 1 2 127 128 253 254 255) + (v128.const i8x16 255 254 253 128 127 2 1 0 -0 -1 -2 -3 -125 -126 -127 -128)) + (v128.const i8x16 0 0 0 0 0 0 0 -1 -1 0 0 0 0 0 0 0)) + +;; i8x16.eq (i8x16) (i16x8) +(assert_return (invoke "eq" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF) + (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "eq" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255) + (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "eq" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) + (v128.const i16x8 0 0 0 0 0 0 0 0)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "eq" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F) + (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "eq" (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255) + (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "eq" (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255) + (v128.const i16x8 -128 -128 0 0 1 1 255 255)) + (v128.const i8x16 -1 0 -1 0 -1 -1 -1 -1 -1 0 -1 0 -1 0 -1 0)) +(assert_return (invoke "eq" (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55) + (v128.const i16x8 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + +;; i8x16.eq (i8x16) (i32x4) +(assert_return (invoke "eq" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF) + (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "eq" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255) + (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "eq" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) + (v128.const i32x4 0 0 0 0)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "eq" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F) + (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "eq" (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255) + (v128.const i32x4 2206368128 16776957 2130837760 4294901120)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "eq" (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255) + (v128.const i32x4 -128 0 1 255)) + (v128.const i8x16 -1 0 0 0 -1 -1 -1 -1 -1 0 0 0 -1 0 0 0)) +(assert_return (invoke "eq" (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55) + (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + +;; ne + +;; i8x16.ne (i8x16) (i8x16) + +;; hex vs hex +(assert_return (invoke "ne" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF) + (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "ne" (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00) + (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "ne" (v128.const i8x16 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0) + (v128.const i8x16 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "ne" (v128.const i8x16 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F) + (v128.const i8x16 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "ne" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00) + (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "ne" (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF) + (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "ne" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x09 0x10 0x11 0x12 0x0A 0x0B 0x1A 0x1B 0xAA 0xAB 0xFF) + (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x09 0x10 0x11 0x12 0x0A 0x0B 0x1A 0x1B 0xAA 0xAB 0xFF)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + +;; hex vs dec +(assert_return (invoke "ne" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF) + (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "ne" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "ne" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80) + (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "ne" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80) + (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "ne" (v128.const i8x16 0x80 0x81 0x82 0x83 0xFD 0xFE 0xFF 0x00 0x00 0x01 0x02 0x7F 0x80 0xFD 0xFE 0xFF) + (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + +;; dec vs dec +(assert_return (invoke "ne" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "ne" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "ne" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255) + (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "ne" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "ne" (v128.const i8x16 255 255 255 255 255 255 255 255 0 0 0 0 0 0 0 0) + (v128.const i8x16 255 255 255 255 255 255 255 255 0 0 0 0 0 0 0 0)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "ne" (v128.const i8x16 0 0 0 0 0 0 0 0 255 255 255 255 255 255 255 255) + (v128.const i8x16 0 0 0 0 0 0 0 0 255 255 255 255 255 255 255 255)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "ne" (v128.const i8x16 128 129 130 131 253 254 255 -0 0 1 2 127 128 253 254 255) + (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 -0 0 1 2 127 128 253 254 255)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + +;; hex vs float +(assert_return (invoke "ne" (v128.const i8x16 0x00 0x00 0x00 0xc3 0x00 0x00 0xfe 0xc2 0x00 0x00 0x80 0xbf 0x00 0x00 0x00 0x00) + (v128.const f32x4 -128.0 -127.0 -1.0 0.0)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "ne" (v128.const i8x16 0x00 0x00 0x80 0x3f 0x00 0x00 0xfe 0x42 0x00 0x00 0x00 0x43 0x00 0x00 0x7f 0x43) + (v128.const f32x4 1.0 127.0 128.0 255.0)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + +;; not equal +(assert_return (invoke "ne" (v128.const i8x16 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F) + (v128.const i8x16 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF) + (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x09 0x10 0x11 0x12 0x0A 0x0B 0x1A 0x1B 0xAA 0xAB 0xFF) + (v128.const i8x16 0xFF 0xAB 0xAA 0x1B 0x1A 0x0B 0x0A 0x12 0x11 0x10 0x09 0x04 0x03 0x02 0x01 0x00)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const i8x16 0x80 0x81 0x82 0x83 0xFD 0xFE 0xFF 0x00 0x00 0x01 0x02 0x7F 0x80 0xFD 0xFE 0xFF) + (v128.const i8x16 255 254 253 128 127 2 1 0 0 -1 -2 -3 -125 -126 -127 -128)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 0 0 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const i8x16 128 129 130 131 253 254 255 -0 0 1 2 127 128 253 254 255) + (v128.const i8x16 255 254 253 128 127 2 1 0 -0 -1 -2 -3 -125 -126 -127 -128)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 0 0 -1 -1 -1 -1 -1 -1 -1)) + +;; i8x16.ne (i8x16) (i16x8) +(assert_return (invoke "ne" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF) + (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "ne" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255) + (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "ne" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) + (v128.const i16x8 0 0 0 0 0 0 0 0)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "ne" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F) + (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "ne" (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255) + (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "ne" (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255) + (v128.const i16x8 -128 -128 0 0 1 1 255 255)) + (v128.const i8x16 0 -1 0 -1 0 0 0 0 0 -1 0 -1 0 -1 0 -1)) +(assert_return (invoke "ne" (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55) + (v128.const i16x8 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + +;; i8x16.ne (i8x16) (i32x4) +(assert_return (invoke "ne" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF) + (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "ne" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255) + (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "ne" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) + (v128.const i32x4 0 0 0 0)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "ne" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F) + (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "ne" (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255) + (v128.const i32x4 2206368128 16776957 2130837760 4294901120)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "ne" (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255) + (v128.const i32x4 -128 0 1 255)) + (v128.const i8x16 0 -1 -1 -1 0 0 0 0 0 -1 -1 -1 0 -1 -1 -1)) +(assert_return (invoke "ne" (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55) + (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + +;; lt_s + +;; i8x16.lt_s (i8x16) (i8x16) + +;; hex vs hex +(assert_return (invoke "lt_s" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF) + (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "lt_s" (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00) + (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "lt_s" (v128.const i8x16 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0) + (v128.const i8x16 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "lt_s" (v128.const i8x16 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F) + (v128.const i8x16 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "lt_s" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00) + (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "lt_s" (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF) + (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "lt_s" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x09 0x10 0x11 0x12 0x0A 0x0B 0x1A 0x1B 0xAA 0xAB 0xFF) + (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x09 0x10 0x11 0x12 0x0A 0x0B 0x1A 0x1B 0xAA 0xAB 0xFF)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + +;; hex vs dec +(assert_return (invoke "lt_s" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF) + (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "lt_s" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "lt_s" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80) + (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "lt_s" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80) + (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "lt_s" (v128.const i8x16 0x80 0x81 0x82 0x83 0xFD 0xFE 0xFF 0x00 0x00 0x01 0x02 0x7F 0x80 0xFD 0xFE 0xFF) + (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + +;; dec vs dec +(assert_return (invoke "lt_s" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "lt_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "lt_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255) + (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "lt_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "lt_s" (v128.const i8x16 255 255 255 255 255 255 255 255 0 0 0 0 0 0 0 0) + (v128.const i8x16 255 255 255 255 255 255 255 255 0 0 0 0 0 0 0 0)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "lt_s" (v128.const i8x16 0 0 0 0 0 0 0 0 255 255 255 255 255 255 255 255) + (v128.const i8x16 0 0 0 0 0 0 0 0 255 255 255 255 255 255 255 255)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "lt_s" (v128.const i8x16 128 129 130 131 253 254 255 -0 0 1 2 127 128 253 254 255) + (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 -0 0 1 2 127 128 253 254 255)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + +;; hex vs float +(assert_return (invoke "lt_s" (v128.const i8x16 0x00 0x00 0x00 0xc3 0x00 0x00 0xfe 0xc2 0x00 0x00 0x80 0xbf 0x00 0x00 0x00 0x00) + (v128.const f32x4 -128.0 -127.0 -1.0 0.0)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "lt_s" (v128.const i8x16 0x00 0x00 0x80 0x3f 0x00 0x00 0xfe 0x42 0x00 0x00 0x00 0x43 0x00 0x00 0x7f 0x43) + (v128.const f32x4 1.0 127.0 128.0 255.0)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + +;; not equal +(assert_return (invoke "lt_s" (v128.const i8x16 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F) + (v128.const i8x16 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "lt_s" (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF) + (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00)) + (v128.const i8x16 0 0 0 0 0 0 0 0 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "lt_s" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x09 0x10 0x11 0x12 0x0A 0x0B 0x1A 0x1B 0xAA 0xAB 0xFF) + (v128.const i8x16 0xFF 0xAB 0xAA 0x1B 0x1A 0x0B 0x0A 0x12 0x11 0x10 0x09 0x04 0x03 0x02 0x01 0x00)) + (v128.const i8x16 0 0 0 -1 -1 -1 0 -1 0 -1 0 0 0 -1 -1 -1)) +(assert_return (invoke "lt_s" (v128.const i8x16 0x80 0x81 0x82 0x83 0xFD 0xFE 0xFF 0x00 0x00 0x01 0x02 0x7F 0x80 0xFD 0xFE 0xFF) + (v128.const i8x16 255 254 253 128 127 2 1 0 0 -1 -2 -3 -125 -126 -127 -128)) + (v128.const i8x16 -1 -1 -1 0 -1 -1 -1 0 0 0 0 0 -1 0 0 0)) +(assert_return (invoke "lt_s" (v128.const i8x16 128 129 130 131 253 254 255 -0 0 1 2 127 128 253 254 255) + (v128.const i8x16 255 254 253 128 127 2 1 0 -0 -1 -2 -3 -125 -126 -127 -128)) + (v128.const i8x16 -1 -1 -1 0 -1 -1 -1 0 0 0 0 0 -1 0 0 0)) + +;; i8x16.lt_s (i8x16) (i16x8) +(assert_return (invoke "lt_s" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF) + (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "lt_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255) + (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "lt_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) + (v128.const i16x8 0 0 0 0 0 0 0 0)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "lt_s" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F) + (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "lt_s" (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255) + (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "lt_s" (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255) + (v128.const i16x8 -128 -128 0 0 1 1 255 255)) + (v128.const i8x16 0 -1 0 -1 0 0 0 0 0 0 0 0 0 -1 0 -1)) +(assert_return (invoke "lt_s" (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55) + (v128.const i16x8 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + +;; i8x16.lt_s (i8x16) (i32x4) +(assert_return (invoke "lt_s" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF) + (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "lt_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255) + (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "lt_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) + (v128.const i32x4 0 0 0 0)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "lt_s" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F) + (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "lt_s" (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255) + (v128.const i32x4 2206368128 16776957 2130837760 4294901120)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "lt_s" (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255) + (v128.const i32x4 -128 0 1 255)) + (v128.const i8x16 0 -1 -1 -1 0 0 0 0 0 0 0 0 0 -1 -1 -1)) +(assert_return (invoke "lt_s" (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55) + (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + +;; lt_u + +;; i8x16.lt_u (i8x16) (i8x16) + +;; hex vs hex +(assert_return (invoke "lt_u" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF) + (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "lt_u" (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00) + (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "lt_u" (v128.const i8x16 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0) + (v128.const i8x16 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "lt_u" (v128.const i8x16 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F) + (v128.const i8x16 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "lt_u" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00) + (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "lt_u" (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF) + (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "lt_u" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x09 0x10 0x11 0x12 0x0A 0x0B 0x1A 0x1B 0xAA 0xAB 0xFF) + (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x09 0x10 0x11 0x12 0x0A 0x0B 0x1A 0x1B 0xAA 0xAB 0xFF)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + +;; hex vs dec +(assert_return (invoke "lt_u" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF) + (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "lt_u" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "lt_u" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80) + (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "lt_u" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80) + (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "lt_u" (v128.const i8x16 0x80 0x81 0x82 0x83 0xFD 0xFE 0xFF 0x00 0x00 0x01 0x02 0x7F 0x80 0xFD 0xFE 0xFF) + (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + +;; dec vs dec +(assert_return (invoke "lt_u" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "lt_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "lt_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255) + (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "lt_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "lt_u" (v128.const i8x16 255 255 255 255 255 255 255 255 0 0 0 0 0 0 0 0) + (v128.const i8x16 255 255 255 255 255 255 255 255 0 0 0 0 0 0 0 0)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "lt_u" (v128.const i8x16 0 0 0 0 0 0 0 0 255 255 255 255 255 255 255 255) + (v128.const i8x16 0 0 0 0 0 0 0 0 255 255 255 255 255 255 255 255)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "lt_u" (v128.const i8x16 128 129 130 131 253 254 255 -0 0 1 2 127 128 253 254 255) + (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 -0 0 1 2 127 128 253 254 255)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + +;; hex vs float +(assert_return (invoke "lt_u" (v128.const i8x16 0x00 0x00 0x00 0xc3 0x00 0x00 0xfe 0xc2 0x00 0x00 0x80 0xbf 0x00 0x00 0x00 0x00) + (v128.const f32x4 -128.0 -127.0 -1.0 0.0)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "lt_u" (v128.const i8x16 0x00 0x00 0x80 0x3f 0x00 0x00 0xfe 0x42 0x00 0x00 0x00 0x43 0x00 0x00 0x7f 0x43) + (v128.const f32x4 1.0 127.0 128.0 255.0)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + +;; not equal +(assert_return (invoke "lt_u" (v128.const i8x16 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F) + (v128.const i8x16 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "lt_u" (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF) + (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 0 0 0 0 0 0 0 0)) +(assert_return (invoke "lt_u" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x09 0x10 0x11 0x12 0x0A 0x0B 0x1A 0x1B 0xAA 0xAB 0xFF) + (v128.const i8x16 0xFF 0xAB 0xAA 0x1B 0x1A 0x0B 0x0A 0x12 0x11 0x10 0x09 0x04 0x03 0x02 0x01 0x00)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 0 -1 0 -1 0 0 0 0 0 0)) +(assert_return (invoke "lt_u" (v128.const i8x16 0x80 0x81 0x82 0x83 0xFD 0xFE 0xFF 0x00 0x00 0x01 0x02 0x7F 0x80 0xFD 0xFE 0xFF) + (v128.const i8x16 255 254 253 128 127 2 1 0 0 -1 -2 -3 -125 -126 -127 -128)) + (v128.const i8x16 -1 -1 -1 0 0 0 0 0 0 -1 -1 -1 -1 0 0 0)) +(assert_return (invoke "lt_u" (v128.const i8x16 128 129 130 131 253 254 255 -0 0 1 2 127 128 253 254 255) + (v128.const i8x16 255 254 253 128 127 2 1 0 -0 -1 -2 -3 -125 -126 -127 -128)) + (v128.const i8x16 -1 -1 -1 0 0 0 0 0 0 -1 -1 -1 -1 0 0 0)) + +;; i8x16.lt_u (i8x16) (i16x8) +(assert_return (invoke "lt_u" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF) + (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "lt_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255) + (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "lt_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) + (v128.const i16x8 0 0 0 0 0 0 0 0)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "lt_u" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F) + (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "lt_u" (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255) + (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "lt_u" (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255) + (v128.const i16x8 -128 -128 0 0 1 1 255 255)) + (v128.const i8x16 0 -1 0 -1 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "lt_u" (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55) + (v128.const i16x8 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + +;; i8x16.lt_u (i8x16) (i32x4) +(assert_return (invoke "lt_u" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF) + (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "lt_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255) + (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "lt_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) + (v128.const i32x4 0 0 0 0)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "lt_u" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F) + (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "lt_u" (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255) + (v128.const i32x4 2206368128 16776957 2130837760 4294901120)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "lt_u" (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255) + (v128.const i32x4 -128 0 1 255)) + (v128.const i8x16 0 -1 -1 -1 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "lt_u" (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55) + (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + +;; le_s + +;; i8x16.le_s (i8x16) (i8x16) + +;; hex vs hex +(assert_return (invoke "le_s" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF) + (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "le_s" (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00) + (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "le_s" (v128.const i8x16 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0) + (v128.const i8x16 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "le_s" (v128.const i8x16 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F) + (v128.const i8x16 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "le_s" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00) + (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "le_s" (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF) + (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "le_s" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x09 0x10 0x11 0x12 0x0A 0x0B 0x1A 0x1B 0xAA 0xAB 0xFF) + (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x09 0x10 0x11 0x12 0x0A 0x0B 0x1A 0x1B 0xAA 0xAB 0xFF)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + +;; hex vs dec +(assert_return (invoke "le_s" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF) + (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "le_s" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "le_s" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80) + (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "le_s" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80) + (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "le_s" (v128.const i8x16 0x80 0x81 0x82 0x83 0xFD 0xFE 0xFF 0x00 0x00 0x01 0x02 0x7F 0x80 0xFD 0xFE 0xFF) + (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + +;; dec vs dec +(assert_return (invoke "le_s" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "le_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "le_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255) + (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "le_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "le_s" (v128.const i8x16 255 255 255 255 255 255 255 255 0 0 0 0 0 0 0 0) + (v128.const i8x16 255 255 255 255 255 255 255 255 0 0 0 0 0 0 0 0)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "le_s" (v128.const i8x16 0 0 0 0 0 0 0 0 255 255 255 255 255 255 255 255) + (v128.const i8x16 0 0 0 0 0 0 0 0 255 255 255 255 255 255 255 255)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "le_s" (v128.const i8x16 128 129 130 131 253 254 255 -0 0 1 2 127 128 253 254 255) + (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 -0 0 1 2 127 128 253 254 255)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + +;; hex vs float +(assert_return (invoke "le_s" (v128.const i8x16 0x00 0x00 0x00 0xc3 0x00 0x00 0xfe 0xc2 0x00 0x00 0x80 0xbf 0x00 0x00 0x00 0x00) + (v128.const f32x4 -128.0 -127.0 -1.0 0.0)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "le_s" (v128.const i8x16 0x00 0x00 0x80 0x3f 0x00 0x00 0xfe 0x42 0x00 0x00 0x00 0x43 0x00 0x00 0x7f 0x43) + (v128.const f32x4 1.0 127.0 128.0 255.0)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + +;; not equal +(assert_return (invoke "le_s" (v128.const i8x16 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F) + (v128.const i8x16 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "le_s" (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF) + (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00)) + (v128.const i8x16 0 0 0 0 0 0 0 0 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "le_s" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x09 0x10 0x11 0x12 0x0A 0x0B 0x1A 0x1B 0xAA 0xAB 0xFF) + (v128.const i8x16 0xFF 0xAB 0xAA 0x1B 0x1A 0x0B 0x0A 0x12 0x11 0x10 0x09 0x04 0x03 0x02 0x01 0x00)) + (v128.const i8x16 0 0 0 -1 -1 -1 0 -1 0 -1 0 0 0 -1 -1 -1)) +(assert_return (invoke "le_s" (v128.const i8x16 0x80 0x81 0x82 0x83 0xFD 0xFE 0xFF 0x00 0x00 0x01 0x02 0x7F 0x80 0xFD 0xFE 0xFF) + (v128.const i8x16 255 254 253 128 127 2 1 0 0 -1 -2 -3 -125 -126 -127 -128)) + (v128.const i8x16 -1 -1 -1 0 -1 -1 -1 -1 -1 0 0 0 -1 0 0 0)) +(assert_return (invoke "le_s" (v128.const i8x16 128 129 130 131 253 254 255 -0 0 1 2 127 128 253 254 255) + (v128.const i8x16 255 254 253 128 127 2 1 0 -0 -1 -2 -3 -125 -126 -127 -128)) + (v128.const i8x16 -1 -1 -1 0 -1 -1 -1 -1 -1 0 0 0 -1 0 0 0)) + +;; i8x16.le_s (i8x16) (i16x8) +(assert_return (invoke "le_s" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF) + (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "le_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255) + (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "le_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) + (v128.const i16x8 0 0 0 0 0 0 0 0)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "le_s" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F) + (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "le_s" (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255) + (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "le_s" (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255) + (v128.const i16x8 -128 -128 0 0 1 1 255 255)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 0 -1 0 -1 -1 -1 -1)) +(assert_return (invoke "le_s" (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55) + (v128.const i16x8 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + +;; i8x16.le_s (i8x16) (i32x4) +(assert_return (invoke "le_s" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF) + (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "le_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255) + (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "le_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) + (v128.const i32x4 0 0 0 0)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "le_s" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F) + (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "le_s" (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255) + (v128.const i32x4 2206368128 16776957 2130837760 4294901120)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "le_s" (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255) + (v128.const i32x4 -128 0 1 255)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 0 0 0 -1 -1 -1 -1)) +(assert_return (invoke "le_s" (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55) + (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + +;; le_u + +;; i8x16.le_u (i8x16) (i8x16) + +;; hex vs hex +(assert_return (invoke "le_u" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF) + (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "le_u" (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00) + (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "le_u" (v128.const i8x16 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0) + (v128.const i8x16 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "le_u" (v128.const i8x16 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F) + (v128.const i8x16 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "le_u" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00) + (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "le_u" (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF) + (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "le_u" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x09 0x10 0x11 0x12 0x0A 0x0B 0x1A 0x1B 0xAA 0xAB 0xFF) + (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x09 0x10 0x11 0x12 0x0A 0x0B 0x1A 0x1B 0xAA 0xAB 0xFF)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + +;; hex vs dec +(assert_return (invoke "le_u" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF) + (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "le_u" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "le_u" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80) + (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "le_u" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80) + (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "le_u" (v128.const i8x16 0x80 0x81 0x82 0x83 0xFD 0xFE 0xFF 0x00 0x00 0x01 0x02 0x7F 0x80 0xFD 0xFE 0xFF) + (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + +;; dec vs dec +(assert_return (invoke "le_u" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "le_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "le_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255) + (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "le_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "le_u" (v128.const i8x16 255 255 255 255 255 255 255 255 0 0 0 0 0 0 0 0) + (v128.const i8x16 255 255 255 255 255 255 255 255 0 0 0 0 0 0 0 0)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "le_u" (v128.const i8x16 0 0 0 0 0 0 0 0 255 255 255 255 255 255 255 255) + (v128.const i8x16 0 0 0 0 0 0 0 0 255 255 255 255 255 255 255 255)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "le_u" (v128.const i8x16 128 129 130 131 253 254 255 -0 0 1 2 127 128 253 254 255) + (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 -0 0 1 2 127 128 253 254 255)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + +;; hex vs float +(assert_return (invoke "le_u" (v128.const i8x16 0x00 0x00 0x00 0xc3 0x00 0x00 0xfe 0xc2 0x00 0x00 0x80 0xbf 0x00 0x00 0x00 0x00) + (v128.const f32x4 -128.0 -127.0 -1.0 0.0)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "le_u" (v128.const i8x16 0x00 0x00 0x80 0x3f 0x00 0x00 0xfe 0x42 0x00 0x00 0x00 0x43 0x00 0x00 0x7f 0x43) + (v128.const f32x4 1.0 127.0 128.0 255.0)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + +;; not equal +(assert_return (invoke "le_u" (v128.const i8x16 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F) + (v128.const i8x16 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "le_u" (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF) + (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 0 0 0 0 0 0 0 0)) +(assert_return (invoke "le_u" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x09 0x10 0x11 0x12 0x0A 0x0B 0x1A 0x1B 0xAA 0xAB 0xFF) + (v128.const i8x16 0xFF 0xAB 0xAA 0x1B 0x1A 0x0B 0x0A 0x12 0x11 0x10 0x09 0x04 0x03 0x02 0x01 0x00)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 0 -1 0 -1 0 0 0 0 0 0)) +(assert_return (invoke "le_u" (v128.const i8x16 0x80 0x81 0x82 0x83 0xFD 0xFE 0xFF 0x00 0x00 0x01 0x02 0x7F 0x80 0xFD 0xFE 0xFF) + (v128.const i8x16 255 254 253 128 127 2 1 0 0 -1 -2 -3 -125 -126 -127 -128)) + (v128.const i8x16 -1 -1 -1 0 0 0 0 -1 -1 -1 -1 -1 -1 0 0 0)) +(assert_return (invoke "le_u" (v128.const i8x16 128 129 130 131 253 254 255 -0 0 1 2 127 128 253 254 255) + (v128.const i8x16 255 254 253 128 127 2 1 0 -0 -1 -2 -3 -125 -126 -127 -128)) + (v128.const i8x16 -1 -1 -1 0 0 0 0 -1 -1 -1 -1 -1 -1 0 0 0)) + +;; i8x16.le_u (i8x16) (i16x8) +(assert_return (invoke "le_u" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF) + (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "le_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255) + (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "le_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) + (v128.const i16x8 0 0 0 0 0 0 0 0)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "le_u" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F) + (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "le_u" (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255) + (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "le_u" (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255) + (v128.const i16x8 -128 -128 0 0 1 1 255 255)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 0 -1 0 -1 0 -1 0)) +(assert_return (invoke "le_u" (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55) + (v128.const i16x8 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + +;; i8x16.le_u (i8x16) (i32x4) +(assert_return (invoke "le_u" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF) + (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "le_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255) + (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "le_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) + (v128.const i32x4 0 0 0 0)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "le_u" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F) + (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "le_u" (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255) + (v128.const i32x4 2206368128 16776957 2130837760 4294901120)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "le_u" (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255) + (v128.const i32x4 -128 0 1 255)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 0 0 0 -1 0 0 0)) +(assert_return (invoke "le_u" (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55) + (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + +;; gt_s + +;; i8x16.gt_s (i8x16) (i8x16) + +;; hex vs hex +(assert_return (invoke "gt_s" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF) + (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "gt_s" (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00) + (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "gt_s" (v128.const i8x16 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0) + (v128.const i8x16 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "gt_s" (v128.const i8x16 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F) + (v128.const i8x16 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "gt_s" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00) + (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "gt_s" (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF) + (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "gt_s" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x09 0x10 0x11 0x12 0x0A 0x0B 0x1A 0x1B 0xAA 0xAB 0xFF) + (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x09 0x10 0x11 0x12 0x0A 0x0B 0x1A 0x1B 0xAA 0xAB 0xFF)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + +;; hex vs dec +(assert_return (invoke "gt_s" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF) + (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "gt_s" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "gt_s" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80) + (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "gt_s" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80) + (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "gt_s" (v128.const i8x16 0x80 0x81 0x82 0x83 0xFD 0xFE 0xFF 0x00 0x00 0x01 0x02 0x7F 0x80 0xFD 0xFE 0xFF) + (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + +;; dec vs dec +(assert_return (invoke "gt_s" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "gt_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "gt_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255) + (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "gt_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "gt_s" (v128.const i8x16 255 255 255 255 255 255 255 255 0 0 0 0 0 0 0 0) + (v128.const i8x16 255 255 255 255 255 255 255 255 0 0 0 0 0 0 0 0)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "gt_s" (v128.const i8x16 0 0 0 0 0 0 0 0 255 255 255 255 255 255 255 255) + (v128.const i8x16 0 0 0 0 0 0 0 0 255 255 255 255 255 255 255 255)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "gt_s" (v128.const i8x16 128 129 130 131 253 254 255 -0 0 1 2 127 128 253 254 255) + (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 -0 0 1 2 127 128 253 254 255)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + +;; hex vs float +(assert_return (invoke "gt_s" (v128.const i8x16 0x00 0x00 0x00 0xc3 0x00 0x00 0xfe 0xc2 0x00 0x00 0x80 0xbf 0x00 0x00 0x00 0x00) + (v128.const f32x4 -128.0 -127.0 -1.0 0.0)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "gt_s" (v128.const i8x16 0x00 0x00 0x80 0x3f 0x00 0x00 0xfe 0x42 0x00 0x00 0x00 0x43 0x00 0x00 0x7f 0x43) + (v128.const f32x4 1.0 127.0 128.0 255.0)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + +;; not equal +(assert_return (invoke "gt_s" (v128.const i8x16 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F) + (v128.const i8x16 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "gt_s" (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF) + (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 0 0 0 0 0 0 0 0)) +(assert_return (invoke "gt_s" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x09 0x10 0x11 0x12 0x0A 0x0B 0x1A 0x1B 0xAA 0xAB 0xFF) + (v128.const i8x16 0xFF 0xAB 0xAA 0x1B 0x1A 0x0B 0x0A 0x12 0x11 0x10 0x09 0x04 0x03 0x02 0x01 0x00)) + (v128.const i8x16 -1 -1 -1 0 0 0 -1 0 -1 0 -1 -1 -1 0 0 0)) +(assert_return (invoke "gt_s" (v128.const i8x16 0x80 0x81 0x82 0x83 0xFD 0xFE 0xFF 0x00 0x00 0x01 0x02 0x7F 0x80 0xFD 0xFE 0xFF) + (v128.const i8x16 255 254 253 128 127 2 1 0 0 -1 -2 -3 -125 -126 -127 -128)) + (v128.const i8x16 0 0 0 -1 0 0 0 0 0 -1 -1 -1 0 -1 -1 -1)) +(assert_return (invoke "gt_s" (v128.const i8x16 128 129 130 131 253 254 255 -0 0 1 2 127 128 253 254 255) + (v128.const i8x16 255 254 253 128 127 2 1 0 -0 -1 -2 -3 -125 -126 -127 -128)) + (v128.const i8x16 0 0 0 -1 0 0 0 0 0 -1 -1 -1 0 -1 -1 -1)) + +;; i8x16.gt_s (i8x16) (i16x8) +(assert_return (invoke "gt_s" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF) + (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "gt_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255) + (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "gt_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) + (v128.const i16x8 0 0 0 0 0 0 0 0)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "gt_s" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F) + (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "gt_s" (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255) + (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "gt_s" (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255) + (v128.const i16x8 -128 -128 0 0 1 1 255 255)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 -1 0 -1 0 0 0 0)) +(assert_return (invoke "gt_s" (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55) + (v128.const i16x8 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + +;; i8x16.gt_s (i8x16) (i32x4) +(assert_return (invoke "gt_s" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF) + (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "gt_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255) + (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "gt_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) + (v128.const i32x4 0 0 0 0)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "gt_s" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F) + (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "gt_s" (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255) + (v128.const i32x4 2206368128 16776957 2130837760 4294901120)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "gt_s" (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255) + (v128.const i32x4 -128 0 1 255)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 -1 -1 -1 0 0 0 0)) +(assert_return (invoke "gt_s" (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55) + (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + +;; gt_u + +;; i8x16.gt_u (i8x16) (i8x16) + +;; hex vs hex +(assert_return (invoke "gt_u" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF) + (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "gt_u" (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00) + (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "gt_u" (v128.const i8x16 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0) + (v128.const i8x16 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "gt_u" (v128.const i8x16 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F) + (v128.const i8x16 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "gt_u" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00) + (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "gt_u" (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF) + (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "gt_u" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x09 0x10 0x11 0x12 0x0A 0x0B 0x1A 0x1B 0xAA 0xAB 0xFF) + (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x09 0x10 0x11 0x12 0x0A 0x0B 0x1A 0x1B 0xAA 0xAB 0xFF)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + +;; hex vs dec +(assert_return (invoke "gt_u" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF) + (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "gt_u" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "gt_u" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80) + (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "gt_u" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80) + (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "gt_u" (v128.const i8x16 0x80 0x81 0x82 0x83 0xFD 0xFE 0xFF 0x00 0x00 0x01 0x02 0x7F 0x80 0xFD 0xFE 0xFF) + (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + +;; dec vs dec +(assert_return (invoke "gt_u" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "gt_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "gt_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255) + (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "gt_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "gt_u" (v128.const i8x16 255 255 255 255 255 255 255 255 0 0 0 0 0 0 0 0) + (v128.const i8x16 255 255 255 255 255 255 255 255 0 0 0 0 0 0 0 0)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "gt_u" (v128.const i8x16 0 0 0 0 0 0 0 0 255 255 255 255 255 255 255 255) + (v128.const i8x16 0 0 0 0 0 0 0 0 255 255 255 255 255 255 255 255)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "gt_u" (v128.const i8x16 128 129 130 131 253 254 255 -0 0 1 2 127 128 253 254 255) + (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 -0 0 1 2 127 128 253 254 255)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + +;; hex vs float +(assert_return (invoke "gt_u" (v128.const i8x16 0x00 0x00 0x00 0xc3 0x00 0x00 0xfe 0xc2 0x00 0x00 0x80 0xbf 0x00 0x00 0x00 0x00) + (v128.const f32x4 -128.0 -127.0 -1.0 0.0)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "gt_u" (v128.const i8x16 0x00 0x00 0x80 0x3f 0x00 0x00 0xfe 0x42 0x00 0x00 0x00 0x43 0x00 0x00 0x7f 0x43) + (v128.const f32x4 1.0 127.0 128.0 255.0)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + +;; not equal +(assert_return (invoke "gt_u" (v128.const i8x16 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F) + (v128.const i8x16 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "gt_u" (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF) + (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00)) + (v128.const i8x16 0 0 0 0 0 0 0 0 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "gt_u" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x09 0x10 0x11 0x12 0x0A 0x0B 0x1A 0x1B 0xAA 0xAB 0xFF) + (v128.const i8x16 0xFF 0xAB 0xAA 0x1B 0x1A 0x0B 0x0A 0x12 0x11 0x10 0x09 0x04 0x03 0x02 0x01 0x00)) + (v128.const i8x16 0 0 0 0 0 0 -1 0 -1 0 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "gt_u" (v128.const i8x16 0x80 0x81 0x82 0x83 0xFD 0xFE 0xFF 0x00 0x00 0x01 0x02 0x7F 0x80 0xFD 0xFE 0xFF) + (v128.const i8x16 255 254 253 128 127 2 1 0 0 -1 -2 -3 -125 -126 -127 -128)) + (v128.const i8x16 0 0 0 -1 -1 -1 -1 0 0 0 0 0 0 -1 -1 -1)) +(assert_return (invoke "gt_u" (v128.const i8x16 128 129 130 131 253 254 255 -0 0 1 2 127 128 253 254 255) + (v128.const i8x16 255 254 253 128 127 2 1 0 -0 -1 -2 -3 -125 -126 -127 -128)) + (v128.const i8x16 0 0 0 -1 -1 -1 -1 0 0 0 0 0 0 -1 -1 -1)) + +;; i8x16.gt_u (i8x16) (i16x8) +(assert_return (invoke "gt_u" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF) + (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "gt_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255) + (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "gt_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) + (v128.const i16x8 0 0 0 0 0 0 0 0)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "gt_u" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F) + (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "gt_u" (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255) + (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "gt_u" (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255) + (v128.const i16x8 -128 -128 0 0 1 1 255 255)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 -1 0 -1 0 -1 0 -1)) +(assert_return (invoke "gt_u" (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55) + (v128.const i16x8 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + +;; i8x16.gt_u (i8x16) (i32x4) +(assert_return (invoke "gt_u" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF) + (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "gt_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255) + (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "gt_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) + (v128.const i32x4 0 0 0 0)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "gt_u" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F) + (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "gt_u" (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255) + (v128.const i32x4 2206368128 16776957 2130837760 4294901120)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "gt_u" (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255) + (v128.const i32x4 -128 0 1 255)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 -1 -1 -1 0 -1 -1 -1)) +(assert_return (invoke "gt_u" (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55) + (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + +;; ge_s + +;; i8x16.ge_s (i8x16) (i8x16) + +;; hex vs hex +(assert_return (invoke "ge_s" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF) + (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "ge_s" (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00) + (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "ge_s" (v128.const i8x16 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0) + (v128.const i8x16 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "ge_s" (v128.const i8x16 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F) + (v128.const i8x16 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "ge_s" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00) + (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "ge_s" (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF) + (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "ge_s" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x09 0x10 0x11 0x12 0x0A 0x0B 0x1A 0x1B 0xAA 0xAB 0xFF) + (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x09 0x10 0x11 0x12 0x0A 0x0B 0x1A 0x1B 0xAA 0xAB 0xFF)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + +;; hex vs dec +(assert_return (invoke "ge_s" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF) + (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "ge_s" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "ge_s" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80) + (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "ge_s" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80) + (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "ge_s" (v128.const i8x16 0x80 0x81 0x82 0x83 0xFD 0xFE 0xFF 0x00 0x00 0x01 0x02 0x7F 0x80 0xFD 0xFE 0xFF) + (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + +;; dec vs dec +(assert_return (invoke "ge_s" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "ge_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "ge_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255) + (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "ge_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "ge_s" (v128.const i8x16 255 255 255 255 255 255 255 255 0 0 0 0 0 0 0 0) + (v128.const i8x16 255 255 255 255 255 255 255 255 0 0 0 0 0 0 0 0)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "ge_s" (v128.const i8x16 0 0 0 0 0 0 0 0 255 255 255 255 255 255 255 255) + (v128.const i8x16 0 0 0 0 0 0 0 0 255 255 255 255 255 255 255 255)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "ge_s" (v128.const i8x16 128 129 130 131 253 254 255 -0 0 1 2 127 128 253 254 255) + (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 -0 0 1 2 127 128 253 254 255)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + +;; hex vs float +(assert_return (invoke "ge_s" (v128.const i8x16 0x00 0x00 0x00 0xc3 0x00 0x00 0xfe 0xc2 0x00 0x00 0x80 0xbf 0x00 0x00 0x00 0x00) + (v128.const f32x4 -128.0 -127.0 -1.0 0.0)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "ge_s" (v128.const i8x16 0x00 0x00 0x80 0x3f 0x00 0x00 0xfe 0x42 0x00 0x00 0x00 0x43 0x00 0x00 0x7f 0x43) + (v128.const f32x4 1.0 127.0 128.0 255.0)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + +;; not equal +(assert_return (invoke "ge_s" (v128.const i8x16 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F) + (v128.const i8x16 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "ge_s" (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF) + (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 0 0 0 0 0 0 0 0)) +(assert_return (invoke "ge_s" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x09 0x10 0x11 0x12 0x0A 0x0B 0x1A 0x1B 0xAA 0xAB 0xFF) + (v128.const i8x16 0xFF 0xAB 0xAA 0x1B 0x1A 0x0B 0x0A 0x12 0x11 0x10 0x09 0x04 0x03 0x02 0x01 0x00)) + (v128.const i8x16 -1 -1 -1 0 0 0 -1 0 -1 0 -1 -1 -1 0 0 0)) +(assert_return (invoke "ge_s" (v128.const i8x16 0x80 0x81 0x82 0x83 0xFD 0xFE 0xFF 0x00 0x00 0x01 0x02 0x7F 0x80 0xFD 0xFE 0xFF) + (v128.const i8x16 255 254 253 128 127 2 1 0 0 -1 -2 -3 -125 -126 -127 -128)) + (v128.const i8x16 0 0 0 -1 0 0 0 -1 -1 -1 -1 -1 0 -1 -1 -1)) +(assert_return (invoke "ge_s" (v128.const i8x16 128 129 130 131 253 254 255 -0 0 1 2 127 128 253 254 255) + (v128.const i8x16 255 254 253 128 127 2 1 0 -0 -1 -2 -3 -125 -126 -127 -128)) + (v128.const i8x16 0 0 0 -1 0 0 0 -1 -1 -1 -1 -1 0 -1 -1 -1)) + +;; i8x16.ge_s (i8x16) (i16x8) +(assert_return (invoke "ge_s" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF) + (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "ge_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255) + (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "ge_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) + (v128.const i16x8 0 0 0 0 0 0 0 0)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "ge_s" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F) + (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "ge_s" (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255) + (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "ge_s" (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255) + (v128.const i16x8 -128 -128 0 0 1 1 255 255)) + (v128.const i8x16 -1 0 -1 0 -1 -1 -1 -1 -1 -1 -1 -1 -1 0 -1 0)) +(assert_return (invoke "ge_s" (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55) + (v128.const i16x8 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + +;; i8x16.ge_s (i8x16) (i32x4) +(assert_return (invoke "ge_s" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF) + (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "ge_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255) + (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "ge_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) + (v128.const i32x4 0 0 0 0)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "ge_s" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F) + (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "ge_s" (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255) + (v128.const i32x4 2206368128 16776957 2130837760 4294901120)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "ge_s" (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255) + (v128.const i32x4 -128 0 1 255)) + (v128.const i8x16 -1 0 0 0 -1 -1 -1 -1 -1 -1 -1 -1 -1 0 0 0)) +(assert_return (invoke "ge_s" (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55) + (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + +;; ge_u + +;; i8x16.ge_u (i8x16) (i8x16) + +;; hex vs hex +(assert_return (invoke "ge_u" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF) + (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "ge_u" (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00) + (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "ge_u" (v128.const i8x16 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0) + (v128.const i8x16 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "ge_u" (v128.const i8x16 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F) + (v128.const i8x16 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "ge_u" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00) + (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "ge_u" (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF) + (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "ge_u" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x09 0x10 0x11 0x12 0x0A 0x0B 0x1A 0x1B 0xAA 0xAB 0xFF) + (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x09 0x10 0x11 0x12 0x0A 0x0B 0x1A 0x1B 0xAA 0xAB 0xFF)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + +;; hex vs dec +(assert_return (invoke "ge_u" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF) + (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "ge_u" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "ge_u" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80) + (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "ge_u" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80) + (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "ge_u" (v128.const i8x16 0x80 0x81 0x82 0x83 0xFD 0xFE 0xFF 0x00 0x00 0x01 0x02 0x7F 0x80 0xFD 0xFE 0xFF) + (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + +;; dec vs dec +(assert_return (invoke "ge_u" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "ge_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "ge_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255) + (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "ge_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "ge_u" (v128.const i8x16 255 255 255 255 255 255 255 255 0 0 0 0 0 0 0 0) + (v128.const i8x16 255 255 255 255 255 255 255 255 0 0 0 0 0 0 0 0)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "ge_u" (v128.const i8x16 0 0 0 0 0 0 0 0 255 255 255 255 255 255 255 255) + (v128.const i8x16 0 0 0 0 0 0 0 0 255 255 255 255 255 255 255 255)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "ge_u" (v128.const i8x16 128 129 130 131 253 254 255 -0 0 1 2 127 128 253 254 255) + (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 -0 0 1 2 127 128 253 254 255)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + +;; hex vs float +(assert_return (invoke "ge_u" (v128.const i8x16 0x00 0x00 0x00 0xc3 0x00 0x00 0xfe 0xc2 0x00 0x00 0x80 0xbf 0x00 0x00 0x00 0x00) + (v128.const f32x4 -128.0 -127.0 -1.0 0.0)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "ge_u" (v128.const i8x16 0x00 0x00 0x80 0x3f 0x00 0x00 0xfe 0x42 0x00 0x00 0x00 0x43 0x00 0x00 0x7f 0x43) + (v128.const f32x4 1.0 127.0 128.0 255.0)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + +;; not equal +(assert_return (invoke "ge_u" (v128.const i8x16 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F) + (v128.const i8x16 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "ge_u" (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF) + (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00)) + (v128.const i8x16 0 0 0 0 0 0 0 0 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "ge_u" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x09 0x10 0x11 0x12 0x0A 0x0B 0x1A 0x1B 0xAA 0xAB 0xFF) + (v128.const i8x16 0xFF 0xAB 0xAA 0x1B 0x1A 0x0B 0x0A 0x12 0x11 0x10 0x09 0x04 0x03 0x02 0x01 0x00)) + (v128.const i8x16 0 0 0 0 0 0 -1 0 -1 0 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "ge_u" (v128.const i8x16 0x80 0x81 0x82 0x83 0xFD 0xFE 0xFF 0x00 0x00 0x01 0x02 0x7F 0x80 0xFD 0xFE 0xFF) + (v128.const i8x16 255 254 253 128 127 2 1 0 0 -1 -2 -3 -125 -126 -127 -128)) + (v128.const i8x16 0 0 0 -1 -1 -1 -1 -1 -1 0 0 0 0 -1 -1 -1)) +(assert_return (invoke "ge_u" (v128.const i8x16 128 129 130 131 253 254 255 -0 0 1 2 127 128 253 254 255) + (v128.const i8x16 255 254 253 128 127 2 1 0 -0 -1 -2 -3 -125 -126 -127 -128)) + (v128.const i8x16 0 0 0 -1 -1 -1 -1 -1 -1 0 0 0 0 -1 -1 -1)) + +;; i8x16.ge_u (i8x16) (i16x8) +(assert_return (invoke "ge_u" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF) + (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "ge_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255) + (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "ge_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) + (v128.const i16x8 0 0 0 0 0 0 0 0)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "ge_u" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F) + (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "ge_u" (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255) + (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "ge_u" (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255) + (v128.const i16x8 -128 -128 0 0 1 1 255 255)) + (v128.const i8x16 -1 0 -1 0 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "ge_u" (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55) + (v128.const i16x8 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + +;; i8x16.ge_u (i8x16) (i32x4) +(assert_return (invoke "ge_u" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF) + (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "ge_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255) + (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "ge_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) + (v128.const i32x4 0 0 0 0)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "ge_u" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F) + (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "ge_u" (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255) + (v128.const i32x4 2206368128 16776957 2130837760 4294901120)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "ge_u" (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255) + (v128.const i32x4 -128 0 1 255)) + (v128.const i8x16 -1 0 0 0 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "ge_u" (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55) + (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + + +;; Type check + +(assert_invalid (module (func (result v128) (i8x16.eq (i32.const 0) (f32.const 0)))) "type mismatch") +(assert_invalid (module (func (result v128) (i8x16.ge_s (i32.const 0) (f32.const 0)))) "type mismatch") +(assert_invalid (module (func (result v128) (i8x16.ge_u (i32.const 0) (f32.const 0)))) "type mismatch") +(assert_invalid (module (func (result v128) (i8x16.gt_s (i32.const 0) (f32.const 0)))) "type mismatch") +(assert_invalid (module (func (result v128) (i8x16.gt_u (i32.const 0) (f32.const 0)))) "type mismatch") +(assert_invalid (module (func (result v128) (i8x16.le_s (i32.const 0) (f32.const 0)))) "type mismatch") +(assert_invalid (module (func (result v128) (i8x16.le_u (i32.const 0) (f32.const 0)))) "type mismatch") +(assert_invalid (module (func (result v128) (i8x16.lt_s (i32.const 0) (f32.const 0)))) "type mismatch") +(assert_invalid (module (func (result v128) (i8x16.lt_u (i32.const 0) (f32.const 0)))) "type mismatch") +(assert_invalid (module (func (result v128) (i8x16.ne (i32.const 0) (f32.const 0)))) "type mismatch") + + +;; combination + +(module (memory 1) + (func (export "eq-in-block") + (block + (drop + (block (result v128) + (i8x16.eq + (block (result v128) (v128.load (i32.const 0))) + (block (result v128) (v128.load (i32.const 1))) + ) + ) + ) + ) + ) + (func (export "ne-in-block") + (block + (drop + (block (result v128) + (i8x16.ne + (block (result v128) (v128.load (i32.const 0))) + (block (result v128) (v128.load (i32.const 1))) + ) + ) + ) + ) + ) + (func (export "lt_s-in-block") + (block + (drop + (block (result v128) + (i8x16.lt_s + (block (result v128) (v128.load (i32.const 0))) + (block (result v128) (v128.load (i32.const 1))) + ) + ) + ) + ) + ) + (func (export "le_u-in-block") + (block + (drop + (block (result v128) + (i8x16.le_u + (block (result v128) (v128.load (i32.const 0))) + (block (result v128) (v128.load (i32.const 1))) + ) + ) + ) + ) + ) + (func (export "gt_u-in-block") + (block + (drop + (block (result v128) + (i8x16.gt_u + (block (result v128) (v128.load (i32.const 0))) + (block (result v128) (v128.load (i32.const 1))) + ) + ) + ) + ) + ) + (func (export "ge_s-in-block") + (block + (drop + (block (result v128) + (i8x16.ge_s + (block (result v128) (v128.load (i32.const 0))) + (block (result v128) (v128.load (i32.const 1))) + ) + ) + ) + ) + ) + (func (export "nested-eq") + (drop + (i8x16.eq + (i8x16.eq + (i8x16.eq + (v128.load (i32.const 0)) + (v128.load (i32.const 1)) + ) + (i8x16.eq + (v128.load (i32.const 2)) + (v128.load (i32.const 3)) + ) + ) + (i8x16.eq + (i8x16.eq + (v128.load (i32.const 0)) + (v128.load (i32.const 1)) + ) + (i8x16.eq + (v128.load (i32.const 2)) + (v128.load (i32.const 3)) + ) + ) + ) + ) + ) + (func (export "nested-ne") + (drop + (i8x16.ne + (i8x16.ne + (i8x16.ne + (v128.load (i32.const 0)) + (v128.load (i32.const 1)) + ) + (i8x16.ne + (v128.load (i32.const 2)) + (v128.load (i32.const 3)) + ) + ) + (i8x16.ne + (i8x16.ne + (v128.load (i32.const 0)) + (v128.load (i32.const 1)) + ) + (i8x16.ne + (v128.load (i32.const 2)) + (v128.load (i32.const 3)) + ) + ) + ) + ) + ) + (func (export "nested-lt_s") + (drop + (i8x16.lt_s + (i8x16.lt_s + (i8x16.lt_s + (v128.load (i32.const 0)) + (v128.load (i32.const 1)) + ) + (i8x16.lt_s + (v128.load (i32.const 2)) + (v128.load (i32.const 3)) + ) + ) + (i8x16.lt_s + (i8x16.lt_s + (v128.load (i32.const 0)) + (v128.load (i32.const 1)) + ) + (i8x16.lt_s + (v128.load (i32.const 2)) + (v128.load (i32.const 3)) + ) + ) + ) + ) + ) + (func (export "nested-le_u") + (drop + (i8x16.le_u + (i8x16.le_u + (i8x16.le_u + (v128.load (i32.const 0)) + (v128.load (i32.const 1)) + ) + (i8x16.le_u + (v128.load (i32.const 2)) + (v128.load (i32.const 3)) + ) + ) + (i8x16.le_u + (i8x16.le_u + (v128.load (i32.const 0)) + (v128.load (i32.const 1)) + ) + (i8x16.le_u + (v128.load (i32.const 2)) + (v128.load (i32.const 3)) + ) + ) + ) + ) + ) + (func (export "nested-gt_u") + (drop + (i8x16.gt_u + (i8x16.gt_u + (i8x16.gt_u + (v128.load (i32.const 0)) + (v128.load (i32.const 1)) + ) + (i8x16.gt_u + (v128.load (i32.const 2)) + (v128.load (i32.const 3)) + ) + ) + (i8x16.gt_u + (i8x16.gt_u + (v128.load (i32.const 0)) + (v128.load (i32.const 1)) + ) + (i8x16.gt_u + (v128.load (i32.const 2)) + (v128.load (i32.const 3)) + ) + ) + ) + ) + ) + (func (export "nested-ge_s") + (drop + (i8x16.ge_s + (i8x16.ge_s + (i8x16.ge_s + (v128.load (i32.const 0)) + (v128.load (i32.const 1)) + ) + (i8x16.ge_s + (v128.load (i32.const 2)) + (v128.load (i32.const 3)) + ) + ) + (i8x16.ge_s + (i8x16.ge_s + (v128.load (i32.const 0)) + (v128.load (i32.const 1)) + ) + (i8x16.ge_s + (v128.load (i32.const 2)) + (v128.load (i32.const 3)) + ) + ) + ) + ) + ) + (func (export "as-param") + (drop + (i8x16.ge_u + (i8x16.eq + (i8x16.lt_s + (v128.load (i32.const 0)) + (v128.load (i32.const 1)) + ) + (i8x16.le_u + (v128.load (i32.const 2)) + (v128.load (i32.const 3)) + ) + ) + (i8x16.ne + (i8x16.gt_s + (v128.load (i32.const 0)) + (v128.load (i32.const 1)) + ) + (i8x16.lt_u + (v128.load (i32.const 2)) + (v128.load (i32.const 3)) + ) + ) + ) + ) + ) +) +(assert_return (invoke "eq-in-block")) +(assert_return (invoke "ne-in-block")) +(assert_return (invoke "lt_s-in-block")) +(assert_return (invoke "le_u-in-block")) +(assert_return (invoke "gt_u-in-block")) +(assert_return (invoke "ge_s-in-block")) +(assert_return (invoke "nested-eq")) +(assert_return (invoke "nested-ne")) +(assert_return (invoke "nested-lt_s")) +(assert_return (invoke "nested-le_u")) +(assert_return (invoke "nested-gt_u")) +(assert_return (invoke "nested-ge_s")) +(assert_return (invoke "as-param")) + + +;; Test operation with empty argument + +(assert_invalid + (module + (func $i8x16.eq-1st-arg-empty (result v128) + (i8x16.eq (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i8x16.eq-arg-empty (result v128) + (i8x16.eq) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i8x16.ne-1st-arg-empty (result v128) + (i8x16.ne (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i8x16.ne-arg-empty (result v128) + (i8x16.ne) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i8x16.lt_s-1st-arg-empty (result v128) + (i8x16.lt_s (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i8x16.lt_s-arg-empty (result v128) + (i8x16.lt_s) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i8x16.lt_u-1st-arg-empty (result v128) + (i8x16.lt_u (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i8x16.lt_u-arg-empty (result v128) + (i8x16.lt_u) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i8x16.le_s-1st-arg-empty (result v128) + (i8x16.le_s (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i8x16.le_s-arg-empty (result v128) + (i8x16.le_s) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i8x16.le_u-1st-arg-empty (result v128) + (i8x16.le_u (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i8x16.le_u-arg-empty (result v128) + (i8x16.le_u) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i8x16.gt_s-1st-arg-empty (result v128) + (i8x16.gt_s (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i8x16.gt_s-arg-empty (result v128) + (i8x16.gt_s) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i8x16.gt_u-1st-arg-empty (result v128) + (i8x16.gt_u (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i8x16.gt_u-arg-empty (result v128) + (i8x16.gt_u) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i8x16.ge_s-1st-arg-empty (result v128) + (i8x16.ge_s (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i8x16.ge_s-arg-empty (result v128) + (i8x16.ge_s) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i8x16.ge_u-1st-arg-empty (result v128) + (i8x16.ge_u (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i8x16.ge_u-arg-empty (result v128) + (i8x16.ge_u) + ) + ) + "type mismatch" +) \ No newline at end of file diff --git a/runtime/near-vm/tests/wast/spec/proposals/simd/simd_i8x16_sat_arith.wast b/runtime/near-vm/tests/wast/spec/proposals/simd/simd_i8x16_sat_arith.wast new file mode 100644 index 00000000000..a799a8b7398 --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/proposals/simd/simd_i8x16_sat_arith.wast @@ -0,0 +1,718 @@ +;; Tests for i8x16 arithmetic operations on major boundary values and all special values. + + +(module + (func (export "i8x16.add_sat_s") (param v128 v128) (result v128) (i8x16.add_sat_s (local.get 0) (local.get 1))) + (func (export "i8x16.add_sat_u") (param v128 v128) (result v128) (i8x16.add_sat_u (local.get 0) (local.get 1))) + (func (export "i8x16.sub_sat_s") (param v128 v128) (result v128) (i8x16.sub_sat_s (local.get 0) (local.get 1))) + (func (export "i8x16.sub_sat_u") (param v128 v128) (result v128) (i8x16.sub_sat_u (local.get 0) (local.get 1))) +) + + +;; i8x16.add_sat_s +(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) +(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) + (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2)) +(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i8x16 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2)) +(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 63 63 63 63 63 63 63 63 63 63 63 63 63 63 63 63) + (v128.const i8x16 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64)) + (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127)) +(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64) + (v128.const i8x16 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64)) + (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127)) +(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63) + (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64)) + (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127)) +(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64) + (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64)) + (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)) +(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65) + (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64)) + (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)) +(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 125 125 125 125 125 125 125 125 125 125 125 125 125 125 125 125) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) + (v128.const i8x16 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126)) +(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) + (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127)) +(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) + (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127)) +(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127)) +(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)) +(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)) +(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127) + (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127)) + (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127)) +(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128) + (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)) + (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)) +(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128) + (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127)) + (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)) +(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i8x16 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2)) +(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255) + (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127)) + (v128.const i8x16 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126)) +(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255) + (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)) + (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)) +(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255) + (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)) + (v128.const i8x16 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2)) +(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f) + (v128.const i8x16 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40)) + (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127)) +(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40) + (v128.const i8x16 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40)) + (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127)) +(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f) + (v128.const i8x16 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40)) + (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127)) +(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40) + (v128.const i8x16 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40)) + (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)) +(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40) + (v128.const i8x16 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41)) + (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)) +(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f) + (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f)) + (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127)) +(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f) + (v128.const i8x16 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01)) + (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127)) +(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80) + (v128.const i8x16 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01)) + (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)) +(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f) + (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80) + (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)) + (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)) +(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff) + (v128.const i8x16 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff) + (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff)) + (v128.const i8x16 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2)) +(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80) + (v128.const f32x4 -0.0 -0.0 -0.0 -0.0)) + (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)) +(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1) + (v128.const f32x4 +inf +inf +inf +inf)) + (v128.const i8x16 0x01 0x01 0x81 0x7f 0x01 0x01 0x81 0x7f 0x01 0x01 0x81 0x7f 0x01 0x01 0x81 0x7f)) +(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const i8x16 0x01 0x01 0x81 0 0x01 0x01 0x81 0 0x01 0x01 0x81 0 0x01 0x01 0x81 0)) +(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1) + (v128.const f32x4 nan nan nan nan)) + (v128.const i8x16 0x01 0x01 0xc1 0x7f 0x01 0x01 0xc1 0x7f 0x01 0x01 0xc1 0x7f 0x01 0x01 0xc1 0x7f)) +(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const i8x16 0x01 0x01 0xc1 0 0x01 0x01 0xc1 0 0x01 0x01 0xc1 0 0x01 0x01 0xc1 0)) +(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15) + (v128.const i8x16 0 0xff 0xfe 0xfd 0xfc 0xfb 0xfa 0xf9 0xf8 0xf7 0xf6 0xf5 0xf4 0xf3 0xf2 0xf1)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15) + (v128.const i8x16 0 2 4 6 8 10 12 14 16 18 20 22 24 26 28 30)) + (v128.const i8x16 0 3 6 9 12 15 18 21 24 27 30 33 36 39 42 45)) + +;; i8x16.add_sat_u +(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) +(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) + (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2)) +(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)) +(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)) +(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)) +(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 63 63 63 63 63 63 63 63 63 63 63 63 63 63 63 63) + (v128.const i8x16 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64)) + (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127)) +(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64) + (v128.const i8x16 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64)) + (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128)) +(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63) + (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64)) + (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)) +(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64) + (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64)) + (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)) +(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65) + (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64)) + (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)) +(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 125 125 125 125 125 125 125 125 125 125 125 125 125 125 125 125) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) + (v128.const i8x16 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126)) +(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) + (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127)) +(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) + (v128.const i8x16 129 129 129 129 129 129 129 129 129 129 129 129 129 129 129 129)) +(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)) +(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)) +(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)) +(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127) + (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127)) + (v128.const i8x16 254 254 254 254 254 254 254 254 254 254 254 254 254 254 254 254)) +(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128) + (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)) + (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)) +(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128) + (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127)) + (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)) +(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)) +(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) + (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)) +(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)) +(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255) + (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127)) + (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)) +(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255) + (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)) + (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)) +(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255) + (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)) + (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)) +(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f) + (v128.const i8x16 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40)) + (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127)) +(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40) + (v128.const i8x16 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40)) + (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128)) +(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f) + (v128.const i8x16 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40)) + (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)) +(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40) + (v128.const i8x16 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40)) + (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)) +(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40) + (v128.const i8x16 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41)) + (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)) +(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f) + (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f)) + (v128.const i8x16 254 254 254 254 254 254 254 254 254 254 254 254 254 254 254 254)) +(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f) + (v128.const i8x16 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01)) + (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128)) +(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80) + (v128.const i8x16 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01)) + (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)) +(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f) + (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)) + (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)) +(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80) + (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)) + (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)) +(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff) + (v128.const i8x16 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01)) + (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)) +(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff) + (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff)) + (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)) +(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80) + (v128.const f32x4 -0.0 -0.0 -0.0 -0.0)) + (v128.const i8x16 0x80 0x80 0x80 0xff 0x80 0x80 0x80 0xff 0x80 0x80 0x80 0xff 0x80 0x80 0x80 0xff)) +(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1) + (v128.const f32x4 +inf +inf +inf +inf)) + (v128.const i8x16 0x01 0x01 0x81 0x80 0x01 0x01 0x81 0x80 0x01 0x01 0x81 0x80 0x01 0x01 0x81 0x80)) +(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const i8x16 0x01 0x01 0x81 0xff 0x01 0x01 0x81 0xff 0x01 0x01 0x81 0xff 0x01 0x01 0x81 0xff)) +(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1) + (v128.const f32x4 nan nan nan nan)) + (v128.const i8x16 0x01 0x01 0xc1 0x80 0x01 0x01 0xc1 0x80 0x01 0x01 0xc1 0x80 0x01 0x01 0xc1 0x80)) +(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const i8x16 0x01 0x01 0xc1 0xff 0x01 0x01 0xc1 0xff 0x01 0x01 0xc1 0xff 0x01 0x01 0xc1 0xff)) +(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15) + (v128.const i8x16 0 0xff 0xfe 0xfd 0xfc 0xfb 0xfa 0xf9 0xf8 0xf7 0xf6 0xf5 0xf4 0xf3 0xf2 0xf1)) + (v128.const i8x16 0 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff)) +(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15) + (v128.const i8x16 0 2 4 6 8 10 12 14 16 18 20 22 24 26 28 30)) + (v128.const i8x16 0 3 6 9 12 15 18 21 24 27 30 33 36 39 42 45)) + +;; i8x16.sub_sat_s +(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) +(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2)) +(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 63 63 63 63 63 63 63 63 63 63 63 63 63 63 63 63) + (v128.const i8x16 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64) + (v128.const i8x16 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63) + (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64)) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) +(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64) + (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65) + (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 125 125 125 125 125 125 125 125 125 125 125 125 125 125 125 125) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) + (v128.const i8x16 124 124 124 124 124 124 124 124 124 124 124 124 124 124 124 124)) +(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) + (v128.const i8x16 125 125 125 125 125 125 125 125 125 125 125 125 125 125 125 125)) +(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) + (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)) +(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i8x16 -125 -125 -125 -125 -125 -125 -125 -125 -125 -125 -125 -125 -125 -125 -125 -125)) +(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i8x16 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126)) +(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127)) +(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127) + (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128) + (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128) + (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) + (v128.const i8x16 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2)) +(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255) + (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127)) + (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)) +(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255) + (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)) + (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127)) +(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255) + (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f) + (v128.const i8x16 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40) + (v128.const i8x16 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f) + (v128.const i8x16 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40)) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) +(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40) + (v128.const i8x16 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40) + (v128.const i8x16 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41)) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) +(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f) + (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f) + (v128.const i8x16 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01)) + (v128.const i8x16 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126)) +(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80) + (v128.const i8x16 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01)) + (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127)) +(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f) + (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)) + (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127)) +(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80) + (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff) + (v128.const i8x16 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01)) + (v128.const i8x16 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2)) +(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff) + (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80) + (v128.const f32x4 -0.0 -0.0 -0.0 -0.0)) + (v128.const i8x16 0x80 0x80 0x80 0 0x80 0x80 0x80 0 0x80 0x80 0x80 0 0x80 0x80 0x80 0)) +(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1) + (v128.const f32x4 +inf +inf +inf +inf)) + (v128.const i8x16 0x01 0x01 0x7f 0x82 0x01 0x01 0x7f 0x82 0x01 0x01 0x7f 0x82 0x01 0x01 0x7f 0x82)) +(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const i8x16 0x01 0x01 0x7f 0x02 0x01 0x01 0x7f 0x02 0x01 0x01 0x7f 0x02 0x01 0x01 0x7f 0x02)) +(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1) + (v128.const f32x4 nan nan nan nan)) + (v128.const i8x16 0x01 0x01 0x41 0x82 0x01 0x01 0x41 0x82 0x01 0x01 0x41 0x82 0x01 0x01 0x41 0x82)) +(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const i8x16 0x01 0x01 0x41 0x02 0x01 0x01 0x41 0x02 0x01 0x01 0x41 0x02 0x01 0x01 0x41 0x02)) +(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15) + (v128.const i8x16 0 0xff 0xfe 0xfd 0xfc 0xfb 0xfa 0xf9 0xf8 0xf7 0xf6 0xf5 0xf4 0xf3 0xf2 0xf1)) + (v128.const i8x16 0 0x02 0x04 0x06 0x08 0x0a 0x0c 0x0e 0x10 0x12 0x14 0x16 0x18 0x1a 0x1c 0x1e)) +(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15) + (v128.const i8x16 0 2 4 6 8 10 12 14 16 18 20 22 24 26 28 30)) + (v128.const i8x16 0 -1 -2 -3 -4 -5 -6 -7 -8 -9 -10 -11 -12 -13 -14 -15)) + +;; i8x16.sub_sat_u +(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 63 63 63 63 63 63 63 63 63 63 63 63 63 63 63 63) + (v128.const i8x16 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64) + (v128.const i8x16 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63) + (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64)) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) +(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64) + (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65) + (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 125 125 125 125 125 125 125 125 125 125 125 125 125 125 125 125) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) + (v128.const i8x16 124 124 124 124 124 124 124 124 124 124 124 124 124 124 124 124)) +(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) + (v128.const i8x16 125 125 125 125 125 125 125 125 125 125 125 125 125 125 125 125)) +(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) + (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127)) +(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127) + (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128) + (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128) + (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)) +(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) + (v128.const i8x16 254 254 254 254 254 254 254 254 254 254 254 254 254 254 254 254)) +(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255) + (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127)) + (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128)) +(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255) + (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)) + (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127)) +(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255) + (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f) + (v128.const i8x16 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40) + (v128.const i8x16 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f) + (v128.const i8x16 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40)) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) +(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40) + (v128.const i8x16 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40) + (v128.const i8x16 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41)) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) +(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f) + (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f) + (v128.const i8x16 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01)) + (v128.const i8x16 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126)) +(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80) + (v128.const i8x16 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f) + (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80) + (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff) + (v128.const i8x16 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01)) + (v128.const i8x16 254 254 254 254 254 254 254 254 254 254 254 254 254 254 254 254)) +(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff) + (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80) + (v128.const f32x4 -0.0 -0.0 -0.0 -0.0)) + (v128.const i8x16 0x80 0x80 0x80 0 0x80 0x80 0x80 0 0x80 0x80 0x80 0 0x80 0x80 0x80 0)) +(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1) + (v128.const f32x4 +inf +inf +inf +inf)) + (v128.const i8x16 0x01 0x01 0 0 0x01 0x01 0 0 0x01 0x01 0 0 0x01 0x01 0 0)) +(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1) + (v128.const f32x4 -inf -inf -inf -inf)) + (v128.const i8x16 0x01 0x01 0 0 0x01 0x01 0 0 0x01 0x01 0 0 0x01 0x01 0 0)) +(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1) + (v128.const f32x4 nan nan nan nan)) + (v128.const i8x16 0x01 0x01 0 0 0x01 0x01 0 0 0x01 0x01 0 0 0x01 0x01 0 0)) +(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1) + (v128.const f32x4 -nan -nan -nan -nan)) + (v128.const i8x16 0x01 0x01 0 0 0x01 0x01 0 0 0x01 0x01 0 0 0x01 0x01 0 0)) +(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15) + (v128.const i8x16 0 0xff 0xfe 0xfd 0xfc 0xfb 0xfa 0xf9 0xf8 0xf7 0xf6 0xf5 0xf4 0xf3 0xf2 0xf1)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15) + (v128.const i8x16 0 2 4 6 8 10 12 14 16 18 20 22 24 26 28 30)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + +;; Malformed cases: non-existent op names +(assert_malformed (module quote + "(func (result v128) (i8x16.add_sat (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1) (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2)))") + "unknown operator") +(assert_malformed (module quote + "(func (result v128) (i8x16.sub_sat (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1) (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2)))") + "unknown operator") +(assert_malformed (module quote + "(func (result v128) (i8x16.mul_sat (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1) (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2)))") + "unknown operator") +(assert_malformed (module quote + "(func (result v128) (i8x16.div_sat (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1) (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2)))") + "unknown operator") +(assert_malformed (module quote + "(func (result v128) (i32x4.add_sat_s (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0)))") + "unknown operator") +(assert_malformed (module quote + "(func (result v128) (i32x4.add_sat_u (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0)))") + "unknown operator") +(assert_malformed (module quote + "(func (result v128) (i32x4.sub_sat_s (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0)))") + "unknown operator") +(assert_malformed (module quote + "(func (result v128) (i32x4.sub_sat_u (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0)))") + "unknown operator") +(assert_malformed (module quote + "(func (result v128) (f32x4.add_sat_s (v128.const f32x4 0 0 0 0) (v128.const f32x4 0 0 0 0)))") + "unknown operator") +(assert_malformed (module quote + "(func (result v128) (f32x4.add_sat_u (v128.const f32x4 0 0 0 0) (v128.const f32x4 0 0 0 0)))") + "unknown operator") +(assert_malformed (module quote + "(func (result v128) (f32x4.sub_sat_s (v128.const f32x4 0 0 0 0) (v128.const f32x4 0 0 0 0)))") + "unknown operator") +(assert_malformed (module quote + "(func (result v128) (f32x4.sub_sat_u (v128.const f32x4 0 0 0 0) (v128.const f32x4 0 0 0 0)))") + "unknown operator") + +;; type check +(assert_invalid (module (func (result v128) (i8x16.add_sat_s (i32.const 0) (f32.const 0.0)))) "type mismatch") +(assert_invalid (module (func (result v128) (i8x16.add_sat_u (i32.const 0) (f32.const 0.0)))) "type mismatch") +(assert_invalid (module (func (result v128) (i8x16.sub_sat_s (i32.const 0) (f32.const 0.0)))) "type mismatch") +(assert_invalid (module (func (result v128) (i8x16.sub_sat_u (i32.const 0) (f32.const 0.0)))) "type mismatch") + +;; Test operation with empty argument + +(assert_invalid + (module + (func $i8x16.add_sat_s-1st-arg-empty (result v128) + (i8x16.add_sat_s (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i8x16.add_sat_s-arg-empty (result v128) + (i8x16.add_sat_s) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i8x16.add_sat_u-1st-arg-empty (result v128) + (i8x16.add_sat_u (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i8x16.add_sat_u-arg-empty (result v128) + (i8x16.add_sat_u) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i8x16.sub_sat_s-1st-arg-empty (result v128) + (i8x16.sub_sat_s (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i8x16.sub_sat_s-arg-empty (result v128) + (i8x16.sub_sat_s) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i8x16.sub_sat_u-1st-arg-empty (result v128) + (i8x16.sub_sat_u (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i8x16.sub_sat_u-arg-empty (result v128) + (i8x16.sub_sat_u) + ) + ) + "type mismatch" +) + +;; combination +(module + (func (export "sat-add_s-sub_s") (param v128 v128 v128) (result v128) + (i8x16.add_sat_s (i8x16.sub_sat_s (local.get 0) (local.get 1))(local.get 2))) + (func (export "sat-add_s-sub_u") (param v128 v128 v128) (result v128) + (i8x16.add_sat_s (i8x16.sub_sat_u (local.get 0) (local.get 1))(local.get 2))) + (func (export "sat-add_u-sub_s") (param v128 v128 v128) (result v128) + (i8x16.add_sat_u (i8x16.sub_sat_s (local.get 0) (local.get 1))(local.get 2))) + (func (export "sat-add_u-sub_u") (param v128 v128 v128) (result v128) + (i8x16.add_sat_u (i8x16.sub_sat_u (local.get 0) (local.get 1))(local.get 2))) + (func (export "sat-add_s-neg") (param v128 v128) (result v128) + (i8x16.add_sat_s (i8x16.neg (local.get 0)) (local.get 1))) + (func (export "sat-add_u-neg") (param v128 v128) (result v128) + (i8x16.add_sat_u (i8x16.neg (local.get 0)) (local.get 1))) + (func (export "sat-sub_s-neg") (param v128 v128) (result v128) + (i8x16.sub_sat_s (i8x16.neg (local.get 0)) (local.get 1))) + (func (export "sat-sub_u-neg") (param v128 v128) (result v128) + (i8x16.sub_sat_u (i8x16.neg (local.get 0)) (local.get 1))) +) + +(assert_return (invoke "sat-add_s-sub_s" (v128.const i8x16 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64) + (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127) + (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)) + (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)) +(assert_return (invoke "sat-add_s-sub_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255) + (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128) + (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "sat-add_u-sub_s" (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1) + (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127)) + (v128.const i8x16 254 254 254 254 254 254 254 254 254 254 254 254 254 254 254 254)) +(assert_return (invoke "sat-add_u-sub_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) + (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)) +(assert_return (invoke "sat-add_s-neg" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128) + (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "sat-add_u-neg" (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127) + (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)) + (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)) +(assert_return (invoke "sat-sub_s-neg" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128) + (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127)) + (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)) +(assert_return (invoke "sat-sub_u-neg" (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127) + (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)) + (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) \ No newline at end of file diff --git a/runtime/near-vm/tests/wast/spec/proposals/simd/simd_int_to_int_extend.wast b/runtime/near-vm/tests/wast/spec/proposals/simd/simd_int_to_int_extend.wast new file mode 100644 index 00000000000..be8d554ca5e --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/proposals/simd/simd_int_to_int_extend.wast @@ -0,0 +1,599 @@ +;; Tests for int-to-int extension operations. + +(module + (func (export "i16x8.extend_high_i8x16_s") (param v128) (result v128) (i16x8.extend_high_i8x16_s (local.get 0))) + (func (export "i16x8.extend_high_i8x16_u") (param v128) (result v128) (i16x8.extend_high_i8x16_u (local.get 0))) + (func (export "i16x8.extend_low_i8x16_s") (param v128) (result v128) (i16x8.extend_low_i8x16_s (local.get 0))) + (func (export "i16x8.extend_low_i8x16_u") (param v128) (result v128) (i16x8.extend_low_i8x16_u (local.get 0))) + (func (export "i32x4.extend_high_i16x8_s") (param v128) (result v128) (i32x4.extend_high_i16x8_s (local.get 0))) + (func (export "i32x4.extend_high_i16x8_u") (param v128) (result v128) (i32x4.extend_high_i16x8_u (local.get 0))) + (func (export "i32x4.extend_low_i16x8_s") (param v128) (result v128) (i32x4.extend_low_i16x8_s (local.get 0))) + (func (export "i32x4.extend_low_i16x8_u") (param v128) (result v128) (i32x4.extend_low_i16x8_u (local.get 0))) + (func (export "i64x2.extend_high_i32x4_s") (param v128) (result v128) (i64x2.extend_high_i32x4_s (local.get 0))) + (func (export "i64x2.extend_high_i32x4_u") (param v128) (result v128) (i64x2.extend_high_i32x4_u (local.get 0))) + (func (export "i64x2.extend_low_i32x4_s") (param v128) (result v128) (i64x2.extend_low_i32x4_s (local.get 0))) + (func (export "i64x2.extend_low_i32x4_u") (param v128) (result v128) (i64x2.extend_low_i32x4_u (local.get 0))) +) + +(assert_return (invoke "i16x8.extend_high_i8x16_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.extend_high_i8x16_s" (v128.const i8x16 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1)) + (v128.const i16x8 1 1 1 1 1 1 1 1)) +(assert_return (invoke "i16x8.extend_high_i8x16_s" (v128.const i8x16 0 0 0 0 0 0 0 0 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "i16x8.extend_high_i8x16_s" (v128.const i8x16 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.extend_high_i8x16_s" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 0 0 0 0 0 0 0 0)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.extend_high_i8x16_s" (v128.const i8x16 1 1 1 1 1 1 1 1 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "i16x8.extend_high_i8x16_s" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 1 1 1 1 1 1 1 1)) + (v128.const i16x8 1 1 1 1 1 1 1 1)) +(assert_return (invoke "i16x8.extend_high_i8x16_s" (v128.const i8x16 126 126 126 126 126 126 126 126 127 127 127 127 127 127 127 127)) + (v128.const i16x8 127 127 127 127 127 127 127 127)) +(assert_return (invoke "i16x8.extend_high_i8x16_s" (v128.const i8x16 127 127 127 127 127 127 127 127 126 126 126 126 126 126 126 126)) + (v128.const i16x8 126 126 126 126 126 126 126 126)) +(assert_return (invoke "i16x8.extend_high_i8x16_s" (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127)) + (v128.const i16x8 127 127 127 127 127 127 127 127)) +(assert_return (invoke "i16x8.extend_high_i8x16_s" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)) + (v128.const i16x8 -128 -128 -128 -128 -128 -128 -128 -128)) +(assert_return (invoke "i16x8.extend_high_i8x16_s" (v128.const i8x16 127 127 127 127 127 127 127 127 -128 -128 -128 -128 -128 -128 -128 -128)) + (v128.const i16x8 -128 -128 -128 -128 -128 -128 -128 -128)) +(assert_return (invoke "i16x8.extend_high_i8x16_s" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 127 127 127 127 127 127 127 127)) + (v128.const i16x8 127 127 127 127 127 127 127 127)) +(assert_return (invoke "i16x8.extend_high_i8x16_s" (v128.const i8x16 127 127 127 127 127 127 127 127 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "i16x8.extend_high_i8x16_s" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 127 127 127 127 127 127 127 127)) + (v128.const i16x8 127 127 127 127 127 127 127 127)) +(assert_return (invoke "i16x8.extend_high_i8x16_s" (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -128 -128 -128 -128 -128 -128 -128 -128)) + (v128.const i16x8 -128 -128 -128 -128 -128 -128 -128 -128)) +(assert_return (invoke "i16x8.extend_high_i8x16_s" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -127 -127 -127 -127 -127 -127 -127 -127)) + (v128.const i16x8 -127 -127 -127 -127 -127 -127 -127 -127)) +(assert_return (invoke "i16x8.extend_high_i8x16_s" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "i16x8.extend_high_i8x16_s" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -128 -128 -128 -128 -128 -128 -128 -128)) + (v128.const i16x8 -128 -128 -128 -128 -128 -128 -128 -128)) + +(assert_return (invoke "i16x8.extend_high_i8x16_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.extend_high_i8x16_u" (v128.const i8x16 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1)) + (v128.const i16x8 1 1 1 1 1 1 1 1)) +(assert_return (invoke "i16x8.extend_high_i8x16_u" (v128.const i8x16 0 0 0 0 0 0 0 0 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i16x8 255 255 255 255 255 255 255 255)) +(assert_return (invoke "i16x8.extend_high_i8x16_u" (v128.const i8x16 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.extend_high_i8x16_u" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 0 0 0 0 0 0 0 0)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.extend_high_i8x16_u" (v128.const i8x16 1 1 1 1 1 1 1 1 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i16x8 255 255 255 255 255 255 255 255)) +(assert_return (invoke "i16x8.extend_high_i8x16_u" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 1 1 1 1 1 1 1 1)) + (v128.const i16x8 1 1 1 1 1 1 1 1)) +(assert_return (invoke "i16x8.extend_high_i8x16_u" (v128.const i8x16 126 126 126 126 126 126 126 126 127 127 127 127 127 127 127 127)) + (v128.const i16x8 127 127 127 127 127 127 127 127)) +(assert_return (invoke "i16x8.extend_high_i8x16_u" (v128.const i8x16 127 127 127 127 127 127 127 127 126 126 126 126 126 126 126 126)) + (v128.const i16x8 126 126 126 126 126 126 126 126)) +(assert_return (invoke "i16x8.extend_high_i8x16_u" (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127)) + (v128.const i16x8 127 127 127 127 127 127 127 127)) +(assert_return (invoke "i16x8.extend_high_i8x16_u" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)) + (v128.const i16x8 128 128 128 128 128 128 128 128)) +(assert_return (invoke "i16x8.extend_high_i8x16_u" (v128.const i8x16 127 127 127 127 127 127 127 127 -128 -128 -128 -128 -128 -128 -128 -128)) + (v128.const i16x8 128 128 128 128 128 128 128 128)) +(assert_return (invoke "i16x8.extend_high_i8x16_u" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 127 127 127 127 127 127 127 127)) + (v128.const i16x8 127 127 127 127 127 127 127 127)) +(assert_return (invoke "i16x8.extend_high_i8x16_u" (v128.const i8x16 127 127 127 127 127 127 127 127 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i16x8 255 255 255 255 255 255 255 255)) +(assert_return (invoke "i16x8.extend_high_i8x16_u" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 127 127 127 127 127 127 127 127)) + (v128.const i16x8 127 127 127 127 127 127 127 127)) +(assert_return (invoke "i16x8.extend_high_i8x16_u" (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -128 -128 -128 -128 -128 -128 -128 -128)) + (v128.const i16x8 128 128 128 128 128 128 128 128)) +(assert_return (invoke "i16x8.extend_high_i8x16_u" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -127 -127 -127 -127 -127 -127 -127 -127)) + (v128.const i16x8 129 129 129 129 129 129 129 129)) +(assert_return (invoke "i16x8.extend_high_i8x16_u" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i16x8 255 255 255 255 255 255 255 255)) +(assert_return (invoke "i16x8.extend_high_i8x16_u" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -128 -128 -128 -128 -128 -128 -128 -128)) + (v128.const i16x8 128 128 128 128 128 128 128 128)) + +(assert_return (invoke "i16x8.extend_low_i8x16_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.extend_low_i8x16_s" (v128.const i8x16 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.extend_low_i8x16_s" (v128.const i8x16 0 0 0 0 0 0 0 0 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.extend_low_i8x16_s" (v128.const i8x16 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0)) + (v128.const i16x8 1 1 1 1 1 1 1 1)) +(assert_return (invoke "i16x8.extend_low_i8x16_s" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 0 0 0 0 0 0 0 0)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "i16x8.extend_low_i8x16_s" (v128.const i8x16 1 1 1 1 1 1 1 1 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i16x8 1 1 1 1 1 1 1 1)) +(assert_return (invoke "i16x8.extend_low_i8x16_s" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 1 1 1 1 1 1 1 1)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "i16x8.extend_low_i8x16_s" (v128.const i8x16 126 126 126 126 126 126 126 126 127 127 127 127 127 127 127 127)) + (v128.const i16x8 126 126 126 126 126 126 126 126)) +(assert_return (invoke "i16x8.extend_low_i8x16_s" (v128.const i8x16 127 127 127 127 127 127 127 127 126 126 126 126 126 126 126 126)) + (v128.const i16x8 127 127 127 127 127 127 127 127)) +(assert_return (invoke "i16x8.extend_low_i8x16_s" (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127)) + (v128.const i16x8 127 127 127 127 127 127 127 127)) +(assert_return (invoke "i16x8.extend_low_i8x16_s" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)) + (v128.const i16x8 -128 -128 -128 -128 -128 -128 -128 -128)) +(assert_return (invoke "i16x8.extend_low_i8x16_s" (v128.const i8x16 127 127 127 127 127 127 127 127 -128 -128 -128 -128 -128 -128 -128 -128)) + (v128.const i16x8 127 127 127 127 127 127 127 127)) +(assert_return (invoke "i16x8.extend_low_i8x16_s" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 127 127 127 127 127 127 127 127)) + (v128.const i16x8 -128 -128 -128 -128 -128 -128 -128 -128)) +(assert_return (invoke "i16x8.extend_low_i8x16_s" (v128.const i8x16 127 127 127 127 127 127 127 127 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i16x8 127 127 127 127 127 127 127 127)) +(assert_return (invoke "i16x8.extend_low_i8x16_s" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 127 127 127 127 127 127 127 127)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "i16x8.extend_low_i8x16_s" (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -128 -128 -128 -128 -128 -128 -128 -128)) + (v128.const i16x8 -127 -127 -127 -127 -127 -127 -127 -127)) +(assert_return (invoke "i16x8.extend_low_i8x16_s" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -127 -127 -127 -127 -127 -127 -127 -127)) + (v128.const i16x8 -128 -128 -128 -128 -128 -128 -128 -128)) +(assert_return (invoke "i16x8.extend_low_i8x16_s" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i16x8 -128 -128 -128 -128 -128 -128 -128 -128)) +(assert_return (invoke "i16x8.extend_low_i8x16_s" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -128 -128 -128 -128 -128 -128 -128 -128)) + (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) + +(assert_return (invoke "i16x8.extend_low_i8x16_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.extend_low_i8x16_u" (v128.const i8x16 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.extend_low_i8x16_u" (v128.const i8x16 0 0 0 0 0 0 0 0 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.extend_low_i8x16_u" (v128.const i8x16 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0)) + (v128.const i16x8 1 1 1 1 1 1 1 1)) +(assert_return (invoke "i16x8.extend_low_i8x16_u" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 0 0 0 0 0 0 0 0)) + (v128.const i16x8 255 255 255 255 255 255 255 255)) +(assert_return (invoke "i16x8.extend_low_i8x16_u" (v128.const i8x16 1 1 1 1 1 1 1 1 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i16x8 1 1 1 1 1 1 1 1)) +(assert_return (invoke "i16x8.extend_low_i8x16_u" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 1 1 1 1 1 1 1 1)) + (v128.const i16x8 255 255 255 255 255 255 255 255)) +(assert_return (invoke "i16x8.extend_low_i8x16_u" (v128.const i8x16 126 126 126 126 126 126 126 126 127 127 127 127 127 127 127 127)) + (v128.const i16x8 126 126 126 126 126 126 126 126)) +(assert_return (invoke "i16x8.extend_low_i8x16_u" (v128.const i8x16 127 127 127 127 127 127 127 127 126 126 126 126 126 126 126 126)) + (v128.const i16x8 127 127 127 127 127 127 127 127)) +(assert_return (invoke "i16x8.extend_low_i8x16_u" (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127)) + (v128.const i16x8 127 127 127 127 127 127 127 127)) +(assert_return (invoke "i16x8.extend_low_i8x16_u" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)) + (v128.const i16x8 128 128 128 128 128 128 128 128)) +(assert_return (invoke "i16x8.extend_low_i8x16_u" (v128.const i8x16 127 127 127 127 127 127 127 127 -128 -128 -128 -128 -128 -128 -128 -128)) + (v128.const i16x8 127 127 127 127 127 127 127 127)) +(assert_return (invoke "i16x8.extend_low_i8x16_u" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 127 127 127 127 127 127 127 127)) + (v128.const i16x8 128 128 128 128 128 128 128 128)) +(assert_return (invoke "i16x8.extend_low_i8x16_u" (v128.const i8x16 127 127 127 127 127 127 127 127 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i16x8 127 127 127 127 127 127 127 127)) +(assert_return (invoke "i16x8.extend_low_i8x16_u" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 127 127 127 127 127 127 127 127)) + (v128.const i16x8 255 255 255 255 255 255 255 255)) +(assert_return (invoke "i16x8.extend_low_i8x16_u" (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -128 -128 -128 -128 -128 -128 -128 -128)) + (v128.const i16x8 129 129 129 129 129 129 129 129)) +(assert_return (invoke "i16x8.extend_low_i8x16_u" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -127 -127 -127 -127 -127 -127 -127 -127)) + (v128.const i16x8 128 128 128 128 128 128 128 128)) +(assert_return (invoke "i16x8.extend_low_i8x16_u" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -1 -1 -1 -1 -1 -1 -1 -1)) + (v128.const i16x8 128 128 128 128 128 128 128 128)) +(assert_return (invoke "i16x8.extend_low_i8x16_u" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -128 -128 -128 -128 -128 -128 -128 -128)) + (v128.const i16x8 255 255 255 255 255 255 255 255)) + +(assert_return (invoke "i32x4.extend_high_i16x8_s" (v128.const i16x8 0 0 0 0 0 0 0 0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.extend_high_i16x8_s" (v128.const i16x8 0 0 0 0 1 1 1 1)) + (v128.const i32x4 1 1 1 1)) +(assert_return (invoke "i32x4.extend_high_i16x8_s" (v128.const i16x8 0 0 0 0 -1 -1 -1 -1)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "i32x4.extend_high_i16x8_s" (v128.const i16x8 1 1 1 1 0 0 0 0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.extend_high_i16x8_s" (v128.const i16x8 -1 -1 -1 -1 0 0 0 0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.extend_high_i16x8_s" (v128.const i16x8 1 1 1 1 -1 -1 -1 -1)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "i32x4.extend_high_i16x8_s" (v128.const i16x8 -1 -1 -1 -1 1 1 1 1)) + (v128.const i32x4 1 1 1 1)) +(assert_return (invoke "i32x4.extend_high_i16x8_s" (v128.const i16x8 32766 32766 32766 32766 32767 32767 32767 32767)) + (v128.const i32x4 32767 32767 32767 32767)) +(assert_return (invoke "i32x4.extend_high_i16x8_s" (v128.const i16x8 32767 32767 32767 32767 32766 32766 32766 32766)) + (v128.const i32x4 32766 32766 32766 32766)) +(assert_return (invoke "i32x4.extend_high_i16x8_s" (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767)) + (v128.const i32x4 32767 32767 32767 32767)) +(assert_return (invoke "i32x4.extend_high_i16x8_s" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)) + (v128.const i32x4 -32768 -32768 -32768 -32768)) +(assert_return (invoke "i32x4.extend_high_i16x8_s" (v128.const i16x8 32767 32767 32767 32767 -32768 -32768 -32768 -32768)) + (v128.const i32x4 -32768 -32768 -32768 -32768)) +(assert_return (invoke "i32x4.extend_high_i16x8_s" (v128.const i16x8 -32768 -32768 -32768 -32768 32767 32767 32767 32767)) + (v128.const i32x4 32767 32767 32767 32767)) +(assert_return (invoke "i32x4.extend_high_i16x8_s" (v128.const i16x8 32767 32767 32767 32767 -1 -1 -1 -1)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "i32x4.extend_high_i16x8_s" (v128.const i16x8 -1 -1 -1 -1 32767 32767 32767 32767)) + (v128.const i32x4 32767 32767 32767 32767)) +(assert_return (invoke "i32x4.extend_high_i16x8_s" (v128.const i16x8 -32767 -32767 -32767 -32767 -32768 -32768 -32768 -32768)) + (v128.const i32x4 -32768 -32768 -32768 -32768)) +(assert_return (invoke "i32x4.extend_high_i16x8_s" (v128.const i16x8 -32768 -32768 -32768 -32768 -32767 -32767 -32767 -32767)) + (v128.const i32x4 -32767 -32767 -32767 -32767)) +(assert_return (invoke "i32x4.extend_high_i16x8_s" (v128.const i16x8 -32768 -32768 -32768 -32768 -1 -1 -1 -1)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "i32x4.extend_high_i16x8_s" (v128.const i16x8 -1 -1 -1 -1 -32768 -32768 -32768 -32768)) + (v128.const i32x4 -32768 -32768 -32768 -32768)) + +(assert_return (invoke "i32x4.extend_high_i16x8_u" (v128.const i16x8 0 0 0 0 0 0 0 0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.extend_high_i16x8_u" (v128.const i16x8 0 0 0 0 1 1 1 1)) + (v128.const i32x4 1 1 1 1)) +(assert_return (invoke "i32x4.extend_high_i16x8_u" (v128.const i16x8 0 0 0 0 -1 -1 -1 -1)) + (v128.const i32x4 65535 65535 65535 65535)) +(assert_return (invoke "i32x4.extend_high_i16x8_u" (v128.const i16x8 1 1 1 1 0 0 0 0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.extend_high_i16x8_u" (v128.const i16x8 -1 -1 -1 -1 0 0 0 0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.extend_high_i16x8_u" (v128.const i16x8 1 1 1 1 -1 -1 -1 -1)) + (v128.const i32x4 65535 65535 65535 65535)) +(assert_return (invoke "i32x4.extend_high_i16x8_u" (v128.const i16x8 -1 -1 -1 -1 1 1 1 1)) + (v128.const i32x4 1 1 1 1)) +(assert_return (invoke "i32x4.extend_high_i16x8_u" (v128.const i16x8 32766 32766 32766 32766 32767 32767 32767 32767)) + (v128.const i32x4 32767 32767 32767 32767)) +(assert_return (invoke "i32x4.extend_high_i16x8_u" (v128.const i16x8 32767 32767 32767 32767 32766 32766 32766 32766)) + (v128.const i32x4 32766 32766 32766 32766)) +(assert_return (invoke "i32x4.extend_high_i16x8_u" (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767)) + (v128.const i32x4 32767 32767 32767 32767)) +(assert_return (invoke "i32x4.extend_high_i16x8_u" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)) + (v128.const i32x4 32768 32768 32768 32768)) +(assert_return (invoke "i32x4.extend_high_i16x8_u" (v128.const i16x8 32767 32767 32767 32767 -32768 -32768 -32768 -32768)) + (v128.const i32x4 32768 32768 32768 32768)) +(assert_return (invoke "i32x4.extend_high_i16x8_u" (v128.const i16x8 -32768 -32768 -32768 -32768 32767 32767 32767 32767)) + (v128.const i32x4 32767 32767 32767 32767)) +(assert_return (invoke "i32x4.extend_high_i16x8_u" (v128.const i16x8 32767 32767 32767 32767 -1 -1 -1 -1)) + (v128.const i32x4 65535 65535 65535 65535)) +(assert_return (invoke "i32x4.extend_high_i16x8_u" (v128.const i16x8 -1 -1 -1 -1 32767 32767 32767 32767)) + (v128.const i32x4 32767 32767 32767 32767)) +(assert_return (invoke "i32x4.extend_high_i16x8_u" (v128.const i16x8 -32767 -32767 -32767 -32767 -32768 -32768 -32768 -32768)) + (v128.const i32x4 32768 32768 32768 32768)) +(assert_return (invoke "i32x4.extend_high_i16x8_u" (v128.const i16x8 -32768 -32768 -32768 -32768 -32767 -32767 -32767 -32767)) + (v128.const i32x4 32769 32769 32769 32769)) +(assert_return (invoke "i32x4.extend_high_i16x8_u" (v128.const i16x8 -32768 -32768 -32768 -32768 -1 -1 -1 -1)) + (v128.const i32x4 65535 65535 65535 65535)) +(assert_return (invoke "i32x4.extend_high_i16x8_u" (v128.const i16x8 -1 -1 -1 -1 -32768 -32768 -32768 -32768)) + (v128.const i32x4 32768 32768 32768 32768)) + +(assert_return (invoke "i32x4.extend_low_i16x8_s" (v128.const i16x8 0 0 0 0 0 0 0 0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.extend_low_i16x8_s" (v128.const i16x8 0 0 0 0 1 1 1 1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.extend_low_i16x8_s" (v128.const i16x8 0 0 0 0 -1 -1 -1 -1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.extend_low_i16x8_s" (v128.const i16x8 1 1 1 1 0 0 0 0)) + (v128.const i32x4 1 1 1 1)) +(assert_return (invoke "i32x4.extend_low_i16x8_s" (v128.const i16x8 -1 -1 -1 -1 0 0 0 0)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "i32x4.extend_low_i16x8_s" (v128.const i16x8 1 1 1 1 -1 -1 -1 -1)) + (v128.const i32x4 1 1 1 1)) +(assert_return (invoke "i32x4.extend_low_i16x8_s" (v128.const i16x8 -1 -1 -1 -1 1 1 1 1)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "i32x4.extend_low_i16x8_s" (v128.const i16x8 32766 32766 32766 32766 32767 32767 32767 32767)) + (v128.const i32x4 32766 32766 32766 32766)) +(assert_return (invoke "i32x4.extend_low_i16x8_s" (v128.const i16x8 32767 32767 32767 32767 32766 32766 32766 32766)) + (v128.const i32x4 32767 32767 32767 32767)) +(assert_return (invoke "i32x4.extend_low_i16x8_s" (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767)) + (v128.const i32x4 32767 32767 32767 32767)) +(assert_return (invoke "i32x4.extend_low_i16x8_s" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)) + (v128.const i32x4 -32768 -32768 -32768 -32768)) +(assert_return (invoke "i32x4.extend_low_i16x8_s" (v128.const i16x8 32767 32767 32767 32767 -32768 -32768 -32768 -32768)) + (v128.const i32x4 32767 32767 32767 32767)) +(assert_return (invoke "i32x4.extend_low_i16x8_s" (v128.const i16x8 -32768 -32768 -32768 -32768 32767 32767 32767 32767)) + (v128.const i32x4 -32768 -32768 -32768 -32768)) +(assert_return (invoke "i32x4.extend_low_i16x8_s" (v128.const i16x8 32767 32767 32767 32767 -1 -1 -1 -1)) + (v128.const i32x4 32767 32767 32767 32767)) +(assert_return (invoke "i32x4.extend_low_i16x8_s" (v128.const i16x8 -1 -1 -1 -1 32767 32767 32767 32767)) + (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "i32x4.extend_low_i16x8_s" (v128.const i16x8 -32767 -32767 -32767 -32767 -32768 -32768 -32768 -32768)) + (v128.const i32x4 -32767 -32767 -32767 -32767)) +(assert_return (invoke "i32x4.extend_low_i16x8_s" (v128.const i16x8 -32768 -32768 -32768 -32768 -32767 -32767 -32767 -32767)) + (v128.const i32x4 -32768 -32768 -32768 -32768)) +(assert_return (invoke "i32x4.extend_low_i16x8_s" (v128.const i16x8 -32768 -32768 -32768 -32768 -1 -1 -1 -1)) + (v128.const i32x4 -32768 -32768 -32768 -32768)) +(assert_return (invoke "i32x4.extend_low_i16x8_s" (v128.const i16x8 -1 -1 -1 -1 -32768 -32768 -32768 -32768)) + (v128.const i32x4 -1 -1 -1 -1)) + +(assert_return (invoke "i32x4.extend_low_i16x8_u" (v128.const i16x8 0 0 0 0 0 0 0 0)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.extend_low_i16x8_u" (v128.const i16x8 0 0 0 0 1 1 1 1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.extend_low_i16x8_u" (v128.const i16x8 0 0 0 0 -1 -1 -1 -1)) + (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.extend_low_i16x8_u" (v128.const i16x8 1 1 1 1 0 0 0 0)) + (v128.const i32x4 1 1 1 1)) +(assert_return (invoke "i32x4.extend_low_i16x8_u" (v128.const i16x8 -1 -1 -1 -1 0 0 0 0)) + (v128.const i32x4 65535 65535 65535 65535)) +(assert_return (invoke "i32x4.extend_low_i16x8_u" (v128.const i16x8 1 1 1 1 -1 -1 -1 -1)) + (v128.const i32x4 1 1 1 1)) +(assert_return (invoke "i32x4.extend_low_i16x8_u" (v128.const i16x8 -1 -1 -1 -1 1 1 1 1)) + (v128.const i32x4 65535 65535 65535 65535)) +(assert_return (invoke "i32x4.extend_low_i16x8_u" (v128.const i16x8 32766 32766 32766 32766 32767 32767 32767 32767)) + (v128.const i32x4 32766 32766 32766 32766)) +(assert_return (invoke "i32x4.extend_low_i16x8_u" (v128.const i16x8 32767 32767 32767 32767 32766 32766 32766 32766)) + (v128.const i32x4 32767 32767 32767 32767)) +(assert_return (invoke "i32x4.extend_low_i16x8_u" (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767)) + (v128.const i32x4 32767 32767 32767 32767)) +(assert_return (invoke "i32x4.extend_low_i16x8_u" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)) + (v128.const i32x4 32768 32768 32768 32768)) +(assert_return (invoke "i32x4.extend_low_i16x8_u" (v128.const i16x8 32767 32767 32767 32767 -32768 -32768 -32768 -32768)) + (v128.const i32x4 32767 32767 32767 32767)) +(assert_return (invoke "i32x4.extend_low_i16x8_u" (v128.const i16x8 -32768 -32768 -32768 -32768 32767 32767 32767 32767)) + (v128.const i32x4 32768 32768 32768 32768)) +(assert_return (invoke "i32x4.extend_low_i16x8_u" (v128.const i16x8 32767 32767 32767 32767 -1 -1 -1 -1)) + (v128.const i32x4 32767 32767 32767 32767)) +(assert_return (invoke "i32x4.extend_low_i16x8_u" (v128.const i16x8 -1 -1 -1 -1 32767 32767 32767 32767)) + (v128.const i32x4 65535 65535 65535 65535)) +(assert_return (invoke "i32x4.extend_low_i16x8_u" (v128.const i16x8 -32767 -32767 -32767 -32767 -32768 -32768 -32768 -32768)) + (v128.const i32x4 32769 32769 32769 32769)) +(assert_return (invoke "i32x4.extend_low_i16x8_u" (v128.const i16x8 -32768 -32768 -32768 -32768 -32767 -32767 -32767 -32767)) + (v128.const i32x4 32768 32768 32768 32768)) +(assert_return (invoke "i32x4.extend_low_i16x8_u" (v128.const i16x8 -32768 -32768 -32768 -32768 -1 -1 -1 -1)) + (v128.const i32x4 32768 32768 32768 32768)) +(assert_return (invoke "i32x4.extend_low_i16x8_u" (v128.const i16x8 -1 -1 -1 -1 -32768 -32768 -32768 -32768)) + (v128.const i32x4 65535 65535 65535 65535)) + +(assert_return (invoke "i64x2.extend_high_i32x4_s" (v128.const i32x4 0 0 0 0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "i64x2.extend_high_i32x4_s" (v128.const i32x4 0 0 1 1)) + (v128.const i64x2 1 1)) +(assert_return (invoke "i64x2.extend_high_i32x4_s" (v128.const i32x4 0 0 -1 -1)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "i64x2.extend_high_i32x4_s" (v128.const i32x4 1 1 0 0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "i64x2.extend_high_i32x4_s" (v128.const i32x4 -1 -1 0 0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "i64x2.extend_high_i32x4_s" (v128.const i32x4 1 1 -1 -1)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "i64x2.extend_high_i32x4_s" (v128.const i32x4 -1 -1 1 1)) + (v128.const i64x2 1 1)) +(assert_return (invoke "i64x2.extend_high_i32x4_s" (v128.const i32x4 2147483646 2147483646 2147483647 2147483647)) + (v128.const i64x2 2147483647 2147483647)) +(assert_return (invoke "i64x2.extend_high_i32x4_s" (v128.const i32x4 2147483647 2147483647 2147483646 2147483646)) + (v128.const i64x2 2147483646 2147483646)) +(assert_return (invoke "i64x2.extend_high_i32x4_s" (v128.const i32x4 2147483647 2147483647 2147483647 2147483647)) + (v128.const i64x2 2147483647 2147483647)) +(assert_return (invoke "i64x2.extend_high_i32x4_s" (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648)) + (v128.const i64x2 -2147483648 -2147483648)) +(assert_return (invoke "i64x2.extend_high_i32x4_s" (v128.const i32x4 2147483647 2147483647 -2147483648 -2147483648)) + (v128.const i64x2 -2147483648 -2147483648)) +(assert_return (invoke "i64x2.extend_high_i32x4_s" (v128.const i32x4 -2147483648 -2147483648 2147483647 2147483647)) + (v128.const i64x2 2147483647 2147483647)) +(assert_return (invoke "i64x2.extend_high_i32x4_s" (v128.const i32x4 2147483647 2147483647 -1 -1)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "i64x2.extend_high_i32x4_s" (v128.const i32x4 -1 -1 2147483647 2147483647)) + (v128.const i64x2 2147483647 2147483647)) +(assert_return (invoke "i64x2.extend_high_i32x4_s" (v128.const i32x4 -2147483647 -2147483647 -2147483648 -2147483648)) + (v128.const i64x2 -2147483648 -2147483648)) +(assert_return (invoke "i64x2.extend_high_i32x4_s" (v128.const i32x4 -2147483648 -2147483648 -2147483647 -2147483647)) + (v128.const i64x2 -2147483647 -2147483647)) +(assert_return (invoke "i64x2.extend_high_i32x4_s" (v128.const i32x4 -2147483648 -2147483648 -1 -1)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "i64x2.extend_high_i32x4_s" (v128.const i32x4 -1 -1 -2147483648 -2147483648)) + (v128.const i64x2 -2147483648 -2147483648)) + +(assert_return (invoke "i64x2.extend_high_i32x4_u" (v128.const i32x4 0 0 0 0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "i64x2.extend_high_i32x4_u" (v128.const i32x4 0 0 1 1)) + (v128.const i64x2 1 1)) +(assert_return (invoke "i64x2.extend_high_i32x4_u" (v128.const i32x4 0 0 -1 -1)) + (v128.const i64x2 4294967295 4294967295)) +(assert_return (invoke "i64x2.extend_high_i32x4_u" (v128.const i32x4 1 1 0 0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "i64x2.extend_high_i32x4_u" (v128.const i32x4 -1 -1 0 0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "i64x2.extend_high_i32x4_u" (v128.const i32x4 1 1 -1 -1)) + (v128.const i64x2 4294967295 4294967295)) +(assert_return (invoke "i64x2.extend_high_i32x4_u" (v128.const i32x4 -1 -1 1 1)) + (v128.const i64x2 1 1)) +(assert_return (invoke "i64x2.extend_high_i32x4_u" (v128.const i32x4 2147483646 2147483646 2147483647 2147483647)) + (v128.const i64x2 2147483647 2147483647)) +(assert_return (invoke "i64x2.extend_high_i32x4_u" (v128.const i32x4 2147483647 2147483647 2147483646 2147483646)) + (v128.const i64x2 2147483646 2147483646)) +(assert_return (invoke "i64x2.extend_high_i32x4_u" (v128.const i32x4 2147483647 2147483647 2147483647 2147483647)) + (v128.const i64x2 2147483647 2147483647)) +(assert_return (invoke "i64x2.extend_high_i32x4_u" (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648)) + (v128.const i64x2 2147483648 2147483648)) +(assert_return (invoke "i64x2.extend_high_i32x4_u" (v128.const i32x4 2147483647 2147483647 -2147483648 -2147483648)) + (v128.const i64x2 2147483648 2147483648)) +(assert_return (invoke "i64x2.extend_high_i32x4_u" (v128.const i32x4 -2147483648 -2147483648 2147483647 2147483647)) + (v128.const i64x2 2147483647 2147483647)) +(assert_return (invoke "i64x2.extend_high_i32x4_u" (v128.const i32x4 2147483647 2147483647 -1 -1)) + (v128.const i64x2 4294967295 4294967295)) +(assert_return (invoke "i64x2.extend_high_i32x4_u" (v128.const i32x4 -1 -1 2147483647 2147483647)) + (v128.const i64x2 2147483647 2147483647)) +(assert_return (invoke "i64x2.extend_high_i32x4_u" (v128.const i32x4 -2147483647 -2147483647 -2147483648 -2147483648)) + (v128.const i64x2 2147483648 2147483648)) +(assert_return (invoke "i64x2.extend_high_i32x4_u" (v128.const i32x4 -2147483648 -2147483648 -2147483647 -2147483647)) + (v128.const i64x2 2147483649 2147483649)) +(assert_return (invoke "i64x2.extend_high_i32x4_u" (v128.const i32x4 -2147483648 -2147483648 -1 -1)) + (v128.const i64x2 4294967295 4294967295)) +(assert_return (invoke "i64x2.extend_high_i32x4_u" (v128.const i32x4 -1 -1 -2147483648 -2147483648)) + (v128.const i64x2 2147483648 2147483648)) + +(assert_return (invoke "i64x2.extend_low_i32x4_s" (v128.const i32x4 0 0 0 0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "i64x2.extend_low_i32x4_s" (v128.const i32x4 0 0 1 1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "i64x2.extend_low_i32x4_s" (v128.const i32x4 0 0 -1 -1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "i64x2.extend_low_i32x4_s" (v128.const i32x4 1 1 0 0)) + (v128.const i64x2 1 1)) +(assert_return (invoke "i64x2.extend_low_i32x4_s" (v128.const i32x4 -1 -1 0 0)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "i64x2.extend_low_i32x4_s" (v128.const i32x4 1 1 -1 -1)) + (v128.const i64x2 1 1)) +(assert_return (invoke "i64x2.extend_low_i32x4_s" (v128.const i32x4 -1 -1 1 1)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "i64x2.extend_low_i32x4_s" (v128.const i32x4 2147483646 2147483646 2147483647 2147483647)) + (v128.const i64x2 2147483646 2147483646)) +(assert_return (invoke "i64x2.extend_low_i32x4_s" (v128.const i32x4 2147483647 2147483647 2147483646 2147483646)) + (v128.const i64x2 2147483647 2147483647)) +(assert_return (invoke "i64x2.extend_low_i32x4_s" (v128.const i32x4 2147483647 2147483647 2147483647 2147483647)) + (v128.const i64x2 2147483647 2147483647)) +(assert_return (invoke "i64x2.extend_low_i32x4_s" (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648)) + (v128.const i64x2 -2147483648 -2147483648)) +(assert_return (invoke "i64x2.extend_low_i32x4_s" (v128.const i32x4 2147483647 2147483647 -2147483648 -2147483648)) + (v128.const i64x2 2147483647 2147483647)) +(assert_return (invoke "i64x2.extend_low_i32x4_s" (v128.const i32x4 -2147483648 -2147483648 2147483647 2147483647)) + (v128.const i64x2 -2147483648 -2147483648)) +(assert_return (invoke "i64x2.extend_low_i32x4_s" (v128.const i32x4 2147483647 2147483647 -1 -1)) + (v128.const i64x2 2147483647 2147483647)) +(assert_return (invoke "i64x2.extend_low_i32x4_s" (v128.const i32x4 -1 -1 2147483647 2147483647)) + (v128.const i64x2 -1 -1)) +(assert_return (invoke "i64x2.extend_low_i32x4_s" (v128.const i32x4 -2147483647 -2147483647 -2147483648 -2147483648)) + (v128.const i64x2 -2147483647 -2147483647)) +(assert_return (invoke "i64x2.extend_low_i32x4_s" (v128.const i32x4 -2147483648 -2147483648 -2147483647 -2147483647)) + (v128.const i64x2 -2147483648 -2147483648)) +(assert_return (invoke "i64x2.extend_low_i32x4_s" (v128.const i32x4 -2147483648 -2147483648 -1 -1)) + (v128.const i64x2 -2147483648 -2147483648)) +(assert_return (invoke "i64x2.extend_low_i32x4_s" (v128.const i32x4 -1 -1 -2147483648 -2147483648)) + (v128.const i64x2 -1 -1)) + +(assert_return (invoke "i64x2.extend_low_i32x4_u" (v128.const i32x4 0 0 0 0)) + (v128.const i64x2 0 0)) +(assert_return (invoke "i64x2.extend_low_i32x4_u" (v128.const i32x4 0 0 1 1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "i64x2.extend_low_i32x4_u" (v128.const i32x4 0 0 -1 -1)) + (v128.const i64x2 0 0)) +(assert_return (invoke "i64x2.extend_low_i32x4_u" (v128.const i32x4 1 1 0 0)) + (v128.const i64x2 1 1)) +(assert_return (invoke "i64x2.extend_low_i32x4_u" (v128.const i32x4 -1 -1 0 0)) + (v128.const i64x2 4294967295 4294967295)) +(assert_return (invoke "i64x2.extend_low_i32x4_u" (v128.const i32x4 1 1 -1 -1)) + (v128.const i64x2 1 1)) +(assert_return (invoke "i64x2.extend_low_i32x4_u" (v128.const i32x4 -1 -1 1 1)) + (v128.const i64x2 4294967295 4294967295)) +(assert_return (invoke "i64x2.extend_low_i32x4_u" (v128.const i32x4 2147483646 2147483646 2147483647 2147483647)) + (v128.const i64x2 2147483646 2147483646)) +(assert_return (invoke "i64x2.extend_low_i32x4_u" (v128.const i32x4 2147483647 2147483647 2147483646 2147483646)) + (v128.const i64x2 2147483647 2147483647)) +(assert_return (invoke "i64x2.extend_low_i32x4_u" (v128.const i32x4 2147483647 2147483647 2147483647 2147483647)) + (v128.const i64x2 2147483647 2147483647)) +(assert_return (invoke "i64x2.extend_low_i32x4_u" (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648)) + (v128.const i64x2 2147483648 2147483648)) +(assert_return (invoke "i64x2.extend_low_i32x4_u" (v128.const i32x4 2147483647 2147483647 -2147483648 -2147483648)) + (v128.const i64x2 2147483647 2147483647)) +(assert_return (invoke "i64x2.extend_low_i32x4_u" (v128.const i32x4 -2147483648 -2147483648 2147483647 2147483647)) + (v128.const i64x2 2147483648 2147483648)) +(assert_return (invoke "i64x2.extend_low_i32x4_u" (v128.const i32x4 2147483647 2147483647 -1 -1)) + (v128.const i64x2 2147483647 2147483647)) +(assert_return (invoke "i64x2.extend_low_i32x4_u" (v128.const i32x4 -1 -1 2147483647 2147483647)) + (v128.const i64x2 4294967295 4294967295)) +(assert_return (invoke "i64x2.extend_low_i32x4_u" (v128.const i32x4 -2147483647 -2147483647 -2147483648 -2147483648)) + (v128.const i64x2 2147483649 2147483649)) +(assert_return (invoke "i64x2.extend_low_i32x4_u" (v128.const i32x4 -2147483648 -2147483648 -2147483647 -2147483647)) + (v128.const i64x2 2147483648 2147483648)) +(assert_return (invoke "i64x2.extend_low_i32x4_u" (v128.const i32x4 -2147483648 -2147483648 -1 -1)) + (v128.const i64x2 2147483648 2147483648)) +(assert_return (invoke "i64x2.extend_low_i32x4_u" (v128.const i32x4 -1 -1 -2147483648 -2147483648)) + (v128.const i64x2 4294967295 4294967295)) + + +;; type check +(assert_invalid (module (func (result v128) (i16x8.extend_high_i8x16_s (i32.const 0)))) "type mismatch") +(assert_invalid (module (func (result v128) (i16x8.extend_high_i8x16_u (i32.const 0)))) "type mismatch") +(assert_invalid (module (func (result v128) (i16x8.extend_low_i8x16_s (i32.const 0)))) "type mismatch") +(assert_invalid (module (func (result v128) (i16x8.extend_low_i8x16_u (i32.const 0)))) "type mismatch") +(assert_invalid (module (func (result v128) (i32x4.extend_high_i16x8_s (i32.const 0)))) "type mismatch") +(assert_invalid (module (func (result v128) (i32x4.extend_high_i16x8_u (i32.const 0)))) "type mismatch") +(assert_invalid (module (func (result v128) (i32x4.extend_low_i16x8_s (i32.const 0)))) "type mismatch") +(assert_invalid (module (func (result v128) (i32x4.extend_low_i16x8_u (i32.const 0)))) "type mismatch") +(assert_invalid (module (func (result v128) (i64x2.extend_high_i32x4_s (i32.const 0)))) "type mismatch") +(assert_invalid (module (func (result v128) (i64x2.extend_high_i32x4_u (i32.const 0)))) "type mismatch") +(assert_invalid (module (func (result v128) (i64x2.extend_low_i32x4_s (i32.const 0)))) "type mismatch") +(assert_invalid (module (func (result v128) (i64x2.extend_low_i32x4_u (i32.const 0)))) "type mismatch") + +;; Test operation with empty argument + +(assert_invalid + (module + (func $i16x8.extend_high_i8x16_s-arg-empty (result v128) + (i16x8.extend_high_i8x16_s) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i16x8.extend_high_i8x16_u-arg-empty (result v128) + (i16x8.extend_high_i8x16_u) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i16x8.extend_low_i8x16_s-arg-empty (result v128) + (i16x8.extend_low_i8x16_s) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i16x8.extend_low_i8x16_u-arg-empty (result v128) + (i16x8.extend_low_i8x16_u) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i32x4.extend_high_i16x8_s-arg-empty (result v128) + (i32x4.extend_high_i16x8_s) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i32x4.extend_high_i16x8_u-arg-empty (result v128) + (i32x4.extend_high_i16x8_u) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i32x4.extend_low_i16x8_s-arg-empty (result v128) + (i32x4.extend_low_i16x8_s) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i32x4.extend_low_i16x8_u-arg-empty (result v128) + (i32x4.extend_low_i16x8_u) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i64x2.extend_high_i32x4_s-arg-empty (result v128) + (i64x2.extend_high_i32x4_s) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i64x2.extend_high_i32x4_u-arg-empty (result v128) + (i64x2.extend_high_i32x4_u) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i64x2.extend_low_i32x4_s-arg-empty (result v128) + (i64x2.extend_low_i32x4_s) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i64x2.extend_low_i32x4_u-arg-empty (result v128) + (i64x2.extend_low_i32x4_u) + ) + ) + "type mismatch" +) + diff --git a/runtime/near-vm/tests/wast/spec/proposals/simd/simd_lane.wast b/runtime/near-vm/tests/wast/spec/proposals/simd/simd_lane.wast new file mode 100644 index 00000000000..9d4b5fd7296 --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/proposals/simd/simd_lane.wast @@ -0,0 +1,1265 @@ +;; Tests for the extract_lane, replace_lane, swizzle and shuffle group instructions + + +(module + (func (export "i8x16_extract_lane_s-first") (param v128) (result i32) + (i8x16.extract_lane_s 0 (local.get 0))) + (func (export "i8x16_extract_lane_s-last") (param v128) (result i32) + (i8x16.extract_lane_s 15 (local.get 0))) + (func (export "i8x16_extract_lane_u-first") (param v128) (result i32) + (i8x16.extract_lane_u 0 (local.get 0))) + (func (export "i8x16_extract_lane_u-last") (param v128) (result i32) + (i8x16.extract_lane_u 15 (local.get 0))) + (func (export "i16x8_extract_lane_s-first") (param v128) (result i32) + (i16x8.extract_lane_s 0 (local.get 0))) + (func (export "i16x8_extract_lane_s-last") (param v128) (result i32) + (i16x8.extract_lane_s 7 (local.get 0))) + (func (export "i16x8_extract_lane_u-first") (param v128) (result i32) + (i16x8.extract_lane_u 0 (local.get 0))) + (func (export "i16x8_extract_lane_u-last") (param v128) (result i32) + (i16x8.extract_lane_u 7 (local.get 0))) + (func (export "i32x4_extract_lane-first") (param v128) (result i32) + (i32x4.extract_lane 0 (local.get 0))) + (func (export "i32x4_extract_lane-last") (param v128) (result i32) + (i32x4.extract_lane 3 (local.get 0))) + (func (export "f32x4_extract_lane-first") (param v128) (result f32) + (f32x4.extract_lane 0 (local.get 0))) + (func (export "f32x4_extract_lane-last") (param v128) (result f32) + (f32x4.extract_lane 3 (local.get 0))) + (func (export "i8x16_replace_lane-first") (param v128 i32) (result v128) + (i8x16.replace_lane 0 (local.get 0) (local.get 1))) + (func (export "i8x16_replace_lane-last") (param v128 i32) (result v128) + (i8x16.replace_lane 15 (local.get 0) (local.get 1))) + (func (export "i16x8_replace_lane-first") (param v128 i32) (result v128) + (i16x8.replace_lane 0 (local.get 0) (local.get 1))) + (func (export "i16x8_replace_lane-last") (param v128 i32) (result v128) + (i16x8.replace_lane 7 (local.get 0) (local.get 1))) + (func (export "i32x4_replace_lane-first") (param v128 i32) (result v128) + (i32x4.replace_lane 0 (local.get 0) (local.get 1))) + (func (export "i32x4_replace_lane-last") (param v128 i32) (result v128) + (i32x4.replace_lane 3 (local.get 0) (local.get 1))) + (func (export "f32x4_replace_lane-first") (param v128 f32) (result v128) + (f32x4.replace_lane 0 (local.get 0) (local.get 1))) + (func (export "f32x4_replace_lane-last") (param v128 f32) (result v128) + (f32x4.replace_lane 3 (local.get 0) (local.get 1))) + (func (export "i64x2_extract_lane-first") (param v128) (result i64) + (i64x2.extract_lane 0 (local.get 0))) + (func (export "i64x2_extract_lane-last") (param v128) (result i64) + (i64x2.extract_lane 1 (local.get 0))) + (func (export "f64x2_extract_lane-first") (param v128) (result f64) + (f64x2.extract_lane 0 (local.get 0))) + (func (export "f64x2_extract_lane-last") (param v128) (result f64) + (f64x2.extract_lane 1 (local.get 0))) + (func (export "i64x2_replace_lane-first") (param v128 i64) (result v128) + (i64x2.replace_lane 0 (local.get 0) (local.get 1))) + (func (export "i64x2_replace_lane-last") (param v128 i64) (result v128) + (i64x2.replace_lane 1 (local.get 0) (local.get 1))) + (func (export "f64x2_replace_lane-first") (param v128 f64) (result v128) + (f64x2.replace_lane 0 (local.get 0) (local.get 1))) + (func (export "f64x2_replace_lane-last") (param v128 f64) (result v128) + (f64x2.replace_lane 1 (local.get 0) (local.get 1))) + + ;; Swizzle and shuffle + (func (export "v8x16_swizzle") (param v128 v128) (result v128) + (i8x16.swizzle (local.get 0) (local.get 1))) + (func (export "v8x16_shuffle-1") (param v128 v128) (result v128) + (i8x16.shuffle 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 (local.get 0) (local.get 1))) + (func (export "v8x16_shuffle-2") (param v128 v128) (result v128) + (i8x16.shuffle 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 (local.get 0) (local.get 1))) + (func (export "v8x16_shuffle-3") (param v128 v128) (result v128) + (i8x16.shuffle 31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 (local.get 0) (local.get 1))) + (func (export "v8x16_shuffle-4") (param v128 v128) (result v128) + (i8x16.shuffle 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0 (local.get 0) (local.get 1))) + (func (export "v8x16_shuffle-5") (param v128 v128) (result v128) + (i8x16.shuffle 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 (local.get 0) (local.get 1))) + (func (export "v8x16_shuffle-6") (param v128 v128) (result v128) + (i8x16.shuffle 16 16 16 16 16 16 16 16 16 16 16 16 16 16 16 16 (local.get 0) (local.get 1))) + (func (export "v8x16_shuffle-7") (param v128 v128) (result v128) + (i8x16.shuffle 0 0 0 0 0 0 0 0 16 16 16 16 16 16 16 16 (local.get 0) (local.get 1))) +) + +(assert_return (invoke "i8x16_extract_lane_s-first" (v128.const i8x16 127 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) (i32.const 127)) +(assert_return (invoke "i8x16_extract_lane_s-first" (v128.const i8x16 0x7f 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) (i32.const 127)) +(assert_return (invoke "i8x16_extract_lane_s-first" (v128.const i8x16 255 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) (i32.const -1)) +(assert_return (invoke "i8x16_extract_lane_s-first" (v128.const i8x16 0xff 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) (i32.const -1)) +(assert_return (invoke "i8x16_extract_lane_u-first" (v128.const i8x16 255 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) (i32.const 255)) +(assert_return (invoke "i8x16_extract_lane_u-first" (v128.const i8x16 0xff 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) (i32.const 255)) +(assert_return (invoke "i8x16_extract_lane_s-last" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -128)) (i32.const -128)) +(assert_return (invoke "i8x16_extract_lane_s-last" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0x80)) (i32.const -128)) +(assert_return (invoke "i8x16_extract_lane_u-last" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -1)) (i32.const 255)) +(assert_return (invoke "i8x16_extract_lane_u-last" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0xff)) (i32.const 255)) +(assert_return (invoke "i8x16_extract_lane_u-last" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -128)) (i32.const 128)) +(assert_return (invoke "i8x16_extract_lane_u-last" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0x80)) (i32.const 128)) + +(assert_return (invoke "i16x8_extract_lane_s-first" (v128.const i16x8 32767 0 0 0 0 0 0 0)) (i32.const 32767)) +(assert_return (invoke "i16x8_extract_lane_s-first" (v128.const i16x8 0x7fff 0 0 0 0 0 0 0)) (i32.const 32767)) +(assert_return (invoke "i16x8_extract_lane_s-first" (v128.const i16x8 65535 0 0 0 0 0 0 0)) (i32.const -1)) +(assert_return (invoke "i16x8_extract_lane_s-first" (v128.const i16x8 0xffff 0 0 0 0 0 0 0)) (i32.const -1)) +(assert_return (invoke "i16x8_extract_lane_s-first" (v128.const i16x8 012_345 0 0 0 0 0 0 0)) (i32.const 12345)) +(assert_return (invoke "i16x8_extract_lane_s-first" (v128.const i16x8 -0x0_1234 0 0 0 0 0 0 0)) (i32.const -0x1234)) +(assert_return (invoke "i16x8_extract_lane_u-first" (v128.const i16x8 65535 0 0 0 0 0 0 0)) (i32.const 65535)) +(assert_return (invoke "i16x8_extract_lane_u-first" (v128.const i16x8 0xffff 0 0 0 0 0 0 0)) (i32.const 65535)) +(assert_return (invoke "i16x8_extract_lane_u-first" (v128.const i16x8 012_345 0 0 0 0 0 0 0)) (i32.const 12345)) +(assert_return (invoke "i16x8_extract_lane_u-first" (v128.const i16x8 -0x0_1234 0 0 0 0 0 0 0)) (i32.const 60876)) +(assert_return (invoke "i16x8_extract_lane_s-last" (v128.const i16x8 0 0 0 0 0 0 0 -32768)) (i32.const -32768)) +(assert_return (invoke "i16x8_extract_lane_s-last" (v128.const i16x8 0 0 0 0 0 0 0 0x8000)) (i32.const -32768)) +(assert_return (invoke "i16x8_extract_lane_s-last" (v128.const i16x8 0 0 0 0 0 0 0 06_789)) (i32.const 6789)) +(assert_return (invoke "i16x8_extract_lane_s-last" (v128.const i16x8 0 0 0 0 0 0 0 -0x0_6789)) (i32.const -0x6789)) +(assert_return (invoke "i16x8_extract_lane_u-last" (v128.const i16x8 0 0 0 0 0 0 0 -1)) (i32.const 65535)) +(assert_return (invoke "i16x8_extract_lane_u-last" (v128.const i16x8 0 0 0 0 0 0 0 0xffff)) (i32.const 65535)) +(assert_return (invoke "i16x8_extract_lane_u-last" (v128.const i16x8 0 0 0 0 0 0 0 -32768)) (i32.const 32768)) +(assert_return (invoke "i16x8_extract_lane_u-last" (v128.const i16x8 0 0 0 0 0 0 0 0x8000)) (i32.const 32768)) +(assert_return (invoke "i16x8_extract_lane_u-last" (v128.const i16x8 0 0 0 0 0 0 0 06_789)) (i32.const 6789)) +(assert_return (invoke "i16x8_extract_lane_u-last" (v128.const i16x8 0 0 0 0 0 0 0 -0x0_6789)) (i32.const 39031)) + +(assert_return (invoke "i32x4_extract_lane-first" (v128.const i32x4 2147483647 0 0 0)) (i32.const 2147483647)) +(assert_return (invoke "i32x4_extract_lane-first" (v128.const i32x4 0x7fffffff 0 0 0)) (i32.const 2147483647)) +(assert_return (invoke "i32x4_extract_lane-first" (v128.const i32x4 4294967295 0 0 0)) (i32.const -1)) +(assert_return (invoke "i32x4_extract_lane-first" (v128.const i32x4 0xffffffff 0 0 0)) (i32.const -1)) +(assert_return (invoke "i32x4_extract_lane-first" (v128.const i32x4 01_234_567_890 0 0 0)) (i32.const 1234567890)) +(assert_return (invoke "i32x4_extract_lane-first" (v128.const i32x4 -0x0_1234_5678 0 0 0)) (i32.const -0x12345678)) +(assert_return (invoke "i32x4_extract_lane-last" (v128.const i32x4 0 0 0 -2147483648)) (i32.const -2147483648)) +(assert_return (invoke "i32x4_extract_lane-last" (v128.const i32x4 0 0 0 0x80000000)) (i32.const -2147483648)) +(assert_return (invoke "i32x4_extract_lane-last" (v128.const i32x4 0 0 0 -1)) (i32.const -1)) +(assert_return (invoke "i32x4_extract_lane-last" (v128.const i32x4 0 0 0 0xffffffff)) (i32.const -1)) +(assert_return (invoke "i32x4_extract_lane-last" (v128.const i32x4 0 0 0 0_987_654_321)) (i32.const 987654321)) +(assert_return (invoke "i32x4_extract_lane-last" (v128.const i32x4 0 0 0 -0x0_1234_5678)) (i32.const -0x12345678)) + +(assert_return (invoke "i64x2_extract_lane-first" (v128.const i64x2 9223372036854775807 0)) (i64.const 9223372036854775807)) +(assert_return (invoke "i64x2_extract_lane-first" (v128.const i64x2 0x7ffffffffffffffe 0)) (i64.const 0x7ffffffffffffffe)) +(assert_return (invoke "i64x2_extract_lane-first" (v128.const i64x2 18446744073709551615 0)) (i64.const -1)) +(assert_return (invoke "i64x2_extract_lane-first" (v128.const i64x2 0xffffffffffffffff 0)) (i64.const -1)) +(assert_return (invoke "i64x2_extract_lane-first" (v128.const i64x2 01_234_567_890_123_456_789 0)) (i64.const 1234567890123456789)) +(assert_return (invoke "i64x2_extract_lane-first" (v128.const i64x2 0x0_1234_5678_90AB_cdef 0)) (i64.const 0x1234567890abcdef)) +(assert_return (invoke "i64x2_extract_lane-last" (v128.const i64x2 0 9223372036854775808)) (i64.const -9223372036854775808)) +(assert_return (invoke "i64x2_extract_lane-last" (v128.const i64x2 0 0x8000000000000000)) (i64.const -0x8000000000000000)) +(assert_return (invoke "i64x2_extract_lane-last" (v128.const i64x2 0 0x8000000000000000)) (i64.const 0x8000000000000000)) +(assert_return (invoke "i64x2_extract_lane-last" (v128.const i8x16 0 0 0 0 0 0 0 0 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0x7f)) (i64.const 9223372036854775807)) +(assert_return (invoke "i64x2_extract_lane-last" (v128.const i16x8 0 0 0 0 0 0 0 0x8000)) (i64.const -9223372036854775808)) +(assert_return (invoke "i64x2_extract_lane-last" (v128.const i32x4 0 0 0xffffffff 0x7fffffff)) (i64.const 9223372036854775807)) +(assert_return (invoke "i64x2_extract_lane-last" (v128.const f64x2 -inf +inf)) (i64.const 0x7ff0000000000000)) +(assert_return (invoke "i64x2_extract_lane-last" (v128.const i64x2 0 01_234_567_890_123_456_789)) (i64.const 1234567890123456789)) +(assert_return (invoke "i64x2_extract_lane-last" (v128.const i64x2 0 0x0_1234_5678_90AB_cdef)) (i64.const 0x1234567890abcdef)) + +(assert_return (invoke "f32x4_extract_lane-first" (v128.const f32x4 -5.0 0.0 0.0 0.0)) (f32.const -5.0)) +(assert_return (invoke "f32x4_extract_lane-first" (v128.const f32x4 1e38 0.0 0.0 0.0)) (f32.const 1e38)) +(assert_return (invoke "f32x4_extract_lane-first" (v128.const f32x4 0x1.fffffep127 0.0 0.0 0.0)) (f32.const 0x1.fffffep127)) +(assert_return (invoke "f32x4_extract_lane-first" (v128.const f32x4 0x1p127 0.0 0.0 0.0)) (f32.const 0x1p127)) +(assert_return (invoke "f32x4_extract_lane-first" (v128.const f32x4 inf 0.0 0.0 0.0)) (f32.const inf)) +(assert_return (invoke "f32x4_extract_lane-first" (v128.const f32x4 nan inf 0.0 0.0)) (f32.const nan)) +(assert_return (invoke "f32x4_extract_lane-first" (v128.const f32x4 0123456789.0123456789e+019 0.0 0.0 0.0)) (f32.const 123456789.0123456789e+019)) +(assert_return (invoke "f32x4_extract_lane-first" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0.0 0.0 0.0)) (f32.const 0x123456789ABCDEF.019aFp-019)) +(assert_return (invoke "f32x4_extract_lane-last" (v128.const f32x4 0.0 0.0 0.0 -1e38)) (f32.const -1e38)) +(assert_return (invoke "f32x4_extract_lane-last" (v128.const f32x4 0.0 0.0 0.0 -0x1.fffffep127)) (f32.const -0x1.fffffep127)) +(assert_return (invoke "f32x4_extract_lane-last" (v128.const f32x4 0.0 0.0 0.0 -0x1p127)) (f32.const -0x1p127)) +(assert_return (invoke "f32x4_extract_lane-last" (v128.const f32x4 0.0 0.0 0.0 -inf)) (f32.const -inf)) +(assert_return (invoke "f32x4_extract_lane-last" (v128.const f32x4 0.0 0.0 -inf nan)) (f32.const nan)) +(assert_return (invoke "f32x4_extract_lane-last" (v128.const f32x4 0.0 0.0 0.0 0123456789.)) (f32.const 123456789.0)) +(assert_return (invoke "f32x4_extract_lane-last" (v128.const f32x4 0.0 0.0 0.0 0x0123456789ABCDEF.)) (f32.const 0x123456789ABCDEF.0p0)) + +(assert_return (invoke "f64x2_extract_lane-first" (v128.const f64x2 -1.5 0.0)) (f64.const -1.5)) +(assert_return (invoke "f64x2_extract_lane-first" (v128.const f64x2 1.5 0.0)) (f64.const 1.5)) +(assert_return (invoke "f64x2_extract_lane-first" (v128.const f64x2 -1.7976931348623157e-308 0x0p+0)) (f64.const -1.7976931348623157e-308)) +(assert_return (invoke "f64x2_extract_lane-first" (v128.const f64x2 1.7976931348623157e-308 0x0p-0)) (f64.const 1.7976931348623157e-308)) +(assert_return (invoke "f64x2_extract_lane-first" (v128.const f64x2 -0x1.fffffffffffffp-1023 0x0p+0)) (f64.const -0x1.fffffffffffffp-1023)) +(assert_return (invoke "f64x2_extract_lane-first" (v128.const f64x2 0x1.fffffffffffffp-1023 0x0p-0)) (f64.const 0x1.fffffffffffffp-1023)) +(assert_return (invoke "f64x2_extract_lane-first" (v128.const f64x2 -inf 0.0)) (f64.const -inf)) +(assert_return (invoke "f64x2_extract_lane-first" (v128.const f64x2 inf 0.0)) (f64.const inf)) +(assert_return (invoke "f64x2_extract_lane-first" (v128.const f64x2 -nan -0.0)) (f64.const -nan)) +(assert_return (invoke "f64x2_extract_lane-first" (v128.const f64x2 nan 0.0)) (f64.const nan)) +(assert_return (invoke "f64x2_extract_lane-first" (v128.const f64x2 0123456789.0123456789e+019 0.0)) (f64.const 123456789.0123456789e+019)) +(assert_return (invoke "f64x2_extract_lane-first" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0.0)) (f64.const 0x123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)) +(assert_return (invoke "f64x2_extract_lane-last" (v128.const f64x2 0.0 2.25)) (f64.const 2.25)) +(assert_return (invoke "f64x2_extract_lane-last" (v128.const f64x2 0.0 -2.25)) (f64.const -2.25)) +(assert_return (invoke "f64x2_extract_lane-last" (v128.const f64x2 0x0p-0 -1.7976931348623157e+308)) (f64.const -1.7976931348623157e+308)) +(assert_return (invoke "f64x2_extract_lane-last" (v128.const f64x2 0x0p+0 1.7976931348623157e+308)) (f64.const 1.7976931348623157e+308)) +(assert_return (invoke "f64x2_extract_lane-last" (v128.const f64x2 0x0p-0 -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2_extract_lane-last" (v128.const f64x2 0x0p+0 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2_extract_lane-last" (v128.const f64x2 -0.0 -inf)) (f64.const -inf)) +(assert_return (invoke "f64x2_extract_lane-last" (v128.const f64x2 0.0 inf)) (f64.const inf)) +(assert_return (invoke "f64x2_extract_lane-last" (v128.const f64x2 -0.0 -nan)) (f64.const -nan)) +(assert_return (invoke "f64x2_extract_lane-last" (v128.const f64x2 0.0 nan)) (f64.const nan)) +(assert_return (invoke "f64x2_extract_lane-last" (v128.const f64x2 0.0 0123456789.)) (f64.const 123456789.0)) +(assert_return (invoke "f64x2_extract_lane-last" (v128.const f64x2 0.0 0x0123456789ABCDEFabcdef.)) (f64.const 0x123456789ABCDEFabcdef.0)) + +(assert_return (invoke "f64x2_extract_lane-last" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) (f64.const 0.0)) +(assert_return (invoke "f64x2_extract_lane-last" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0x80)) (f64.const -0.0)) +(assert_return (invoke "f64x2_extract_lane-last" (v128.const i16x8 0 0 0 0 0 0 0 0x4000)) (f64.const 2.0)) +(assert_return (invoke "f64x2_extract_lane-last" (v128.const i16x8 0 0 0 0 0 0 0 0xc000)) (f64.const -2.0)) +(assert_return (invoke "f64x2_extract_lane-last" (v128.const i32x4 0 0 0xffffffff 0x7fefffff)) (f64.const 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2_extract_lane-last" (v128.const i32x4 0 0 0 0x00100000)) (f64.const 0x1.0000000000000p-1022)) +(assert_return (invoke "f64x2_extract_lane-last" (v128.const i32x4 0 0 0xffffffff 0x000fffff)) (f64.const 0x1.ffffffffffffep-1023)) +(assert_return (invoke "f64x2_extract_lane-last" (v128.const i32x4 0 0 1 0)) (f64.const 0x0.0000000000002p-1023)) + +(assert_return (invoke "i8x16_replace_lane-first" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (i32.const 127)) (v128.const i8x16 127 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i8x16_replace_lane-first" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (i32.const 128)) (v128.const i8x16 -128 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i8x16_replace_lane-first" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (i32.const 255)) (v128.const i8x16 -1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i8x16_replace_lane-first" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (i32.const 256)) (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i8x16_replace_lane-last" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (i32.const -128)) (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -128)) +(assert_return (invoke "i8x16_replace_lane-last" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (i32.const -129)) (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 127)) +(assert_return (invoke "i8x16_replace_lane-last" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (i32.const 32767)) (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0xff)) +(assert_return (invoke "i8x16_replace_lane-last" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (i32.const -32768)) (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + +(assert_return (invoke "i16x8_replace_lane-first" (v128.const i16x8 0 0 0 0 0 0 0 0) (i32.const 32767)) (v128.const i16x8 32767 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8_replace_lane-first" (v128.const i16x8 0 0 0 0 0 0 0 0) (i32.const 32768)) (v128.const i16x8 -32768 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8_replace_lane-first" (v128.const i16x8 0 0 0 0 0 0 0 0) (i32.const 65535)) (v128.const i16x8 -1 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8_replace_lane-first" (v128.const i16x8 0 0 0 0 0 0 0 0) (i32.const 65536)) (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8_replace_lane-first" (v128.const i16x8 0 0 0 0 0 0 0 0) (i32.const 012345)) (v128.const i16x8 012_345 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8_replace_lane-first" (v128.const i16x8 0 0 0 0 0 0 0 0) (i32.const -0x01234)) (v128.const i16x8 -0x0_1234 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8_replace_lane-last" (v128.const i16x8 0 0 0 0 0 0 0 0) (i32.const -32768)) (v128.const i16x8 0 0 0 0 0 0 0 -32768)) +(assert_return (invoke "i16x8_replace_lane-last" (v128.const i16x8 0 0 0 0 0 0 0 0) (i32.const -32769)) (v128.const i16x8 0 0 0 0 0 0 0 32767)) +(assert_return (invoke "i16x8_replace_lane-last" (v128.const i16x8 0 0 0 0 0 0 0 0) (i32.const 0x7fffffff)) (v128.const i16x8 0 0 0 0 0 0 0 0xffff)) +(assert_return (invoke "i16x8_replace_lane-last" (v128.const i16x8 0 0 0 0 0 0 0 0) (i32.const 0x80000000)) (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8_replace_lane-last" (v128.const i16x8 0 0 0 0 0 0 0 0) (i32.const 054321)) (v128.const i16x8 0 0 0 0 0 0 0 054_321)) +(assert_return (invoke "i16x8_replace_lane-last" (v128.const i16x8 0 0 0 0 0 0 0 0) (i32.const -0x04321)) (v128.const i16x8 0 0 0 0 0 0 0 -0x0_4321)) + +(assert_return (invoke "i32x4_replace_lane-first" (v128.const i32x4 0 0 0 0) (i32.const 2147483647)) (v128.const i32x4 2147483647 0 0 0)) +(assert_return (invoke "i32x4_replace_lane-first" (v128.const i32x4 0 0 0 0) (i32.const 4294967295)) (v128.const i32x4 -1 0 0 0)) +(assert_return (invoke "i32x4_replace_lane-first" (v128.const i32x4 0 0 0 0) (i32.const 01234567890)) (v128.const i32x4 01_234_567_890 0 0 0)) +(assert_return (invoke "i32x4_replace_lane-first" (v128.const i32x4 0 0 0 0) (i32.const -0x012345678)) (v128.const i32x4 -0x0_1234_5678 0 0 0)) +(assert_return (invoke "i32x4_replace_lane-last" (v128.const i32x4 0 0 0 0) (i32.const 2147483648)) (v128.const i32x4 0 0 0 2147483648)) +(assert_return (invoke "i32x4_replace_lane-last" (v128.const i32x4 0 0 0 0) (i32.const -2147483648)) (v128.const i32x4 0 0 0 -2147483648)) +(assert_return (invoke "i32x4_replace_lane-last" (v128.const i32x4 0 0 0 0) (i32.const 01234567890)) (v128.const i32x4 0 0 0 01_234_567_890)) +(assert_return (invoke "i32x4_replace_lane-last" (v128.const i32x4 0 0 0 0) (i32.const -0x012345678)) (v128.const i32x4 0 0 0 -0x0_1234_5678)) + +(assert_return (invoke "f32x4_replace_lane-first" (v128.const f32x4 0.0 0.0 0.0 0.0) (f32.const 53.0)) (v128.const f32x4 53.0 0.0 0.0 0.0)) +(assert_return (invoke "f32x4_replace_lane-first" (v128.const i32x4 0 0 0 0 ) (f32.const 53.0)) (v128.const f32x4 53.0 0.0 0.0 0.0)) +(assert_return (invoke "f32x4_replace_lane-first" (v128.const f32x4 0.0 0.0 0.0 0.0) (f32.const nan)) (v128.const f32x4 nan 0.0 0.0 0.0)) +(assert_return (invoke "f32x4_replace_lane-first" (v128.const f32x4 0.0 0.0 0.0 0.0) (f32.const inf)) (v128.const f32x4 inf 0.0 0.0 0.0)) +(assert_return (invoke "f32x4_replace_lane-first" (v128.const f32x4 nan 0.0 0.0 0.0) (f32.const 3.14)) (v128.const f32x4 3.14 0.0 0.0 0.0)) +(assert_return (invoke "f32x4_replace_lane-first" (v128.const f32x4 inf 0.0 0.0 0.0) (f32.const 1e38)) (v128.const f32x4 1e38 0.0 0.0 0.0)) +(assert_return (invoke "f32x4_replace_lane-first" (v128.const f32x4 inf 0.0 0.0 0.0) (f32.const 0x1.fffffep127)) (v128.const f32x4 0x1.fffffep127 0.0 0.0 0.0)) +(assert_return (invoke "f32x4_replace_lane-first" (v128.const f32x4 inf 0.0 0.0 0.0) (f32.const 0x1p127)) (v128.const f32x4 0x1p127 0.0 0.0 0.0)) +(assert_return (invoke "f32x4_replace_lane-first" (v128.const f32x4 0.0 0.0 0.0 0.0) (f32.const 0123456789)) (v128.const f32x4 0123456789 0.0 0.0 0.0)) +(assert_return (invoke "f32x4_replace_lane-first" (v128.const f32x4 0.0 0.0 0.0 0.0) (f32.const 0123456789.)) (v128.const f32x4 0123456789. 0.0 0.0 0.0)) +(assert_return (invoke "f32x4_replace_lane-first" (v128.const f32x4 0.0 0.0 0.0 0.0) (f32.const 0x0123456789ABCDEF)) (v128.const f32x4 0x0123456789ABCDEF 0.0 0.0 0.0)) +(assert_return (invoke "f32x4_replace_lane-first" (v128.const f32x4 0.0 0.0 0.0 0.0) (f32.const 0x0123456789ABCDEF.)) (v128.const f32x4 0x0123456789ABCDEF. 0.0 0.0 0.0)) +(assert_return (invoke "f32x4_replace_lane-last" (v128.const f32x4 0.0 0.0 0.0 0.0) (f32.const -53.0)) (v128.const f32x4 0.0 0.0 0.0 -53.0)) +(assert_return (invoke "f32x4_replace_lane-last" (v128.const i32x4 0 0 0 0) (f32.const -53.0)) (v128.const f32x4 0.0 0.0 0.0 -53.0)) +(assert_return (invoke "f32x4_replace_lane-last" (v128.const f32x4 0.0 0.0 0.0 0.0) (f32.const nan)) (v128.const f32x4 0.0 0.0 0.0 nan)) +(assert_return (invoke "f32x4_replace_lane-last" (v128.const f32x4 0.0 0.0 0.0 0.0) (f32.const -inf)) (v128.const f32x4 0.0 0.0 0.0 -inf)) +(assert_return (invoke "f32x4_replace_lane-last" (v128.const f32x4 0.0 0.0 0.0 nan) (f32.const 3.14)) (v128.const f32x4 0.0 0.0 0.0 3.14)) +(assert_return (invoke "f32x4_replace_lane-last" (v128.const f32x4 0.0 0.0 0.0 -inf) (f32.const -1e38)) (v128.const f32x4 0.0 0.0 0.0 -1e38)) +(assert_return (invoke "f32x4_replace_lane-last" (v128.const f32x4 0.0 0.0 0.0 -inf) (f32.const -0x1.fffffep127)) (v128.const f32x4 0.0 0.0 0.0 -0x1.fffffep127)) +(assert_return (invoke "f32x4_replace_lane-last" (v128.const f32x4 0.0 0.0 0.0 -inf) (f32.const -0x1p127)) (v128.const f32x4 0.0 0.0 0.0 -0x1p127)) +(assert_return (invoke "f32x4_replace_lane-last" (v128.const f32x4 0.0 0.0 0.0 0.0) (f32.const 0123456789e019)) (v128.const f32x4 0.0 0.0 0.0 0123456789e019)) +(assert_return (invoke "f32x4_replace_lane-last" (v128.const f32x4 0.0 0.0 0.0 0.0) (f32.const 0123456789.e+019)) (v128.const f32x4 0.0 0.0 0.0 0123456789.e+019)) +(assert_return (invoke "f32x4_replace_lane-last" (v128.const f32x4 0.0 0.0 0.0 0.0) (f32.const 0x0123456789ABCDEFp019)) (v128.const f32x4 0.0 0.0 0.0 0x0123456789ABCDEFp019)) +(assert_return (invoke "f32x4_replace_lane-last" (v128.const f32x4 0.0 0.0 0.0 0.0) (f32.const 0x0123456789ABCDEF.p-019)) (v128.const f32x4 0.0 0.0 0.0 0x0123456789ABCDEF.p-019)) + +(assert_return (invoke "i64x2_replace_lane-first" (v128.const i64x2 0 0) (i64.const 9223372036854775807)) (v128.const i64x2 9223372036854775807 0)) +(assert_return (invoke "i64x2_replace_lane-first" (v128.const i64x2 0 0) (i64.const 18446744073709551615)) (v128.const i64x2 -1 0)) +(assert_return (invoke "i64x2_replace_lane-first" (v128.const i64x2 0 0) (i64.const 01234567890123456789)) (v128.const i64x2 01_234_567_890_123_456_789 0)) +(assert_return (invoke "i64x2_replace_lane-first" (v128.const i64x2 0 0) (i64.const 0x01234567890abcdef)) (v128.const i64x2 0x0_1234_5678_90AB_cdef 0)) +(assert_return (invoke "i64x2_replace_lane-last" (v128.const i64x2 0 0) (i64.const 9223372036854775808)) (v128.const i64x2 0 9223372036854775808)) +(assert_return (invoke "i64x2_replace_lane-last" (v128.const i64x2 0 0) (i64.const 9223372036854775808)) (v128.const i64x2 0 -9223372036854775808)) +(assert_return (invoke "i64x2_replace_lane-last" (v128.const i64x2 0 0) (i64.const 01234567890123456789)) (v128.const i64x2 0 01_234_567_890_123_456_789)) +(assert_return (invoke "i64x2_replace_lane-last" (v128.const i64x2 0 0) (i64.const 0x01234567890abcdef)) (v128.const i64x2 0 0x0_1234_5678_90AB_cdef)) + +(assert_return (invoke "f64x2_replace_lane-first" (v128.const f64x2 1.0 1.0) (f64.const 0x0p+0)) (v128.const f64x2 0.0 1.0)) +(assert_return (invoke "f64x2_replace_lane-first" (v128.const f64x2 -1.0 -1.0) (f64.const -0x0p-0)) (v128.const f64x2 -0.0 -1.0)) +(assert_return (invoke "f64x2_replace_lane-first" (v128.const f64x2 0.0 0.0) (f64.const 1.25)) (v128.const f64x2 1.25 0.0)) +(assert_return (invoke "f64x2_replace_lane-first" (v128.const f64x2 0.0 0.0) (f64.const -1.25)) (v128.const f64x2 -1.25 0.0)) +(assert_return (invoke "f64x2_replace_lane-first" (v128.const f64x2 -nan 0.0) (f64.const -1.7976931348623157e+308)) (v128.const f64x2 -1.7976931348623157e+308 0.0)) +(assert_return (invoke "f64x2_replace_lane-first" (v128.const f64x2 nan 0.0) (f64.const 1.7976931348623157e+308)) (v128.const f64x2 1.7976931348623157e+308 0.0)) +(assert_return (invoke "f64x2_replace_lane-first" (v128.const f64x2 -inf 0.0) (f64.const -0x1.fffffffffffffp-1023)) (v128.const f64x2 -0x1.fffffffffffffp-1023 0.0)) +(assert_return (invoke "f64x2_replace_lane-first" (v128.const f64x2 inf 0.0) (f64.const 0x1.fffffffffffffp-1023)) (v128.const f64x2 0x1.fffffffffffffp-1023 0.0)) +(assert_return (invoke "f64x2_replace_lane-first" (v128.const f64x2 0.0 0.0) (f64.const -nan)) (v128.const f64x2 -nan 0.0)) +(assert_return (invoke "f64x2_replace_lane-first" (v128.const f64x2 0.0 0.0) (f64.const nan)) (v128.const f64x2 nan 0.0)) +(assert_return (invoke "f64x2_replace_lane-first" (v128.const f64x2 0.0 0.0) (f64.const -inf)) (v128.const f64x2 -inf 0.0)) +(assert_return (invoke "f64x2_replace_lane-first" (v128.const f64x2 0.0 0.0) (f64.const inf)) (v128.const f64x2 inf 0.0)) +(assert_return (invoke "f64x2_replace_lane-first" (v128.const f64x2 0.0 0.0) (f64.const 0123456789)) (v128.const f64x2 0123456789 0.0)) +(assert_return (invoke "f64x2_replace_lane-first" (v128.const f64x2 0.0 0.0) (f64.const 0123456789.)) (v128.const f64x2 0123456789. 0.0)) +(assert_return (invoke "f64x2_replace_lane-first" (v128.const f64x2 0.0 0.0) (f64.const 0x0123456789ABCDEFabcdef)) (v128.const f64x2 0x0123456789ABCDEFabcdef 0.0)) +(assert_return (invoke "f64x2_replace_lane-first" (v128.const f64x2 0.0 0.0) (f64.const 0x0123456789ABCDEFabcdef.)) (v128.const f64x2 0x0123456789ABCDEFabcdef. 0.0)) +(assert_return (invoke "f64x2_replace_lane-last" (v128.const f64x2 2.0 2.0) (f64.const 0.0)) (v128.const f64x2 2.0 0.0)) +(assert_return (invoke "f64x2_replace_lane-last" (v128.const f64x2 -2.0 -2.0) (f64.const -0.0)) (v128.const f64x2 -2.0 -0.0)) +(assert_return (invoke "f64x2_replace_lane-last" (v128.const f64x2 0.0 0.0) (f64.const 2.25)) (v128.const f64x2 0.0 2.25)) +(assert_return (invoke "f64x2_replace_lane-last" (v128.const f64x2 0.0 0.0) (f64.const -2.25)) (v128.const f64x2 0.0 -2.25)) +(assert_return (invoke "f64x2_replace_lane-last" (v128.const f64x2 0.0 -nan) (f64.const -1.7976931348623157e+308)) (v128.const f64x2 0.0 -1.7976931348623157e+308)) +(assert_return (invoke "f64x2_replace_lane-last" (v128.const f64x2 0.0 nan) (f64.const 1.7976931348623157e+308)) (v128.const f64x2 0.0 1.7976931348623157e+308)) +(assert_return (invoke "f64x2_replace_lane-last" (v128.const f64x2 0.0 -inf) (f64.const -0x1.fffffffffffffp-1023)) (v128.const f64x2 0.0 -0x1.fffffffffffffp-1023)) +(assert_return (invoke "f64x2_replace_lane-last" (v128.const f64x2 0.0 inf) (f64.const 0x1.fffffffffffffp-1023)) (v128.const f64x2 0.0 0x1.fffffffffffffp-1023)) +(assert_return (invoke "f64x2_replace_lane-last" (v128.const f64x2 0.0 0.0) (f64.const -nan)) (v128.const f64x2 0.0 -nan)) +(assert_return (invoke "f64x2_replace_lane-last" (v128.const f64x2 0.0 0.0) (f64.const nan)) (v128.const f64x2 0.0 nan)) +(assert_return (invoke "f64x2_replace_lane-last" (v128.const f64x2 0.0 0.0) (f64.const -inf)) (v128.const f64x2 0.0 -inf)) +(assert_return (invoke "f64x2_replace_lane-last" (v128.const f64x2 0.0 0.0) (f64.const inf)) (v128.const f64x2 0.0 inf)) +(assert_return (invoke "f64x2_replace_lane-last" (v128.const f64x2 0.0 0.0) (f64.const 0123456789e019)) (v128.const f64x2 0.0 0123456789e019)) +(assert_return (invoke "f64x2_replace_lane-last" (v128.const f64x2 0.0 0.0) (f64.const 0123456789e+019)) (v128.const f64x2 0.0 0123456789e+019)) +(assert_return (invoke "f64x2_replace_lane-last" (v128.const f64x2 0.0 0.0) (f64.const 0123456789.e019)) (v128.const f64x2 0.0 0123456789.e019)) +(assert_return (invoke "f64x2_replace_lane-last" (v128.const f64x2 0.0 0.0) (f64.const 0123456789.e-019)) (v128.const f64x2 0.0 0123456789.e-019)) + +(assert_return (invoke "v8x16_swizzle" + (v128.const i8x16 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31) + (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)) + (v128.const i8x16 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31)) +(assert_return (invoke "v8x16_swizzle" + (v128.const i8x16 -16 -15 -14 -13 -12 -11 -10 -9 -8 -7 -6 -5 -4 -3 -2 -1) + (v128.const i8x16 -8 -7 -6 -5 -4 -3 -2 -1 16 17 18 19 20 21 22 23)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "v8x16_swizzle" + (v128.const i8x16 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115) + (v128.const i8x16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0)) + (v128.const i8x16 115 114 113 112 111 110 109 108 107 106 105 104 103 102 101 100)) +(assert_return (invoke "v8x16_swizzle" + (v128.const i8x16 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115) + (v128.const i8x16 -1 1 -2 2 -3 3 -4 4 -5 5 -6 6 -7 7 -8 8)) + (v128.const i8x16 0 101 0 102 0 103 0 104 0 105 0 106 0 107 0 108)) +(assert_return (invoke "v8x16_swizzle" + (v128.const i8x16 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115) + (v128.const i8x16 9 16 10 17 11 18 12 19 13 20 14 21 15 22 16 23)) + (v128.const i8x16 109 0 110 0 111 0 112 0 113 0 114 0 115 0 0 0)) +(assert_return (invoke "v8x16_swizzle" + (v128.const i8x16 0x64 0x65 0x66 0x67 0x68 0x69 0x6a 0x6b 0x6c 0x6d 0x6e 0x6f 0x70 0x71 0x72 0x73) + (v128.const i8x16 9 16 10 17 11 18 12 19 13 20 14 21 15 22 16 23)) + (v128.const i8x16 0x6d 0 0x6e 0 0x6f 0 0x70 0 0x71 0 0x72 0 0x73 0 0 0)) +(assert_return (invoke "v8x16_swizzle" + (v128.const i16x8 0x6465 0x6667 0x6869 0x6a6b 0x6c6d 0x6e6f 0x7071 0x7273) + (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)) + (v128.const i16x8 0x6465 0x6667 0x6869 0x6a6b 0x6c6d 0x6e6f 0x7071 0x7273)) +(assert_return (invoke "v8x16_swizzle" + (v128.const i32x4 0x64656667 0x68696a6b 0x6c6d6e6f 0x70717273) + (v128.const i8x16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0)) + (v128.const i32x4 0x73727170 0x6f6e6d6c 0x6b6a6968 0x67666564)) +(assert_return (invoke "v8x16_swizzle" + (v128.const f32x4 nan -nan inf -inf) + (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)) + (v128.const i32x4 0x7fc00000 0xffc00000 0x7f800000 0xff800000)) +(assert_return (invoke "v8x16_swizzle" + (v128.const i32x4 0x67666564 0x6b6a6968 0x6f6e6d5c 0x73727170) + (v128.const f32x4 0.0 -0.0 inf -inf)) + (v128.const i32x4 0x64646464 0x00646464 0x00006464 0x00006464)) + +(assert_return (invoke "v8x16_shuffle-1" + (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15) + (v128.const i8x16 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31)) + (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)) +(assert_return (invoke "v8x16_shuffle-2" + (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15) + (v128.const i8x16 -16 -15 -14 -13 -12 -11 -10 -9 -8 -7 -6 -5 -4 -3 -2 -1)) + (v128.const i8x16 -16 -15 -14 -13 -12 -11 -10 -9 -8 -7 -6 -5 -4 -3 -2 -1)) +(assert_return (invoke "v8x16_shuffle-3" + (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15) + (v128.const i8x16 -16 -15 -14 -13 -12 -11 -10 -9 -8 -7 -6 -5 -4 -3 -2 -1)) + (v128.const i8x16 -1 -2 -3 -4 -5 -6 -7 -8 -9 -10 -11 -12 -13 -14 -15 -16)) +(assert_return (invoke "v8x16_shuffle-4" + (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15) + (v128.const i8x16 -16 -15 -14 -13 -12 -11 -10 -9 -8 -7 -6 -5 -4 -3 -2 -1)) + (v128.const i8x16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0)) +(assert_return (invoke "v8x16_shuffle-5" + (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15) + (v128.const i8x16 -16 -15 -14 -13 -12 -11 -10 -9 -8 -7 -6 -5 -4 -3 -2 -1)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "v8x16_shuffle-6" + (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15) + (v128.const i8x16 -16 -15 -14 -13 -12 -11 -10 -9 -8 -7 -6 -5 -4 -3 -2 -1)) + (v128.const i8x16 -16 -16 -16 -16 -16 -16 -16 -16 -16 -16 -16 -16 -16 -16 -16 -16)) +(assert_return (invoke "v8x16_shuffle-7" + (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15) + (v128.const i8x16 -16 -15 -14 -13 -12 -11 -10 -9 -8 -7 -6 -5 -4 -3 -2 -1)) + (v128.const i8x16 0 0 0 0 0 0 0 0 -16 -16 -16 -16 -16 -16 -16 -16)) +(assert_return (invoke "v8x16_shuffle-1" + (v128.const i8x16 0x64 0x65 0x66 0x67 0x68 0x69 0x6a 0x6b 0x6c 0x6d 0x6e 0x6f 0x70 0x71 0x72 0x73) + (v128.const i8x16 0xf0 0xf1 0xf2 0xf3 0xf4 0xf5 0xf6 0xf7 0xf8 0xf9 0xfa 0xfb 0xfc 0xfd 0xfe 0xff)) + (v128.const i8x16 0x64 0x65 0x66 0x67 0x68 0x69 0x6a 0x6b 0x6c 0x6d 0x6e 0x6f 0x70 0x71 0x72 0x73)) +(assert_return (invoke "v8x16_shuffle-1" + (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0b0a 0x0d0c 0x0f0e) + (v128.const i8x16 -16 -15 -14 -13 -12 -11 -10 -9 -8 -7 -6 -5 -4 -3 -2 -1)) + (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0b0a 0x0d0c 0x0f0e)) +(assert_return (invoke "v8x16_shuffle-2" + (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15) + (v128.const i32x4 0xf3f2f1f0 0xf7f6f5f4 0xfbfaf9f8 0xfffefdfc)) + (v128.const i32x4 0xf3f2f1f0 0xf7f6f5f4 0xfbfaf9f8 0xfffefdfc)) +(assert_return (invoke "v8x16_shuffle-1" + (v128.const i32x4 0x10203 0x4050607 0x8090a0b 0xc0d0e0f) + (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)) + (v128.const i32x4 0x10203 0x4050607 0x8090a0b 0xc0d0e0f)) +(assert_return (invoke "v8x16_shuffle-1" + (v128.const f32x4 1.0 nan inf -inf) + (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)) + (v128.const i32x4 0x3f800000 0x7fc00000 0x7f800000 0xff800000)) +(assert_return (invoke "v8x16_shuffle-1" + (v128.const i32x4 0x10203 0x4050607 0x8090a0b 0xc0d0e0f) + (v128.const f32x4 -0.0 nan inf -inf)) + (v128.const i32x4 0x10203 0x4050607 0x8090a0b 0xc0d0e0f)) + +;; More literals +(assert_return (invoke "v8x16_swizzle" + (v128.const i32x4 1_234_567_890 0x1234_5678 01_234_567_890 0x0_1234_5678) + (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)) + (v128.const i32x4 0x4996_02d2 0x1234_5678 0x4996_02d2 0x1234_5678)) +(assert_return (invoke "v8x16_shuffle-1" + (v128.const i64x2 1_234_567_890_123_456_789_0 0x1234_5678_90AB_cdef) + (v128.const i64x2 01_234_567_890_123_456_789_0 0x0_1234_5678_90AB_cdef)) + (v128.const i32x4 0xeb1f_0ad2 0xab54_a98c 0x90ab_cdef 0x1234_5678)) + +;; Syntax errors for negative values + +(assert_malformed (module quote "(func (result i32) (i8x16.extract_lane_s -1 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)))") "unexpected token") +(assert_malformed (module quote "(func (result i32) (i8x16.extract_lane_u -1 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)))") "unexpected token") +(assert_malformed (module quote "(func (result i32) (i16x8.extract_lane_s -1 (v128.const i16x8 0 0 0 0 0 0 0 0)))") "unexpected token") +(assert_malformed (module quote "(func (result i32) (i16x8.extract_lane_u -1 (v128.const i16x8 0 0 0 0 0 0 0 0)))") "unexpected token") +(assert_malformed (module quote "(func (result i32) (i32x4.extract_lane -1 (v128.const i32x4 0 0 0 0)))") "unexpected token") +(assert_malformed (module quote "(func (result f32) (f32x4.extract_lane -1 (v128.const f32x4 0 0 0 0)))") "unexpected token") +(assert_malformed (module quote "(func (result v128) (i8x16.replace_lane -1 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (i32.const 1)))") "unexpected token") +(assert_malformed (module quote "(func (result v128) (i16x8.replace_lane -1 (v128.const i16x8 0 0 0 0 0 0 0 0) (i32.const 1)))") "unexpected token") +(assert_malformed (module quote "(func (result v128) (i32x4.replace_lane -1 (v128.const i32x4 0 0 0 0) (i32.const 1)))") "unexpected token") +(assert_malformed (module quote "(func (result v128) (f32x4.replace_lane -1 (v128.const f32x4 0 0 0 0) (i32.const 1)))") "unexpected token") +(assert_malformed (module quote "(func (result i64) (i64x2.extract_lane -1 (v128.const i64x2 0 0)))") "unexpected token") +(assert_malformed (module quote "(func (result f64) (f64x2.extract_lane -1 (v128.const f64x2 0 0)))") "unexpected token") +(assert_malformed (module quote "(func (result v128) (i64x2.replace_lane -1 (v128.const i64x2 0 0) (i64.const 1)))") "unexpected token") +(assert_malformed (module quote "(func (result v128) (f64x2.replace_lane -1 (v128.const f64x2 0 0) (f64.const 1)))") "unexpected token") + +;; Malformed lane index value + +(assert_malformed (module quote "(func (result i32) (i8x16.extract_lane_s 256 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)))") "malformed lane index") +(assert_malformed (module quote "(func (result i32) (i8x16.extract_lane_u 256 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)))") "malformed lane index") +(assert_malformed (module quote "(func (result i32) (i16x8.extract_lane_s 256 (v128.const i16x8 0 0 0 0 0 0 0 0)))") "malformed lane index") +(assert_malformed (module quote "(func (result i32) (i16x8.extract_lane_u 256 (v128.const i16x8 0 0 0 0 0 0 0 0)))") "malformed lane index") +(assert_malformed (module quote "(func (result i32) (i32x4.extract_lane 256 (v128.const i32x4 0 0 0 0)))") "malformed lane index") +(assert_malformed (module quote "(func (result f32) (f32x4.extract_lane 256 (v128.const f32x4 0 0 0 0)))") "malformed lane index") +(assert_malformed (module quote "(func (result v128) (i8x16.replace_lane 256 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (i32.const 1)))") "malformed lane index") +(assert_malformed (module quote "(func (result v128) (i16x8.replace_lane 256 (v128.const i16x8 0 0 0 0 0 0 0 0) (i32.const 1)))") "malformed lane index") +(assert_malformed (module quote "(func (result v128) (i32x4.replace_lane 256 (v128.const i32x4 0 0 0 0) (i32.const 1)))") "malformed lane index") +(assert_malformed (module quote "(func (result v128) (f32x4.replace_lane 256 (v128.const f32x4 0 0 0 0) (i32.const 1)))") "malformed lane index") +(assert_malformed (module quote "(func (result i64) (i64x2.extract_lane 256 (v128.const i64x2 0 0)))") "malformed lane index") +(assert_malformed (module quote "(func (result f64) (f64x2.extract_lane 256 (v128.const f64x2 0 0)))") "malformed lane index") +(assert_malformed (module quote "(func (result v128) (i64x2.replace_lane 256 (v128.const i64x2 0 0) (i64.const 1)))") "malformed lane index") +(assert_malformed (module quote "(func (result v128) (f64x2.replace_lane 256 (v128.const f64x2 0 0) (f64.const 1)))") "malformed lane index") + +;; Invalid lane index value + +(assert_invalid (module (func (result i32) (i8x16.extract_lane_s 16 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)))) "invalid lane index") +(assert_invalid (module (func (result i32) (i8x16.extract_lane_s 255 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)))) "invalid lane index") +(assert_invalid (module (func (result i32) (i8x16.extract_lane_u 16 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)))) "invalid lane index") +(assert_invalid (module (func (result i32) (i8x16.extract_lane_u 255 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)))) "invalid lane index") +(assert_invalid (module (func (result i32) (i16x8.extract_lane_s 8 (v128.const i16x8 0 0 0 0 0 0 0 0)))) "invalid lane index") +(assert_invalid (module (func (result i32) (i16x8.extract_lane_s 255 (v128.const i16x8 0 0 0 0 0 0 0 0)))) "invalid lane index") +(assert_invalid (module (func (result i32) (i16x8.extract_lane_u 8 (v128.const i16x8 0 0 0 0 0 0 0 0)))) "invalid lane index") +(assert_invalid (module (func (result i32) (i16x8.extract_lane_u 255 (v128.const i16x8 0 0 0 0 0 0 0 0)))) "invalid lane index") +(assert_invalid (module (func (result i32) (i32x4.extract_lane 4 (v128.const i32x4 0 0 0 0)))) "invalid lane index") +(assert_invalid (module (func (result i32) (i32x4.extract_lane 255 (v128.const i32x4 0 0 0 0)))) "invalid lane index") +(assert_invalid (module (func (result f32) (f32x4.extract_lane 4 (v128.const f32x4 0 0 0 0)))) "invalid lane index") +(assert_invalid (module (func (result f32) (f32x4.extract_lane 255 (v128.const f32x4 0 0 0 0)))) "invalid lane index") +(assert_invalid (module (func (result v128) (i8x16.replace_lane 16 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (i32.const 1)))) "invalid lane index") +(assert_invalid (module (func (result v128) (i8x16.replace_lane 255 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (i32.const 1)))) "invalid lane index") +(assert_invalid (module (func (result v128) (i16x8.replace_lane 16 (v128.const i16x8 0 0 0 0 0 0 0 0) (i32.const 1)))) "invalid lane index") +(assert_invalid (module (func (result v128) (i16x8.replace_lane 255 (v128.const i16x8 0 0 0 0 0 0 0 0) (i32.const 1)))) "invalid lane index") +(assert_invalid (module (func (result v128) (i32x4.replace_lane 4 (v128.const i32x4 0 0 0 0) (i32.const 1)))) "invalid lane index") +(assert_invalid (module (func (result v128) (i32x4.replace_lane 255 (v128.const i32x4 0 0 0 0) (i32.const 1)))) "invalid lane index") +(assert_invalid (module (func (result v128) (f32x4.replace_lane 4 (v128.const f32x4 0 0 0 0) (i32.const 1)))) "invalid lane index") +(assert_invalid (module (func (result v128) (f32x4.replace_lane 255 (v128.const f32x4 0 0 0 0) (i32.const 1)))) "invalid lane index") +(assert_invalid (module (func (result i64) (i64x2.extract_lane 2 (v128.const i64x2 0 0)))) "invalid lane index") +(assert_invalid (module (func (result i64) (i64x2.extract_lane 255 (v128.const i64x2 0 0)))) "invalid lane index") +(assert_invalid (module (func (result f64) (f64x2.extract_lane 2 (v128.const f64x2 0 0)))) "invalid lane index") +(assert_invalid (module (func (result f64) (f64x2.extract_lane 255 (v128.const f64x2 0 0)))) "invalid lane index") +(assert_invalid (module (func (result v128) (i64x2.replace_lane 2 (v128.const i64x2 0 0) (i64.const 1)))) "invalid lane index") +(assert_invalid (module (func (result v128) (i64x2.replace_lane 255 (v128.const i64x2 0 0) (i64.const 1)))) "invalid lane index") +(assert_invalid (module (func (result v128) (f64x2.replace_lane 2 (v128.const f64x2 0 0) (f64.const 1)))) "invalid lane index") +(assert_invalid (module (func (result v128) (f64x2.replace_lane 255 (v128.const f64x2 0 0) (f64.const 1.0)))) "invalid lane index") + +;; Lane index is determined by the instruction's interpretation only. + +(assert_invalid (module (func (result i32) (i16x8.extract_lane_s 8 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)))) "invalid lane index") +(assert_invalid (module (func (result i32) (i16x8.extract_lane_u 8 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)))) "invalid lane index") +(assert_invalid (module (func (result i32) (i32x4.extract_lane 4 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)))) "invalid lane index") +(assert_invalid (module (func (result i32) (f32x4.extract_lane 4 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)))) "invalid lane index") +(assert_invalid (module (func (result v128) (i16x8.replace_lane 8 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (i32.const 1)))) "invalid lane index") +(assert_invalid (module (func (result v128) (i32x4.replace_lane 4 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (i32.const 1)))) "invalid lane index") +(assert_invalid (module (func (result v128) (f32x4.replace_lane 4 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (i32.const 1)))) "invalid lane index") +(assert_invalid (module (func (result i64) (i64x2.extract_lane 2 (v128.const i64x2 0 0)))) "invalid lane index") +(assert_invalid (module (func (result f64) (f64x2.extract_lane 2 (v128.const f64x2 0 0)))) "invalid lane index") +(assert_invalid (module (func (result v128) (i64x2.replace_lane 2 (v128.const i64x2 0 0) (i64.const 1)))) "invalid lane index") +(assert_invalid (module (func (result v128) (f64x2.replace_lane 2 (v128.const f64x2 0 0) (f64.const 1.0)))) "invalid lane index") + +;; Invalid parameters: required v128 but pass other types + +(assert_invalid (module (func (result i32) (i8x16.extract_lane_s 0 (i32.const 0)))) "type mismatch") +(assert_invalid (module (func (result i32) (i8x16.extract_lane_u 0 (i64.const 0)))) "type mismatch") +(assert_invalid (module (func (result i32) (i8x16.extract_lane_s 0 (f32.const 0.0)))) "type mismatch") +(assert_invalid (module (func (result i32) (i8x16.extract_lane_u 0 (f64.const 0.0)))) "type mismatch") +(assert_invalid (module (func (result i32) (i32x4.extract_lane 0 (i32.const 0)))) "type mismatch") +(assert_invalid (module (func (result f32) (f32x4.extract_lane 0 (f32.const 0.0)))) "type mismatch") +(assert_invalid (module (func (result v128) (i8x16.replace_lane 0 (i32.const 0) (i32.const 1)))) "type mismatch") +(assert_invalid (module (func (result v128) (i16x8.replace_lane 0 (i64.const 0) (i32.const 1)))) "type mismatch") +(assert_invalid (module (func (result v128) (i32x4.replace_lane 0 (i32.const 0) (i32.const 1)))) "type mismatch") +(assert_invalid (module (func (result v128) (f32x4.replace_lane 0 (f32.const 0.0) (i32.const 1)))) "type mismatch") +(assert_invalid (module (func (result i64) (i64x2.extract_lane 0 (i64.const 0)))) "type mismatch") +(assert_invalid (module (func (result f64) (f64x2.extract_lane 0 (f64.const 0.0)))) "type mismatch") +(assert_invalid (module (func (result v128) (i32x4.replace_lane 0 (i32.const 0) (i32.const 1)))) "type mismatch") +(assert_invalid (module (func (result v128) (f32x4.replace_lane 0 (f32.const 0.0) (i32.const 1)))) "type mismatch") + +;; Invalid types for the replaced value + +(assert_invalid (module (func (result v128) (i8x16.replace_lane 0 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (f32.const 1.0)))) "type mismatch") +(assert_invalid (module (func (result v128) (i16x8.replace_lane 0 (v128.const i16x8 0 0 0 0 0 0 0 0) (f64.const 1.0)))) "type mismatch") +(assert_invalid (module (func (result v128) (i32x4.replace_lane 0 (v128.const i32x4 0 0 0 0) (f32.const 1.0)))) "type mismatch") +(assert_invalid (module (func (result v128) (f32x4.replace_lane 0 (v128.const f32x4 0 0 0 0) (i32.const 1)))) "type mismatch") + +(assert_invalid (module (func (result v128) (i64x2.replace_lane 0 (v128.const i64x2 0 0) (f64.const 1.0)))) "type mismatch") +(assert_invalid (module (func (result v128) (f64x2.replace_lane 0 (v128.const f64x2 0 0) (i64.const 1)))) "type mismatch") + +;; Invalid types for swizzle and shuffle values +(assert_invalid (module (func (result v128) + (i8x16.swizzle (i32.const 1) (v128.const i8x16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0)))) "type mismatch") +(assert_invalid (module (func (result v128) + (i8x16.swizzle (v128.const i8x16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0) (i32.const 2)))) "type mismatch") +(assert_invalid (module (func (result v128) + (i8x16.shuffle 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 (f32.const 3.0) + (v128.const i8x16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0)))) "type mismatch") +(assert_invalid (module (func (result v128) + (i8x16.shuffle 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 + (v128.const i8x16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0) (f32.const 4.0)))) "type mismatch") + +;; i8x16.shuffle: the 1st argument must be 16-byte literals in 0..32 +(assert_malformed (module quote "(func (param v128) (result v128)" + "(i8x16.shuffle 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 (local.get 0) (local.get 0)))") + "invalid lane length") +(assert_malformed (module quote "(func (param v128) (result v128)" + "(i8x16.shuffle 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 (local.get 0) (local.get 0)))") + "invalid lane length") +(assert_malformed (module quote "(func (result v128)" + "(i8x16.shuffle 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 -1" + "(v128.const i8x16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0)" + "(v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)))") "malformed lane index") +(assert_malformed (module quote "(func (result v128)" + "(i8x16.shuffle 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 256" + "(v128.const i8x16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0)" + "(v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)))") "malformed lane index") +(assert_invalid (module (func (result v128) + (i8x16.shuffle 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 255 + (v128.const i8x16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0) + (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)))) "invalid lane index") + +;; Possible wrong instruction names that'd be used + +(assert_malformed (module quote "(func (result i32) (i8x16.extract_lane 0 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)))") "unknown operator") +(assert_malformed (module quote "(func (result i32) (i16x8.extract_lane 0 (v128.const i16x8 0 0 0 0 0 0 0 0)))") "unknown operator") +(assert_malformed (module quote "(func (result i32) (i32x4.extract_lane_s 0 (v128.const i32x4 0 0 0 0)))") "unknown operator") +(assert_malformed (module quote "(func (result i32) (i32x4.extract_lane_u 0 (v128.const i32x4 0 0 0 0)))") "unknown operator") +(assert_malformed (module quote "(func (result i32) (i64x2.extract_lane_s 0 (v128.const i64x2 0 0)))") "unknown operator") +(assert_malformed (module quote "(func (result i32) (i64x2.extract_lane_u 0 (v128.const i64x2 0 0)))") "unknown operator") + + +;; Old shuffle instruction names will not work +(assert_malformed (module quote "(func (result v128) " + "(i8x16.shuffle1 (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15) " + "(v128.const i8x16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0)))") + "unknown operator") +(assert_malformed (module quote "(func (result v128) " + "(i8x16.shuffle2_imm 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 " + "(v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15) " + "(v128.const i8x16 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31)))") + "unknown operator") +;; i8x16 not v8x16 +(assert_malformed (module quote "(func (result v128) " + "(v8x16.swizzle (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15) " + "(v128.const i8x16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0)))") + "unknown operator") +(assert_malformed (module quote "(func (result v128) " + "(v8x16.shuffle 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 " + "(v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15) " + "(v128.const i8x16 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31)))") + "unknown operator") + + +;; Malformed lane index + +;; Pass params as the lane index + +(assert_malformed (module quote "(func (param i32) (result i32) (i8x16.extract_lane_s (local.get 0) (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)))") "unexpected token") +(assert_malformed (module quote "(func (param i32) (result i32) (i8x16.extract_lane_u (local.get 0) (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)))") "unexpected token") +(assert_malformed (module quote "(func (param i32) (result i32) (i16x8.extract_lane_s (local.get 0) (v128.const i16x8 0 0 0 0 0 0 0 0)))") "unexpected token") +(assert_malformed (module quote "(func (param i32) (result i32) (i16x8.extract_lane_u (local.get 0) (v128.const i16x8 0 0 0 0 0 0 0 0)))") "unexpected token") +(assert_malformed (module quote "(func (param i32) (result i32) (i32x4.extract_lane (local.get 0) (v128.const i32x4 0 0 0 0)))") "unexpected token") +(assert_malformed (module quote "(func (param i32) (result f32) (f32x4.extract_lane (local.get 0) (v128.const f32x4 0 0 0 0)))") "unexpected token") +(assert_malformed (module quote "(func (param i32) (result v128) (i8x16.replace_lane (local.get 0) (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (i32.const 1)))") "unexpected token") +(assert_malformed (module quote "(func (param i32) (result v128) (i16x8.replace_lane (local.get 0) (v128.const i16x8 0 0 0 0 0 0 0 0) (i32.const 1)))") "unexpected token") +(assert_malformed (module quote "(func (param i32) (result v128) (i32x4.replace_lane (local.get 0) (v128.const i32x4 0 0 0 0) (i32.const 1)))") "unexpected token") +(assert_malformed (module quote "(func (param i32) (result v128) (f32x4.replace_lane (local.get 0) (v128.const f32x4 0 0 0 0) (f32.const 1.0)))") "unexpected token") + +(assert_malformed (module quote "(func (param i32) (result i64) (i64x2.extract_lane (local.get 0) (v128.const i64x2 0 0)))") "unexpected token") +(assert_malformed (module quote "(func (param i32) (result f64) (f64x2.extract_lane (local.get 0) (v128.const f64x2 0 0)))") "unexpected token") +(assert_malformed (module quote "(func (param i32) (result v128) (i64x2.replace_lane (local.get 0) (v128.const i64x2 0 0) (i64.const 1)))") "unexpected token") +(assert_malformed (module quote "(func (param i32) (result v128) (f64x2.replace_lane (local.get 0) (v128.const f64x2 0 0) (f64.const 1.0)))") "unexpected token") + +;; Pass non-literal as the lane index + +(assert_malformed (module quote "(func (result i32) (i8x16.extract_lane_s 1.5 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)))") "unexpected token") +(assert_malformed (module quote "(func (result i32) (i8x16.extract_lane_u nan (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)))") "unexpected token") +(assert_malformed (module quote "(func (result i32) (i16x8.extract_lane_s inf (v128.const i16x8 0 0 0 0 0 0 0 0)))") "unexpected token") +(assert_malformed (module quote "(func (result i32) (i16x8.extract_lane_u -inf (v128.const i16x8 0 0 0 0 0 0 0 0)))") "unexpected token") +(assert_malformed (module quote "(func (result i32) (i32x4.extract_lane nan (v128.const i32x4 0 0 0 0)))") "unexpected token") +(assert_malformed (module quote "(func (result f32) (f32x4.extract_lane nan (v128.const f32x4 0 0 0 0)))") "unexpected token") +(assert_malformed (module quote "(func (result v128) (i8x16.replace_lane -2.5 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (i32.const 1)))") "unexpected token") +(assert_malformed (module quote "(func (result v128) (i16x8.replace_lane nan (v128.const i16x8 0 0 0 0 0 0 0 0) (i32.const 1)))") "unexpected token") +(assert_malformed (module quote "(func (result v128) (i32x4.replace_lane inf (v128.const i32x4 0 0 0 0) (i32.const 1)))") "unexpected token") +(assert_malformed (module quote "(func (result v128) (f32x4.replace_lane -inf (v128.const f32x4 0 0 0 0) (f32.const 1.1)))") "unexpected token") + +;; i8x16.shuffle expects a 16-byte literals as first argument +(assert_malformed (module quote "(func (result v128) " + "(i8x16.shuffle (v128.const i8x16 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31) " + "(v128.const i8x16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0) " + "(v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)))") "invalid lane length") +(assert_malformed (module quote "(func (result v128) " + "(i8x16.shuffle 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15.0) " + "(v128.const i8x16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0) " + "(v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)))") "malformed lane index") +(assert_malformed (module quote "(func (result v128) " + "(i8x16.shuffle 0.5 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15) " + "(v128.const i8x16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0) " + "(v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)))") "malformed lane index") +(assert_malformed (module quote "(func (result v128) " + "(i8x16.shuffle -inf 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15) " + "(v128.const i8x16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0) " + "(v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)))") "malformed lane index") +(assert_malformed (module quote "(func (result v128) " + "(i8x16.shuffle 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 inf) " + "(v128.const i8x16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0) " + "(v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)))") "malformed lane index") +(assert_malformed (module quote "(func (result v128) " + "(i8x16.shuffle nan 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15) " + "(v128.const i8x16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0) " + "(v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)))") "malformed lane index") + + +;; Combination with each other + +(module + ;; as *.replace_lane's operand + (func (export "i8x16_extract_lane_s") (param v128 v128) (result v128) + (i8x16.replace_lane 0 (local.get 0) (i8x16.extract_lane_s 0 (local.get 1)))) + (func (export "i8x16_extract_lane_u") (param v128 v128) (result v128) + (i8x16.replace_lane 0 (local.get 0) (i8x16.extract_lane_u 0 (local.get 1)))) + (func (export "i16x8_extract_lane_s") (param v128 v128) (result v128) + (i16x8.replace_lane 0 (local.get 0) (i16x8.extract_lane_s 0 (local.get 1)))) + (func (export "i16x8_extract_lane_u") (param v128 v128) (result v128) + (i16x8.replace_lane 0 (local.get 0) (i16x8.extract_lane_u 0 (local.get 1)))) + (func (export "i32x4_extract_lane") (param v128 v128) (result v128) + (i32x4.replace_lane 0 (local.get 0) (i32x4.extract_lane 0 (local.get 1)))) + (func (export "f32x4_extract_lane") (param v128 v128) (result v128) + (i32x4.replace_lane 0 (local.get 0) (i32x4.extract_lane 0 (local.get 1)))) + (func (export "i64x2_extract_lane") (param v128 v128) (result v128) + (i64x2.replace_lane 0 (local.get 0) (i64x2.extract_lane 0 (local.get 1)))) + (func (export "f64x2_extract_lane") (param v128 v128) (result v128) + (f64x2.replace_lane 0 (local.get 0) (f64x2.extract_lane 0 (local.get 1)))) + + ;; as *.extract_lane's operand + (func (export "i8x16_replace_lane-s") (param v128 i32) (result i32) + (i8x16.extract_lane_s 15 (i8x16.replace_lane 15 (local.get 0) (local.get 1)))) + (func (export "i8x16_replace_lane-u") (param v128 i32) (result i32) + (i8x16.extract_lane_u 15 (i8x16.replace_lane 15 (local.get 0) (local.get 1)))) + (func (export "i16x8_replace_lane-s") (param v128 i32) (result i32) + (i16x8.extract_lane_s 7 (i16x8.replace_lane 7 (local.get 0) (local.get 1)))) + (func (export "i16x8_replace_lane-u") (param v128 i32) (result i32) + (i16x8.extract_lane_u 7 (i16x8.replace_lane 7 (local.get 0) (local.get 1)))) + (func (export "i32x4_replace_lane") (param v128 i32) (result i32) + (i32x4.extract_lane 3 (i32x4.replace_lane 3 (local.get 0) (local.get 1)))) + (func (export "f32x4_replace_lane") (param v128 f32) (result f32) + (f32x4.extract_lane 3 (f32x4.replace_lane 3 (local.get 0) (local.get 1)))) + (func (export "i64x2_replace_lane") (param v128 i64) (result i64) + (i64x2.extract_lane 1 (i64x2.replace_lane 1 (local.get 0) (local.get 1)))) + (func (export "f64x2_replace_lane") (param v128 f64) (result f64) + (f64x2.extract_lane 1 (f64x2.replace_lane 1 (local.get 0) (local.get 1)))) + + ;; i8x16.replace outputs as shuffle operand + (func (export "as-v8x16_swizzle-operand") (param v128 i32 v128) (result v128) + (i8x16.swizzle (i8x16.replace_lane 0 (local.get 0) (local.get 1)) (local.get 2))) + (func (export "as-v8x16_shuffle-operands") (param v128 i32 v128 i32) (result v128) + (i8x16.shuffle 16 1 18 3 20 5 22 7 24 9 26 11 28 13 30 15 + (i8x16.replace_lane 0 (local.get 0) (local.get 1)) + (i8x16.replace_lane 15 (local.get 2) (local.get 3)))) +) + +(assert_return (invoke "i8x16_extract_lane_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) (v128.const i8x16 -1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i8x16_extract_lane_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) (v128.const i8x16 255 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8_extract_lane_s" (v128.const i16x8 0 0 0 0 0 0 0 0) (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) (v128.const i16x8 -1 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8_extract_lane_u" (v128.const i16x8 0 0 0 0 0 0 0 0) (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) (v128.const i16x8 65535 0 0 0 0 0 0 0)) +(assert_return (invoke "i32x4_extract_lane" (v128.const i32x4 0 0 0 0) (v128.const i32x4 0x10000 -1 -1 -1)) (v128.const i32x4 65536 0 0 0)) +(assert_return (invoke "f32x4_extract_lane" (v128.const f32x4 0 0 0 0) (v128.const f32x4 1e38 nan nan nan)) (v128.const f32x4 1e38 0 0 0)) +(assert_return (invoke "i8x16_replace_lane-s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (i32.const 255)) (i32.const -1)) +(assert_return (invoke "i8x16_replace_lane-u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (i32.const 255)) (i32.const 255)) +(assert_return (invoke "i16x8_replace_lane-s" (v128.const i16x8 0 0 0 0 0 0 0 0) (i32.const 65535)) (i32.const -1)) +(assert_return (invoke "i16x8_replace_lane-u" (v128.const i16x8 0 0 0 0 0 0 0 0) (i32.const 65535)) (i32.const 65535)) +(assert_return (invoke "i32x4_replace_lane" (v128.const i32x4 0 0 0 0) (i32.const -1)) (i32.const -1)) +(assert_return (invoke "f32x4_replace_lane" (v128.const f32x4 0 0 0 0) (f32.const 1.25)) (f32.const 1.25)) + +(assert_return (invoke "i64x2_extract_lane" (v128.const i64x2 0 0) (v128.const i64x2 0xffffffffffffffff -1)) (v128.const i64x2 0xffffffffffffffff 0)) +(assert_return (invoke "f64x2_extract_lane" (v128.const f64x2 0 0) (v128.const f64x2 1e308 nan)) (v128.const f64x2 1e308 0)) +(assert_return (invoke "i64x2_replace_lane" (v128.const i64x2 0 0) (i64.const -1)) (i64.const -1)) +(assert_return (invoke "f64x2_replace_lane" (v128.const f64x2 0 0) (f64.const 2.5)) (f64.const 2.5)) + +(assert_return (invoke "as-v8x16_swizzle-operand" + (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15) (i32.const 255) + (v128.const i8x16 -1 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1)) + (v128.const i8x16 0 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1)) +(assert_return (invoke "as-v8x16_shuffle-operands" + (v128.const i8x16 0 255 0 255 15 255 0 255 255 255 0 255 127 255 0 255) (i32.const 1) + (v128.const i8x16 0x55 0 0x55 0 0x55 0 0x55 0 0x55 0 0x55 0 0x55 1 0x55 -1) (i32.const 0)) + (v128.const i8x16 0x55 0xff 0x55 0xff 0x55 0xff 0x55 0xff 0x55 0xff 0x55 0xff 0x55 0xff 0x55 0xff)) + +;; Combination with other SIMD instructions + +(module + ;; Constructing SIMD values + (func (export "as-i8x16_splat-operand") (param v128) (result v128) + (i8x16.splat (i8x16.extract_lane_s 0 (local.get 0)))) + (func (export "as-i16x8_splat-operand") (param v128) (result v128) + (i16x8.splat (i16x8.extract_lane_u 0 (local.get 0)))) + (func (export "as-i32x4_splat-operand") (param v128) (result v128) + (i32x4.splat (i32x4.extract_lane 0 (local.get 0)))) + (func (export "as-f32x4_splat-operand") (param v128) (result v128) + (f32x4.splat (f32x4.extract_lane 0 (local.get 0)))) + (func (export "as-i64x2_splat-operand") (param v128) (result v128) + (i64x2.splat (i64x2.extract_lane 0 (local.get 0)))) + (func (export "as-f64x2_splat-operand") (param v128) (result v128) + (f64x2.splat (f64x2.extract_lane 0 (local.get 0)))) + + ;; Integer arithmetic + (func (export "as-i8x16_add-operands") (param v128 i32 v128 i32) (result v128) + (i8x16.add (i8x16.replace_lane 0 (local.get 0) (local.get 1)) (i8x16.replace_lane 15 (local.get 2) (local.get 3)))) + (func (export "as-i16x8_add-operands") (param v128 i32 v128 i32) (result v128) + (i16x8.add (i16x8.replace_lane 0 (local.get 0) (local.get 1)) (i16x8.replace_lane 7 (local.get 2) (local.get 3)))) + (func (export "as-i32x4_add-operands") (param v128 i32 v128 i32) (result v128) + (i32x4.add (i32x4.replace_lane 0 (local.get 0) (local.get 1)) (i32x4.replace_lane 3 (local.get 2) (local.get 3)))) + (func (export "as-i64x2_add-operands") (param v128 i64 v128 i64) (result v128) + (i64x2.add (i64x2.replace_lane 0 (local.get 0) (local.get 1)) (i64x2.replace_lane 1 (local.get 2) (local.get 3)))) + + (func (export "swizzle-as-i8x16_add-operands") (param v128 v128 v128 v128) (result v128) + (i8x16.add (i8x16.swizzle (local.get 0) (local.get 1)) (i8x16.swizzle (local.get 2) (local.get 3)))) + (func (export "shuffle-as-i8x16_sub-operands") (param v128 v128 v128 v128) (result v128) + (i8x16.sub (i8x16.shuffle 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 (local.get 0) (local.get 1)) + (i8x16.shuffle 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 (local.get 2) (local.get 3)))) + + ;; Boolean horizontal reductions + (func (export "as-i8x16_any_true-operand") (param v128 i32) (result i32) + (v128.any_true (i8x16.replace_lane 0 (local.get 0) (local.get 1)))) + (func (export "as-i16x8_any_true-operand") (param v128 i32) (result i32) + (v128.any_true (i16x8.replace_lane 0 (local.get 0) (local.get 1)))) + (func (export "as-i32x4_any_true-operand1") (param v128 i32) (result i32) + (v128.any_true (i32x4.replace_lane 0 (local.get 0) (local.get 1)))) + (func (export "as-i32x4_any_true-operand2") (param v128 i64) (result i32) + (v128.any_true (i64x2.replace_lane 0 (local.get 0) (local.get 1)))) + + (func (export "swizzle-as-i8x16_all_true-operands") (param v128 v128) (result i32) + (i8x16.all_true (i8x16.swizzle (local.get 0) (local.get 1)))) + (func (export "shuffle-as-i8x16_any_true-operands") (param v128 v128) (result i32) + (v128.any_true (i8x16.shuffle 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 (local.get 0) (local.get 1)))) +) + +(assert_return (invoke "as-i8x16_splat-operand" (v128.const i8x16 0xff 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "as-i16x8_splat-operand" (v128.const i16x8 -1 -1 -1 -1 0 0 0 0)) (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "as-i32x4_splat-operand" (v128.const i32x4 0x10000 0 0 0)) (v128.const i32x4 65536 65536 65536 65536)) +(assert_return (invoke "as-f32x4_splat-operand" (v128.const f32x4 3.14 nan nan nan)) (v128.const f32x4 3.14 3.14 3.14 3.14)) +(assert_return (invoke "as-i64x2_splat-operand" (v128.const i64x2 -1 0)) (v128.const i64x2 -1 -1)) +(assert_return (invoke "as-f64x2_splat-operand" (v128.const f64x2 inf nan)) (v128.const f64x2 inf inf)) +(assert_return (invoke "as-i8x16_add-operands" + (v128.const i8x16 0xff 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16) (i32.const 1) + (v128.const i8x16 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 0xff) (i32.const 1)) + (v128.const i8x16 17 17 17 17 17 17 17 17 17 17 17 17 17 17 17 17)) +(assert_return (invoke "as-i16x8_add-operands" + (v128.const i16x8 -1 4 9 16 25 36 49 64) (i32.const 1) + (v128.const i16x8 64 49 36 25 16 9 4 -1) (i32.const 1)) + (v128.const i16x8 65 53 45 41 41 45 53 65)) +(assert_return (invoke "as-i32x4_add-operands" + (v128.const i32x4 -1 8 27 64) (i32.const 1) (v128.const i32x4 64 27 8 -1) (i32.const 1)) (v128.const i32x4 65 35 35 65)) +(assert_return (invoke "as-i64x2_add-operands" + (v128.const i64x2 -1 8) (i64.const 1) (v128.const i64x2 64 27) (i64.const 1)) (v128.const i64x2 65 9)) + +(assert_return (invoke "swizzle-as-i8x16_add-operands" + (v128.const i8x16 -16 -15 -14 -13 -12 -11 -10 -9 -8 -7 -6 -5 -4 -3 -2 -1) + (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15) + (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15) + (v128.const i8x16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0)) + (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "shuffle-as-i8x16_sub-operands" + (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15) + (v128.const i8x16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0) + (v128.const i8x16 -16 -15 -14 -13 -12 -11 -10 -9 -8 -7 -6 -5 -4 -3 -2 -1) + (v128.const i8x16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0)) + (v128.const i8x16 -15 -13 -11 -9 -7 -5 -3 -1 1 3 5 7 9 11 13 15)) + +(assert_return (invoke "as-i8x16_any_true-operand" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (i32.const 1)) (i32.const 1)) +(assert_return (invoke "as-i16x8_any_true-operand" (v128.const i16x8 0 0 0 0 0 0 0 0) (i32.const 1)) (i32.const 1)) +(assert_return (invoke "as-i32x4_any_true-operand1" (v128.const i32x4 1 0 0 0) (i32.const 0)) (i32.const 0)) +(assert_return (invoke "as-i32x4_any_true-operand2" (v128.const i64x2 1 0) (i64.const 0)) (i32.const 0)) + +(assert_return (invoke "swizzle-as-i8x16_all_true-operands" + (v128.const i8x16 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16) + (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)) (i32.const 1)) +(assert_return (invoke "swizzle-as-i8x16_all_true-operands" + (v128.const i8x16 -16 -15 -14 -13 -12 -11 -10 -9 -8 -7 -6 -5 -4 -3 -2 -1) + (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 16)) (i32.const 0)) +(assert_return (invoke "shuffle-as-i8x16_any_true-operands" + (v128.const i8x16 -16 -15 -14 -13 -12 -11 -10 -9 -8 -7 -6 -5 -4 -3 -2 -1) + (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)) (i32.const 1)) + +;; Load and store + +(module + (memory 1) + (func (export "as-v128_store-operand-1") (param v128 i32) (result v128) + (v128.store (i32.const 0) (i8x16.replace_lane 0 (local.get 0) (local.get 1))) + (v128.load (i32.const 0))) + (func (export "as-v128_store-operand-2") (param v128 i32) (result v128) + (v128.store (i32.const 0) (i16x8.replace_lane 0 (local.get 0) (local.get 1))) + (v128.load (i32.const 0))) + (func (export "as-v128_store-operand-3") (param v128 i32) (result v128) + (v128.store (i32.const 0) (i32x4.replace_lane 0 (local.get 0) (local.get 1))) + (v128.load (i32.const 0))) + (func (export "as-v128_store-operand-4") (param v128 f32) (result v128) + (v128.store (i32.const 0) (f32x4.replace_lane 0 (local.get 0) (local.get 1))) + (v128.load (i32.const 0))) + (func (export "as-v128_store-operand-5") (param v128 i64) (result v128) + (v128.store (i32.const 0) (i64x2.replace_lane 0 (local.get 0) (local.get 1))) + (v128.load (i32.const 0))) + (func (export "as-v128_store-operand-6") (param v128 f64) (result v128) + (v128.store (i32.const 0) (f64x2.replace_lane 0 (local.get 0) (local.get 1))) + (v128.load (i32.const 0))) +) + +(assert_return (invoke "as-v128_store-operand-1" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (i32.const 1)) (v128.const i8x16 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "as-v128_store-operand-2" (v128.const i16x8 0 0 0 0 0 0 0 0) (i32.const 256)) (v128.const i16x8 0x100 0 0 0 0 0 0 0)) +(assert_return (invoke "as-v128_store-operand-3" (v128.const i32x4 0 0 0 0) (i32.const 0xffffffff)) (v128.const i32x4 -1 0 0 0)) +(assert_return (invoke "as-v128_store-operand-4" (v128.const f32x4 0 0 0 0) (f32.const 3.14)) (v128.const f32x4 3.14 0 0 0)) +(assert_return (invoke "as-v128_store-operand-5" (v128.const i64x2 0 0) (i64.const 0xffffffffffffffff)) (v128.const i64x2 -1 0)) +(assert_return (invoke "as-v128_store-operand-6" (v128.const f64x2 0 0) (f64.const 3.14)) (v128.const f64x2 3.14 0)) + +;; As the argument of wasm core ops + +(module + (global $g (mut v128) (v128.const f32x4 0.0 0.0 0.0 0.0)) + (global $h (mut v128) (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + (func (export "as-if-condition-value") (param v128) (result i32) + (if (result i32) (i8x16.extract_lane_s 0 (local.get 0)) (then (i32.const 0xff)) (else (i32.const 0)))) + (func (export "as-return-value-1") (param v128 i32) (result v128) + (return (i16x8.replace_lane 0 (local.get 0) (local.get 1)))) + (func (export "as-local_set-value") (param v128) (result i32) (local i32) + (local.set 1 (i32x4.extract_lane 0 (local.get 0))) + (return (local.get 1))) + (func (export "as-global_set-value-1") (param v128 f32) (result v128) + (global.set $g (f32x4.replace_lane 0 (local.get 0) (local.get 1))) + (return (global.get $g))) + + (func (export "as-return-value-2") (param v128 v128) (result v128) + (return (i8x16.swizzle (local.get 0) (local.get 1)))) + (func (export "as-global_set-value-2") (param v128 v128) (result v128) + (global.set $h (i8x16.shuffle 0 1 2 3 4 5 6 7 24 25 26 27 28 29 30 31 (local.get 0) (local.get 1))) + (return (global.get $h))) + + (func (export "as-local_set-value-1") (param v128) (result i64) (local i64) + (local.set 1 (i64x2.extract_lane 0 (local.get 0))) + (return (local.get 1))) + (func (export "as-global_set-value-3") (param v128 f64) (result v128) + (global.set $g (f64x2.replace_lane 0 (local.get 0) (local.get 1))) + (return (global.get $g))) +) + +(assert_return (invoke "as-if-condition-value" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) (i32.const 0)) +(assert_return (invoke "as-return-value-1" (v128.const i16x8 0 0 0 0 0 0 0 0) (i32.const 1)) (v128.const i16x8 1 0 0 0 0 0 0 0)) +(assert_return (invoke "as-local_set-value" (v128.const i32x4 -1 -1 -1 -1)) (i32.const -1)) +(assert_return (invoke "as-global_set-value-1" (v128.const f32x4 0 0 0 0)(f32.const 3.14)) (v128.const f32x4 3.14 0 0 0)) + +(assert_return (invoke "as-return-value-2" + (v128.const i8x16 -16 -15 -14 -13 -12 -11 -10 -9 -8 -7 -6 -5 -4 -3 -2 -1) + (v128.const i8x16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0)) + (v128.const i8x16 -1 -2 -3 -4 -5 -6 -7 -8 -9 -10 -11 -12 -13 -14 -15 -16)) +(assert_return (invoke "as-global_set-value-2" + (v128.const i8x16 -16 -15 -14 -13 -12 -11 -10 -9 -8 -7 -6 -5 -4 -3 -2 -1) + (v128.const i8x16 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1)) + (v128.const i8x16 -16 -15 -14 -13 -12 -11 -10 -9 8 7 6 5 4 3 2 1)) + +(assert_return (invoke "as-local_set-value-1" (v128.const i64x2 -1 -1)) (i64.const -1)) +(assert_return (invoke "as-global_set-value-3" (v128.const f64x2 0 0)(f64.const 3.14)) (v128.const f64x2 3.14 0)) + +;; Non-nat lane index + +(assert_malformed (module quote "(func (result i32) (i8x16.extract_lane_u +0x0f (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)))") "unexpected token") +(assert_malformed (module quote "(func (result f32) (f32x4.extract_lane +03 (v128.const f32x4 0 0 0 0)))") "unexpected token") +(assert_malformed (module quote "(func (result i64) (i64x2.extract_lane +1 (v128.const i64x2 0 0)))") "unexpected token") +(assert_malformed (module quote "(func (result v128) (i8x16.replace_lane +015 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (i32.const 1)))") "unexpected token") +(assert_malformed (module quote "(func (result v128) (i16x8.replace_lane +0x7 (v128.const i16x8 0 0 0 0 0 0 0 0) (i32.const 1)))") "unexpected token") +(assert_malformed (module quote "(func (result v128) (i32x4.replace_lane +3 (v128.const i32x4 0 0 0 0) (i32.const 1)))") "unexpected token") +(assert_malformed (module quote "(func (result v128) (f64x2.replace_lane +0x01 (v128.const f64x2 0 0) (f64.const 1.0)))") "unexpected token") + +;; Lane index literal + +(module (func (result i32) (i8x16.extract_lane_s 0x0f (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)))) +(module (func (result i32) (i16x8.extract_lane_s 0x07 (v128.const i16x8 0 0 0 0 0 0 0 0)))) +(module (func (result i32) (i16x8.extract_lane_u 0x0_7 (v128.const i16x8 0 0 0 0 0 0 0 0)))) +(module (func (result i32) (i32x4.extract_lane 03 (v128.const i32x4 0 0 0 0)))) +(module (func (result f64) (f64x2.extract_lane 0x1 (v128.const f64x2 0 0)))) +(module (func (result v128) (f32x4.replace_lane 0x3 (v128.const f32x4 0 0 0 0) (f32.const 1.0)))) +(module (func (result v128) (i64x2.replace_lane 01 (v128.const i64x2 0 0) (i64.const 1)))) + +;; 1.0 is malformed lane index + +(assert_malformed (module quote "(func (result i32) (i8x16.extract_lane_s 1.0 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)))") "unexpected token") + +;; Test operation with empty argument + +(assert_malformed + (module quote + "(func $i8x16.extract_lane_s-1st-arg-empty (result i32)" + " (i8x16.extract_lane_s (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))" + ")" + ) + "unexpected token" +) +(assert_invalid + (module + (func $i8x16.extract_lane_s-2nd-arg-empty (result i32) + (i8x16.extract_lane_s 0) + ) + ) + "type mismatch" +) +(assert_malformed + (module quote + "(func $i8x16.extract_lane_s-arg-empty (result i32)" + " (i8x16.extract_lane_s)" + ")" + ) + "unexpected token" +) +(assert_malformed + (module quote + "(func $i16x8.extract_lane_u-1st-arg-empty (result i32)" + " (i16x8.extract_lane_u (v128.const i16x8 0 0 0 0 0 0 0 0))" + ")" + ) + "unexpected token" +) +(assert_invalid + (module + (func $i16x8.extract_lane_u-2nd-arg-empty (result i32) + (i16x8.extract_lane_u 0) + ) + ) + "type mismatch" +) +(assert_malformed + (module quote + "(func $i16x8.extract_lane_u-arg-empty (result i32)" + " (i16x8.extract_lane_u)" + ")" + ) + "unexpected token" +) +(assert_malformed + (module quote + "(func $i32x4.extract_lane-1st-arg-empty (result i32)" + " (i32x4.extract_lane (v128.const i32x4 0 0 0 0))" + ")" + ) + "unexpected token" +) +(assert_invalid + (module + (func $i32x4.extract_lane-2nd-arg-empty (result i32) + (i32x4.extract_lane 0) + ) + ) + "type mismatch" +) +(assert_malformed + (module quote + "(func $i32x4.extract_lane-arg-empty (result i32)" + " (i32x4.extract_lane)" + ")" + ) + "unexpected token" +) +(assert_malformed + (module quote + "(func $i64x2.extract_lane-1st-arg-empty (result i64)" + " (i64x2.extract_lane (v128.const i64x2 0 0))" + ")" + ) + "unexpected token" +) +(assert_invalid + (module + (func $i64x2.extract_lane-2nd-arg-empty (result i64) + (i64x2.extract_lane 0) + ) + ) + "type mismatch" +) +(assert_malformed + (module quote + "(func $i64x2.extract_lane-arg-empty (result i64)" + " (i64x2.extract_lane)" + ")" + ) + "unexpected token" +) +(assert_malformed + (module quote + "(func $f32x4.extract_lane-1st-arg-empty (result f32)" + " (f32x4.extract_lane (v128.const f32x4 0 0 0 0))" + ")" + ) + "unexpected token" +) +(assert_invalid + (module + (func $f32x4.extract_lane-2nd-arg-empty (result f32) + (f32x4.extract_lane 0) + ) + ) + "type mismatch" +) +(assert_malformed + (module quote + "(func $f32x4.extract_lane-arg-empty (result f32)" + " (f32x4.extract_lane)" + ")" + ) + "unexpected token" +) +(assert_malformed + (module quote + "(func $f64x2.extract_lane-1st-arg-empty (result f64)" + " (f64x2.extract_lane (v128.const f64x2 0 0))" + ")" + ) + "unexpected token" +) +(assert_invalid + (module + (func $f64x2.extract_lane-2nd-arg-empty (result f64) + (f64x2.extract_lane 0) + ) + ) + "type mismatch" +) +(assert_malformed + (module quote + "(func $f64x2.extract_lane-arg-empty (result f64)" + " (f64x2.extract_lane)" + ")" + ) + "unexpected token" +) +(assert_malformed + (module quote + "(func $i8x16.replace_lane-1st-arg-empty (result v128)" + " (i8x16.replace_lane (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (i32.const 1))" + ")" + ) + "unexpected token" +) +(assert_invalid + (module + (func $i8x16.replace_lane-2nd-arg-empty (result v128) + (i8x16.replace_lane 0 (i32.const 1)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i8x16.replace_lane-3rd-arg-empty (result v128) + (i8x16.replace_lane 0 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + ) + ) + "type mismatch" +) +(assert_malformed + (module quote + "(func $i8x16.replace_lane-arg-empty (result v128)" + " (i8x16.replace_lane)" + ")" + ) + "unexpected token" +) +(assert_malformed + (module quote + "(func $i16x8.replace_lane-1st-arg-empty (result v128)" + " (i16x8.replace_lane (v128.const i16x8 0 0 0 0 0 0 0 0) (i32.const 1))" + ")" + ) + "unexpected token" +) +(assert_invalid + (module + (func $i16x8.replace_lane-2nd-arg-empty (result v128) + (i16x8.replace_lane 0 (i32.const 1)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i16x8.replace_lane-3rd-arg-empty (result v128) + (i16x8.replace_lane 0 (v128.const i16x8 0 0 0 0 0 0 0 0)) + ) + ) + "type mismatch" +) +(assert_malformed + (module quote + "(func $i16x8.replace_lane-arg-empty (result v128)" + " (i16x8.replace_lane)" + ")" + ) + "unexpected token" +) +(assert_malformed + (module quote + "(func $i32x4.replace_lane-1st-arg-empty (result v128)" + " (i32x4.replace_lane (v128.const i32x4 0 0 0 0) (i32.const 1))" + ")" + ) + "unexpected token" +) +(assert_invalid + (module + (func $i32x4.replace_lane-2nd-arg-empty (result v128) + (i32x4.replace_lane 0 (i32.const 1)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i32x4.replace_lane-3rd-arg-empty (result v128) + (i32x4.replace_lane 0 (v128.const i32x4 0 0 0 0)) + ) + ) + "type mismatch" +) +(assert_malformed + (module quote + "(func $i32x4.replace_lane-arg-empty (result v128)" + " (i32x4.replace_lane)" + ")" + ) + "unexpected token" +) +(assert_malformed + (module quote + "(func $f32x4.replace_lane-1st-arg-empty (result v128)" + " (f32x4.replace_lane (v128.const f32x4 0 0 0 0) (f32.const 1.0))" + ")" + ) + "unexpected token" +) +(assert_invalid + (module + (func $f32x4.replace_lane-2nd-arg-empty (result v128) + (f32x4.replace_lane 0 (f32.const 1.0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $f32x4.replace_lane-3rd-arg-empty (result v128) + (f32x4.replace_lane 0 (v128.const f32x4 0 0 0 0)) + ) + ) + "type mismatch" +) +(assert_malformed + (module quote + "(func $f32x4.replace_lane-arg-empty (result v128)" + " (f32x4.replace_lane)" + ")" + ) + "unexpected token" +) +(assert_malformed + (module quote + "(func $i64x2.replace_lane-1st-arg-empty (result v128)" + " (i64x2.replace_lane (v128.const i64x2 0 0) (i64.const 1))" + ")" + ) + "unexpected token" +) +(assert_invalid + (module + (func $i64x2.replace_lane-2nd-arg-empty (result v128) + (i64x2.replace_lane 0 (i64.const 1)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i64x2.replace_lane-3rd-arg-empty (result v128) + (i64x2.replace_lane 0 (v128.const i64x2 0 0)) + ) + ) + "type mismatch" +) +(assert_malformed + (module quote + "(func $i64x2.replace_lane-arg-empty (result v128)" + " (i64x2.replace_lane)" + ")" + ) + "unexpected token" +) +(assert_malformed + (module quote + "(func $f64x2.replace_lane-1st-arg-empty (result v128)" + " (f64x2.replace_lane (v128.const f64x2 0 0) (f64.const 1.0))" + ")" + ) + "unexpected token" +) +(assert_invalid + (module + (func $f64x2.replace_lane-2nd-arg-empty (result v128) + (f64x2.replace_lane 0 (f64.const 1.0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $f64x2.replace_lane-3rd-arg-empty (result v128) + (f64x2.replace_lane 0 (v128.const f64x2 0 0)) + ) + ) + "type mismatch" +) +(assert_malformed + (module quote + "(func $f64x2.replace_lane-arg-empty (result v128)" + " (f64x2.replace_lane)" + ")" + ) + "unexpected token" +) +(assert_malformed + (module quote + "(func $i8x16.shuffle-1st-arg-empty (result v128)" + " (i8x16.shuffle" + " (v128.const i8x16 0 1 2 3 5 6 6 7 8 9 10 11 12 13 14 15)" + " (v128.const i8x16 1 2 3 5 6 6 7 8 9 10 11 12 13 14 15 16)" + " )" + ")" + ) + "invalid lane length" +) +(assert_invalid + (module + (func $i8x16.shuffle-2nd-arg-empty (result v128) + (i8x16.shuffle 0 1 2 3 5 6 6 7 8 9 10 11 12 13 14 15 + (v128.const i8x16 1 2 3 5 6 6 7 8 9 10 11 12 13 14 15 16) + ) + ) + ) + "type mismatch" +) +(assert_malformed + (module quote + "(func $i8x16.shuffle-arg-empty (result v128)" + " (i8x16.shuffle)" + ")" + ) + "invalid lane length" +) diff --git a/runtime/near-vm/tests/wast/spec/proposals/simd/simd_load.wast b/runtime/near-vm/tests/wast/spec/proposals/simd/simd_load.wast new file mode 100644 index 00000000000..4b2edc160b9 --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/proposals/simd/simd_load.wast @@ -0,0 +1,188 @@ +;; v128.load operater with normal argument (e.g. (i8x16, i16x8 i32x4)) + +(module + (memory 1) + (data (i32.const 0) "\00\01\02\03\04\05\06\07\08\09\0a\0b\0c\0d\0e\0f\00\01\02\03") + (func (export "v128.load") (result v128) + (v128.load (i32.const 0)) + ) +) + +(assert_return (invoke "v128.load") (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0a 0x0b 0x0c 0x0d 0x0e 0x0f)) +(assert_return (invoke "v128.load") (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0b0a 0x0d0c 0x0f0e)) +(assert_return (invoke "v128.load") (v128.const i32x4 0x03020100 0x07060504 0x0b0a0908 0x0f0e0d0c)) + + +;; v128.load operater as the argument of other SIMD instructions + +(module (memory 1) + (data (i32.const 0) "\00\01\02\03\04\05\06\07\08\09\0a\0b\0c\0d\0e\0f\00\01\02\03") + (func (export "as-i8x16_extract_lane_s-value/0") (result i32) + (i8x16.extract_lane_s 0 (v128.load (i32.const 0))) + ) +) +(assert_return (invoke "as-i8x16_extract_lane_s-value/0") (i32.const 0x00)) + +(module (memory 1) + (data (i32.const 0) "\00\01\02\03\04\05\06\07\08\09\0a\0b\0c\0d\0e\0f\00\01\02\03") + (func (export "as-i8x16.eq-operand") (result v128) + (i8x16.eq (v128.load offset=0 (i32.const 0)) (v128.load offset=16 (i32.const 0))) + ) +) +(assert_return (invoke "as-i8x16.eq-operand") (v128.const i32x4 0xffffffff 0x00000000 0x00000000 0x00000000)) + +(module (memory 1) + (data (i32.const 0) "\00\01\02\03\04\05\06\07\08\09\0a\0b\0c\0d\0e\0f\00\01\02\03") + (func (export "as-v128.not-operand") (result v128) + (v128.not (v128.load (i32.const 0))) + ) + (func (export "as-i8x16.all_true-operand") (result i32) + (i8x16.all_true (v128.load (i32.const 0))) + ) +) +(assert_return (invoke "as-v128.not-operand") (v128.const i32x4 0xfcfdfeff 0xf8f9fafb 0xf4f5f6f7 0xf0f1f2f3)) +(assert_return (invoke "as-i8x16.all_true-operand") (i32.const 0)) + +(module (memory 1) + (data (offset (i32.const 0)) "\AA\AA\AA\AA\AA\AA\AA\AA\AA\AA\AA\AA\AA\AA\AA\AA") + (data (offset (i32.const 16)) "\BB\BB\BB\BB\BB\BB\BB\BB\BB\BB\BB\BB\BB\BB\BB\BB") + (data (offset (i32.const 32)) "\F0\F0\F0\F0\FF\FF\FF\FF\00\00\00\00\FF\00\FF\00") + (func (export "as-v128.bitselect-operand") (result v128) + (v128.bitselect (v128.load (i32.const 0)) (v128.load (i32.const 16)) (v128.load (i32.const 32))) + ) +) +(assert_return (invoke "as-v128.bitselect-operand") (v128.const i32x4 0xabababab 0xaaaaaaaa 0xbbbbbbbb 0xbbaabbaa)) + +(module (memory 1) + (data (offset (i32.const 0)) "\AA\AA\AA\AA\AA\AA\AA\AA\AA\AA\AA\AA\AA\AA\AA\AA") + (func (export "as-i8x16.shl-operand") (result v128) + (i8x16.shl (v128.load (i32.const 0)) (i32.const 1)) + ) +) +(assert_return (invoke "as-i8x16.shl-operand") (v128.const i32x4 0x54545454 0x54545454 0x54545454 0x54545454)) ;; 1010 1000 << 1010 1010 + +(module (memory 1) + (data (offset (i32.const 0)) "\02\00\00\00\02\00\00\00\02\00\00\00\02\00\00\00") + (data (offset (i32.const 16)) "\03\00\00\00\03\00\00\00\03\00\00\00\03\00\00\00") + (func (export "as-add/sub-operand") (result v128) + ;; 2 2 2 2 + 3 3 3 3 = 5 5 5 5 + ;; 5 5 5 5 - 3 3 3 3 = 2 2 2 2 + (i8x16.sub + (i8x16.add (v128.load (i32.const 0)) (v128.load (i32.const 16))) + (v128.load (i32.const 16)) + ) + ) +) +(assert_return (invoke "as-add/sub-operand") (v128.const i32x4 2 2 2 2)) + +(module (memory 1) + (data (offset (i32.const 0)) "\00\00\00\43\00\00\80\3f\66\66\e6\3f\00\00\80\bf") ;; 128 1.0 1.8 -1 + (data (offset (i32.const 16)) "\00\00\00\40\00\00\00\40\00\00\00\40\00\00\00\40") ;; 2.0 2.0 2.0 2.0 + (func (export "as-f32x4.mul-operand") (result v128) + (f32x4.mul (v128.load (i32.const 0)) (v128.load (i32.const 16))) + ) +) +(assert_return (invoke "as-f32x4.mul-operand") (v128.const f32x4 256 2 3.6 -2)) + +(module (memory 1) + (data (offset (i32.const 0)) "\ff\ff\ff\ff\ff\ff\ff\ff\ff\ff\ff\ff\ff\ff\ff\ff") ;; 1111 ... + (func (export "as-f32x4.abs-operand") (result v128) + (f32x4.abs (v128.load (i32.const 0))) + ) +) +(assert_return (invoke "as-f32x4.abs-operand") (v128.const i32x4 0x7fffffff 0x7fffffff 0x7fffffff 0x7fffffff)) ;; 1111 -> 0111 + +(module (memory 1) + (data (offset (i32.const 0)) "\AA\AA\AA\AA\AA\AA\AA\AA\AA\AA\AA\AA\AA\AA\AA\AA") + (data (offset (i32.const 16)) "\02\00\00\00\02\00\00\00\02\00\00\00\02\00\00\00") + (func (export "as-f32x4.min-operand") (result v128) + (f32x4.min (v128.load (i32.const 0)) (v128.load offset=16 (i32.const 1))) + ) +) +(assert_return (invoke "as-f32x4.min-operand") (v128.const i32x4 0xaaaaaaaa 0xaaaaaaaa 0xaaaaaaaa 0xaaaaaaaa)) ;; signed 1010 < 0010 + +(module (memory 1) + (data (offset (i32.const 0)) "\00\00\00\43\00\00\80\3f\66\66\e6\3f\00\00\80\bf") ;; 128 1.0 1.8 -1 + (func (export "as-i32x4.trunc_sat_f32x4_s-operand") (result v128) + (i32x4.trunc_sat_f32x4_s (v128.load (i32.const 0))) + ) +) +(assert_return (invoke "as-i32x4.trunc_sat_f32x4_s-operand") (v128.const i32x4 128 1 1 -1)) ;; 128 1.0 1.8 -1 -> 128 1 1 -1 + +(module (memory 1) + (data (offset (i32.const 0)) "\02\00\00\00\02\00\00\00\02\00\00\00\02\00\00\00") + (func (export "as-f32x4.convert_i32x4_u-operand") (result v128) + (f32x4.convert_i32x4_u (v128.load (i32.const 0))) + ) +) +(assert_return (invoke "as-f32x4.convert_i32x4_u-operand") (v128.const f32x4 2 2 2 2)) + +(module (memory 1) + (data (offset (i32.const 0)) "\64\65\66\67\68\69\6a\6b\6c\6d\6e\6f\70\71\72\73") ;; 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 + (data (offset (i32.const 16)) "\0f\0e\0d\0c\0b\0a\09\08\07\06\05\04\03\02\01\00") ;; 15 14 13 12 11 10 09 08 07 06 05 04 03 02 01 00 + (func (export "as-i8x16.swizzle-operand") (result v128) + (i8x16.swizzle (v128.load (i32.const 0)) (v128.load offset=15 (i32.const 1))) + ) +) +(assert_return(invoke "as-i8x16.swizzle-operand") (v128.const i8x16 115 114 113 112 111 110 109 108 107 106 105 104 103 102 101 100)) + +(module (memory 1) + (data (i32.const 0) "\00\01\02\03\04\05\06\07\08\09\0a\0b\0c\0d\0e\0f\00\01\02\03") + (func (export "as-br-value") (result v128) + (block (result v128) (br 0 (v128.load (i32.const 0)))) + ) +) +(assert_return (invoke "as-br-value") (v128.const i32x4 0x03020100 0x07060504 0x0b0a0908 0x0f0e0d0c)) + + +;; Unknown operator(e.g. v128.load8, v128.load16, v128.load32) + +(assert_malformed + (module quote + "(memory 1)" + "(func (local v128) (drop (v128.load8 (i32.const 0))))" + ) + "unknown operator" +) +(assert_malformed + (module quote + "(memory 1)" + "(func (local v128) (drop (v128.load16 (i32.const 0))))" + ) + "unknown operator" +) +(assert_malformed + (module quote + "(memory 1)" + "(func (local v128) (drop (v128.load32 (i32.const 0))))" + ) + "unknown operator" +) + + +;; Type mismatched (e.g. v128.load(f32.const 0), type address empty) + +(assert_invalid + (module (memory 1) (func (local v128) (drop (v128.load (f32.const 0))))) + "type mismatch" +) +(assert_invalid + (module (memory 1) (func (local v128) (block (br_if 0 (v128.load (i32.const 0)))))) + "type mismatch" +) +(assert_invalid + (module (memory 1) (func (local v128) (v128.load (i32.const 0)))) + "type mismatch" +) + + +;; Type address empty + +(assert_invalid + (module (memory 1) (func (drop (v128.load (local.get 2))))) + "unknown local 2" +) +(assert_invalid + (module (memory 1) (func (drop (v128.load)))) + "type mismatch" +) \ No newline at end of file diff --git a/runtime/near-vm/tests/wast/spec/proposals/simd/simd_load16_lane.wast b/runtime/near-vm/tests/wast/spec/proposals/simd/simd_load16_lane.wast new file mode 100644 index 00000000000..8c72a57335a --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/proposals/simd/simd_load16_lane.wast @@ -0,0 +1,211 @@ +;; Tests for load lane operations. + + +(module + (memory 1) + (data (i32.const 0) "\00\01\02\03\04\05\06\07\08\09\0A\0B\0C\0D\0E\0F") + (func (export "v128.load16_lane_0") + (param $address i32) (param $x v128) (result v128) + (v128.load16_lane 0 (local.get $address) (local.get $x))) + (func (export "v128.load16_lane_1") + (param $address i32) (param $x v128) (result v128) + (v128.load16_lane 1 (local.get $address) (local.get $x))) + (func (export "v128.load16_lane_2") + (param $address i32) (param $x v128) (result v128) + (v128.load16_lane 2 (local.get $address) (local.get $x))) + (func (export "v128.load16_lane_3") + (param $address i32) (param $x v128) (result v128) + (v128.load16_lane 3 (local.get $address) (local.get $x))) + (func (export "v128.load16_lane_4") + (param $address i32) (param $x v128) (result v128) + (v128.load16_lane 4 (local.get $address) (local.get $x))) + (func (export "v128.load16_lane_5") + (param $address i32) (param $x v128) (result v128) + (v128.load16_lane 5 (local.get $address) (local.get $x))) + (func (export "v128.load16_lane_6") + (param $address i32) (param $x v128) (result v128) + (v128.load16_lane 6 (local.get $address) (local.get $x))) + (func (export "v128.load16_lane_7") + (param $address i32) (param $x v128) (result v128) + (v128.load16_lane 7 (local.get $address) (local.get $x))) + (func (export "v128.load16_lane_0_offset_0") + (param $x v128) (result v128) + (v128.load16_lane offset=0 0 (i32.const 0) (local.get $x))) + (func (export "v128.load16_lane_1_offset_1") + (param $x v128) (result v128) + (v128.load16_lane offset=1 1 (i32.const 0) (local.get $x))) + (func (export "v128.load16_lane_2_offset_2") + (param $x v128) (result v128) + (v128.load16_lane offset=2 2 (i32.const 0) (local.get $x))) + (func (export "v128.load16_lane_3_offset_3") + (param $x v128) (result v128) + (v128.load16_lane offset=3 3 (i32.const 0) (local.get $x))) + (func (export "v128.load16_lane_4_offset_4") + (param $x v128) (result v128) + (v128.load16_lane offset=4 4 (i32.const 0) (local.get $x))) + (func (export "v128.load16_lane_5_offset_5") + (param $x v128) (result v128) + (v128.load16_lane offset=5 5 (i32.const 0) (local.get $x))) + (func (export "v128.load16_lane_6_offset_6") + (param $x v128) (result v128) + (v128.load16_lane offset=6 6 (i32.const 0) (local.get $x))) + (func (export "v128.load16_lane_7_offset_7") + (param $x v128) (result v128) + (v128.load16_lane offset=7 7 (i32.const 0) (local.get $x))) + (func (export "v128.load16_lane_0_align_1") + (param $address i32) (param $x v128) (result v128) + (v128.load16_lane align=1 0 (local.get $address) (local.get $x))) + (func (export "v128.load16_lane_0_align_2") + (param $address i32) (param $x v128) (result v128) + (v128.load16_lane align=2 0 (local.get $address) (local.get $x))) + (func (export "v128.load16_lane_1_align_1") + (param $address i32) (param $x v128) (result v128) + (v128.load16_lane align=1 1 (local.get $address) (local.get $x))) + (func (export "v128.load16_lane_1_align_2") + (param $address i32) (param $x v128) (result v128) + (v128.load16_lane align=2 1 (local.get $address) (local.get $x))) + (func (export "v128.load16_lane_2_align_1") + (param $address i32) (param $x v128) (result v128) + (v128.load16_lane align=1 2 (local.get $address) (local.get $x))) + (func (export "v128.load16_lane_2_align_2") + (param $address i32) (param $x v128) (result v128) + (v128.load16_lane align=2 2 (local.get $address) (local.get $x))) + (func (export "v128.load16_lane_3_align_1") + (param $address i32) (param $x v128) (result v128) + (v128.load16_lane align=1 3 (local.get $address) (local.get $x))) + (func (export "v128.load16_lane_3_align_2") + (param $address i32) (param $x v128) (result v128) + (v128.load16_lane align=2 3 (local.get $address) (local.get $x))) + (func (export "v128.load16_lane_4_align_1") + (param $address i32) (param $x v128) (result v128) + (v128.load16_lane align=1 4 (local.get $address) (local.get $x))) + (func (export "v128.load16_lane_4_align_2") + (param $address i32) (param $x v128) (result v128) + (v128.load16_lane align=2 4 (local.get $address) (local.get $x))) + (func (export "v128.load16_lane_5_align_1") + (param $address i32) (param $x v128) (result v128) + (v128.load16_lane align=1 5 (local.get $address) (local.get $x))) + (func (export "v128.load16_lane_5_align_2") + (param $address i32) (param $x v128) (result v128) + (v128.load16_lane align=2 5 (local.get $address) (local.get $x))) + (func (export "v128.load16_lane_6_align_1") + (param $address i32) (param $x v128) (result v128) + (v128.load16_lane align=1 6 (local.get $address) (local.get $x))) + (func (export "v128.load16_lane_6_align_2") + (param $address i32) (param $x v128) (result v128) + (v128.load16_lane align=2 6 (local.get $address) (local.get $x))) + (func (export "v128.load16_lane_7_align_1") + (param $address i32) (param $x v128) (result v128) + (v128.load16_lane align=1 7 (local.get $address) (local.get $x))) + (func (export "v128.load16_lane_7_align_2") + (param $address i32) (param $x v128) (result v128) + (v128.load16_lane align=2 7 (local.get $address) (local.get $x))) +) + +(assert_return (invoke "v128.load16_lane_0" (i32.const 0) + (v128.const i16x8 0 0 0 0 0 0 0 0)) + (v128.const i16x8 256 0 0 0 0 0 0 0)) +(assert_return (invoke "v128.load16_lane_1" (i32.const 1) + (v128.const i16x8 0 0 0 0 0 0 0 0)) + (v128.const i16x8 0 513 0 0 0 0 0 0)) +(assert_return (invoke "v128.load16_lane_2" (i32.const 2) + (v128.const i16x8 0 0 0 0 0 0 0 0)) + (v128.const i16x8 0 0 770 0 0 0 0 0)) +(assert_return (invoke "v128.load16_lane_3" (i32.const 3) + (v128.const i16x8 0 0 0 0 0 0 0 0)) + (v128.const i16x8 0 0 0 1027 0 0 0 0)) +(assert_return (invoke "v128.load16_lane_4" (i32.const 4) + (v128.const i16x8 0 0 0 0 0 0 0 0)) + (v128.const i16x8 0 0 0 0 1284 0 0 0)) +(assert_return (invoke "v128.load16_lane_5" (i32.const 5) + (v128.const i16x8 0 0 0 0 0 0 0 0)) + (v128.const i16x8 0 0 0 0 0 1541 0 0)) +(assert_return (invoke "v128.load16_lane_6" (i32.const 6) + (v128.const i16x8 0 0 0 0 0 0 0 0)) + (v128.const i16x8 0 0 0 0 0 0 1798 0)) +(assert_return (invoke "v128.load16_lane_7" (i32.const 7) + (v128.const i16x8 0 0 0 0 0 0 0 0)) + (v128.const i16x8 0 0 0 0 0 0 0 2055)) +(assert_return (invoke "v128.load16_lane_0_offset_0" (v128.const i16x8 0 0 0 0 0 0 0 0)) + (v128.const i16x8 256 0 0 0 0 0 0 0)) +(assert_return (invoke "v128.load16_lane_1_offset_1" (v128.const i16x8 0 0 0 0 0 0 0 0)) + (v128.const i16x8 0 513 0 0 0 0 0 0)) +(assert_return (invoke "v128.load16_lane_2_offset_2" (v128.const i16x8 0 0 0 0 0 0 0 0)) + (v128.const i16x8 0 0 770 0 0 0 0 0)) +(assert_return (invoke "v128.load16_lane_3_offset_3" (v128.const i16x8 0 0 0 0 0 0 0 0)) + (v128.const i16x8 0 0 0 1027 0 0 0 0)) +(assert_return (invoke "v128.load16_lane_4_offset_4" (v128.const i16x8 0 0 0 0 0 0 0 0)) + (v128.const i16x8 0 0 0 0 1284 0 0 0)) +(assert_return (invoke "v128.load16_lane_5_offset_5" (v128.const i16x8 0 0 0 0 0 0 0 0)) + (v128.const i16x8 0 0 0 0 0 1541 0 0)) +(assert_return (invoke "v128.load16_lane_6_offset_6" (v128.const i16x8 0 0 0 0 0 0 0 0)) + (v128.const i16x8 0 0 0 0 0 0 1798 0)) +(assert_return (invoke "v128.load16_lane_7_offset_7" (v128.const i16x8 0 0 0 0 0 0 0 0)) + (v128.const i16x8 0 0 0 0 0 0 0 2055)) +(assert_return (invoke "v128.load16_lane_0_align_1" (i32.const 0) + (v128.const i16x8 0 0 0 0 0 0 0 0)) + (v128.const i16x8 256 0 0 0 0 0 0 0)) +(assert_return (invoke "v128.load16_lane_0_align_2" (i32.const 0) + (v128.const i16x8 0 0 0 0 0 0 0 0)) + (v128.const i16x8 256 0 0 0 0 0 0 0)) +(assert_return (invoke "v128.load16_lane_1_align_1" (i32.const 1) + (v128.const i16x8 0 0 0 0 0 0 0 0)) + (v128.const i16x8 0 513 0 0 0 0 0 0)) +(assert_return (invoke "v128.load16_lane_1_align_2" (i32.const 1) + (v128.const i16x8 0 0 0 0 0 0 0 0)) + (v128.const i16x8 0 513 0 0 0 0 0 0)) +(assert_return (invoke "v128.load16_lane_2_align_1" (i32.const 2) + (v128.const i16x8 0 0 0 0 0 0 0 0)) + (v128.const i16x8 0 0 770 0 0 0 0 0)) +(assert_return (invoke "v128.load16_lane_2_align_2" (i32.const 2) + (v128.const i16x8 0 0 0 0 0 0 0 0)) + (v128.const i16x8 0 0 770 0 0 0 0 0)) +(assert_return (invoke "v128.load16_lane_3_align_1" (i32.const 3) + (v128.const i16x8 0 0 0 0 0 0 0 0)) + (v128.const i16x8 0 0 0 1027 0 0 0 0)) +(assert_return (invoke "v128.load16_lane_3_align_2" (i32.const 3) + (v128.const i16x8 0 0 0 0 0 0 0 0)) + (v128.const i16x8 0 0 0 1027 0 0 0 0)) +(assert_return (invoke "v128.load16_lane_4_align_1" (i32.const 4) + (v128.const i16x8 0 0 0 0 0 0 0 0)) + (v128.const i16x8 0 0 0 0 1284 0 0 0)) +(assert_return (invoke "v128.load16_lane_4_align_2" (i32.const 4) + (v128.const i16x8 0 0 0 0 0 0 0 0)) + (v128.const i16x8 0 0 0 0 1284 0 0 0)) +(assert_return (invoke "v128.load16_lane_5_align_1" (i32.const 5) + (v128.const i16x8 0 0 0 0 0 0 0 0)) + (v128.const i16x8 0 0 0 0 0 1541 0 0)) +(assert_return (invoke "v128.load16_lane_5_align_2" (i32.const 5) + (v128.const i16x8 0 0 0 0 0 0 0 0)) + (v128.const i16x8 0 0 0 0 0 1541 0 0)) +(assert_return (invoke "v128.load16_lane_6_align_1" (i32.const 6) + (v128.const i16x8 0 0 0 0 0 0 0 0)) + (v128.const i16x8 0 0 0 0 0 0 1798 0)) +(assert_return (invoke "v128.load16_lane_6_align_2" (i32.const 6) + (v128.const i16x8 0 0 0 0 0 0 0 0)) + (v128.const i16x8 0 0 0 0 0 0 1798 0)) +(assert_return (invoke "v128.load16_lane_7_align_1" (i32.const 7) + (v128.const i16x8 0 0 0 0 0 0 0 0)) + (v128.const i16x8 0 0 0 0 0 0 0 2055)) +(assert_return (invoke "v128.load16_lane_7_align_2" (i32.const 7) + (v128.const i16x8 0 0 0 0 0 0 0 0)) + (v128.const i16x8 0 0 0 0 0 0 0 2055)) + +;; type check +(assert_invalid (module (memory 1) + (func (param $x v128) (result v128) + (v128.load16_lane 0 (local.get $x) (i32.const 0)))) + "type mismatch") + +;; invalid lane index +(assert_invalid (module (memory 1) + (func (param $x v128) (result v128) + (v128.load16_lane 8 (i32.const 0) (local.get $x)))) + "invalid lane index") + +;; invalid memarg alignment +(assert_invalid + (module (memory 1) + (func (param $x v128) (result v128) + (v128.load16_lane align=4 0 (i32.const 0) (local.get $x)))) + "alignment must not be larger than natural") \ No newline at end of file diff --git a/runtime/near-vm/tests/wast/spec/proposals/simd/simd_load32_lane.wast b/runtime/near-vm/tests/wast/spec/proposals/simd/simd_load32_lane.wast new file mode 100644 index 00000000000..e67690ff98d --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/proposals/simd/simd_load32_lane.wast @@ -0,0 +1,143 @@ +;; Tests for load lane operations. + + +(module + (memory 1) + (data (i32.const 0) "\00\01\02\03\04\05\06\07\08\09\0A\0B\0C\0D\0E\0F") + (func (export "v128.load32_lane_0") + (param $address i32) (param $x v128) (result v128) + (v128.load32_lane 0 (local.get $address) (local.get $x))) + (func (export "v128.load32_lane_1") + (param $address i32) (param $x v128) (result v128) + (v128.load32_lane 1 (local.get $address) (local.get $x))) + (func (export "v128.load32_lane_2") + (param $address i32) (param $x v128) (result v128) + (v128.load32_lane 2 (local.get $address) (local.get $x))) + (func (export "v128.load32_lane_3") + (param $address i32) (param $x v128) (result v128) + (v128.load32_lane 3 (local.get $address) (local.get $x))) + (func (export "v128.load32_lane_0_offset_0") + (param $x v128) (result v128) + (v128.load32_lane offset=0 0 (i32.const 0) (local.get $x))) + (func (export "v128.load32_lane_1_offset_1") + (param $x v128) (result v128) + (v128.load32_lane offset=1 1 (i32.const 0) (local.get $x))) + (func (export "v128.load32_lane_2_offset_2") + (param $x v128) (result v128) + (v128.load32_lane offset=2 2 (i32.const 0) (local.get $x))) + (func (export "v128.load32_lane_3_offset_3") + (param $x v128) (result v128) + (v128.load32_lane offset=3 3 (i32.const 0) (local.get $x))) + (func (export "v128.load32_lane_0_align_1") + (param $address i32) (param $x v128) (result v128) + (v128.load32_lane align=1 0 (local.get $address) (local.get $x))) + (func (export "v128.load32_lane_0_align_2") + (param $address i32) (param $x v128) (result v128) + (v128.load32_lane align=2 0 (local.get $address) (local.get $x))) + (func (export "v128.load32_lane_0_align_4") + (param $address i32) (param $x v128) (result v128) + (v128.load32_lane align=4 0 (local.get $address) (local.get $x))) + (func (export "v128.load32_lane_1_align_1") + (param $address i32) (param $x v128) (result v128) + (v128.load32_lane align=1 1 (local.get $address) (local.get $x))) + (func (export "v128.load32_lane_1_align_2") + (param $address i32) (param $x v128) (result v128) + (v128.load32_lane align=2 1 (local.get $address) (local.get $x))) + (func (export "v128.load32_lane_1_align_4") + (param $address i32) (param $x v128) (result v128) + (v128.load32_lane align=4 1 (local.get $address) (local.get $x))) + (func (export "v128.load32_lane_2_align_1") + (param $address i32) (param $x v128) (result v128) + (v128.load32_lane align=1 2 (local.get $address) (local.get $x))) + (func (export "v128.load32_lane_2_align_2") + (param $address i32) (param $x v128) (result v128) + (v128.load32_lane align=2 2 (local.get $address) (local.get $x))) + (func (export "v128.load32_lane_2_align_4") + (param $address i32) (param $x v128) (result v128) + (v128.load32_lane align=4 2 (local.get $address) (local.get $x))) + (func (export "v128.load32_lane_3_align_1") + (param $address i32) (param $x v128) (result v128) + (v128.load32_lane align=1 3 (local.get $address) (local.get $x))) + (func (export "v128.load32_lane_3_align_2") + (param $address i32) (param $x v128) (result v128) + (v128.load32_lane align=2 3 (local.get $address) (local.get $x))) + (func (export "v128.load32_lane_3_align_4") + (param $address i32) (param $x v128) (result v128) + (v128.load32_lane align=4 3 (local.get $address) (local.get $x))) +) + +(assert_return (invoke "v128.load32_lane_0" (i32.const 0) + (v128.const i32x4 0 0 0 0)) + (v128.const i32x4 50462976 0 0 0)) +(assert_return (invoke "v128.load32_lane_1" (i32.const 1) + (v128.const i32x4 0 0 0 0)) + (v128.const i32x4 0 67305985 0 0)) +(assert_return (invoke "v128.load32_lane_2" (i32.const 2) + (v128.const i32x4 0 0 0 0)) + (v128.const i32x4 0 0 84148994 0)) +(assert_return (invoke "v128.load32_lane_3" (i32.const 3) + (v128.const i32x4 0 0 0 0)) + (v128.const i32x4 0 0 0 100992003)) +(assert_return (invoke "v128.load32_lane_0_offset_0" (v128.const i32x4 0 0 0 0)) + (v128.const i32x4 50462976 0 0 0)) +(assert_return (invoke "v128.load32_lane_1_offset_1" (v128.const i32x4 0 0 0 0)) + (v128.const i32x4 0 67305985 0 0)) +(assert_return (invoke "v128.load32_lane_2_offset_2" (v128.const i32x4 0 0 0 0)) + (v128.const i32x4 0 0 84148994 0)) +(assert_return (invoke "v128.load32_lane_3_offset_3" (v128.const i32x4 0 0 0 0)) + (v128.const i32x4 0 0 0 100992003)) +(assert_return (invoke "v128.load32_lane_0_align_1" (i32.const 0) + (v128.const i32x4 0 0 0 0)) + (v128.const i32x4 50462976 0 0 0)) +(assert_return (invoke "v128.load32_lane_0_align_2" (i32.const 0) + (v128.const i32x4 0 0 0 0)) + (v128.const i32x4 50462976 0 0 0)) +(assert_return (invoke "v128.load32_lane_0_align_4" (i32.const 0) + (v128.const i32x4 0 0 0 0)) + (v128.const i32x4 50462976 0 0 0)) +(assert_return (invoke "v128.load32_lane_1_align_1" (i32.const 1) + (v128.const i32x4 0 0 0 0)) + (v128.const i32x4 0 67305985 0 0)) +(assert_return (invoke "v128.load32_lane_1_align_2" (i32.const 1) + (v128.const i32x4 0 0 0 0)) + (v128.const i32x4 0 67305985 0 0)) +(assert_return (invoke "v128.load32_lane_1_align_4" (i32.const 1) + (v128.const i32x4 0 0 0 0)) + (v128.const i32x4 0 67305985 0 0)) +(assert_return (invoke "v128.load32_lane_2_align_1" (i32.const 2) + (v128.const i32x4 0 0 0 0)) + (v128.const i32x4 0 0 84148994 0)) +(assert_return (invoke "v128.load32_lane_2_align_2" (i32.const 2) + (v128.const i32x4 0 0 0 0)) + (v128.const i32x4 0 0 84148994 0)) +(assert_return (invoke "v128.load32_lane_2_align_4" (i32.const 2) + (v128.const i32x4 0 0 0 0)) + (v128.const i32x4 0 0 84148994 0)) +(assert_return (invoke "v128.load32_lane_3_align_1" (i32.const 3) + (v128.const i32x4 0 0 0 0)) + (v128.const i32x4 0 0 0 100992003)) +(assert_return (invoke "v128.load32_lane_3_align_2" (i32.const 3) + (v128.const i32x4 0 0 0 0)) + (v128.const i32x4 0 0 0 100992003)) +(assert_return (invoke "v128.load32_lane_3_align_4" (i32.const 3) + (v128.const i32x4 0 0 0 0)) + (v128.const i32x4 0 0 0 100992003)) + +;; type check +(assert_invalid (module (memory 1) + (func (param $x v128) (result v128) + (v128.load32_lane 0 (local.get $x) (i32.const 0)))) + "type mismatch") + +;; invalid lane index +(assert_invalid (module (memory 1) + (func (param $x v128) (result v128) + (v128.load32_lane 4 (i32.const 0) (local.get $x)))) + "invalid lane index") + +;; invalid memarg alignment +(assert_invalid + (module (memory 1) + (func (param $x v128) (result v128) + (v128.load32_lane align=8 0 (i32.const 0) (local.get $x)))) + "alignment must not be larger than natural") \ No newline at end of file diff --git a/runtime/near-vm/tests/wast/spec/proposals/simd/simd_load64_lane.wast b/runtime/near-vm/tests/wast/spec/proposals/simd/simd_load64_lane.wast new file mode 100644 index 00000000000..5883a6eaebe --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/proposals/simd/simd_load64_lane.wast @@ -0,0 +1,97 @@ +;; Tests for load lane operations. + + +(module + (memory 1) + (data (i32.const 0) "\00\01\02\03\04\05\06\07\08\09\0A\0B\0C\0D\0E\0F") + (func (export "v128.load64_lane_0") + (param $address i32) (param $x v128) (result v128) + (v128.load64_lane 0 (local.get $address) (local.get $x))) + (func (export "v128.load64_lane_1") + (param $address i32) (param $x v128) (result v128) + (v128.load64_lane 1 (local.get $address) (local.get $x))) + (func (export "v128.load64_lane_0_offset_0") + (param $x v128) (result v128) + (v128.load64_lane offset=0 0 (i32.const 0) (local.get $x))) + (func (export "v128.load64_lane_1_offset_1") + (param $x v128) (result v128) + (v128.load64_lane offset=1 1 (i32.const 0) (local.get $x))) + (func (export "v128.load64_lane_0_align_1") + (param $address i32) (param $x v128) (result v128) + (v128.load64_lane align=1 0 (local.get $address) (local.get $x))) + (func (export "v128.load64_lane_0_align_2") + (param $address i32) (param $x v128) (result v128) + (v128.load64_lane align=2 0 (local.get $address) (local.get $x))) + (func (export "v128.load64_lane_0_align_4") + (param $address i32) (param $x v128) (result v128) + (v128.load64_lane align=4 0 (local.get $address) (local.get $x))) + (func (export "v128.load64_lane_0_align_8") + (param $address i32) (param $x v128) (result v128) + (v128.load64_lane align=8 0 (local.get $address) (local.get $x))) + (func (export "v128.load64_lane_1_align_1") + (param $address i32) (param $x v128) (result v128) + (v128.load64_lane align=1 1 (local.get $address) (local.get $x))) + (func (export "v128.load64_lane_1_align_2") + (param $address i32) (param $x v128) (result v128) + (v128.load64_lane align=2 1 (local.get $address) (local.get $x))) + (func (export "v128.load64_lane_1_align_4") + (param $address i32) (param $x v128) (result v128) + (v128.load64_lane align=4 1 (local.get $address) (local.get $x))) + (func (export "v128.load64_lane_1_align_8") + (param $address i32) (param $x v128) (result v128) + (v128.load64_lane align=8 1 (local.get $address) (local.get $x))) +) + +(assert_return (invoke "v128.load64_lane_0" (i32.const 0) + (v128.const i64x2 0 0)) + (v128.const i64x2 506097522914230528 0)) +(assert_return (invoke "v128.load64_lane_1" (i32.const 1) + (v128.const i64x2 0 0)) + (v128.const i64x2 0 578437695752307201)) +(assert_return (invoke "v128.load64_lane_0_offset_0" (v128.const i64x2 0 0)) + (v128.const i64x2 506097522914230528 0)) +(assert_return (invoke "v128.load64_lane_1_offset_1" (v128.const i64x2 0 0)) + (v128.const i64x2 0 578437695752307201)) +(assert_return (invoke "v128.load64_lane_0_align_1" (i32.const 0) + (v128.const i64x2 0 0)) + (v128.const i64x2 506097522914230528 0)) +(assert_return (invoke "v128.load64_lane_0_align_2" (i32.const 0) + (v128.const i64x2 0 0)) + (v128.const i64x2 506097522914230528 0)) +(assert_return (invoke "v128.load64_lane_0_align_4" (i32.const 0) + (v128.const i64x2 0 0)) + (v128.const i64x2 506097522914230528 0)) +(assert_return (invoke "v128.load64_lane_0_align_8" (i32.const 0) + (v128.const i64x2 0 0)) + (v128.const i64x2 506097522914230528 0)) +(assert_return (invoke "v128.load64_lane_1_align_1" (i32.const 1) + (v128.const i64x2 0 0)) + (v128.const i64x2 0 578437695752307201)) +(assert_return (invoke "v128.load64_lane_1_align_2" (i32.const 1) + (v128.const i64x2 0 0)) + (v128.const i64x2 0 578437695752307201)) +(assert_return (invoke "v128.load64_lane_1_align_4" (i32.const 1) + (v128.const i64x2 0 0)) + (v128.const i64x2 0 578437695752307201)) +(assert_return (invoke "v128.load64_lane_1_align_8" (i32.const 1) + (v128.const i64x2 0 0)) + (v128.const i64x2 0 578437695752307201)) + +;; type check +(assert_invalid (module (memory 1) + (func (param $x v128) (result v128) + (v128.load64_lane 0 (local.get $x) (i32.const 0)))) + "type mismatch") + +;; invalid lane index +(assert_invalid (module (memory 1) + (func (param $x v128) (result v128) + (v128.load64_lane 2 (i32.const 0) (local.get $x)))) + "invalid lane index") + +;; invalid memarg alignment +(assert_invalid + (module (memory 1) + (func (param $x v128) (result v128) + (v128.load64_lane align=16 0 (i32.const 0) (local.get $x)))) + "alignment must not be larger than natural") \ No newline at end of file diff --git a/runtime/near-vm/tests/wast/spec/proposals/simd/simd_load8_lane.wast b/runtime/near-vm/tests/wast/spec/proposals/simd/simd_load8_lane.wast new file mode 100644 index 00000000000..d0706f53519 --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/proposals/simd/simd_load8_lane.wast @@ -0,0 +1,299 @@ +;; Tests for load lane operations. + + +(module + (memory 1) + (data (i32.const 0) "\00\01\02\03\04\05\06\07\08\09\0A\0B\0C\0D\0E\0F") + (func (export "v128.load8_lane_0") + (param $address i32) (param $x v128) (result v128) + (v128.load8_lane 0 (local.get $address) (local.get $x))) + (func (export "v128.load8_lane_1") + (param $address i32) (param $x v128) (result v128) + (v128.load8_lane 1 (local.get $address) (local.get $x))) + (func (export "v128.load8_lane_2") + (param $address i32) (param $x v128) (result v128) + (v128.load8_lane 2 (local.get $address) (local.get $x))) + (func (export "v128.load8_lane_3") + (param $address i32) (param $x v128) (result v128) + (v128.load8_lane 3 (local.get $address) (local.get $x))) + (func (export "v128.load8_lane_4") + (param $address i32) (param $x v128) (result v128) + (v128.load8_lane 4 (local.get $address) (local.get $x))) + (func (export "v128.load8_lane_5") + (param $address i32) (param $x v128) (result v128) + (v128.load8_lane 5 (local.get $address) (local.get $x))) + (func (export "v128.load8_lane_6") + (param $address i32) (param $x v128) (result v128) + (v128.load8_lane 6 (local.get $address) (local.get $x))) + (func (export "v128.load8_lane_7") + (param $address i32) (param $x v128) (result v128) + (v128.load8_lane 7 (local.get $address) (local.get $x))) + (func (export "v128.load8_lane_8") + (param $address i32) (param $x v128) (result v128) + (v128.load8_lane 8 (local.get $address) (local.get $x))) + (func (export "v128.load8_lane_9") + (param $address i32) (param $x v128) (result v128) + (v128.load8_lane 9 (local.get $address) (local.get $x))) + (func (export "v128.load8_lane_10") + (param $address i32) (param $x v128) (result v128) + (v128.load8_lane 10 (local.get $address) (local.get $x))) + (func (export "v128.load8_lane_11") + (param $address i32) (param $x v128) (result v128) + (v128.load8_lane 11 (local.get $address) (local.get $x))) + (func (export "v128.load8_lane_12") + (param $address i32) (param $x v128) (result v128) + (v128.load8_lane 12 (local.get $address) (local.get $x))) + (func (export "v128.load8_lane_13") + (param $address i32) (param $x v128) (result v128) + (v128.load8_lane 13 (local.get $address) (local.get $x))) + (func (export "v128.load8_lane_14") + (param $address i32) (param $x v128) (result v128) + (v128.load8_lane 14 (local.get $address) (local.get $x))) + (func (export "v128.load8_lane_15") + (param $address i32) (param $x v128) (result v128) + (v128.load8_lane 15 (local.get $address) (local.get $x))) + (func (export "v128.load8_lane_0_offset_0") + (param $x v128) (result v128) + (v128.load8_lane offset=0 0 (i32.const 0) (local.get $x))) + (func (export "v128.load8_lane_1_offset_1") + (param $x v128) (result v128) + (v128.load8_lane offset=1 1 (i32.const 0) (local.get $x))) + (func (export "v128.load8_lane_2_offset_2") + (param $x v128) (result v128) + (v128.load8_lane offset=2 2 (i32.const 0) (local.get $x))) + (func (export "v128.load8_lane_3_offset_3") + (param $x v128) (result v128) + (v128.load8_lane offset=3 3 (i32.const 0) (local.get $x))) + (func (export "v128.load8_lane_4_offset_4") + (param $x v128) (result v128) + (v128.load8_lane offset=4 4 (i32.const 0) (local.get $x))) + (func (export "v128.load8_lane_5_offset_5") + (param $x v128) (result v128) + (v128.load8_lane offset=5 5 (i32.const 0) (local.get $x))) + (func (export "v128.load8_lane_6_offset_6") + (param $x v128) (result v128) + (v128.load8_lane offset=6 6 (i32.const 0) (local.get $x))) + (func (export "v128.load8_lane_7_offset_7") + (param $x v128) (result v128) + (v128.load8_lane offset=7 7 (i32.const 0) (local.get $x))) + (func (export "v128.load8_lane_8_offset_8") + (param $x v128) (result v128) + (v128.load8_lane offset=8 8 (i32.const 0) (local.get $x))) + (func (export "v128.load8_lane_9_offset_9") + (param $x v128) (result v128) + (v128.load8_lane offset=9 9 (i32.const 0) (local.get $x))) + (func (export "v128.load8_lane_10_offset_10") + (param $x v128) (result v128) + (v128.load8_lane offset=10 10 (i32.const 0) (local.get $x))) + (func (export "v128.load8_lane_11_offset_11") + (param $x v128) (result v128) + (v128.load8_lane offset=11 11 (i32.const 0) (local.get $x))) + (func (export "v128.load8_lane_12_offset_12") + (param $x v128) (result v128) + (v128.load8_lane offset=12 12 (i32.const 0) (local.get $x))) + (func (export "v128.load8_lane_13_offset_13") + (param $x v128) (result v128) + (v128.load8_lane offset=13 13 (i32.const 0) (local.get $x))) + (func (export "v128.load8_lane_14_offset_14") + (param $x v128) (result v128) + (v128.load8_lane offset=14 14 (i32.const 0) (local.get $x))) + (func (export "v128.load8_lane_15_offset_15") + (param $x v128) (result v128) + (v128.load8_lane offset=15 15 (i32.const 0) (local.get $x))) + (func (export "v128.load8_lane_0_align_1") + (param $address i32) (param $x v128) (result v128) + (v128.load8_lane align=1 0 (local.get $address) (local.get $x))) + (func (export "v128.load8_lane_1_align_1") + (param $address i32) (param $x v128) (result v128) + (v128.load8_lane align=1 1 (local.get $address) (local.get $x))) + (func (export "v128.load8_lane_2_align_1") + (param $address i32) (param $x v128) (result v128) + (v128.load8_lane align=1 2 (local.get $address) (local.get $x))) + (func (export "v128.load8_lane_3_align_1") + (param $address i32) (param $x v128) (result v128) + (v128.load8_lane align=1 3 (local.get $address) (local.get $x))) + (func (export "v128.load8_lane_4_align_1") + (param $address i32) (param $x v128) (result v128) + (v128.load8_lane align=1 4 (local.get $address) (local.get $x))) + (func (export "v128.load8_lane_5_align_1") + (param $address i32) (param $x v128) (result v128) + (v128.load8_lane align=1 5 (local.get $address) (local.get $x))) + (func (export "v128.load8_lane_6_align_1") + (param $address i32) (param $x v128) (result v128) + (v128.load8_lane align=1 6 (local.get $address) (local.get $x))) + (func (export "v128.load8_lane_7_align_1") + (param $address i32) (param $x v128) (result v128) + (v128.load8_lane align=1 7 (local.get $address) (local.get $x))) + (func (export "v128.load8_lane_8_align_1") + (param $address i32) (param $x v128) (result v128) + (v128.load8_lane align=1 8 (local.get $address) (local.get $x))) + (func (export "v128.load8_lane_9_align_1") + (param $address i32) (param $x v128) (result v128) + (v128.load8_lane align=1 9 (local.get $address) (local.get $x))) + (func (export "v128.load8_lane_10_align_1") + (param $address i32) (param $x v128) (result v128) + (v128.load8_lane align=1 10 (local.get $address) (local.get $x))) + (func (export "v128.load8_lane_11_align_1") + (param $address i32) (param $x v128) (result v128) + (v128.load8_lane align=1 11 (local.get $address) (local.get $x))) + (func (export "v128.load8_lane_12_align_1") + (param $address i32) (param $x v128) (result v128) + (v128.load8_lane align=1 12 (local.get $address) (local.get $x))) + (func (export "v128.load8_lane_13_align_1") + (param $address i32) (param $x v128) (result v128) + (v128.load8_lane align=1 13 (local.get $address) (local.get $x))) + (func (export "v128.load8_lane_14_align_1") + (param $address i32) (param $x v128) (result v128) + (v128.load8_lane align=1 14 (local.get $address) (local.get $x))) + (func (export "v128.load8_lane_15_align_1") + (param $address i32) (param $x v128) (result v128) + (v128.load8_lane align=1 15 (local.get $address) (local.get $x))) +) + +(assert_return (invoke "v128.load8_lane_0" (i32.const 0) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "v128.load8_lane_1" (i32.const 1) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + (v128.const i8x16 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "v128.load8_lane_2" (i32.const 2) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + (v128.const i8x16 0 0 2 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "v128.load8_lane_3" (i32.const 3) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + (v128.const i8x16 0 0 0 3 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "v128.load8_lane_4" (i32.const 4) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + (v128.const i8x16 0 0 0 0 4 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "v128.load8_lane_5" (i32.const 5) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + (v128.const i8x16 0 0 0 0 0 5 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "v128.load8_lane_6" (i32.const 6) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + (v128.const i8x16 0 0 0 0 0 0 6 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "v128.load8_lane_7" (i32.const 7) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + (v128.const i8x16 0 0 0 0 0 0 0 7 0 0 0 0 0 0 0 0)) +(assert_return (invoke "v128.load8_lane_8" (i32.const 8) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + (v128.const i8x16 0 0 0 0 0 0 0 0 8 0 0 0 0 0 0 0)) +(assert_return (invoke "v128.load8_lane_9" (i32.const 9) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 9 0 0 0 0 0 0)) +(assert_return (invoke "v128.load8_lane_10" (i32.const 10) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 10 0 0 0 0 0)) +(assert_return (invoke "v128.load8_lane_11" (i32.const 11) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 11 0 0 0 0)) +(assert_return (invoke "v128.load8_lane_12" (i32.const 12) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 12 0 0 0)) +(assert_return (invoke "v128.load8_lane_13" (i32.const 13) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 13 0 0)) +(assert_return (invoke "v128.load8_lane_14" (i32.const 14) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 14 0)) +(assert_return (invoke "v128.load8_lane_15" (i32.const 15) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 15)) +(assert_return (invoke "v128.load8_lane_0_offset_0" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "v128.load8_lane_1_offset_1" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + (v128.const i8x16 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "v128.load8_lane_2_offset_2" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + (v128.const i8x16 0 0 2 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "v128.load8_lane_3_offset_3" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + (v128.const i8x16 0 0 0 3 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "v128.load8_lane_4_offset_4" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + (v128.const i8x16 0 0 0 0 4 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "v128.load8_lane_5_offset_5" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + (v128.const i8x16 0 0 0 0 0 5 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "v128.load8_lane_6_offset_6" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + (v128.const i8x16 0 0 0 0 0 0 6 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "v128.load8_lane_7_offset_7" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + (v128.const i8x16 0 0 0 0 0 0 0 7 0 0 0 0 0 0 0 0)) +(assert_return (invoke "v128.load8_lane_8_offset_8" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + (v128.const i8x16 0 0 0 0 0 0 0 0 8 0 0 0 0 0 0 0)) +(assert_return (invoke "v128.load8_lane_9_offset_9" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 9 0 0 0 0 0 0)) +(assert_return (invoke "v128.load8_lane_10_offset_10" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 10 0 0 0 0 0)) +(assert_return (invoke "v128.load8_lane_11_offset_11" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 11 0 0 0 0)) +(assert_return (invoke "v128.load8_lane_12_offset_12" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 12 0 0 0)) +(assert_return (invoke "v128.load8_lane_13_offset_13" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 13 0 0)) +(assert_return (invoke "v128.load8_lane_14_offset_14" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 14 0)) +(assert_return (invoke "v128.load8_lane_15_offset_15" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 15)) +(assert_return (invoke "v128.load8_lane_0_align_1" (i32.const 0) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "v128.load8_lane_1_align_1" (i32.const 1) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + (v128.const i8x16 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "v128.load8_lane_2_align_1" (i32.const 2) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + (v128.const i8x16 0 0 2 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "v128.load8_lane_3_align_1" (i32.const 3) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + (v128.const i8x16 0 0 0 3 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "v128.load8_lane_4_align_1" (i32.const 4) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + (v128.const i8x16 0 0 0 0 4 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "v128.load8_lane_5_align_1" (i32.const 5) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + (v128.const i8x16 0 0 0 0 0 5 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "v128.load8_lane_6_align_1" (i32.const 6) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + (v128.const i8x16 0 0 0 0 0 0 6 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "v128.load8_lane_7_align_1" (i32.const 7) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + (v128.const i8x16 0 0 0 0 0 0 0 7 0 0 0 0 0 0 0 0)) +(assert_return (invoke "v128.load8_lane_8_align_1" (i32.const 8) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + (v128.const i8x16 0 0 0 0 0 0 0 0 8 0 0 0 0 0 0 0)) +(assert_return (invoke "v128.load8_lane_9_align_1" (i32.const 9) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 9 0 0 0 0 0 0)) +(assert_return (invoke "v128.load8_lane_10_align_1" (i32.const 10) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 10 0 0 0 0 0)) +(assert_return (invoke "v128.load8_lane_11_align_1" (i32.const 11) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 11 0 0 0 0)) +(assert_return (invoke "v128.load8_lane_12_align_1" (i32.const 12) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 12 0 0 0)) +(assert_return (invoke "v128.load8_lane_13_align_1" (i32.const 13) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 13 0 0)) +(assert_return (invoke "v128.load8_lane_14_align_1" (i32.const 14) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 14 0)) +(assert_return (invoke "v128.load8_lane_15_align_1" (i32.const 15) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 15)) + +;; type check +(assert_invalid (module (memory 1) + (func (param $x v128) (result v128) + (v128.load8_lane 0 (local.get $x) (i32.const 0)))) + "type mismatch") + +;; invalid lane index +(assert_invalid (module (memory 1) + (func (param $x v128) (result v128) + (v128.load8_lane 16 (i32.const 0) (local.get $x)))) + "invalid lane index") + +;; invalid memarg alignment +(assert_invalid + (module (memory 1) + (func (param $x v128) (result v128) + (v128.load8_lane align=2 0 (i32.const 0) (local.get $x)))) + "alignment must not be larger than natural") \ No newline at end of file diff --git a/runtime/near-vm/tests/wast/spec/proposals/simd/simd_load_extend.wast b/runtime/near-vm/tests/wast/spec/proposals/simd/simd_load_extend.wast new file mode 100644 index 00000000000..b9982bbfd0c --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/proposals/simd/simd_load_extend.wast @@ -0,0 +1,384 @@ +;; Load and Extend test cases + +(module + (memory 1) + (data (i32.const 0) "\00\01\02\03\04\05\06\07\08\09\0A\0B\0C\0D\0E\0F\80\81\82\83\84\85\86\87\88\89") + (data (i32.const 65520) "\0A\0B\0C\0D\0E\0F\80\81\82\83\84\85\86\87\88\89") + + (func (export "v128.load8x8_s") (param $0 i32) (result v128) + (v128.load8x8_s (local.get $0)) + ) + (func (export "v128.load8x8_u") (param $0 i32) (result v128) + (v128.load8x8_u (local.get $0)) + ) + (func (export "v128.load16x4_s") (param $0 i32) (result v128) + (v128.load16x4_s (local.get $0)) + ) + (func (export "v128.load16x4_u") (param $0 i32) (result v128) + (v128.load16x4_u (local.get $0)) + ) + (func (export "v128.load32x2_s") (param $0 i32) (result v128) + (v128.load32x2_s (local.get $0)) + ) + (func (export "v128.load32x2_u") (param $0 i32) (result v128) + (v128.load32x2_u (local.get $0)) + ) + + ;; load by a constant amount + (func (export "v128.load8x8_s_const0") (result v128) + (v128.load8x8_s (i32.const 0)) + ) + (func (export "v128.load8x8_u_const8") (result v128) + (v128.load8x8_u (i32.const 8)) + ) + (func (export "v128.load16x4_s_const10") (result v128) + (v128.load16x4_s (i32.const 10)) + ) + (func (export "v128.load16x4_u_const20") (result v128) + (v128.load16x4_u (i32.const 20)) + ) + (func (export "v128.load32x2_s_const65520") (result v128) + (v128.load32x2_s (i32.const 65520)) + ) + (func (export "v128.load32x2_u_const65526") (result v128) + (v128.load32x2_u (i32.const 65526)) + ) + + ;; load data with different offset/align arguments + ;; i16x8 + (func (export "v128.load8x8_s_offset0") (param $0 i32) (result v128) + (v128.load8x8_s offset=0 (local.get $0)) + ) + (func (export "v128.load8x8_s_align1") (param $0 i32) (result v128) + (v128.load8x8_s align=1 (local.get $0)) + ) + (func (export "v128.load8x8_s_offset0_align1") (param $0 i32) (result v128) + (v128.load8x8_s offset=0 align=1 (local.get $0)) + ) + (func (export "v128.load8x8_s_offset1_align1") (param $0 i32) (result v128) + (v128.load8x8_s offset=1 align=1 (local.get $0)) + ) + (func (export "v128.load8x8_s_offset10_align4") (param $0 i32) (result v128) + (v128.load8x8_s offset=10 align=4 (local.get $0)) + ) + (func (export "v128.load8x8_s_offset20_align8") (param $0 i32) (result v128) + (v128.load8x8_s offset=20 align=8 (local.get $0)) + ) + (func (export "v128.load8x8_u_offset0") (param $0 i32) (result v128) + (v128.load8x8_u offset=0 (local.get $0)) + ) + (func (export "v128.load8x8_u_align1") (param $0 i32) (result v128) + (v128.load8x8_u align=1 (local.get $0)) + ) + (func (export "v128.load8x8_u_offset0_align1") (param $0 i32) (result v128) + (v128.load8x8_u offset=0 align=1 (local.get $0)) + ) + (func (export "v128.load8x8_u_offset1_align1") (param $0 i32) (result v128) + (v128.load8x8_u offset=1 align=1 (local.get $0)) + ) + (func (export "v128.load8x8_u_offset10_align4") (param $0 i32) (result v128) + (v128.load8x8_u offset=10 align=4 (local.get $0)) + ) + (func (export "v128.load8x8_u_offset20_align8") (param $0 i32) (result v128) + (v128.load8x8_u offset=20 align=8 (local.get $0)) + ) + ;; i32x4 + (func (export "v128.load16x4_s_offset0") (param $0 i32) (result v128) + (v128.load16x4_s offset=0 (local.get $0)) + ) + (func (export "v128.load16x4_s_align1") (param $0 i32) (result v128) + (v128.load16x4_s align=1 (local.get $0)) + ) + (func (export "v128.load16x4_s_offset0_align1") (param $0 i32) (result v128) + (v128.load16x4_s offset=0 align=1 (local.get $0)) + ) + (func (export "v128.load16x4_s_offset1_align1") (param $0 i32) (result v128) + (v128.load16x4_s offset=1 align=1 (local.get $0)) + ) + (func (export "v128.load16x4_s_offset10_align4") (param $0 i32) (result v128) + (v128.load16x4_s offset=10 align=4 (local.get $0)) + ) + (func (export "v128.load16x4_s_offset20_align8") (param $0 i32) (result v128) + (v128.load16x4_s offset=20 align=8 (local.get $0)) + ) + (func (export "v128.load16x4_u_offset0") (param $0 i32) (result v128) + (v128.load16x4_u offset=0 (local.get $0)) + ) + (func (export "v128.load16x4_u_align1") (param $0 i32) (result v128) + (v128.load16x4_u align=1 (local.get $0)) + ) + (func (export "v128.load16x4_u_offset0_align1") (param $0 i32) (result v128) + (v128.load16x4_u offset=0 align=1 (local.get $0)) + ) + (func (export "v128.load16x4_u_offset1_align1") (param $0 i32) (result v128) + (v128.load16x4_u offset=1 align=1 (local.get $0)) + ) + (func (export "v128.load16x4_u_offset10_align4") (param $0 i32) (result v128) + (v128.load16x4_u offset=10 align=4 (local.get $0)) + ) + (func (export "v128.load16x4_u_offset20_align8") (param $0 i32) (result v128) + (v128.load16x4_u offset=20 align=8 (local.get $0)) + ) + ;; i64x2 + (func (export "v128.load32x2_s_offset0") (param $0 i32) (result v128) + (v128.load32x2_s offset=0 (local.get $0)) + ) + (func (export "v128.load32x2_s_align1") (param $0 i32) (result v128) + (v128.load32x2_s align=1 (local.get $0)) + ) + (func (export "v128.load32x2_s_offset0_align1") (param $0 i32) (result v128) + (v128.load32x2_s offset=0 align=1 (local.get $0)) + ) + (func (export "v128.load32x2_s_offset1_align1") (param $0 i32) (result v128) + (v128.load32x2_s offset=1 align=1 (local.get $0)) + ) + (func (export "v128.load32x2_s_offset10_align4") (param $0 i32) (result v128) + (v128.load32x2_s offset=10 align=4 (local.get $0)) + ) + (func (export "v128.load32x2_s_offset20_align8") (param $0 i32) (result v128) + (v128.load32x2_s offset=20 align=8 (local.get $0)) + ) + (func (export "v128.load32x2_u_offset0") (param $0 i32) (result v128) + (v128.load32x2_u offset=0 (local.get $0)) + ) + (func (export "v128.load32x2_u_align1") (param $0 i32) (result v128) + (v128.load32x2_u align=1 (local.get $0)) + ) + (func (export "v128.load32x2_u_offset0_align1") (param $0 i32) (result v128) + (v128.load32x2_u offset=0 align=1 (local.get $0)) + ) + (func (export "v128.load32x2_u_offset1_align1") (param $0 i32) (result v128) + (v128.load32x2_u offset=1 align=1 (local.get $0)) + ) + (func (export "v128.load32x2_u_offset10_align4") (param $0 i32) (result v128) + (v128.load32x2_u offset=10 align=4 (local.get $0)) + ) + (func (export "v128.load32x2_u_offset20_align8") (param $0 i32) (result v128) + (v128.load32x2_u offset=20 align=8 (local.get $0)) + ) +) + + +;; normal +(assert_return (invoke "v128.load8x8_s" (i32.const 0)) (v128.const i16x8 0x0000 0x0001 0x0002 0x0003 0x0004 0x0005 0x0006 0x0007)) +(assert_return (invoke "v128.load8x8_u" (i32.const 0)) (v128.const i16x8 0x0000 0x0001 0x0002 0x0003 0x0004 0x0005 0x0006 0x0007)) +(assert_return (invoke "v128.load16x4_s" (i32.const 0)) (v128.const i32x4 0x00000100 0x00000302 0x00000504 0x00000706)) +(assert_return (invoke "v128.load16x4_u" (i32.const 0)) (v128.const i32x4 0x00000100 0x00000302 0x00000504 0x00000706)) +(assert_return (invoke "v128.load32x2_s" (i32.const 0)) (v128.const i64x2 0x0000000003020100 0x0000000007060504)) +(assert_return (invoke "v128.load32x2_u" (i32.const 0)) (v128.const i64x2 0x0000000003020100 0x0000000007060504)) +(assert_return (invoke "v128.load8x8_s" (i32.const 10)) (v128.const i16x8 0x000A 0x000B 0x000C 0x000D 0x000E 0x000F 0xFF80 0xFF81)) +(assert_return (invoke "v128.load8x8_u" (i32.const 10)) (v128.const i16x8 0x000A 0x000B 0x000C 0x000D 0x000E 0x000F 0x0080 0x0081)) +(assert_return (invoke "v128.load16x4_s" (i32.const 10)) (v128.const i32x4 0x00000B0A 0x00000D0C 0x00000F0E 0xFFFF8180)) +(assert_return (invoke "v128.load16x4_u" (i32.const 10)) (v128.const i32x4 0x00000B0A 0x00000D0C 0x00000F0E 0x00008180)) +(assert_return (invoke "v128.load32x2_s" (i32.const 10)) (v128.const i64x2 0x000000000D0C0B0A 0xFFFFFFFF81800F0E)) +(assert_return (invoke "v128.load32x2_u" (i32.const 10)) (v128.const i64x2 0x000000000D0C0B0A 0x0000000081800F0E)) +(assert_return (invoke "v128.load8x8_s" (i32.const 20)) (v128.const i16x8 0xff84 0xff85 0xff86 0xff87 0xff88 0xff89 0x0000 0x0000)) +(assert_return (invoke "v128.load8x8_u" (i32.const 20)) (v128.const i16x8 0x0084 0x0085 0x0086 0x0087 0x0088 0x0089 0x0000 0x0000)) +(assert_return (invoke "v128.load16x4_s" (i32.const 20)) (v128.const i32x4 0xffff8584 0xffff8786 0xffff8988 0x00000000)) +(assert_return (invoke "v128.load16x4_u" (i32.const 20)) (v128.const i32x4 0x00008584 0x00008786 0x00008988 0x00000000)) +(assert_return (invoke "v128.load32x2_s" (i32.const 20)) (v128.const i64x2 0xFFFFFFFF87868584 0x0000000000008988)) +(assert_return (invoke "v128.load32x2_u" (i32.const 20)) (v128.const i64x2 0x0000000087868584 0x0000000000008988)) + +;; load by a constant amount +(assert_return (invoke "v128.load8x8_s_const0") (v128.const i16x8 0x0000 0x0001 0x0002 0x0003 0x0004 0x0005 0x0006 0x0007)) +(assert_return (invoke "v128.load8x8_u_const8") (v128.const i16x8 0x0008 0x0009 0x000A 0x000B 0x000C 0x000D 0x000E 0x000F)) +(assert_return (invoke "v128.load16x4_s_const10") (v128.const i32x4 0x00000B0A 0x00000D0C 0x00000F0E 0xFFFF8180)) +(assert_return (invoke "v128.load16x4_u_const20") (v128.const i32x4 0x00008584 0x00008786 0x00008988 0x00000000)) +(assert_return (invoke "v128.load32x2_s_const65520") (v128.const i64x2 0x000000000D0C0B0A 0xFFFFFFFF81800F0E)) +(assert_return (invoke "v128.load32x2_u_const65526") (v128.const i64x2 0x0000000083828180 0x0000000087868584)) + +;; load data with different offset/align arguments +;; i16x8 +(assert_return (invoke "v128.load8x8_s_offset0" (i32.const 0)) (v128.const i16x8 0x0000 0x0001 0x0002 0x0003 0x0004 0x0005 0x0006 0x0007)) +(assert_return (invoke "v128.load8x8_s_align1" (i32.const 1)) (v128.const i16x8 0x0001 0x0002 0x0003 0x0004 0x0005 0x0006 0x0007 0x0008)) +(assert_return (invoke "v128.load8x8_s_offset0_align1" (i32.const 2)) (v128.const i16x8 0x0002 0x0003 0x0004 0x0005 0x0006 0x0007 0x0008 0x0009)) +(assert_return (invoke "v128.load8x8_s_offset10_align4" (i32.const 3)) (v128.const i16x8 0x000D 0x000E 0x000F 0xFF80 0xFF81 0xFF82 0xFF83 0xFF84)) +(assert_return (invoke "v128.load8x8_s_offset20_align8" (i32.const 4)) (v128.const i16x8 0xFF88 0xFF89 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000)) +(assert_return (invoke "v128.load8x8_u_offset0" (i32.const 0)) (v128.const i16x8 0x0000 0x0001 0x0002 0x0003 0x0004 0x0005 0x0006 0x0007)) +(assert_return (invoke "v128.load8x8_u_align1" (i32.const 1)) (v128.const i16x8 0x0001 0x0002 0x0003 0x0004 0x0005 0x0006 0x0007 0x0008)) +(assert_return (invoke "v128.load8x8_u_offset0_align1" (i32.const 2)) (v128.const i16x8 0x0002 0x0003 0x0004 0x0005 0x0006 0x0007 0x0008 0x0009)) +(assert_return (invoke "v128.load8x8_u_offset10_align4" (i32.const 3)) (v128.const i16x8 0x000D 0x000E 0x000F 0x0080 0x0081 0x0082 0x0083 0x0084)) +(assert_return (invoke "v128.load8x8_u_offset20_align8" (i32.const 4)) (v128.const i16x8 0x0088 0x0089 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000)) +;; i32x4 +(assert_return (invoke "v128.load16x4_s_offset0" (i32.const 0)) (v128.const i32x4 0x00000100 0x00000302 0x00000504 0x00000706)) +(assert_return (invoke "v128.load16x4_s_align1" (i32.const 1)) (v128.const i32x4 0x00000201 0x00000403 0x00000605 0x00000807)) +(assert_return (invoke "v128.load16x4_s_offset0_align1" (i32.const 2)) (v128.const i32x4 0x00000302 0x00000504 0x00000706 0x00000908)) +(assert_return (invoke "v128.load16x4_s_offset10_align4" (i32.const 3)) (v128.const i32x4 0x00000E0D 0xFFFF800F 0xFFFF8281 0xFFFF8483)) +(assert_return (invoke "v128.load16x4_s_offset20_align8" (i32.const 4)) (v128.const i32x4 0xFFFF8988 0x00000000 0x00000000 0x00000000)) +(assert_return (invoke "v128.load16x4_u_offset0" (i32.const 0)) (v128.const i32x4 0x00000100 0x00000302 0x00000504 0x00000706)) +(assert_return (invoke "v128.load16x4_u_align1" (i32.const 1)) (v128.const i32x4 0x00000201 0x00000403 0x00000605 0x00000807)) +(assert_return (invoke "v128.load16x4_u_offset0_align1" (i32.const 2)) (v128.const i32x4 0x00000302 0x00000504 0x00000706 0x00000908)) +(assert_return (invoke "v128.load16x4_u_offset10_align4" (i32.const 3)) (v128.const i32x4 0x00000E0D 0x0000800F 0x00008281 0x00008483)) +(assert_return (invoke "v128.load16x4_u_offset20_align8" (i32.const 4)) (v128.const i32x4 0x00008988 0x00000000 0x00000000 0x00000000)) +;; i64x2 +(assert_return (invoke "v128.load32x2_s_offset0" (i32.const 0)) (v128.const i64x2 0x0000000003020100 0x0000000007060504)) +(assert_return (invoke "v128.load32x2_s_align1" (i32.const 1)) (v128.const i64x2 0x0000000004030201 0x0000000008070605)) +(assert_return (invoke "v128.load32x2_s_offset0_align1" (i32.const 2)) (v128.const i64x2 0x0000000005040302 0x0000000009080706)) +(assert_return (invoke "v128.load32x2_s_offset10_align4" (i32.const 3)) (v128.const i64x2 0xFFFFFFFF800F0E0D 0xFFFFFFFF84838281)) +(assert_return (invoke "v128.load32x2_s_offset20_align8" (i32.const 4)) (v128.const i64x2 0x0000000000008988 0x0000000000000000)) +(assert_return (invoke "v128.load32x2_u_offset0" (i32.const 0)) (v128.const i64x2 0x0000000003020100 0x0000000007060504)) +(assert_return (invoke "v128.load32x2_u_align1" (i32.const 1)) (v128.const i64x2 0x0000000004030201 0x0000000008070605)) +(assert_return (invoke "v128.load32x2_u_offset0_align1" (i32.const 2)) (v128.const i64x2 0x0000000005040302 0x0000000009080706)) +(assert_return (invoke "v128.load32x2_u_offset10_align4" (i32.const 3)) (v128.const i64x2 0x00000000800F0E0D 0x0000000084838281)) +(assert_return (invoke "v128.load32x2_u_offset20_align8" (i32.const 4)) (v128.const i64x2 0x0000000000008988 0x0000000000000000)) + +;; out of bounds memory access +(assert_trap (invoke "v128.load8x8_s" (i32.const -1)) "out of bounds memory access") +(assert_trap (invoke "v128.load8x8_u" (i32.const -1)) "out of bounds memory access") +(assert_trap (invoke "v128.load16x4_s" (i32.const 65536)) "out of bounds memory access") +(assert_trap (invoke "v128.load16x4_u" (i32.const 65536)) "out of bounds memory access") +(assert_trap (invoke "v128.load32x2_s" (i32.const 65529)) "out of bounds memory access") +(assert_trap (invoke "v128.load32x2_u" (i32.const 65529)) "out of bounds memory access") + +(assert_trap (invoke "v128.load8x8_s_offset1_align1" (i32.const -1)) "out of bounds memory access") +(assert_trap (invoke "v128.load8x8_u_offset1_align1" (i32.const -1)) "out of bounds memory access") +(assert_trap (invoke "v128.load16x4_s_offset1_align1" (i32.const -1)) "out of bounds memory access") +(assert_trap (invoke "v128.load16x4_u_offset1_align1" (i32.const -1)) "out of bounds memory access") +(assert_trap (invoke "v128.load32x2_s_offset1_align1" (i32.const -1)) "out of bounds memory access") +(assert_trap (invoke "v128.load32x2_u_offset1_align1" (i32.const -1)) "out of bounds memory access") + +;; type check +(assert_invalid (module (memory 0) (func (result v128) (v128.load8x8_s (f32.const 0)))) "type mismatch") +(assert_invalid (module (memory 0) (func (result v128) (v128.load8x8_u (f32.const 0)))) "type mismatch") +(assert_invalid (module (memory 0) (func (result v128) (v128.load16x4_s (f64.const 0)))) "type mismatch") +(assert_invalid (module (memory 0) (func (result v128) (v128.load16x4_u (f64.const 0)))) "type mismatch") +(assert_invalid (module (memory 0) (func (result v128) (v128.load32x2_s (v128.const i32x4 0 0 0 0)))) "type mismatch") +(assert_invalid (module (memory 0) (func (result v128) (v128.load32x2_u (v128.const i32x4 0 0 0 0)))) "type mismatch") + +;; Test operation with empty argument + +(assert_invalid + (module (memory 0) + (func $v128.load8x8_s-arg-empty (result v128) + (v128.load8x8_s) + ) + ) + "type mismatch" +) +(assert_invalid + (module (memory 0) + (func $v128.load8x8_u-arg-empty (result v128) + (v128.load8x8_u) + ) + ) + "type mismatch" +) +(assert_invalid + (module (memory 0) + (func $v128.load16x4_s-arg-empty (result v128) + (v128.load16x4_s) + ) + ) + "type mismatch" +) +(assert_invalid + (module (memory 0) + (func $v128.load16x4_u-arg-empty (result v128) + (v128.load16x4_u) + ) + ) + "type mismatch" +) +(assert_invalid + (module (memory 0) + (func $v128.load32x2_s-arg-empty (result v128) + (v128.load32x2_s) + ) + ) + "type mismatch" +) +(assert_invalid + (module (memory 0) + (func $v128.load32x2_u-arg-empty (result v128) + (v128.load32x2_u) + ) + ) + "type mismatch" +) + +;; Unknown operator + +(assert_malformed (module quote "(memory 1) (func (drop (i16x8.load16x4_s (i32.const 0))))") "unknown operator") +(assert_malformed (module quote "(memory 1) (func (drop (i16x8.load16x4_u (i32.const 0))))") "unknown operator") +(assert_malformed (module quote "(memory 1) (func (drop (i32x4.load32x2_s (i32.const 0))))") "unknown operator") +(assert_malformed (module quote "(memory 1) (func (drop (i32x4.load32x2_u (i32.const 0))))") "unknown operator") +(assert_malformed (module quote "(memory 1) (func (drop (i64x2.load64x1_s (i32.const 0))))") "unknown operator") +(assert_malformed (module quote "(memory 1) (func (drop (i64x2.load64x1_u (i32.const 0))))") "unknown operator") + +;; combination +(module + (memory 1) + (data (i32.const 0) "\00\01\02\03\04\05\06\07\08\09\0A\0B\0C\0D\0E\0F\80\81\82\83\84\85\86\87\88\89") + (func (export "v128.load8x8_s-in-block") (result v128) + (block (result v128) (block (result v128) (v128.load8x8_s (i32.const 0)))) + ) + (func (export "v128.load8x8_u-in-block") (result v128) + (block (result v128) (block (result v128) (v128.load8x8_u (i32.const 1)))) + ) + (func (export "v128.load16x4_s-in-block") (result v128) + (block (result v128) (block (result v128) (v128.load16x4_s (i32.const 2)))) + ) + (func (export "v128.load16x4_u-in-block") (result v128) + (block (result v128) (block (result v128) (v128.load16x4_u (i32.const 3)))) + ) + (func (export "v128.load32x2_s-in-block") (result v128) + (block (result v128) (block (result v128) (v128.load32x2_s (i32.const 4)))) + ) + (func (export "v128.load32x2_u-in-block") (result v128) + (block (result v128) (block (result v128) (v128.load32x2_u (i32.const 5)))) + ) + (func (export "v128.load8x8_s-as-br-value") (result v128) + (block (result v128) (br 0 (v128.load8x8_s (i32.const 6)))) + ) + (func (export "v128.load8x8_u-as-br-value") (result v128) + (block (result v128) (br 0 (v128.load8x8_u (i32.const 7)))) + ) + (func (export "v128.load16x4_s-as-br-value") (result v128) + (block (result v128) (br 0 (v128.load16x4_s (i32.const 8)))) + ) + (func (export "v128.load16x4_u-as-br-value") (result v128) + (block (result v128) (br 0 (v128.load16x4_u (i32.const 9)))) + ) + (func (export "v128.load32x2_s-as-br-value") (result v128) + (block (result v128) (br 0 (v128.load32x2_s (i32.const 10)))) + ) + (func (export "v128.load32x2_u-as-br-value") (result v128) + (block (result v128) (br 0 (v128.load32x2_u (i32.const 11)))) + ) + (func (export "v128.load8x8_s-extract_lane_s-operand") (result i32) + (i8x16.extract_lane_s 0 (v128.load8x8_s (i32.const 12))) + ) + (func (export "v128.load8x8_u-extract_lane_s-operand") (result i32) + (i8x16.extract_lane_s 0 (v128.load8x8_u (i32.const 13))) + ) + (func (export "v128.load16x4_s-extract_lane_s-operand") (result i32) + (i8x16.extract_lane_s 0 (v128.load16x4_s (i32.const 14))) + ) + (func (export "v128.load16x4_u-extract_lane_s-operand") (result i32) + (i8x16.extract_lane_s 0 (v128.load16x4_u (i32.const 15))) + ) + (func (export "v128.load32x2_s-extract_lane_s-operand") (result i32) + (i8x16.extract_lane_s 0 (v128.load32x2_s (i32.const 16))) + ) + (func (export "v128.load32x2_u-extract_lane_s-operand") (result i32) + (i8x16.extract_lane_s 0 (v128.load32x2_u (i32.const 17))) + ) +) +(assert_return (invoke "v128.load8x8_s-in-block") (v128.const i16x8 0x0000 0x0001 0x0002 0x0003 0x0004 0x0005 0x0006 0x0007)) +(assert_return (invoke "v128.load8x8_u-in-block") (v128.const i16x8 0x0001 0x0002 0x0003 0x0004 0x0005 0x0006 0x0007 0x0008)) +(assert_return (invoke "v128.load16x4_s-in-block") (v128.const i32x4 0x00000302 0x00000504 0x00000706 0x00000908)) +(assert_return (invoke "v128.load16x4_u-in-block") (v128.const i32x4 0x00000403 0x00000605 0x00000807 0x00000A09)) +(assert_return (invoke "v128.load32x2_s-in-block") (v128.const i64x2 0x0000000007060504 0x000000000B0A0908)) +(assert_return (invoke "v128.load32x2_u-in-block") (v128.const i64x2 0x0000000008070605 0x000000000C0B0A09)) +(assert_return (invoke "v128.load8x8_s-as-br-value") (v128.const i16x8 0x0006 0x0007 0x0008 0x0009 0x000A 0x000B 0x000C 0x000D)) +(assert_return (invoke "v128.load8x8_u-as-br-value") (v128.const i16x8 0x0007 0x0008 0x0009 0x000A 0x000B 0x000C 0x000D 0x000E)) +(assert_return (invoke "v128.load16x4_s-as-br-value") (v128.const i32x4 0x00000908 0x00000B0A 0x00000D0C 0x00000F0E)) +(assert_return (invoke "v128.load16x4_u-as-br-value") (v128.const i32x4 0x00000A09 0x00000C0B 0x00000E0D 0x0000800F)) +(assert_return (invoke "v128.load32x2_s-as-br-value") (v128.const i64x2 0x000000000D0C0B0A 0xFFFFFFFF81800F0E)) +(assert_return (invoke "v128.load32x2_u-as-br-value") (v128.const i64x2 0x000000000E0D0C0B 0x000000008281800F)) +(assert_return (invoke "v128.load8x8_s-extract_lane_s-operand") (i32.const 12)) +(assert_return (invoke "v128.load8x8_u-extract_lane_s-operand") (i32.const 13)) +(assert_return (invoke "v128.load16x4_s-extract_lane_s-operand") (i32.const 14)) +(assert_return (invoke "v128.load16x4_u-extract_lane_s-operand") (i32.const 15)) +(assert_return (invoke "v128.load32x2_s-extract_lane_s-operand") (i32.const -128)) +(assert_return (invoke "v128.load32x2_u-extract_lane_s-operand") (i32.const -127)) diff --git a/runtime/near-vm/tests/wast/spec/proposals/simd/simd_load_splat.wast b/runtime/near-vm/tests/wast/spec/proposals/simd/simd_load_splat.wast new file mode 100644 index 00000000000..d9642f8bd67 --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/proposals/simd/simd_load_splat.wast @@ -0,0 +1,261 @@ +;; Tests for the load_splat instructions + +(module + (memory 1) + (data (i32.const 0) "\00\01\02\03\04\05\06\07\08\09\0A\0B\0C\0D\0E\0F") + (data (i32.const 65520) "\10\11\12\13\14\15\16\17\18\19\1A\1B\1C\1D\1E\1F") + + (func (export "v128.load8_splat") (param $address i32) (result v128) (v128.load8_splat (local.get $address))) + (func (export "v128.load16_splat") (param $address i32) (result v128) (v128.load16_splat (local.get $address))) + (func (export "v128.load32_splat") (param $address i32) (result v128) (v128.load32_splat (local.get $address))) + (func (export "v128.load64_splat") (param $address i32) (result v128) (v128.load64_splat (local.get $address))) + + ;; Load data with different offset/align arguments + (func (export "v8x16.offset0") (param $address i32) (result v128) (v128.load8_splat offset=0 (local.get $address))) + (func (export "v8x16.align1") (param $address i32) (result v128) (v128.load8_splat align=1 (local.get $address))) + (func (export "v8x16.offset1_align1") (param $address i32) (result v128) (v128.load8_splat offset=1 align=1 (local.get $address))) + (func (export "v8x16.offset2_align1") (param $address i32) (result v128) (v128.load8_splat offset=2 align=1 (local.get $address))) + (func (export "v8x16.offset15_align1") (param $address i32) (result v128) (v128.load8_splat offset=15 align=1 (local.get $address))) + + (func (export "v16x8.offset0") (param $address i32) (result v128) (v128.load16_splat offset=0 (local.get $address))) + (func (export "v16x8.align1") (param $address i32) (result v128) (v128.load16_splat align=1 (local.get $address))) + (func (export "v16x8.offset1_align1") (param $address i32) (result v128) (v128.load16_splat offset=1 align=1 (local.get $address))) + (func (export "v16x8.offset2_align1") (param $address i32) (result v128) (v128.load16_splat offset=2 align=1 (local.get $address))) + (func (export "v16x8.offset15_align2") (param $address i32) (result v128) (v128.load16_splat offset=15 align=2 (local.get $address))) + + (func (export "v32x4.offset0") (param $address i32) (result v128) (v128.load32_splat offset=0 (local.get $address))) + (func (export "v32x4.align1") (param $address i32) (result v128) (v128.load32_splat align=1 (local.get $address))) + (func (export "v32x4.offset1_align1") (param $address i32) (result v128) (v128.load32_splat offset=1 align=1 (local.get $address))) + (func (export "v32x4.offset2_align2") (param $address i32) (result v128) (v128.load32_splat offset=2 align=2 (local.get $address))) + (func (export "v32x4.offset15_align4") (param $address i32) (result v128) (v128.load32_splat offset=15 align=4 (local.get $address))) + + (func (export "v64x2.offset0") (param $address i32) (result v128) (v128.load64_splat offset=0 (local.get $address))) + (func (export "v64x2.align1") (param $address i32) (result v128) (v128.load64_splat align=1 (local.get $address))) + (func (export "v64x2.offset1_align2") (param $address i32) (result v128) (v128.load64_splat offset=1 align=2 (local.get $address))) + (func (export "v64x2.offset2_align4") (param $address i32) (result v128) (v128.load64_splat offset=2 align=4 (local.get $address))) + (func (export "v64x2.offset15_align8") (param $address i32) (result v128) (v128.load64_splat offset=15 align=8 (local.get $address))) + + (func (export "v8x16.offset65536") (param $address i32) (result v128) (v128.load8_splat offset=65536 (local.get $address))) + (func (export "v16x8.offset65535") (param $address i32) (result v128) (v128.load16_splat offset=65535 (local.get $address))) + (func (export "v32x4.offset65533") (param $address i32) (result v128) (v128.load32_splat offset=65533 (local.get $address))) + (func (export "v64x2.offset65529") (param $address i32) (result v128) (v128.load64_splat offset=65529 (local.get $address))) +) +(assert_return (invoke "v128.load8_splat" (i32.const 0)) (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "v128.load8_splat" (i32.const 1)) (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) +(assert_return (invoke "v128.load8_splat" (i32.const 2)) (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2)) +(assert_return (invoke "v128.load8_splat" (i32.const 3)) (v128.const i8x16 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3)) +(assert_return (invoke "v128.load8_splat" (i32.const 65535)) (v128.const i8x16 31 31 31 31 31 31 31 31 31 31 31 31 31 31 31 31)) +(assert_return (invoke "v128.load16_splat" (i32.const 4)) (v128.const i16x8 0x0504 0x0504 0x0504 0x0504 0x0504 0x0504 0x0504 0x0504)) +(assert_return (invoke "v128.load16_splat" (i32.const 5)) (v128.const i16x8 0x0605 0x0605 0x0605 0x0605 0x0605 0x0605 0x0605 0x0605)) +(assert_return (invoke "v128.load16_splat" (i32.const 6)) (v128.const i16x8 0x0706 0x0706 0x0706 0x0706 0x0706 0x0706 0x0706 0x0706)) +(assert_return (invoke "v128.load16_splat" (i32.const 7)) (v128.const i16x8 0x0807 0x0807 0x0807 0x0807 0x0807 0x0807 0x0807 0x0807)) +(assert_return (invoke "v128.load16_splat" (i32.const 65534)) (v128.const i16x8 0x1F1E 0x1F1E 0x1F1E 0x1F1E 0x1F1E 0x1F1E 0x1F1E 0x1F1E)) +(assert_return (invoke "v128.load32_splat" (i32.const 8)) (v128.const i32x4 0x0B0A0908 0x0B0A0908 0x0B0A0908 0x0B0A0908)) +(assert_return (invoke "v128.load32_splat" (i32.const 9)) (v128.const i32x4 0x0C0B0A09 0x0C0B0A09 0x0C0B0A09 0x0C0B0A09)) +(assert_return (invoke "v128.load32_splat" (i32.const 10)) (v128.const i32x4 0x0D0C0B0A 0x0D0C0B0A 0x0D0C0B0A 0x0D0C0B0A)) +(assert_return (invoke "v128.load32_splat" (i32.const 11)) (v128.const i32x4 0x0E0D0C0B 0x0E0D0C0B 0x0E0D0C0B 0x0E0D0C0B)) +(assert_return (invoke "v128.load32_splat" (i32.const 65532)) (v128.const i32x4 0x1F1E1D1C 0x1F1E1D1C 0x1F1E1D1C 0x1F1E1D1C)) +(assert_return (invoke "v128.load64_splat" (i32.const 12)) (v128.const i64x2 0x000000000F0E0D0C 0x000000000F0E0D0C)) +(assert_return (invoke "v128.load64_splat" (i32.const 13)) (v128.const i64x2 0x00000000000F0E0D 0x00000000000F0E0D)) +(assert_return (invoke "v128.load64_splat" (i32.const 14)) (v128.const i64x2 0x0000000000000F0E 0x0000000000000F0E)) +(assert_return (invoke "v128.load64_splat" (i32.const 15)) (v128.const i64x2 0x000000000000000F 0x000000000000000F)) +(assert_return (invoke "v128.load64_splat" (i32.const 65528)) (v128.const i64x2 0x1F1E1D1C1B1A1918 0x1F1E1D1C1B1A1918)) + +;; v8x16 +(assert_return (invoke "v8x16.offset0" (i32.const 0)) (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "v8x16.align1" (i32.const 0)) (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "v8x16.offset1_align1" (i32.const 0)) (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) +(assert_return (invoke "v8x16.offset2_align1" (i32.const 0)) (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2)) +(assert_return (invoke "v8x16.offset15_align1" (i32.const 0)) (v128.const i8x16 15 15 15 15 15 15 15 15 15 15 15 15 15 15 15 15)) +(assert_return (invoke "v8x16.offset0" (i32.const 1)) (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) +(assert_return (invoke "v8x16.align1" (i32.const 1)) (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) +(assert_return (invoke "v8x16.offset1_align1" (i32.const 1)) (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2)) +(assert_return (invoke "v8x16.offset2_align1" (i32.const 1)) (v128.const i8x16 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3)) +(assert_return (invoke "v8x16.offset15_align1" (i32.const 1)) (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "v8x16.offset0" (i32.const 65535)) (v128.const i8x16 31 31 31 31 31 31 31 31 31 31 31 31 31 31 31 31)) +(assert_return (invoke "v8x16.align1" (i32.const 65535)) (v128.const i8x16 31 31 31 31 31 31 31 31 31 31 31 31 31 31 31 31)) +;; v16x8 +(assert_return (invoke "v16x8.offset0" (i32.const 0)) (v128.const i16x8 0x0100 0x0100 0x0100 0x0100 0x0100 0x0100 0x0100 0x0100)) +(assert_return (invoke "v16x8.align1" (i32.const 0)) (v128.const i16x8 0x0100 0x0100 0x0100 0x0100 0x0100 0x0100 0x0100 0x0100)) +(assert_return (invoke "v16x8.offset1_align1" (i32.const 0)) (v128.const i16x8 0x0201 0x0201 0x0201 0x0201 0x0201 0x0201 0x0201 0x0201)) +(assert_return (invoke "v16x8.offset2_align1" (i32.const 0)) (v128.const i16x8 0x0302 0x0302 0x0302 0x0302 0x0302 0x0302 0x0302 0x0302)) +(assert_return (invoke "v16x8.offset15_align2" (i32.const 0)) (v128.const i16x8 0x000F 0x000F 0x000F 0x000F 0x000F 0x000F 0x000F 0x000F)) +(assert_return (invoke "v16x8.offset0" (i32.const 1)) (v128.const i16x8 0x0201 0x0201 0x0201 0x0201 0x0201 0x0201 0x0201 0x0201)) +(assert_return (invoke "v16x8.align1" (i32.const 1)) (v128.const i16x8 0x0201 0x0201 0x0201 0x0201 0x0201 0x0201 0x0201 0x0201)) +(assert_return (invoke "v16x8.offset1_align1" (i32.const 1)) (v128.const i16x8 0x0302 0x0302 0x0302 0x0302 0x0302 0x0302 0x0302 0x0302)) +(assert_return (invoke "v16x8.offset2_align1" (i32.const 1)) (v128.const i16x8 0x0403 0x0403 0x0403 0x0403 0x0403 0x0403 0x0403 0x0403)) +(assert_return (invoke "v16x8.offset15_align2" (i32.const 1)) (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000)) +(assert_return (invoke "v16x8.offset0" (i32.const 65534)) (v128.const i16x8 0x1F1E 0x1F1E 0x1F1E 0x1F1E 0x1F1E 0x1F1E 0x1F1E 0x1F1E)) +(assert_return (invoke "v16x8.align1" (i32.const 65534)) (v128.const i16x8 0x1F1E 0x1F1E 0x1F1E 0x1F1E 0x1F1E 0x1F1E 0x1F1E 0x1F1E)) +;; v32x4 +(assert_return (invoke "v32x4.offset0" (i32.const 0)) (v128.const i32x4 0x03020100 0x03020100 0x03020100 0x03020100)) +(assert_return (invoke "v32x4.align1" (i32.const 0)) (v128.const i32x4 0x03020100 0x03020100 0x03020100 0x03020100)) +(assert_return (invoke "v32x4.offset1_align1" (i32.const 0)) (v128.const i32x4 0x04030201 0x04030201 0x04030201 0x04030201)) +(assert_return (invoke "v32x4.offset2_align2" (i32.const 0)) (v128.const i32x4 0x05040302 0x05040302 0x05040302 0x05040302)) +(assert_return (invoke "v32x4.offset15_align4" (i32.const 0)) (v128.const i32x4 0x0000000F 0x0000000F 0x0000000F 0x0000000F)) +(assert_return (invoke "v32x4.offset0" (i32.const 1)) (v128.const i32x4 0x04030201 0x04030201 0x04030201 0x04030201)) +(assert_return (invoke "v32x4.align1" (i32.const 1)) (v128.const i32x4 0x04030201 0x04030201 0x04030201 0x04030201)) +(assert_return (invoke "v32x4.offset1_align1" (i32.const 1)) (v128.const i32x4 0x05040302 0x05040302 0x05040302 0x05040302)) +(assert_return (invoke "v32x4.offset2_align2" (i32.const 1)) (v128.const i32x4 0x06050403 0x06050403 0x06050403 0x06050403)) +(assert_return (invoke "v32x4.offset15_align4" (i32.const 1)) (v128.const i32x4 0x00000000 0x00000000 0x00000000 0x00000000)) +(assert_return (invoke "v32x4.offset0" (i32.const 65532)) (v128.const i32x4 0x1F1E1D1C 0x1F1E1D1C 0x1F1E1D1C 0x1F1E1D1C)) +(assert_return (invoke "v32x4.align1" (i32.const 65532)) (v128.const i32x4 0x1F1E1D1C 0x1F1E1D1C 0x1F1E1D1C 0x1F1E1D1C)) +;; v64x2 +(assert_return (invoke "v64x2.offset0" (i32.const 0)) (v128.const i64x2 0x0706050403020100 0x0706050403020100)) +(assert_return (invoke "v64x2.align1" (i32.const 0)) (v128.const i64x2 0x0706050403020100 0x0706050403020100)) +(assert_return (invoke "v64x2.offset1_align2" (i32.const 0)) (v128.const i64x2 0x0807060504030201 0x0807060504030201)) +(assert_return (invoke "v64x2.offset2_align4" (i32.const 0)) (v128.const i64x2 0x0908070605040302 0x0908070605040302)) +(assert_return (invoke "v64x2.offset15_align8" (i32.const 0)) (v128.const i64x2 0x000000000000000F 0x000000000000000F)) +(assert_return (invoke "v64x2.offset0" (i32.const 1)) (v128.const i64x2 0x0807060504030201 0x0807060504030201)) +(assert_return (invoke "v64x2.align1" (i32.const 1)) (v128.const i64x2 0x0807060504030201 0x0807060504030201)) +(assert_return (invoke "v64x2.offset1_align2" (i32.const 1)) (v128.const i64x2 0x0908070605040302 0x0908070605040302)) +(assert_return (invoke "v64x2.offset2_align4" (i32.const 1)) (v128.const i64x2 0x0A09080706050403 0x0A09080706050403)) +(assert_return (invoke "v64x2.offset15_align8" (i32.const 1)) (v128.const i64x2 0x0000000000000000 0x0000000000000000)) +(assert_return (invoke "v64x2.offset0" (i32.const 65528)) (v128.const i64x2 0x1F1E1D1C1B1A1918 0x1F1E1D1C1B1A1918)) +(assert_return (invoke "v64x2.align1" (i32.const 65528)) (v128.const i64x2 0x1F1E1D1C1B1A1918 0x1F1E1D1C1B1A1918)) + + +;; Out of bounds memory access +(assert_trap (invoke "v128.load8_splat" (i32.const -1)) "out of bounds memory access") +(assert_trap (invoke "v128.load16_splat" (i32.const -1)) "out of bounds memory access") +(assert_trap (invoke "v128.load32_splat" (i32.const -1)) "out of bounds memory access") +(assert_trap (invoke "v128.load64_splat" (i32.const -1)) "out of bounds memory access") +(assert_trap (invoke "v128.load8_splat" (i32.const 65536)) "out of bounds memory access") +(assert_trap (invoke "v128.load16_splat" (i32.const 65535)) "out of bounds memory access") +(assert_trap (invoke "v128.load32_splat" (i32.const 65533)) "out of bounds memory access") +(assert_trap (invoke "v128.load64_splat" (i32.const 65529)) "out of bounds memory access") + +(assert_trap (invoke "v8x16.offset1_align1" (i32.const 65535)) "out of bounds memory access") +(assert_trap (invoke "v8x16.offset2_align1" (i32.const 65535)) "out of bounds memory access") +(assert_trap (invoke "v8x16.offset15_align1" (i32.const 65535)) "out of bounds memory access") +(assert_trap (invoke "v16x8.offset1_align1" (i32.const 65534)) "out of bounds memory access") +(assert_trap (invoke "v16x8.offset2_align1" (i32.const 65534)) "out of bounds memory access") +(assert_trap (invoke "v16x8.offset15_align2" (i32.const 65534)) "out of bounds memory access") +(assert_trap (invoke "v32x4.offset1_align1" (i32.const 65532)) "out of bounds memory access") +(assert_trap (invoke "v32x4.offset2_align2" (i32.const 65532)) "out of bounds memory access") +(assert_trap (invoke "v32x4.offset15_align4" (i32.const 65532)) "out of bounds memory access") +(assert_trap (invoke "v64x2.offset1_align2" (i32.const 65528)) "out of bounds memory access") +(assert_trap (invoke "v64x2.offset2_align4" (i32.const 65528)) "out of bounds memory access") +(assert_trap (invoke "v64x2.offset15_align8" (i32.const 65528)) "out of bounds memory access") + +(assert_trap (invoke "v8x16.offset1_align1" (i32.const -1)) "out of bounds memory access") +(assert_trap (invoke "v16x8.offset1_align1" (i32.const -1)) "out of bounds memory access") +(assert_trap (invoke "v32x4.offset1_align1" (i32.const -1)) "out of bounds memory access") +(assert_trap (invoke "v64x2.offset1_align2" (i32.const -1)) "out of bounds memory access") + +(assert_trap (invoke "v8x16.offset65536" (i32.const 0)) "out of bounds memory access") +(assert_trap (invoke "v16x8.offset65535" (i32.const 0)) "out of bounds memory access") +(assert_trap (invoke "v32x4.offset65533" (i32.const 0)) "out of bounds memory access") +(assert_trap (invoke "v64x2.offset65529" (i32.const 0)) "out of bounds memory access") +(assert_trap (invoke "v8x16.offset65536" (i32.const 1)) "out of bounds memory access") +(assert_trap (invoke "v16x8.offset65535" (i32.const 1)) "out of bounds memory access") +(assert_trap (invoke "v32x4.offset65533" (i32.const 1)) "out of bounds memory access") +(assert_trap (invoke "v64x2.offset65529" (i32.const 1)) "out of bounds memory access") + + +;; Combination + +(module (memory 1) + (data (i32.const 0) "\00\01\02\03\04\05\06\07\08\09\0A") + + (func (export "v128.load8_splat-in-block") (result v128) + (block (result v128) (block (result v128) (v128.load8_splat (i32.const 0)))) + ) + (func (export "v128.load16_splat-in-block") (result v128) + (block (result v128) (block (result v128) (v128.load16_splat (i32.const 1)))) + ) + (func (export "v128.load32_splat-in-block") (result v128) + (block (result v128) (block (result v128) (v128.load32_splat (i32.const 2)))) + ) + (func (export "v128.load64_splat-in-block") (result v128) + (block (result v128) (block (result v128) (v128.load64_splat (i32.const 9)))) + ) + (func (export "v128.load8_splat-as-br-value") (result v128) + (block (result v128) (br 0 (v128.load8_splat (i32.const 3)))) + ) + (func (export "v128.load16_splat-as-br-value") (result v128) + (block (result v128) (br 0 (v128.load16_splat (i32.const 4)))) + ) + (func (export "v128.load32_splat-as-br-value") (result v128) + (block (result v128) (br 0 (v128.load32_splat (i32.const 5)))) + ) + (func (export "v128.load64_splat-as-br-value") (result v128) + (block (result v128) (br 0 (v128.load64_splat (i32.const 10)))) + ) + (func (export "v128.load8_splat-extract_lane_s-operand") (result i32) + (i8x16.extract_lane_s 0 (v128.load8_splat (i32.const 6))) + ) + (func (export "v128.load16_splat-extract_lane_s-operand") (result i32) + (i8x16.extract_lane_s 0 (v128.load16_splat (i32.const 7))) + ) + (func (export "v128.load32_splat-extract_lane_s-operand") (result i32) + (i8x16.extract_lane_s 0 (v128.load32_splat (i32.const 8))) + ) + (func (export "v128.load64_splat-extract_lane_s-operand") (result i32) + (i8x16.extract_lane_s 0 (v128.load64_splat (i32.const 11))) + ) +) +(assert_return (invoke "v128.load8_splat-in-block") (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "v128.load16_splat-in-block") (v128.const i16x8 0x0201 0x0201 0x0201 0x0201 0x0201 0x0201 0x0201 0x0201)) +(assert_return (invoke "v128.load32_splat-in-block") (v128.const i32x4 0x05040302 0x05040302 0x05040302 0x05040302)) +(assert_return (invoke "v128.load64_splat-in-block") (v128.const i64x2 0x0000000000000A09 0x0000000000000A09)) +(assert_return (invoke "v128.load8_splat-as-br-value") (v128.const i8x16 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3)) +(assert_return (invoke "v128.load16_splat-as-br-value") (v128.const i16x8 0x0504 0x0504 0x0504 0x0504 0x0504 0x0504 0x0504 0x0504)) +(assert_return (invoke "v128.load32_splat-as-br-value") (v128.const i32x4 0x08070605 0x08070605 0x08070605 0x08070605)) +(assert_return (invoke "v128.load64_splat-as-br-value") (v128.const i64x2 0x000000000000000A 0x000000000000000A)) +(assert_return (invoke "v128.load8_splat-extract_lane_s-operand") (i32.const 6)) +(assert_return (invoke "v128.load16_splat-extract_lane_s-operand") (i32.const 7)) +(assert_return (invoke "v128.load32_splat-extract_lane_s-operand") (i32.const 8)) +(assert_return (invoke "v128.load64_splat-extract_lane_s-operand") (i32.const 0)) + + +;; Type check + +(assert_invalid (module (memory 0) (func (result v128) (v128.load8_splat (v128.const i32x4 0 0 0 0)))) "type mismatch") +(assert_invalid (module (memory 0) (func (result v128) (v128.load16_splat (v128.const i32x4 0 0 0 0)))) "type mismatch") +(assert_invalid (module (memory 0) (func (result v128) (v128.load32_splat (v128.const i32x4 0 0 0 0)))) "type mismatch") +(assert_invalid (module (memory 0) (func (result v128) (v128.load64_splat (v128.const i32x4 0 0 0 0)))) "type mismatch") + + +;; Unknown operator + +(assert_malformed (module quote "(memory 1) (func (drop (i8x16.load_splat (i32.const 0))))") "unknown operator") +(assert_malformed (module quote "(memory 1) (func (drop (i16x8.load_splat (i32.const 0))))") "unknown operator") +(assert_malformed (module quote "(memory 1) (func (drop (i32x4.load_splat (i32.const 0))))") "unknown operator") +(assert_malformed (module quote "(memory 1) (func (drop (i64x2.load_splat (i32.const 0))))") "unknown operator") + + +;; Test operation with empty argument + +(assert_invalid + (module (memory 0) + (func $v128.load8_splat-arg-empty (result v128) + (v128.load8_splat) + ) + ) + "type mismatch" +) +(assert_invalid + (module (memory 0) + (func $v128.load16_splat-arg-empty (result v128) + (v128.load16_splat) + ) + ) + "type mismatch" +) +(assert_invalid + (module (memory 0) + (func $v128.load32_splat-arg-empty (result v128) + (v128.load32_splat) + ) + ) + "type mismatch" +) +(assert_invalid + (module (memory 0) + (func $v128.load64_splat-arg-empty (result v128) + (v128.load64_splat) + ) + ) + "type mismatch" +) diff --git a/runtime/near-vm/tests/wast/spec/proposals/simd/simd_load_zero.wast b/runtime/near-vm/tests/wast/spec/proposals/simd/simd_load_zero.wast new file mode 100644 index 00000000000..6276a68637d --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/proposals/simd/simd_load_zero.wast @@ -0,0 +1,154 @@ +;; Load and Zero extend test cases + +(module + (memory 1) + (data (i32.const 0) "\00\01\02\03\04\05\06\07\08\09\0A\0B\0C\0D\0E\0F\80\81\82\83\84\85\86\87\88\89") + (data (i32.const 65520) "\0A\0B\0C\0D\0E\0F\80\81\82\83\84\85\86\87\88\89") + + (func (export "v128.load32_zero") (param $0 i32) (result v128) + (v128.load32_zero (local.get $0)) + ) + (func (export "v128.load64_zero") (param $0 i32) (result v128) + (v128.load64_zero (local.get $0)) + ) + + ;; load by a constant amount + (func (export "v128.load32_zero_const0") (result v128) + (v128.load32_zero (i32.const 0)) + ) + (func (export "v128.load64_zero_const8") (result v128) + (v128.load64_zero (i32.const 8)) + ) + + ;; load data with different offset/align arguments + ;; i16x8 + (func (export "v128.load32_zero_offset0") (param $0 i32) (result v128) + (v128.load32_zero offset=0 (local.get $0)) + ) + (func (export "v128.load32_zero_align1") (param $0 i32) (result v128) + (v128.load32_zero align=1 (local.get $0)) + ) + (func (export "v128.load32_zero_offset0_align1") (param $0 i32) (result v128) + (v128.load32_zero offset=0 align=1 (local.get $0)) + ) + (func (export "v128.load32_zero_offset1_align1") (param $0 i32) (result v128) + (v128.load32_zero offset=1 align=1 (local.get $0)) + ) + (func (export "v128.load32_zero_offset10_align4") (param $0 i32) (result v128) + (v128.load32_zero offset=10 align=4 (local.get $0)) + ) + (func (export "v128.load64_zero_offset0") (param $0 i32) (result v128) + (v128.load64_zero offset=0 (local.get $0)) + ) + (func (export "v128.load64_zero_align1") (param $0 i32) (result v128) + (v128.load64_zero align=1 (local.get $0)) + ) + (func (export "v128.load64_zero_offset0_align1") (param $0 i32) (result v128) + (v128.load64_zero offset=0 align=1 (local.get $0)) + ) + (func (export "v128.load64_zero_offset1_align1") (param $0 i32) (result v128) + (v128.load64_zero offset=1 align=1 (local.get $0)) + ) + (func (export "v128.load64_zero_offset10_align4") (param $0 i32) (result v128) + (v128.load64_zero offset=10 align=4 (local.get $0)) + ) + (func (export "v128.load64_zero_offset20_align8") (param $0 i32) (result v128) + (v128.load64_zero offset=20 align=8 (local.get $0)) + ) +) + + +;; normal +(assert_return (invoke "v128.load32_zero" (i32.const 0)) (v128.const i32x4 0x03020100 0x00000000 0x00000000 0x00000000)) +(assert_return (invoke "v128.load64_zero" (i32.const 0)) (v128.const i64x2 0x0706050403020100 0x0000000000000000)) +(assert_return (invoke "v128.load32_zero" (i32.const 10)) (v128.const i32x4 0x0D0C0B0A 0x00000000 0x00000000 0x00000000)) +(assert_return (invoke "v128.load64_zero" (i32.const 10)) (v128.const i64x2 0x81800F0E0D0C0B0A 0x0000000000000000)) +(assert_return (invoke "v128.load32_zero" (i32.const 20)) (v128.const i32x4 0x87868584 0x00000000 0x00000000 0x00000000)) +(assert_return (invoke "v128.load64_zero" (i32.const 20)) (v128.const i64x2 0x0000898887868584 0x0000000000000000)) + +;; load by a constant amount +(assert_return (invoke "v128.load32_zero_const0") (v128.const i32x4 0x03020100 0x00000000 0x00000000 0x00000000)) +(assert_return (invoke "v128.load64_zero_const8") (v128.const i64x2 0x0F0E0D0C0B0A0908 0x0000000000000000)) + +;; load data with different offset/align arguments +;; load32_zero +(assert_return (invoke "v128.load32_zero_offset0" (i32.const 0)) (v128.const i32x4 0x03020100 0x00000000 0x00000000 0x00000000)) +(assert_return (invoke "v128.load32_zero_align1" (i32.const 1)) (v128.const i32x4 0x04030201 0x00000000 0x00000000 0x00000000)) +(assert_return (invoke "v128.load32_zero_offset0_align1" (i32.const 2)) (v128.const i32x4 0x05040302 0x00000000 0x00000000 0x00000000)) +(assert_return (invoke "v128.load32_zero_offset10_align4" (i32.const 3)) (v128.const i32x4 0x800F0E0D 0x00000000 0x00000000 0x00000000)) + +;; load64_zero +(assert_return (invoke "v128.load64_zero_offset0" (i32.const 0)) (v128.const i64x2 0x0706050403020100 0x0000000000000000)) +(assert_return (invoke "v128.load64_zero_align1" (i32.const 1)) (v128.const i64x2 0x0807060504030201 0x0000000000000000)) +(assert_return (invoke "v128.load64_zero_offset0_align1" (i32.const 2)) (v128.const i64x2 0x0908070605040302 0x0000000000000000)) +(assert_return (invoke "v128.load64_zero_offset10_align4" (i32.const 3)) (v128.const i64x2 0x84838281800F0E0D 0x0000000000000000)) +(assert_return (invoke "v128.load64_zero_offset20_align8" (i32.const 4)) (v128.const i64x2 0x0000000000008988 0x0000000000000000)) + +;; out of bounds memory access +(assert_trap (invoke "v128.load32_zero" (i32.const -1)) "out of bounds memory access") +(assert_trap (invoke "v128.load64_zero" (i32.const -1)) "out of bounds memory access") + +(assert_trap (invoke "v128.load32_zero_offset1_align1" (i32.const -1)) "out of bounds memory access") +(assert_trap (invoke "v128.load64_zero_offset1_align1" (i32.const -1)) "out of bounds memory access") + +;; type check +(assert_invalid (module (memory 0) (func (result v128) (v128.load32_zero (f32.const 0)))) "type mismatch") +(assert_invalid (module (memory 0) (func (result v128) (v128.load64_zero (f32.const 0)))) "type mismatch") + +;; Test operation with empty argument + +(assert_invalid + (module (memory 0) + (func $v128.load32_zero-arg-empty (result v128) + (v128.load32_zero) + ) + ) + "type mismatch" +) +(assert_invalid + (module (memory 0) + (func $v128.load64_zero-arg-empty (result v128) + (v128.load64_zero) + ) + ) + "type mismatch" +) + +;; Unknown operator + +(assert_malformed (module quote "(memory 1) (func (drop (i16x8.load16x4_s (i32.const 0))))") "unknown operator") +(assert_malformed (module quote "(memory 1) (func (drop (i16x8.load16x4_u (i32.const 0))))") "unknown operator") +(assert_malformed (module quote "(memory 1) (func (drop (i32x4.load32x2_s (i32.const 0))))") "unknown operator") +(assert_malformed (module quote "(memory 1) (func (drop (i32x4.load32x2_u (i32.const 0))))") "unknown operator") +(assert_malformed (module quote "(memory 1) (func (drop (i64x2.load64x1_s (i32.const 0))))") "unknown operator") +(assert_malformed (module quote "(memory 1) (func (drop (i64x2.load64x1_u (i32.const 0))))") "unknown operator") + +;; combination +(module + (memory 1) + (data (i32.const 0) "\00\01\02\03\04\05\06\07\08\09\0A\0B\0C\0D\0E\0F\80\81\82\83\84\85\86\87\88\89") + (func (export "v128.load32_zero-in-block") (result v128) + (block (result v128) (block (result v128) (v128.load32_zero (i32.const 0)))) + ) + (func (export "v128.load64_zero-in-block") (result v128) + (block (result v128) (block (result v128) (v128.load64_zero (i32.const 1)))) + ) + (func (export "v128.load32_zero-as-br-value") (result v128) + (block (result v128) (br 0 (v128.load32_zero (i32.const 6)))) + ) + (func (export "v128.load64_zero-as-br-value") (result v128) + (block (result v128) (br 0 (v128.load64_zero (i32.const 7)))) + ) + (func (export "v128.load32_zero-extract_lane_s-operand") (result i32) + (i32x4.extract_lane 0 (v128.load32_zero (i32.const 12))) + ) + (func (export "v128.load64_zero-extract_lane_s-operand") (result i64) + (i64x2.extract_lane 0 (v128.load64_zero (i32.const 13))) + ) +) +(assert_return (invoke "v128.load32_zero-in-block") (v128.const i32x4 0x03020100 0x00000000 0x00000000 0x00000000)) +(assert_return (invoke "v128.load64_zero-in-block") (v128.const i64x2 0x0807060504030201 0x0000000000000000)) +(assert_return (invoke "v128.load32_zero-as-br-value") (v128.const i32x4 0x09080706 0x00000000 0x00000000 0x00000000)) +(assert_return (invoke "v128.load64_zero-as-br-value") (v128.const i64x2 0x0E0D0C0B0A090807 0x0000000000000000)) +(assert_return (invoke "v128.load32_zero-extract_lane_s-operand") (i32.const 0x0F0E0D0C)) +(assert_return (invoke "v128.load64_zero-extract_lane_s-operand") (i64.const 0x84838281800F0E0D)) diff --git a/runtime/near-vm/tests/wast/spec/proposals/simd/simd_splat.wast b/runtime/near-vm/tests/wast/spec/proposals/simd/simd_splat.wast new file mode 100644 index 00000000000..4be04ef1779 --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/proposals/simd/simd_splat.wast @@ -0,0 +1,430 @@ +;; Tests for the *_splat instructions + +(module + (func (export "i8x16.splat") (param i32) (result v128) (i8x16.splat (local.get 0))) + (func (export "i16x8.splat") (param i32) (result v128) (i16x8.splat (local.get 0))) + (func (export "i32x4.splat") (param i32) (result v128) (i32x4.splat (local.get 0))) + (func (export "f32x4.splat") (param f32) (result v128) (f32x4.splat (local.get 0))) + (func (export "i64x2.splat") (param i64) (result v128) (i64x2.splat (local.get 0))) + (func (export "f64x2.splat") (param f64) (result v128) (f64x2.splat (local.get 0))) +) + +(assert_return (invoke "i8x16.splat" (i32.const 0)) (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i8x16.splat" (i32.const 5)) (v128.const i8x16 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5)) +(assert_return (invoke "i8x16.splat" (i32.const -5)) (v128.const i8x16 -5 -5 -5 -5 -5 -5 -5 -5 -5 -5 -5 -5 -5 -5 -5 -5)) +(assert_return (invoke "i8x16.splat" (i32.const 257)) (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) +(assert_return (invoke "i8x16.splat" (i32.const 0xff)) (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "i8x16.splat" (i32.const -128)) (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)) +(assert_return (invoke "i8x16.splat" (i32.const 127)) (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127)) +(assert_return (invoke "i8x16.splat" (i32.const -129)) (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127)) +(assert_return (invoke "i8x16.splat" (i32.const 128)) (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)) +(assert_return (invoke "i8x16.splat" (i32.const 0xff7f)) (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f)) +(assert_return (invoke "i8x16.splat" (i32.const 0x80)) (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)) +(assert_return (invoke "i8x16.splat" (i32.const 0xAB)) (v128.const i32x4 0xABABABAB 0xABABABAB 0xABABABAB 0xABABABAB)) + +(assert_return (invoke "i16x8.splat" (i32.const 0)) (v128.const i16x8 0 0 0 0 0 0 0 0)) +(assert_return (invoke "i16x8.splat" (i32.const 5)) (v128.const i16x8 5 5 5 5 5 5 5 5)) +(assert_return (invoke "i16x8.splat" (i32.const -5)) (v128.const i16x8 -5 -5 -5 -5 -5 -5 -5 -5)) +(assert_return (invoke "i16x8.splat" (i32.const 65537)) (v128.const i16x8 1 1 1 1 1 1 1 1)) +(assert_return (invoke "i16x8.splat" (i32.const 0xffff)) (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) +(assert_return (invoke "i16x8.splat" (i32.const -32768)) (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)) +(assert_return (invoke "i16x8.splat" (i32.const 32767)) (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767)) +(assert_return (invoke "i16x8.splat" (i32.const -32769)) (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767)) +(assert_return (invoke "i16x8.splat" (i32.const 32768)) (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)) +(assert_return (invoke "i16x8.splat" (i32.const 0xffff7fff)) (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff)) +(assert_return (invoke "i16x8.splat" (i32.const 0x8000)) (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)) +(assert_return (invoke "i16x8.splat" (i32.const 0xABCD)) (v128.const i32x4 0xABCDABCD 0xABCDABCD 0xABCDABCD 0xABCDABCD)) +(assert_return (invoke "i16x8.splat" (i32.const 012345)) (v128.const i16x8 012_345 012_345 012_345 012_345 012_345 012_345 012_345 012_345)) +(assert_return (invoke "i16x8.splat" (i32.const 0x01234)) (v128.const i16x8 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234)) + +(assert_return (invoke "i32x4.splat" (i32.const 0)) (v128.const i32x4 0 0 0 0)) +(assert_return (invoke "i32x4.splat" (i32.const 5)) (v128.const i32x4 5 5 5 5)) +(assert_return (invoke "i32x4.splat" (i32.const -5)) (v128.const i32x4 -5 -5 -5 -5)) +(assert_return (invoke "i32x4.splat" (i32.const 0xffffffff)) (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "i32x4.splat" (i32.const 4294967295)) (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "i32x4.splat" (i32.const -2147483648)) (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000)) +(assert_return (invoke "i32x4.splat" (i32.const 2147483647)) (v128.const i32x4 0x7fffffff 0x7fffffff 0x7fffffff 0x7fffffff)) +(assert_return (invoke "i32x4.splat" (i32.const 2147483648)) (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000)) +(assert_return (invoke "i32x4.splat" (i32.const 01234567890)) (v128.const i32x4 012_3456_7890 012_3456_7890 012_3456_7890 012_3456_7890)) +(assert_return (invoke "i32x4.splat" (i32.const 0x012345678)) (v128.const i32x4 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678)) + +(assert_return (invoke "f32x4.splat" (f32.const 0.0)) (v128.const f32x4 0.0 0.0 0.0 0.0)) +(assert_return (invoke "f32x4.splat" (f32.const 1.1)) (v128.const f32x4 1.1 1.1 1.1 1.1)) +(assert_return (invoke "f32x4.splat" (f32.const -1.1)) (v128.const f32x4 -1.1 -1.1 -1.1 -1.1)) +(assert_return (invoke "f32x4.splat" (f32.const 1e38)) (v128.const f32x4 1e38 1e38 1e38 1e38)) +(assert_return (invoke "f32x4.splat" (f32.const -1e38)) (v128.const f32x4 -1e38 -1e38 -1e38 -1e38)) +(assert_return (invoke "f32x4.splat" (f32.const 0x1.fffffep127)) (v128.const f32x4 0x1.fffffep127 0x1.fffffep127 0x1.fffffep127 0x1.fffffep127)) +(assert_return (invoke "f32x4.splat" (f32.const -0x1.fffffep127)) (v128.const f32x4 -0x1.fffffep127 -0x1.fffffep127 -0x1.fffffep127 -0x1.fffffep127)) +(assert_return (invoke "f32x4.splat" (f32.const 0x1p127)) (v128.const f32x4 0x1p127 0x1p127 0x1p127 0x1p127)) +(assert_return (invoke "f32x4.splat" (f32.const -0x1p127)) (v128.const f32x4 -0x1p127 -0x1p127 -0x1p127 -0x1p127)) +(assert_return (invoke "f32x4.splat" (f32.const inf)) (v128.const f32x4 inf inf inf inf)) +(assert_return (invoke "f32x4.splat" (f32.const -inf)) (v128.const f32x4 -inf -inf -inf -inf)) +(assert_return (invoke "f32x4.splat" (f32.const nan)) (v128.const f32x4 nan nan nan nan)) +(assert_return (invoke "f32x4.splat" (f32.const nan:0x1)) (v128.const f32x4 nan:0x1 nan:0x1 nan:0x1 nan:0x1)) +(assert_return (invoke "f32x4.splat" (f32.const nan:0x7f_ffff)) (v128.const f32x4 nan:0x7f_ffff nan:0x7f_ffff nan:0x7f_ffff nan:0x7f_ffff)) +(assert_return (invoke "f32x4.splat" (f32.const 0123456789)) (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)) +(assert_return (invoke "f32x4.splat" (f32.const 0123456789.)) (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)) +(assert_return (invoke "f32x4.splat" (f32.const 0x0123456789ABCDEF)) (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)) +(assert_return (invoke "f32x4.splat" (f32.const 0x0123456789ABCDEF.)) (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)) +(assert_return (invoke "f32x4.splat" (f32.const 0123456789e019)) (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)) +(assert_return (invoke "f32x4.splat" (f32.const 0123456789.e+019)) (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)) +(assert_return (invoke "f32x4.splat" (f32.const 0x0123456789ABCDEFp019)) (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)) +(assert_return (invoke "f32x4.splat" (f32.const 0x0123456789ABCDEF.p-019)) (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)) + +(assert_return (invoke "i64x2.splat" (i64.const 0)) (v128.const i64x2 0 0)) +(assert_return (invoke "i64x2.splat" (i64.const -0)) (v128.const i64x2 0 0)) +(assert_return (invoke "i64x2.splat" (i64.const 1)) (v128.const i64x2 1 1)) +(assert_return (invoke "i64x2.splat" (i64.const -1)) (v128.const i64x2 -1 -1)) +(assert_return (invoke "i64x2.splat" (i64.const -9223372036854775808)) (v128.const i64x2 -9223372036854775808 -9223372036854775808)) +(assert_return (invoke "i64x2.splat" (i64.const -9223372036854775808)) (v128.const i64x2 9223372036854775808 9223372036854775808)) +(assert_return (invoke "i64x2.splat" (i64.const 9223372036854775807)) (v128.const i64x2 9223372036854775807 9223372036854775807)) +(assert_return (invoke "i64x2.splat" (i64.const 18446744073709551615)) (v128.const i64x2 -1 -1)) +(assert_return (invoke "i64x2.splat" (i64.const 0x7fffffffffffffff)) (v128.const i64x2 0x7fffffffffffffff 0x7fffffffffffffff)) +(assert_return (invoke "i64x2.splat" (i64.const 0xffffffffffffffff)) (v128.const i64x2 -1 -1)) +(assert_return (invoke "i64x2.splat" (i64.const -0x8000000000000000)) (v128.const i64x2 -0x8000000000000000 -0x8000000000000000)) +(assert_return (invoke "i64x2.splat" (i64.const -0x8000000000000000)) (v128.const i64x2 0x8000000000000000 0x8000000000000000)) +(assert_return (invoke "i64x2.splat" (i64.const 01234567890123456789)) (v128.const i64x2 01_234_567_890_123_456_789 01_234_567_890_123_456_789)) +(assert_return (invoke "i64x2.splat" (i64.const 0x01234567890ABcdef)) (v128.const i64x2 0x0_1234_5678_90AB_cdef 0x0_1234_5678_90AB_cdef)) + +(assert_return (invoke "f64x2.splat" (f64.const 0.0)) (v128.const f64x2 0.0 0.0)) +(assert_return (invoke "f64x2.splat" (f64.const -0.0)) (v128.const f64x2 -0.0 -0.0)) +(assert_return (invoke "f64x2.splat" (f64.const 1.1)) (v128.const f64x2 1.1 1.1)) +(assert_return (invoke "f64x2.splat" (f64.const -1.1)) (v128.const f64x2 -1.1 -1.1)) +(assert_return (invoke "f64x2.splat" (f64.const 0x0.0000000000001p-1022)) (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.splat" (f64.const -0x0.0000000000001p-1022)) (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022)) +(assert_return (invoke "f64x2.splat" (f64.const 0x1p-1022)) (v128.const f64x2 0x1p-1022 0x1p-1022)) +(assert_return (invoke "f64x2.splat" (f64.const -0x1p-1022)) (v128.const f64x2 -0x1p-1022 -0x1p-1022)) +(assert_return (invoke "f64x2.splat" (f64.const 0x1p-1)) (v128.const f64x2 0x1p-1 0x1p-1)) +(assert_return (invoke "f64x2.splat" (f64.const -0x1p-1)) (v128.const f64x2 -0x1p-1 -0x1p-1)) +(assert_return (invoke "f64x2.splat" (f64.const 0x1p+0)) (v128.const f64x2 0x1p+0 0x1p+0)) +(assert_return (invoke "f64x2.splat" (f64.const -0x1p+0)) (v128.const f64x2 -0x1p+0 -0x1p+0)) +(assert_return (invoke "f64x2.splat" (f64.const 0x1.921fb54442d18p+2)) (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.splat" (f64.const -0x1.921fb54442d18p+2)) (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)) +(assert_return (invoke "f64x2.splat" (f64.const 0x1.fffffffffffffp+1023)) (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.splat" (f64.const -0x1.fffffffffffffp+1023)) (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)) +(assert_return (invoke "f64x2.splat" (f64.const inf)) (v128.const f64x2 inf inf)) +(assert_return (invoke "f64x2.splat" (f64.const -inf)) (v128.const f64x2 -inf -inf)) +(assert_return (invoke "f64x2.splat" (f64.const nan)) (v128.const f64x2 nan nan)) +(assert_return (invoke "f64x2.splat" (f64.const -nan)) (v128.const f64x2 -nan -nan)) +(assert_return (invoke "f64x2.splat" (f64.const nan:0x4000000000000)) (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)) +(assert_return (invoke "f64x2.splat" (f64.const -nan:0x4000000000000)) (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)) +(assert_return (invoke "f64x2.splat" (f64.const 0123456789)) (v128.const f64x2 0123456789 0123456789)) +(assert_return (invoke "f64x2.splat" (f64.const 0123456789.)) (v128.const f64x2 0123456789. 0123456789.)) +(assert_return (invoke "f64x2.splat" (f64.const 0x0123456789ABCDEFabcdef)) (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)) +(assert_return (invoke "f64x2.splat" (f64.const 0x0123456789ABCDEFabcdef.)) (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)) +(assert_return (invoke "f64x2.splat" (f64.const 0123456789e019)) (v128.const f64x2 0123456789e019 0123456789e019)) +(assert_return (invoke "f64x2.splat" (f64.const 0123456789e+019)) (v128.const f64x2 0123456789e+019 0123456789e+019)) +(assert_return (invoke "f64x2.splat" (f64.const 0x0123456789ABCDEFabcdef.p019)) (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)) +(assert_return (invoke "f64x2.splat" (f64.const 0x0123456789ABCDEFabcdef.p-019)) (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)) + +;; Unknown operator + +(assert_malformed (module quote "(func (result v128) (v128.splat (i32.const 0)))") "unknown operator") + + +;; Type mismatched + +(assert_invalid (module (func (result v128) i8x16.splat (i64.const 0))) "type mismatch") +(assert_invalid (module (func (result v128) i8x16.splat (f32.const 0.0))) "type mismatch") +(assert_invalid (module (func (result v128) i8x16.splat (f64.const 0.0))) "type mismatch") +(assert_invalid (module (func (result v128) i16x8.splat (i64.const 1))) "type mismatch") +(assert_invalid (module (func (result v128) i16x8.splat (f32.const 1.0))) "type mismatch") +(assert_invalid (module (func (result v128) i16x8.splat (f64.const 1.0))) "type mismatch") +(assert_invalid (module (func (result v128) i32x4.splat (i64.const 2))) "type mismatch") +(assert_invalid (module (func (result v128) i32x4.splat (f32.const 2.0))) "type mismatch") +(assert_invalid (module (func (result v128) i32x4.splat (f64.const 2.0))) "type mismatch") +(assert_invalid (module (func (result v128) f32x4.splat (i32.const 4))) "type mismatch") +(assert_invalid (module (func (result v128) f32x4.splat (i64.const 4))) "type mismatch") +(assert_invalid (module (func (result v128) f32x4.splat (f64.const 4.0))) "type mismatch") +(assert_invalid (module (func (result v128) i64x2.splat (i32.const 0))) "type mismatch") +(assert_invalid (module (func (result v128) i64x2.splat (f64.const 0.0))) "type mismatch") +(assert_invalid (module (func (result v128) f64x2.splat (i32.const 0))) "type mismatch") +(assert_invalid (module (func (result v128) f64x2.splat (f32.const 0.0))) "type mismatch") + + +;; V128 splat operators as the argument of other SIMD instructions + +;; v128.store and v128.load +(module (memory 1) + (func (export "as-v128_store-operand-1") (param i32) (result v128) + (v128.store (i32.const 0) (i8x16.splat (local.get 0))) + (v128.load (i32.const 0))) + (func (export "as-v128_store-operand-2") (param i32) (result v128) + (v128.store (i32.const 0) (i16x8.splat (local.get 0))) + (v128.load (i32.const 0))) + (func (export "as-v128_store-operand-3") (param i32) (result v128) + (v128.store (i32.const 0) (i32x4.splat (local.get 0))) + (v128.load (i32.const 0))) + (func (export "as-v128_store-operand-4") (param i64) (result v128) + (v128.store (i32.const 0) (i64x2.splat (local.get 0))) + (v128.load (i32.const 0))) + (func (export "as-v128_store-operand-5") (param f64) (result v128) + (v128.store (i32.const 0) (f64x2.splat (local.get 0))) + (v128.load (i32.const 0))) +) + +(assert_return (invoke "as-v128_store-operand-1" (i32.const 1)) (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) +(assert_return (invoke "as-v128_store-operand-2" (i32.const 256)) (v128.const i16x8 0x100 0x100 0x100 0x100 0x100 0x100 0x100 0x100)) +(assert_return (invoke "as-v128_store-operand-3" (i32.const 0xffffffff)) (v128.const i32x4 -1 -1 -1 -1)) +(assert_return (invoke "as-v128_store-operand-4" (i64.const 1)) (v128.const i64x2 1 1)) +(assert_return (invoke "as-v128_store-operand-5" (f64.const -0x1p+0)) (v128.const f64x2 -0x1p+0 -0x1p+0)) + +(module + ;; Accessing lane + (func (export "as-i8x16_extract_lane_s-operand-first") (param i32) (result i32) + (i8x16.extract_lane_s 0 (i8x16.splat (local.get 0)))) + (func (export "as-i8x16_extract_lane_s-operand-last") (param i32) (result i32) + (i8x16.extract_lane_s 15 (i8x16.splat (local.get 0)))) + (func (export "as-i16x8_extract_lane_s-operand-first") (param i32) (result i32) + (i16x8.extract_lane_s 0 (i16x8.splat (local.get 0)))) + (func (export "as-i16x8_extract_lane_s-operand-last") (param i32) (result i32) + (i16x8.extract_lane_s 7 (i16x8.splat (local.get 0)))) + (func (export "as-i32x4_extract_lane_s-operand-first") (param i32) (result i32) + (i32x4.extract_lane 0 (i32x4.splat (local.get 0)))) + (func (export "as-i32x4_extract_lane_s-operand-last") (param i32) (result i32) + (i32x4.extract_lane 3 (i32x4.splat (local.get 0)))) + (func (export "as-f32x4_extract_lane_s-operand-first") (param f32) (result f32) + (f32x4.extract_lane 0 (f32x4.splat (local.get 0)))) + (func (export "as-f32x4_extract_lane_s-operand-last") (param f32) (result f32) + (f32x4.extract_lane 3 (f32x4.splat (local.get 0)))) + (func (export "as-v8x16_swizzle-operands") (param i32) (param i32) (result v128) + (i8x16.swizzle (i8x16.splat (local.get 0)) (i8x16.splat (local.get 1)))) + (func (export "as-i64x2_extract_lane-operand-first") (param i64) (result i64) + (i64x2.extract_lane 0 (i64x2.splat (local.get 0)))) + (func (export "as-i64x2_extract_lane-operand-last") (param i64) (result i64) + (i64x2.extract_lane 1 (i64x2.splat (local.get 0)))) + (func (export "as-f64x2_extract_lane-operand-first") (param f64) (result f64) + (f64x2.extract_lane 0 (f64x2.splat (local.get 0)))) + (func (export "as-f64x2_extract_lane-operand-last") (param f64) (result f64) + (f64x2.extract_lane 1 (f64x2.splat (local.get 0)))) + + ;; Integer arithmetic + (func (export "as-i8x16_add_sub-operands") (param i32 i32 i32) (result v128) + (i8x16.add (i8x16.splat (local.get 0)) + (i8x16.sub (i8x16.splat (local.get 1)) (i8x16.splat (local.get 2))))) + (func (export "as-i16x8_add_sub_mul-operands") (param i32 i32 i32 i32) (result v128) + (i16x8.add (i16x8.splat (local.get 0)) + (i16x8.sub (i16x8.splat (local.get 1)) + (i16x8.mul (i16x8.splat (local.get 2)) (i16x8.splat (local.get 3)))))) + (func (export "as-i32x4_add_sub_mul-operands") (param i32 i32 i32 i32) (result v128) + (i32x4.add (i32x4.splat (local.get 0)) + (i32x4.sub (i32x4.splat (local.get 1)) + (i32x4.mul (i32x4.splat (local.get 2)) (i32x4.splat (local.get 3)))))) + + (func (export "as-i64x2_add_sub_mul-operands") (param i64 i64 i64 i64) (result v128) + (i64x2.add (i64x2.splat (local.get 0)) + (i64x2.sub (i64x2.splat (local.get 1)) + (i64x2.mul (i64x2.splat (local.get 2)) (i64x2.splat (local.get 3)))))) + (func (export "as-f64x2_add_sub_mul-operands") (param f64 f64 f64 f64) (result v128) + (f64x2.add (f64x2.splat (local.get 0)) + (f64x2.sub (f64x2.splat (local.get 1)) + (f64x2.mul (f64x2.splat (local.get 2)) (f64x2.splat (local.get 3)))))) + + ;; Saturating integer arithmetic + (func (export "as-i8x16_add_sat_s-operands") (param i32 i32) (result v128) + (i8x16.add_sat_s (i8x16.splat (local.get 0)) (i8x16.splat (local.get 1)))) + (func (export "as-i16x8_add_sat_s-operands") (param i32 i32) (result v128) + (i16x8.add_sat_s (i16x8.splat (local.get 0)) (i16x8.splat (local.get 1)))) + (func (export "as-i8x16_sub_sat_u-operands") (param i32 i32) (result v128) + (i8x16.sub_sat_u (i8x16.splat (local.get 0)) (i8x16.splat (local.get 1)))) + (func (export "as-i16x8_sub_sat_u-operands") (param i32 i32) (result v128) + (i16x8.sub_sat_u (i16x8.splat (local.get 0)) (i16x8.splat (local.get 1)))) + + ;; Bit shifts + (func (export "as-i8x16_shr_s-operand") (param i32 i32) (result v128) + (i8x16.shr_s (i8x16.splat (local.get 0)) (local.get 1))) + (func (export "as-i16x8_shr_s-operand") (param i32 i32) (result v128) + (i16x8.shr_s (i16x8.splat (local.get 0)) (local.get 1))) + (func (export "as-i32x4_shr_s-operand") (param i32 i32) (result v128) + (i32x4.shr_s (i32x4.splat (local.get 0)) (local.get 1))) + + ;; Bitwise operantions + (func (export "as-v128_and-operands") (param i32 i32) (result v128) + (v128.and (i8x16.splat (local.get 0)) (i8x16.splat (local.get 1)))) + (func (export "as-v128_or-operands") (param i32 i32) (result v128) + (v128.or (i16x8.splat (local.get 0)) (i16x8.splat (local.get 1)))) + (func (export "as-v128_xor-operands") (param i32 i32) (result v128) + (v128.xor (i32x4.splat (local.get 0)) (i32x4.splat (local.get 1)))) + + ;; Boolean horizontal reductions + (func (export "as-i8x16_all_true-operand") (param i32) (result i32) + (i8x16.all_true (i8x16.splat (local.get 0)))) + (func (export "as-i16x8_all_true-operand") (param i32) (result i32) + (i16x8.all_true (i16x8.splat (local.get 0)))) + (func (export "as-i32x4_all_true-operand1") (param i32) (result i32) + (i32x4.all_true (i32x4.splat (local.get 0)))) + (func (export "as-i32x4_all_true-operand2") (param i64) (result i32) + (i32x4.all_true (i64x2.splat (local.get 0)))) + + ;; Comparisons + (func (export "as-i8x16_eq-operands") (param i32 i32) (result v128) + (i8x16.eq (i8x16.splat (local.get 0)) (i8x16.splat (local.get 1)))) + (func (export "as-i16x8_eq-operands") (param i32 i32) (result v128) + (i16x8.eq (i16x8.splat (local.get 0)) (i16x8.splat (local.get 1)))) + (func (export "as-i32x4_eq-operands1") (param i32 i32) (result v128) + (i32x4.eq (i32x4.splat (local.get 0)) (i32x4.splat (local.get 1)))) + (func (export "as-i32x4_eq-operands2") (param i64 i64) (result v128) + (i32x4.eq (i64x2.splat (local.get 0)) (i64x2.splat (local.get 1)))) + (func (export "as-f32x4_eq-operands") (param f32 f32) (result v128) + (f32x4.eq (f32x4.splat (local.get 0)) (f32x4.splat (local.get 1)))) + (func (export "as-f64x2_eq-operands") (param f64 f64) (result v128) + (f64x2.eq (f64x2.splat (local.get 0)) (f64x2.splat (local.get 1)))) + + ;; Floating-point sign bit operations + (func (export "as-f32x4_abs-operand") (param f32) (result v128) + (f32x4.abs (f32x4.splat (local.get 0)))) + + ;; Floating-point min + (func (export "as-f32x4_min-operands") (param f32 f32) (result v128) + (f32x4.min (f32x4.splat (local.get 0)) (f32x4.splat (local.get 1)))) + + ;; Floating-point arithmetic + (func (export "as-f32x4_div-operands") (param f32 f32) (result v128) + (f32x4.div (f32x4.splat (local.get 0)) (f32x4.splat (local.get 1)))) + + ;; Conversions + (func (export "as-f32x4_convert_s_i32x4-operand") (param i32) (result v128) + (f32x4.convert_i32x4_s (i32x4.splat (local.get 0)))) + (func (export "as-i32x4_trunc_s_f32x4_sat-operand") (param f32) (result v128) + (i32x4.trunc_sat_f32x4_s (f32x4.splat (local.get 0)))) +) + +(assert_return (invoke "as-i8x16_extract_lane_s-operand-first" (i32.const 42)) (i32.const 42)) +(assert_return (invoke "as-i8x16_extract_lane_s-operand-last" (i32.const -42)) (i32.const -42)) +(assert_return (invoke "as-i16x8_extract_lane_s-operand-first" (i32.const 0xffff7fff)) (i32.const 32767)) +(assert_return (invoke "as-i16x8_extract_lane_s-operand-last" (i32.const 0x8000)) (i32.const -32768)) +(assert_return (invoke "as-i32x4_extract_lane_s-operand-first" (i32.const 0x7fffffff)) (i32.const 2147483647)) +(assert_return (invoke "as-i32x4_extract_lane_s-operand-last" (i32.const 0x80000000)) (i32.const -2147483648)) +(assert_return (invoke "as-f32x4_extract_lane_s-operand-first" (f32.const 1.5)) (f32.const 1.5)) +(assert_return (invoke "as-f32x4_extract_lane_s-operand-last" (f32.const -0.25)) (f32.const -0.25)) +(assert_return (invoke "as-v8x16_swizzle-operands" (i32.const 1) (i32.const -1)) (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "as-i64x2_extract_lane-operand-last" (i64.const -42)) (i64.const -42)) +(assert_return (invoke "as-i64x2_extract_lane-operand-first" (i64.const 42)) (i64.const 42)) +(assert_return (invoke "as-f64x2_extract_lane-operand-first" (f64.const 1.5)) (f64.const 1.5)) +(assert_return (invoke "as-f64x2_extract_lane-operand-last" (f64.const -0x1p+0)) (f64.const -0x1p+0)) + +(assert_return (invoke "as-i8x16_add_sub-operands" (i32.const 3) (i32.const 2) (i32.const 1)) (v128.const i8x16 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4)) +(assert_return (invoke "as-i16x8_add_sub_mul-operands" (i32.const 257) (i32.const 128) (i32.const 16) (i32.const 16)) (v128.const i16x8 129 129 129 129 129 129 129 129)) +(assert_return (invoke "as-i32x4_add_sub_mul-operands" (i32.const 65535) (i32.const 65537) (i32.const 256) (i32.const 256)) (v128.const i32x4 0x10000 0x10000 0x10000 0x10000)) +(assert_return (invoke "as-i64x2_add_sub_mul-operands" (i64.const 0x7fffffff) (i64.const 0x1_0000_0001) (i64.const 65536) (i64.const 65536)) (v128.const i64x2 0x8000_0000 0x8000_0000)) +(assert_return (invoke "as-f64x2_add_sub_mul-operands" (f64.const 0x1p-1) (f64.const 0.75) (f64.const 0x1p-1) (f64.const 0.5)) (v128.const f64x2 0x1p+0 0x1p+0)) + +(assert_return (invoke "as-i8x16_add_sat_s-operands" (i32.const 0x7f) (i32.const 1)) (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f)) +(assert_return (invoke "as-i16x8_add_sat_s-operands" (i32.const 0x7fff) (i32.const 1)) (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff)) +(assert_return (invoke "as-i8x16_sub_sat_u-operands" (i32.const 0x7f) (i32.const 0xff)) (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "as-i16x8_sub_sat_u-operands" (i32.const 0x7fff) (i32.const 0xffff)) (v128.const i16x8 0 0 0 0 0 0 0 0)) + +(assert_return (invoke "as-i8x16_shr_s-operand" (i32.const 0xf0) (i32.const 3)) (v128.const i8x16 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2)) +(assert_return (invoke "as-i16x8_shr_s-operand" (i32.const 0x100) (i32.const 4)) (v128.const i16x8 16 16 16 16 16 16 16 16)) +(assert_return (invoke "as-i32x4_shr_s-operand" (i32.const -1) (i32.const 16)) (v128.const i32x4 -1 -1 -1 -1)) + +(assert_return (invoke "as-v128_and-operands" (i32.const 0x11) (i32.const 0xff)) (v128.const i8x16 17 17 17 17 17 17 17 17 17 17 17 17 17 17 17 17)) +(assert_return (invoke "as-v128_or-operands" (i32.const 0) (i32.const 0xffff)) (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff)) +(assert_return (invoke "as-v128_xor-operands" (i32.const 0xf0f0f0f0) (i32.const 0xffffffff)) (v128.const i32x4 0xf0f0f0f 0xf0f0f0f 0xf0f0f0f 0xf0f0f0f)) + +(assert_return (invoke "as-i8x16_all_true-operand" (i32.const 0)) (i32.const 0)) +(assert_return (invoke "as-i16x8_all_true-operand" (i32.const 0xffff)) (i32.const 1)) +(assert_return (invoke "as-i32x4_all_true-operand1" (i32.const 0xf0f0f0f0)) (i32.const 1)) +(assert_return (invoke "as-i32x4_all_true-operand2" (i64.const -1)) (i32.const 1)) + +(assert_return (invoke "as-i8x16_eq-operands" (i32.const 1) (i32.const 2)) (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) +(assert_return (invoke "as-i16x8_eq-operands" (i32.const -1) (i32.const 65535)) (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff)) +(assert_return (invoke "as-i32x4_eq-operands1" (i32.const -1) (i32.const 0xffffffff)) (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff)) +(assert_return (invoke "as-f32x4_eq-operands" (f32.const +0.0) (f32.const -0.0)) (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff)) +(assert_return (invoke "as-i32x4_eq-operands2" (i64.const 1) (i64.const 2)) (v128.const i64x2 0xffffffff00000000 0xffffffff00000000)) +(assert_return (invoke "as-f64x2_eq-operands" (f64.const +0.0) (f64.const -0.0)) (v128.const i64x2 -1 -1)) + +(assert_return (invoke "as-f32x4_abs-operand" (f32.const -1.125)) (v128.const f32x4 1.125 1.125 1.125 1.125)) +(assert_return (invoke "as-f32x4_min-operands" (f32.const 0.25) (f32.const 1e-38)) (v128.const f32x4 1e-38 1e-38 1e-38 1e-38)) +(assert_return (invoke "as-f32x4_div-operands" (f32.const 1.0) (f32.const 8.0)) (v128.const f32x4 0.125 0.125 0.125 0.125)) + +(assert_return (invoke "as-f32x4_convert_s_i32x4-operand" (i32.const 12345)) (v128.const f32x4 12345.0 12345.0 12345.0 12345.0)) +(assert_return (invoke "as-i32x4_trunc_s_f32x4_sat-operand" (f32.const 1.1)) (v128.const i32x4 1 1 1 1)) + + +;; As the argument of control constructs and WASM instructions + +(module + (global $g (mut v128) (v128.const f32x4 0.0 0.0 0.0 0.0)) + (func (export "as-br-value1") (param i32) (result v128) + (block (result v128) (br 0 (i8x16.splat (local.get 0))))) + (func (export "as-return-value1") (param i32) (result v128) + (return (i16x8.splat (local.get 0)))) + (func (export "as-local_set-value1") (param i32) (result v128) (local v128) + (local.set 1 (i32x4.splat (local.get 0))) + (return (local.get 1))) + (func (export "as-global_set-value1") (param f32) (result v128) + (global.set $g (f32x4.splat (local.get 0))) + (return (global.get $g))) + (func (export "as-br-value2") (param i64) (result v128) + (block (result v128) (br 0 (i64x2.splat (local.get 0))))) + (func (export "as-return-value2") (param i64) (result v128) + (return (i64x2.splat (local.get 0)))) + (func (export "as-local_set-value2") (param i64) (result v128) (local v128) + (local.set 1 (i64x2.splat (local.get 0))) + (return (local.get 1))) + (func (export "as-global_set-value2") (param f64) (result v128) + (global.set $g (f64x2.splat (local.get 0))) + (return (global.get $g))) +) + +(assert_return (invoke "as-br-value1" (i32.const 0xAB)) (v128.const i8x16 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB)) +(assert_return (invoke "as-return-value1" (i32.const 0xABCD)) (v128.const i16x8 0xABCD 0xABCD 0xABCD 0xABCD 0xABCD 0xABCD 0xABCD 0xABCD)) +(assert_return (invoke "as-local_set-value1" (i32.const 0x10000)) (v128.const i32x4 0x10000 0x10000 0x10000 0x10000)) +(assert_return (invoke "as-global_set-value1" (f32.const 1.0)) (v128.const f32x4 1.0 1.0 1.0 1.0)) +(assert_return (invoke "as-br-value2" (i64.const 0xABCD)) (v128.const i64x2 0xABCD 0xABCD)) +(assert_return (invoke "as-return-value2" (i64.const 0xABCD)) (v128.const i64x2 0xABCD 0xABCD)) +(assert_return (invoke "as-local_set-value2" (i64.const 0x10000)) (v128.const i64x2 0x10000 0x10000)) +(assert_return (invoke "as-global_set-value2" (f64.const 1.0)) (v128.const f64x2 1.0 1.0)) + + +;; Test operation with empty argument + +(assert_invalid + (module + (func $i8x16.splat-arg-empty (result v128) + (i8x16.splat) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i16x8.splat-arg-empty (result v128) + (i16x8.splat) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i32x4.splat-arg-empty (result v128) + (i32x4.splat) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $f32x4.splat-arg-empty (result v128) + (f32x4.splat) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $i64x2.splat-arg-empty (result v128) + (i64x2.splat) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $f64x2.splat-arg-empty (result v128) + (f64x2.splat) + ) + ) + "type mismatch" +) diff --git a/runtime/near-vm/tests/wast/spec/proposals/simd/simd_store.wast b/runtime/near-vm/tests/wast/spec/proposals/simd/simd_store.wast new file mode 100644 index 00000000000..50349c41bd8 --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/proposals/simd/simd_store.wast @@ -0,0 +1,166 @@ +;; v128.store operater with normal argument (e.g. (i8x16, i16x8, i32x4, f32x4)) + +(module + (memory 1) + (func (export "v128.store_i8x16") (result v128) + (v128.store (i32.const 0) (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)) + (v128.load (i32.const 0)) + ) + (func (export "v128.store_i16x8") (result v128) + (v128.store (i32.const 0) (v128.const i16x8 0 1 2 3 4 5 6 7)) + (v128.load (i32.const 0)) + ) + (func (export "v128.store_i16x8_2") (result v128) + (v128.store (i32.const 0) (v128.const i16x8 012_345 012_345 012_345 012_345 012_345 012_345 012_345 012_345)) + (v128.load (i32.const 0)) + ) + (func (export "v128.store_i16x8_3") (result v128) + (v128.store (i32.const 0) (v128.const i16x8 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234)) + (v128.load (i32.const 0)) + ) + (func (export "v128.store_i32x4") (result v128) + (v128.store (i32.const 0) (v128.const i32x4 0 1 2 3)) + (v128.load (i32.const 0)) + ) + (func (export "v128.store_i32x4_2") (result v128) + (v128.store (i32.const 0) (v128.const i32x4 0_123_456_789 0_123_456_789 0_123_456_789 0_123_456_789)) + (v128.load (i32.const 0)) + ) + (func (export "v128.store_i32x4_3") (result v128) + (v128.store (i32.const 0) (v128.const i32x4 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678)) + (v128.load (i32.const 0)) + ) + + (func (export "v128.store_f32x4") (result v128) + (v128.store (i32.const 0) (v128.const f32x4 0 1 2 3)) + (v128.load (i32.const 0)) + ) +) + +(assert_return (invoke "v128.store_i8x16") (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)) +(assert_return (invoke "v128.store_i16x8") (v128.const i16x8 0 1 2 3 4 5 6 7)) +(assert_return (invoke "v128.store_i16x8_2") (v128.const i16x8 12345 12345 12345 12345 12345 12345 12345 12345)) +(assert_return (invoke "v128.store_i16x8_3") (v128.const i16x8 0x1234 0x1234 0x1234 0x1234 0x1234 0x1234 0x1234 0x1234)) +(assert_return (invoke "v128.store_i32x4") (v128.const i32x4 0 1 2 3)) +(assert_return (invoke "v128.store_i32x4_2") (v128.const i32x4 123456789 123456789 123456789 123456789)) +(assert_return (invoke "v128.store_i32x4_3") (v128.const i32x4 0x12345678 0x12345678 0x12345678 0x12345678)) +(assert_return (invoke "v128.store_f32x4") (v128.const f32x4 0 1 2 3)) + + +;; v128.store operator as the argument of control constructs and instructions + +(module + (memory 1) + (func (export "as-block-value") + (block (v128.store (i32.const 0) (v128.const i32x4 0 0 0 0))) + ) + (func (export "as-loop-value") + (loop (v128.store (i32.const 0) (v128.const i32x4 0 0 0 0))) + ) + (func (export "as-br-value") + (block (br 0 (v128.store (i32.const 0) (v128.const i32x4 0 0 0 0)))) + ) + (func (export "as-br_if-value") + (block + (br_if 0 (v128.store (i32.const 0) (v128.const i32x4 0 0 0 0)) (i32.const 1)) + ) + ) + (func (export "as-br_if-value-cond") + (block + (br_if 0 (i32.const 6) (v128.store (i32.const 0) (v128.const i32x4 0 0 0 0))) + ) + ) + (func (export "as-br_table-value") + (block + (br_table 0 (v128.store (i32.const 0) (v128.const i32x4 0 0 0 0)) (i32.const 1)) + ) + ) + (func (export "as-return-value") + (return (v128.store (i32.const 0) (v128.const i32x4 0 0 0 0))) + ) + (func (export "as-if-then") + (if (i32.const 1) (then (v128.store (i32.const 0) (v128.const i32x4 0 0 0 0)))) + ) + (func (export "as-if-else") + (if (i32.const 0) (then) (else (v128.store (i32.const 0) (v128.const i32x4 0 0 0 0)))) + ) +) + +(assert_return (invoke "as-block-value")) +(assert_return (invoke "as-loop-value")) +(assert_return (invoke "as-br-value")) +(assert_return (invoke "as-br_if-value")) +(assert_return (invoke "as-br_if-value-cond")) +(assert_return (invoke "as-br_table-value")) +(assert_return (invoke "as-return-value")) +(assert_return (invoke "as-if-then")) +(assert_return (invoke "as-if-else")) + + +;; Unknown operator(e.g. v128.store8, v128.store16, v128.store32) + +(assert_malformed + (module quote + "(memory 1)" + "(func (v128.store8 (i32.const 0) (v128.const i32x4 0 0 0 0)))" + ) + "unknown operator" +) +(assert_malformed + (module quote + "(memory 1)" + "(func (v128.store16 (i32.const 0) (v128.const i32x4 0 0 0 0)))" + ) + "unknown operator" +) +(assert_malformed + (module quote + "(memory 1)" + "(func (v128.store32 (i32.const 0) (v128.const i32x4 0 0 0 0)))" + ) + "unknown operator" +) + + +;; Type mismatched (e.g. v128.load(f32.const 0), type address empty) + +(assert_invalid + (module (memory 1) (func (v128.store (f32.const 0) (v128.const i32x4 0 0 0 0)))) + "type mismatch" +) +(assert_invalid + (module (memory 1) (func (local v128) (block (br_if 0 (v128.store))))) + "type mismatch" +) +(assert_invalid + (module (memory 1) (func (result v128) (v128.store (i32.const 0) (v128.const i32x4 0 0 0 0)))) + "type mismatch" +) + + +;; Test operation with empty argument + +(assert_invalid + (module (memory 0) + (func $v128.store-1st-arg-empty + (v128.store (v128.const i32x4 0 0 0 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module (memory 0) + (func $v128.store-2nd-arg-empty + (v128.store (i32.const 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module (memory 0) + (func $v128.store-arg-empty + (v128.store) + ) + ) + "type mismatch" +) diff --git a/runtime/near-vm/tests/wast/spec/proposals/simd/simd_store16_lane.wast b/runtime/near-vm/tests/wast/spec/proposals/simd/simd_store16_lane.wast new file mode 100644 index 00000000000..d8ea35c3fa4 --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/proposals/simd/simd_store16_lane.wast @@ -0,0 +1,299 @@ +;; Tests for store lane operations. + + +(module + (memory 1) + (global $zero (mut v128) (v128.const i32x4 0 0 0 0)) + (func (export "v128.store16_lane_0") + (param $address i32) (param $x v128) (result i64) (local $ret i64) + (v128.store16_lane 0 (local.get $address) (local.get $x)) + (local.set $ret (i64.load (local.get $address))) + (v128.store (local.get $address) (global.get $zero)) (local.get $ret)) + (func (export "v128.store16_lane_1") + (param $address i32) (param $x v128) (result i64) (local $ret i64) + (v128.store16_lane 1 (local.get $address) (local.get $x)) + (local.set $ret (i64.load (local.get $address))) + (v128.store (local.get $address) (global.get $zero)) (local.get $ret)) + (func (export "v128.store16_lane_2") + (param $address i32) (param $x v128) (result i64) (local $ret i64) + (v128.store16_lane 2 (local.get $address) (local.get $x)) + (local.set $ret (i64.load (local.get $address))) + (v128.store (local.get $address) (global.get $zero)) (local.get $ret)) + (func (export "v128.store16_lane_3") + (param $address i32) (param $x v128) (result i64) (local $ret i64) + (v128.store16_lane 3 (local.get $address) (local.get $x)) + (local.set $ret (i64.load (local.get $address))) + (v128.store (local.get $address) (global.get $zero)) (local.get $ret)) + (func (export "v128.store16_lane_4") + (param $address i32) (param $x v128) (result i64) (local $ret i64) + (v128.store16_lane 4 (local.get $address) (local.get $x)) + (local.set $ret (i64.load (local.get $address))) + (v128.store (local.get $address) (global.get $zero)) (local.get $ret)) + (func (export "v128.store16_lane_5") + (param $address i32) (param $x v128) (result i64) (local $ret i64) + (v128.store16_lane 5 (local.get $address) (local.get $x)) + (local.set $ret (i64.load (local.get $address))) + (v128.store (local.get $address) (global.get $zero)) (local.get $ret)) + (func (export "v128.store16_lane_6") + (param $address i32) (param $x v128) (result i64) (local $ret i64) + (v128.store16_lane 6 (local.get $address) (local.get $x)) + (local.set $ret (i64.load (local.get $address))) + (v128.store (local.get $address) (global.get $zero)) (local.get $ret)) + (func (export "v128.store16_lane_7") + (param $address i32) (param $x v128) (result i64) (local $ret i64) + (v128.store16_lane 7 (local.get $address) (local.get $x)) + (local.set $ret (i64.load (local.get $address))) + (v128.store (local.get $address) (global.get $zero)) (local.get $ret)) + (func (export "v128.store16_lane_0_offset_0") + (param $x v128) (result i64) (local $ret i64) + (v128.store16_lane offset=0 0 (i32.const 0) (local.get $x)) + (local.set $ret (i64.load offset=0 (i32.const 0))) + (v128.store offset=0 (i32.const 0) (global.get $zero)) + (local.get $ret)) + (func (export "v128.store16_lane_1_offset_1") + (param $x v128) (result i64) (local $ret i64) + (v128.store16_lane offset=1 1 (i32.const 0) (local.get $x)) + (local.set $ret (i64.load offset=1 (i32.const 0))) + (v128.store offset=1 (i32.const 0) (global.get $zero)) + (local.get $ret)) + (func (export "v128.store16_lane_2_offset_2") + (param $x v128) (result i64) (local $ret i64) + (v128.store16_lane offset=2 2 (i32.const 0) (local.get $x)) + (local.set $ret (i64.load offset=2 (i32.const 0))) + (v128.store offset=2 (i32.const 0) (global.get $zero)) + (local.get $ret)) + (func (export "v128.store16_lane_3_offset_3") + (param $x v128) (result i64) (local $ret i64) + (v128.store16_lane offset=3 3 (i32.const 0) (local.get $x)) + (local.set $ret (i64.load offset=3 (i32.const 0))) + (v128.store offset=3 (i32.const 0) (global.get $zero)) + (local.get $ret)) + (func (export "v128.store16_lane_4_offset_4") + (param $x v128) (result i64) (local $ret i64) + (v128.store16_lane offset=4 4 (i32.const 0) (local.get $x)) + (local.set $ret (i64.load offset=4 (i32.const 0))) + (v128.store offset=4 (i32.const 0) (global.get $zero)) + (local.get $ret)) + (func (export "v128.store16_lane_5_offset_5") + (param $x v128) (result i64) (local $ret i64) + (v128.store16_lane offset=5 5 (i32.const 0) (local.get $x)) + (local.set $ret (i64.load offset=5 (i32.const 0))) + (v128.store offset=5 (i32.const 0) (global.get $zero)) + (local.get $ret)) + (func (export "v128.store16_lane_6_offset_6") + (param $x v128) (result i64) (local $ret i64) + (v128.store16_lane offset=6 6 (i32.const 0) (local.get $x)) + (local.set $ret (i64.load offset=6 (i32.const 0))) + (v128.store offset=6 (i32.const 0) (global.get $zero)) + (local.get $ret)) + (func (export "v128.store16_lane_7_offset_7") + (param $x v128) (result i64) (local $ret i64) + (v128.store16_lane offset=7 7 (i32.const 0) (local.get $x)) + (local.set $ret (i64.load offset=7 (i32.const 0))) + (v128.store offset=7 (i32.const 0) (global.get $zero)) + (local.get $ret)) + (func (export "v128.store16_lane_0_align_1") + (param $address i32) (param $x v128) (result i64) (local $ret i64) + (v128.store16_lane align=1 0 (local.get $address) (local.get $x)) + (local.set $ret (i64.load (local.get $address))) + (v128.store offset=0 (i32.const 0) (global.get $zero)) + (local.get $ret)) + (func (export "v128.store16_lane_0_align_2") + (param $address i32) (param $x v128) (result i64) (local $ret i64) + (v128.store16_lane align=2 0 (local.get $address) (local.get $x)) + (local.set $ret (i64.load (local.get $address))) + (v128.store offset=0 (i32.const 0) (global.get $zero)) + (local.get $ret)) + (func (export "v128.store16_lane_1_align_1") + (param $address i32) (param $x v128) (result i64) (local $ret i64) + (v128.store16_lane align=1 1 (local.get $address) (local.get $x)) + (local.set $ret (i64.load (local.get $address))) + (v128.store offset=1 (i32.const 0) (global.get $zero)) + (local.get $ret)) + (func (export "v128.store16_lane_1_align_2") + (param $address i32) (param $x v128) (result i64) (local $ret i64) + (v128.store16_lane align=2 1 (local.get $address) (local.get $x)) + (local.set $ret (i64.load (local.get $address))) + (v128.store offset=1 (i32.const 0) (global.get $zero)) + (local.get $ret)) + (func (export "v128.store16_lane_2_align_1") + (param $address i32) (param $x v128) (result i64) (local $ret i64) + (v128.store16_lane align=1 2 (local.get $address) (local.get $x)) + (local.set $ret (i64.load (local.get $address))) + (v128.store offset=2 (i32.const 0) (global.get $zero)) + (local.get $ret)) + (func (export "v128.store16_lane_2_align_2") + (param $address i32) (param $x v128) (result i64) (local $ret i64) + (v128.store16_lane align=2 2 (local.get $address) (local.get $x)) + (local.set $ret (i64.load (local.get $address))) + (v128.store offset=2 (i32.const 0) (global.get $zero)) + (local.get $ret)) + (func (export "v128.store16_lane_3_align_1") + (param $address i32) (param $x v128) (result i64) (local $ret i64) + (v128.store16_lane align=1 3 (local.get $address) (local.get $x)) + (local.set $ret (i64.load (local.get $address))) + (v128.store offset=3 (i32.const 0) (global.get $zero)) + (local.get $ret)) + (func (export "v128.store16_lane_3_align_2") + (param $address i32) (param $x v128) (result i64) (local $ret i64) + (v128.store16_lane align=2 3 (local.get $address) (local.get $x)) + (local.set $ret (i64.load (local.get $address))) + (v128.store offset=3 (i32.const 0) (global.get $zero)) + (local.get $ret)) + (func (export "v128.store16_lane_4_align_1") + (param $address i32) (param $x v128) (result i64) (local $ret i64) + (v128.store16_lane align=1 4 (local.get $address) (local.get $x)) + (local.set $ret (i64.load (local.get $address))) + (v128.store offset=4 (i32.const 0) (global.get $zero)) + (local.get $ret)) + (func (export "v128.store16_lane_4_align_2") + (param $address i32) (param $x v128) (result i64) (local $ret i64) + (v128.store16_lane align=2 4 (local.get $address) (local.get $x)) + (local.set $ret (i64.load (local.get $address))) + (v128.store offset=4 (i32.const 0) (global.get $zero)) + (local.get $ret)) + (func (export "v128.store16_lane_5_align_1") + (param $address i32) (param $x v128) (result i64) (local $ret i64) + (v128.store16_lane align=1 5 (local.get $address) (local.get $x)) + (local.set $ret (i64.load (local.get $address))) + (v128.store offset=5 (i32.const 0) (global.get $zero)) + (local.get $ret)) + (func (export "v128.store16_lane_5_align_2") + (param $address i32) (param $x v128) (result i64) (local $ret i64) + (v128.store16_lane align=2 5 (local.get $address) (local.get $x)) + (local.set $ret (i64.load (local.get $address))) + (v128.store offset=5 (i32.const 0) (global.get $zero)) + (local.get $ret)) + (func (export "v128.store16_lane_6_align_1") + (param $address i32) (param $x v128) (result i64) (local $ret i64) + (v128.store16_lane align=1 6 (local.get $address) (local.get $x)) + (local.set $ret (i64.load (local.get $address))) + (v128.store offset=6 (i32.const 0) (global.get $zero)) + (local.get $ret)) + (func (export "v128.store16_lane_6_align_2") + (param $address i32) (param $x v128) (result i64) (local $ret i64) + (v128.store16_lane align=2 6 (local.get $address) (local.get $x)) + (local.set $ret (i64.load (local.get $address))) + (v128.store offset=6 (i32.const 0) (global.get $zero)) + (local.get $ret)) + (func (export "v128.store16_lane_7_align_1") + (param $address i32) (param $x v128) (result i64) (local $ret i64) + (v128.store16_lane align=1 7 (local.get $address) (local.get $x)) + (local.set $ret (i64.load (local.get $address))) + (v128.store offset=7 (i32.const 0) (global.get $zero)) + (local.get $ret)) + (func (export "v128.store16_lane_7_align_2") + (param $address i32) (param $x v128) (result i64) (local $ret i64) + (v128.store16_lane align=2 7 (local.get $address) (local.get $x)) + (local.set $ret (i64.load (local.get $address))) + (v128.store offset=7 (i32.const 0) (global.get $zero)) + (local.get $ret)) +) + +(assert_return (invoke "v128.store16_lane_0" (i32.const 0) + (v128.const i16x8 256 0 0 0 0 0 0 0)) + (i64.const 256)) +(assert_return (invoke "v128.store16_lane_1" (i32.const 1) + (v128.const i16x8 0 513 0 0 0 0 0 0)) + (i64.const 513)) +(assert_return (invoke "v128.store16_lane_2" (i32.const 2) + (v128.const i16x8 0 0 770 0 0 0 0 0)) + (i64.const 770)) +(assert_return (invoke "v128.store16_lane_3" (i32.const 3) + (v128.const i16x8 0 0 0 1027 0 0 0 0)) + (i64.const 1027)) +(assert_return (invoke "v128.store16_lane_4" (i32.const 4) + (v128.const i16x8 0 0 0 0 1284 0 0 0)) + (i64.const 1284)) +(assert_return (invoke "v128.store16_lane_5" (i32.const 5) + (v128.const i16x8 0 0 0 0 0 1541 0 0)) + (i64.const 1541)) +(assert_return (invoke "v128.store16_lane_6" (i32.const 6) + (v128.const i16x8 0 0 0 0 0 0 1798 0)) + (i64.const 1798)) +(assert_return (invoke "v128.store16_lane_7" (i32.const 7) + (v128.const i16x8 0 0 0 0 0 0 0 2055)) + (i64.const 2055)) +(assert_return (invoke "v128.store16_lane_0_offset_0" (v128.const i16x8 256 0 0 0 0 0 0 0)) + (i64.const 256)) +(assert_return (invoke "v128.store16_lane_1_offset_1" (v128.const i16x8 0 513 0 0 0 0 0 0)) + (i64.const 513)) +(assert_return (invoke "v128.store16_lane_2_offset_2" (v128.const i16x8 0 0 770 0 0 0 0 0)) + (i64.const 770)) +(assert_return (invoke "v128.store16_lane_3_offset_3" (v128.const i16x8 0 0 0 1027 0 0 0 0)) + (i64.const 1027)) +(assert_return (invoke "v128.store16_lane_4_offset_4" (v128.const i16x8 0 0 0 0 1284 0 0 0)) + (i64.const 1284)) +(assert_return (invoke "v128.store16_lane_5_offset_5" (v128.const i16x8 0 0 0 0 0 1541 0 0)) + (i64.const 1541)) +(assert_return (invoke "v128.store16_lane_6_offset_6" (v128.const i16x8 0 0 0 0 0 0 1798 0)) + (i64.const 1798)) +(assert_return (invoke "v128.store16_lane_7_offset_7" (v128.const i16x8 0 0 0 0 0 0 0 2055)) + (i64.const 2055)) +(assert_return (invoke "v128.store16_lane_0_align_1" (i32.const 0) + (v128.const i16x8 256 0 0 0 0 0 0 0)) + (i64.const 256)) +(assert_return (invoke "v128.store16_lane_0_align_2" (i32.const 0) + (v128.const i16x8 256 0 0 0 0 0 0 0)) + (i64.const 256)) +(assert_return (invoke "v128.store16_lane_1_align_1" (i32.const 1) + (v128.const i16x8 0 513 0 0 0 0 0 0)) + (i64.const 513)) +(assert_return (invoke "v128.store16_lane_1_align_2" (i32.const 1) + (v128.const i16x8 0 513 0 0 0 0 0 0)) + (i64.const 513)) +(assert_return (invoke "v128.store16_lane_2_align_1" (i32.const 2) + (v128.const i16x8 0 0 770 0 0 0 0 0)) + (i64.const 770)) +(assert_return (invoke "v128.store16_lane_2_align_2" (i32.const 2) + (v128.const i16x8 0 0 770 0 0 0 0 0)) + (i64.const 770)) +(assert_return (invoke "v128.store16_lane_3_align_1" (i32.const 3) + (v128.const i16x8 0 0 0 1027 0 0 0 0)) + (i64.const 1027)) +(assert_return (invoke "v128.store16_lane_3_align_2" (i32.const 3) + (v128.const i16x8 0 0 0 1027 0 0 0 0)) + (i64.const 1027)) +(assert_return (invoke "v128.store16_lane_4_align_1" (i32.const 4) + (v128.const i16x8 0 0 0 0 1284 0 0 0)) + (i64.const 1284)) +(assert_return (invoke "v128.store16_lane_4_align_2" (i32.const 4) + (v128.const i16x8 0 0 0 0 1284 0 0 0)) + (i64.const 1284)) +(assert_return (invoke "v128.store16_lane_5_align_1" (i32.const 5) + (v128.const i16x8 0 0 0 0 0 1541 0 0)) + (i64.const 1541)) +(assert_return (invoke "v128.store16_lane_5_align_2" (i32.const 5) + (v128.const i16x8 0 0 0 0 0 1541 0 0)) + (i64.const 1541)) +(assert_return (invoke "v128.store16_lane_6_align_1" (i32.const 6) + (v128.const i16x8 0 0 0 0 0 0 1798 0)) + (i64.const 1798)) +(assert_return (invoke "v128.store16_lane_6_align_2" (i32.const 6) + (v128.const i16x8 0 0 0 0 0 0 1798 0)) + (i64.const 1798)) +(assert_return (invoke "v128.store16_lane_7_align_1" (i32.const 7) + (v128.const i16x8 0 0 0 0 0 0 0 2055)) + (i64.const 2055)) +(assert_return (invoke "v128.store16_lane_7_align_2" (i32.const 7) + (v128.const i16x8 0 0 0 0 0 0 0 2055)) + (i64.const 2055)) + +;; type check +(assert_invalid (module (memory 1) + (func (param $x v128) (result v128) + (v128.store16_lane 0 (local.get $x) (i32.const 0)))) + "type mismatch") + +;; invalid lane index +(assert_invalid (module (memory 1) + (func (param $x v128) (result v128) + (v128.store16_lane 8 (i32.const 0) (local.get $x)))) + "invalid lane index") + +;; invalid memarg alignment +(assert_invalid + (module (memory 1) + (func (param $x v128) (result v128) + (v128.store16_lane align=4 0 (i32.const 0) (local.get $x)))) + "alignment must not be larger than natural") \ No newline at end of file diff --git a/runtime/near-vm/tests/wast/spec/proposals/simd/simd_store32_lane.wast b/runtime/near-vm/tests/wast/spec/proposals/simd/simd_store32_lane.wast new file mode 100644 index 00000000000..847bab9e6f2 --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/proposals/simd/simd_store32_lane.wast @@ -0,0 +1,199 @@ +;; Tests for store lane operations. + + +(module + (memory 1) + (global $zero (mut v128) (v128.const i32x4 0 0 0 0)) + (func (export "v128.store32_lane_0") + (param $address i32) (param $x v128) (result i64) (local $ret i64) + (v128.store32_lane 0 (local.get $address) (local.get $x)) + (local.set $ret (i64.load (local.get $address))) + (v128.store (local.get $address) (global.get $zero)) (local.get $ret)) + (func (export "v128.store32_lane_1") + (param $address i32) (param $x v128) (result i64) (local $ret i64) + (v128.store32_lane 1 (local.get $address) (local.get $x)) + (local.set $ret (i64.load (local.get $address))) + (v128.store (local.get $address) (global.get $zero)) (local.get $ret)) + (func (export "v128.store32_lane_2") + (param $address i32) (param $x v128) (result i64) (local $ret i64) + (v128.store32_lane 2 (local.get $address) (local.get $x)) + (local.set $ret (i64.load (local.get $address))) + (v128.store (local.get $address) (global.get $zero)) (local.get $ret)) + (func (export "v128.store32_lane_3") + (param $address i32) (param $x v128) (result i64) (local $ret i64) + (v128.store32_lane 3 (local.get $address) (local.get $x)) + (local.set $ret (i64.load (local.get $address))) + (v128.store (local.get $address) (global.get $zero)) (local.get $ret)) + (func (export "v128.store32_lane_0_offset_0") + (param $x v128) (result i64) (local $ret i64) + (v128.store32_lane offset=0 0 (i32.const 0) (local.get $x)) + (local.set $ret (i64.load offset=0 (i32.const 0))) + (v128.store offset=0 (i32.const 0) (global.get $zero)) + (local.get $ret)) + (func (export "v128.store32_lane_1_offset_1") + (param $x v128) (result i64) (local $ret i64) + (v128.store32_lane offset=1 1 (i32.const 0) (local.get $x)) + (local.set $ret (i64.load offset=1 (i32.const 0))) + (v128.store offset=1 (i32.const 0) (global.get $zero)) + (local.get $ret)) + (func (export "v128.store32_lane_2_offset_2") + (param $x v128) (result i64) (local $ret i64) + (v128.store32_lane offset=2 2 (i32.const 0) (local.get $x)) + (local.set $ret (i64.load offset=2 (i32.const 0))) + (v128.store offset=2 (i32.const 0) (global.get $zero)) + (local.get $ret)) + (func (export "v128.store32_lane_3_offset_3") + (param $x v128) (result i64) (local $ret i64) + (v128.store32_lane offset=3 3 (i32.const 0) (local.get $x)) + (local.set $ret (i64.load offset=3 (i32.const 0))) + (v128.store offset=3 (i32.const 0) (global.get $zero)) + (local.get $ret)) + (func (export "v128.store32_lane_0_align_1") + (param $address i32) (param $x v128) (result i64) (local $ret i64) + (v128.store32_lane align=1 0 (local.get $address) (local.get $x)) + (local.set $ret (i64.load (local.get $address))) + (v128.store offset=0 (i32.const 0) (global.get $zero)) + (local.get $ret)) + (func (export "v128.store32_lane_0_align_2") + (param $address i32) (param $x v128) (result i64) (local $ret i64) + (v128.store32_lane align=2 0 (local.get $address) (local.get $x)) + (local.set $ret (i64.load (local.get $address))) + (v128.store offset=0 (i32.const 0) (global.get $zero)) + (local.get $ret)) + (func (export "v128.store32_lane_0_align_4") + (param $address i32) (param $x v128) (result i64) (local $ret i64) + (v128.store32_lane align=4 0 (local.get $address) (local.get $x)) + (local.set $ret (i64.load (local.get $address))) + (v128.store offset=0 (i32.const 0) (global.get $zero)) + (local.get $ret)) + (func (export "v128.store32_lane_1_align_1") + (param $address i32) (param $x v128) (result i64) (local $ret i64) + (v128.store32_lane align=1 1 (local.get $address) (local.get $x)) + (local.set $ret (i64.load (local.get $address))) + (v128.store offset=1 (i32.const 0) (global.get $zero)) + (local.get $ret)) + (func (export "v128.store32_lane_1_align_2") + (param $address i32) (param $x v128) (result i64) (local $ret i64) + (v128.store32_lane align=2 1 (local.get $address) (local.get $x)) + (local.set $ret (i64.load (local.get $address))) + (v128.store offset=1 (i32.const 0) (global.get $zero)) + (local.get $ret)) + (func (export "v128.store32_lane_1_align_4") + (param $address i32) (param $x v128) (result i64) (local $ret i64) + (v128.store32_lane align=4 1 (local.get $address) (local.get $x)) + (local.set $ret (i64.load (local.get $address))) + (v128.store offset=1 (i32.const 0) (global.get $zero)) + (local.get $ret)) + (func (export "v128.store32_lane_2_align_1") + (param $address i32) (param $x v128) (result i64) (local $ret i64) + (v128.store32_lane align=1 2 (local.get $address) (local.get $x)) + (local.set $ret (i64.load (local.get $address))) + (v128.store offset=2 (i32.const 0) (global.get $zero)) + (local.get $ret)) + (func (export "v128.store32_lane_2_align_2") + (param $address i32) (param $x v128) (result i64) (local $ret i64) + (v128.store32_lane align=2 2 (local.get $address) (local.get $x)) + (local.set $ret (i64.load (local.get $address))) + (v128.store offset=2 (i32.const 0) (global.get $zero)) + (local.get $ret)) + (func (export "v128.store32_lane_2_align_4") + (param $address i32) (param $x v128) (result i64) (local $ret i64) + (v128.store32_lane align=4 2 (local.get $address) (local.get $x)) + (local.set $ret (i64.load (local.get $address))) + (v128.store offset=2 (i32.const 0) (global.get $zero)) + (local.get $ret)) + (func (export "v128.store32_lane_3_align_1") + (param $address i32) (param $x v128) (result i64) (local $ret i64) + (v128.store32_lane align=1 3 (local.get $address) (local.get $x)) + (local.set $ret (i64.load (local.get $address))) + (v128.store offset=3 (i32.const 0) (global.get $zero)) + (local.get $ret)) + (func (export "v128.store32_lane_3_align_2") + (param $address i32) (param $x v128) (result i64) (local $ret i64) + (v128.store32_lane align=2 3 (local.get $address) (local.get $x)) + (local.set $ret (i64.load (local.get $address))) + (v128.store offset=3 (i32.const 0) (global.get $zero)) + (local.get $ret)) + (func (export "v128.store32_lane_3_align_4") + (param $address i32) (param $x v128) (result i64) (local $ret i64) + (v128.store32_lane align=4 3 (local.get $address) (local.get $x)) + (local.set $ret (i64.load (local.get $address))) + (v128.store offset=3 (i32.const 0) (global.get $zero)) + (local.get $ret)) +) + +(assert_return (invoke "v128.store32_lane_0" (i32.const 0) + (v128.const i32x4 50462976 0 0 0)) + (i64.const 50462976)) +(assert_return (invoke "v128.store32_lane_1" (i32.const 1) + (v128.const i32x4 0 67305985 0 0)) + (i64.const 67305985)) +(assert_return (invoke "v128.store32_lane_2" (i32.const 2) + (v128.const i32x4 0 0 84148994 0)) + (i64.const 84148994)) +(assert_return (invoke "v128.store32_lane_3" (i32.const 3) + (v128.const i32x4 0 0 0 100992003)) + (i64.const 100992003)) +(assert_return (invoke "v128.store32_lane_0_offset_0" (v128.const i32x4 50462976 0 0 0)) + (i64.const 50462976)) +(assert_return (invoke "v128.store32_lane_1_offset_1" (v128.const i32x4 0 67305985 0 0)) + (i64.const 67305985)) +(assert_return (invoke "v128.store32_lane_2_offset_2" (v128.const i32x4 0 0 84148994 0)) + (i64.const 84148994)) +(assert_return (invoke "v128.store32_lane_3_offset_3" (v128.const i32x4 0 0 0 100992003)) + (i64.const 100992003)) +(assert_return (invoke "v128.store32_lane_0_align_1" (i32.const 0) + (v128.const i32x4 50462976 0 0 0)) + (i64.const 50462976)) +(assert_return (invoke "v128.store32_lane_0_align_2" (i32.const 0) + (v128.const i32x4 50462976 0 0 0)) + (i64.const 50462976)) +(assert_return (invoke "v128.store32_lane_0_align_4" (i32.const 0) + (v128.const i32x4 50462976 0 0 0)) + (i64.const 50462976)) +(assert_return (invoke "v128.store32_lane_1_align_1" (i32.const 1) + (v128.const i32x4 0 67305985 0 0)) + (i64.const 67305985)) +(assert_return (invoke "v128.store32_lane_1_align_2" (i32.const 1) + (v128.const i32x4 0 67305985 0 0)) + (i64.const 67305985)) +(assert_return (invoke "v128.store32_lane_1_align_4" (i32.const 1) + (v128.const i32x4 0 67305985 0 0)) + (i64.const 67305985)) +(assert_return (invoke "v128.store32_lane_2_align_1" (i32.const 2) + (v128.const i32x4 0 0 84148994 0)) + (i64.const 84148994)) +(assert_return (invoke "v128.store32_lane_2_align_2" (i32.const 2) + (v128.const i32x4 0 0 84148994 0)) + (i64.const 84148994)) +(assert_return (invoke "v128.store32_lane_2_align_4" (i32.const 2) + (v128.const i32x4 0 0 84148994 0)) + (i64.const 84148994)) +(assert_return (invoke "v128.store32_lane_3_align_1" (i32.const 3) + (v128.const i32x4 0 0 0 100992003)) + (i64.const 100992003)) +(assert_return (invoke "v128.store32_lane_3_align_2" (i32.const 3) + (v128.const i32x4 0 0 0 100992003)) + (i64.const 100992003)) +(assert_return (invoke "v128.store32_lane_3_align_4" (i32.const 3) + (v128.const i32x4 0 0 0 100992003)) + (i64.const 100992003)) + +;; type check +(assert_invalid (module (memory 1) + (func (param $x v128) (result v128) + (v128.store32_lane 0 (local.get $x) (i32.const 0)))) + "type mismatch") + +;; invalid lane index +(assert_invalid (module (memory 1) + (func (param $x v128) (result v128) + (v128.store32_lane 4 (i32.const 0) (local.get $x)))) + "invalid lane index") + +;; invalid memarg alignment +(assert_invalid + (module (memory 1) + (func (param $x v128) (result v128) + (v128.store32_lane align=8 0 (i32.const 0) (local.get $x)))) + "alignment must not be larger than natural") \ No newline at end of file diff --git a/runtime/near-vm/tests/wast/spec/proposals/simd/simd_store64_lane.wast b/runtime/near-vm/tests/wast/spec/proposals/simd/simd_store64_lane.wast new file mode 100644 index 00000000000..2ed1dcd689d --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/proposals/simd/simd_store64_lane.wast @@ -0,0 +1,131 @@ +;; Tests for store lane operations. + + +(module + (memory 1) + (global $zero (mut v128) (v128.const i32x4 0 0 0 0)) + (func (export "v128.store64_lane_0") + (param $address i32) (param $x v128) (result i64) (local $ret i64) + (v128.store64_lane 0 (local.get $address) (local.get $x)) + (local.set $ret (i64.load (local.get $address))) + (v128.store (local.get $address) (global.get $zero)) (local.get $ret)) + (func (export "v128.store64_lane_1") + (param $address i32) (param $x v128) (result i64) (local $ret i64) + (v128.store64_lane 1 (local.get $address) (local.get $x)) + (local.set $ret (i64.load (local.get $address))) + (v128.store (local.get $address) (global.get $zero)) (local.get $ret)) + (func (export "v128.store64_lane_0_offset_0") + (param $x v128) (result i64) (local $ret i64) + (v128.store64_lane offset=0 0 (i32.const 0) (local.get $x)) + (local.set $ret (i64.load offset=0 (i32.const 0))) + (v128.store offset=0 (i32.const 0) (global.get $zero)) + (local.get $ret)) + (func (export "v128.store64_lane_1_offset_1") + (param $x v128) (result i64) (local $ret i64) + (v128.store64_lane offset=1 1 (i32.const 0) (local.get $x)) + (local.set $ret (i64.load offset=1 (i32.const 0))) + (v128.store offset=1 (i32.const 0) (global.get $zero)) + (local.get $ret)) + (func (export "v128.store64_lane_0_align_1") + (param $address i32) (param $x v128) (result i64) (local $ret i64) + (v128.store64_lane align=1 0 (local.get $address) (local.get $x)) + (local.set $ret (i64.load (local.get $address))) + (v128.store offset=0 (i32.const 0) (global.get $zero)) + (local.get $ret)) + (func (export "v128.store64_lane_0_align_2") + (param $address i32) (param $x v128) (result i64) (local $ret i64) + (v128.store64_lane align=2 0 (local.get $address) (local.get $x)) + (local.set $ret (i64.load (local.get $address))) + (v128.store offset=0 (i32.const 0) (global.get $zero)) + (local.get $ret)) + (func (export "v128.store64_lane_0_align_4") + (param $address i32) (param $x v128) (result i64) (local $ret i64) + (v128.store64_lane align=4 0 (local.get $address) (local.get $x)) + (local.set $ret (i64.load (local.get $address))) + (v128.store offset=0 (i32.const 0) (global.get $zero)) + (local.get $ret)) + (func (export "v128.store64_lane_0_align_8") + (param $address i32) (param $x v128) (result i64) (local $ret i64) + (v128.store64_lane align=8 0 (local.get $address) (local.get $x)) + (local.set $ret (i64.load (local.get $address))) + (v128.store offset=0 (i32.const 0) (global.get $zero)) + (local.get $ret)) + (func (export "v128.store64_lane_1_align_1") + (param $address i32) (param $x v128) (result i64) (local $ret i64) + (v128.store64_lane align=1 1 (local.get $address) (local.get $x)) + (local.set $ret (i64.load (local.get $address))) + (v128.store offset=1 (i32.const 0) (global.get $zero)) + (local.get $ret)) + (func (export "v128.store64_lane_1_align_2") + (param $address i32) (param $x v128) (result i64) (local $ret i64) + (v128.store64_lane align=2 1 (local.get $address) (local.get $x)) + (local.set $ret (i64.load (local.get $address))) + (v128.store offset=1 (i32.const 0) (global.get $zero)) + (local.get $ret)) + (func (export "v128.store64_lane_1_align_4") + (param $address i32) (param $x v128) (result i64) (local $ret i64) + (v128.store64_lane align=4 1 (local.get $address) (local.get $x)) + (local.set $ret (i64.load (local.get $address))) + (v128.store offset=1 (i32.const 0) (global.get $zero)) + (local.get $ret)) + (func (export "v128.store64_lane_1_align_8") + (param $address i32) (param $x v128) (result i64) (local $ret i64) + (v128.store64_lane align=8 1 (local.get $address) (local.get $x)) + (local.set $ret (i64.load (local.get $address))) + (v128.store offset=1 (i32.const 0) (global.get $zero)) + (local.get $ret)) +) + +(assert_return (invoke "v128.store64_lane_0" (i32.const 0) + (v128.const i64x2 506097522914230528 0)) + (i64.const 506097522914230528)) +(assert_return (invoke "v128.store64_lane_1" (i32.const 1) + (v128.const i64x2 0 578437695752307201)) + (i64.const 578437695752307201)) +(assert_return (invoke "v128.store64_lane_0_offset_0" (v128.const i64x2 506097522914230528 0)) + (i64.const 506097522914230528)) +(assert_return (invoke "v128.store64_lane_1_offset_1" (v128.const i64x2 0 578437695752307201)) + (i64.const 578437695752307201)) +(assert_return (invoke "v128.store64_lane_0_align_1" (i32.const 0) + (v128.const i64x2 506097522914230528 0)) + (i64.const 506097522914230528)) +(assert_return (invoke "v128.store64_lane_0_align_2" (i32.const 0) + (v128.const i64x2 506097522914230528 0)) + (i64.const 506097522914230528)) +(assert_return (invoke "v128.store64_lane_0_align_4" (i32.const 0) + (v128.const i64x2 506097522914230528 0)) + (i64.const 506097522914230528)) +(assert_return (invoke "v128.store64_lane_0_align_8" (i32.const 0) + (v128.const i64x2 506097522914230528 0)) + (i64.const 506097522914230528)) +(assert_return (invoke "v128.store64_lane_1_align_1" (i32.const 1) + (v128.const i64x2 0 578437695752307201)) + (i64.const 578437695752307201)) +(assert_return (invoke "v128.store64_lane_1_align_2" (i32.const 1) + (v128.const i64x2 0 578437695752307201)) + (i64.const 578437695752307201)) +(assert_return (invoke "v128.store64_lane_1_align_4" (i32.const 1) + (v128.const i64x2 0 578437695752307201)) + (i64.const 578437695752307201)) +(assert_return (invoke "v128.store64_lane_1_align_8" (i32.const 1) + (v128.const i64x2 0 578437695752307201)) + (i64.const 578437695752307201)) + +;; type check +(assert_invalid (module (memory 1) + (func (param $x v128) (result v128) + (v128.store64_lane 0 (local.get $x) (i32.const 0)))) + "type mismatch") + +;; invalid lane index +(assert_invalid (module (memory 1) + (func (param $x v128) (result v128) + (v128.store64_lane 2 (i32.const 0) (local.get $x)))) + "invalid lane index") + +;; invalid memarg alignment +(assert_invalid + (module (memory 1) + (func (param $x v128) (result v128) + (v128.store64_lane align=16 0 (i32.const 0) (local.get $x)))) + "alignment must not be larger than natural") \ No newline at end of file diff --git a/runtime/near-vm/tests/wast/spec/proposals/simd/simd_store8_lane.wast b/runtime/near-vm/tests/wast/spec/proposals/simd/simd_store8_lane.wast new file mode 100644 index 00000000000..7258a40dd29 --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/proposals/simd/simd_store8_lane.wast @@ -0,0 +1,427 @@ +;; Tests for store lane operations. + + +(module + (memory 1) + (global $zero (mut v128) (v128.const i32x4 0 0 0 0)) + (func (export "v128.store8_lane_0") + (param $address i32) (param $x v128) (result i64) (local $ret i64) + (v128.store8_lane 0 (local.get $address) (local.get $x)) + (local.set $ret (i64.load (local.get $address))) + (v128.store (local.get $address) (global.get $zero)) (local.get $ret)) + (func (export "v128.store8_lane_1") + (param $address i32) (param $x v128) (result i64) (local $ret i64) + (v128.store8_lane 1 (local.get $address) (local.get $x)) + (local.set $ret (i64.load (local.get $address))) + (v128.store (local.get $address) (global.get $zero)) (local.get $ret)) + (func (export "v128.store8_lane_2") + (param $address i32) (param $x v128) (result i64) (local $ret i64) + (v128.store8_lane 2 (local.get $address) (local.get $x)) + (local.set $ret (i64.load (local.get $address))) + (v128.store (local.get $address) (global.get $zero)) (local.get $ret)) + (func (export "v128.store8_lane_3") + (param $address i32) (param $x v128) (result i64) (local $ret i64) + (v128.store8_lane 3 (local.get $address) (local.get $x)) + (local.set $ret (i64.load (local.get $address))) + (v128.store (local.get $address) (global.get $zero)) (local.get $ret)) + (func (export "v128.store8_lane_4") + (param $address i32) (param $x v128) (result i64) (local $ret i64) + (v128.store8_lane 4 (local.get $address) (local.get $x)) + (local.set $ret (i64.load (local.get $address))) + (v128.store (local.get $address) (global.get $zero)) (local.get $ret)) + (func (export "v128.store8_lane_5") + (param $address i32) (param $x v128) (result i64) (local $ret i64) + (v128.store8_lane 5 (local.get $address) (local.get $x)) + (local.set $ret (i64.load (local.get $address))) + (v128.store (local.get $address) (global.get $zero)) (local.get $ret)) + (func (export "v128.store8_lane_6") + (param $address i32) (param $x v128) (result i64) (local $ret i64) + (v128.store8_lane 6 (local.get $address) (local.get $x)) + (local.set $ret (i64.load (local.get $address))) + (v128.store (local.get $address) (global.get $zero)) (local.get $ret)) + (func (export "v128.store8_lane_7") + (param $address i32) (param $x v128) (result i64) (local $ret i64) + (v128.store8_lane 7 (local.get $address) (local.get $x)) + (local.set $ret (i64.load (local.get $address))) + (v128.store (local.get $address) (global.get $zero)) (local.get $ret)) + (func (export "v128.store8_lane_8") + (param $address i32) (param $x v128) (result i64) (local $ret i64) + (v128.store8_lane 8 (local.get $address) (local.get $x)) + (local.set $ret (i64.load (local.get $address))) + (v128.store (local.get $address) (global.get $zero)) (local.get $ret)) + (func (export "v128.store8_lane_9") + (param $address i32) (param $x v128) (result i64) (local $ret i64) + (v128.store8_lane 9 (local.get $address) (local.get $x)) + (local.set $ret (i64.load (local.get $address))) + (v128.store (local.get $address) (global.get $zero)) (local.get $ret)) + (func (export "v128.store8_lane_10") + (param $address i32) (param $x v128) (result i64) (local $ret i64) + (v128.store8_lane 10 (local.get $address) (local.get $x)) + (local.set $ret (i64.load (local.get $address))) + (v128.store (local.get $address) (global.get $zero)) (local.get $ret)) + (func (export "v128.store8_lane_11") + (param $address i32) (param $x v128) (result i64) (local $ret i64) + (v128.store8_lane 11 (local.get $address) (local.get $x)) + (local.set $ret (i64.load (local.get $address))) + (v128.store (local.get $address) (global.get $zero)) (local.get $ret)) + (func (export "v128.store8_lane_12") + (param $address i32) (param $x v128) (result i64) (local $ret i64) + (v128.store8_lane 12 (local.get $address) (local.get $x)) + (local.set $ret (i64.load (local.get $address))) + (v128.store (local.get $address) (global.get $zero)) (local.get $ret)) + (func (export "v128.store8_lane_13") + (param $address i32) (param $x v128) (result i64) (local $ret i64) + (v128.store8_lane 13 (local.get $address) (local.get $x)) + (local.set $ret (i64.load (local.get $address))) + (v128.store (local.get $address) (global.get $zero)) (local.get $ret)) + (func (export "v128.store8_lane_14") + (param $address i32) (param $x v128) (result i64) (local $ret i64) + (v128.store8_lane 14 (local.get $address) (local.get $x)) + (local.set $ret (i64.load (local.get $address))) + (v128.store (local.get $address) (global.get $zero)) (local.get $ret)) + (func (export "v128.store8_lane_15") + (param $address i32) (param $x v128) (result i64) (local $ret i64) + (v128.store8_lane 15 (local.get $address) (local.get $x)) + (local.set $ret (i64.load (local.get $address))) + (v128.store (local.get $address) (global.get $zero)) (local.get $ret)) + (func (export "v128.store8_lane_0_offset_0") + (param $x v128) (result i64) (local $ret i64) + (v128.store8_lane offset=0 0 (i32.const 0) (local.get $x)) + (local.set $ret (i64.load offset=0 (i32.const 0))) + (v128.store offset=0 (i32.const 0) (global.get $zero)) + (local.get $ret)) + (func (export "v128.store8_lane_1_offset_1") + (param $x v128) (result i64) (local $ret i64) + (v128.store8_lane offset=1 1 (i32.const 0) (local.get $x)) + (local.set $ret (i64.load offset=1 (i32.const 0))) + (v128.store offset=1 (i32.const 0) (global.get $zero)) + (local.get $ret)) + (func (export "v128.store8_lane_2_offset_2") + (param $x v128) (result i64) (local $ret i64) + (v128.store8_lane offset=2 2 (i32.const 0) (local.get $x)) + (local.set $ret (i64.load offset=2 (i32.const 0))) + (v128.store offset=2 (i32.const 0) (global.get $zero)) + (local.get $ret)) + (func (export "v128.store8_lane_3_offset_3") + (param $x v128) (result i64) (local $ret i64) + (v128.store8_lane offset=3 3 (i32.const 0) (local.get $x)) + (local.set $ret (i64.load offset=3 (i32.const 0))) + (v128.store offset=3 (i32.const 0) (global.get $zero)) + (local.get $ret)) + (func (export "v128.store8_lane_4_offset_4") + (param $x v128) (result i64) (local $ret i64) + (v128.store8_lane offset=4 4 (i32.const 0) (local.get $x)) + (local.set $ret (i64.load offset=4 (i32.const 0))) + (v128.store offset=4 (i32.const 0) (global.get $zero)) + (local.get $ret)) + (func (export "v128.store8_lane_5_offset_5") + (param $x v128) (result i64) (local $ret i64) + (v128.store8_lane offset=5 5 (i32.const 0) (local.get $x)) + (local.set $ret (i64.load offset=5 (i32.const 0))) + (v128.store offset=5 (i32.const 0) (global.get $zero)) + (local.get $ret)) + (func (export "v128.store8_lane_6_offset_6") + (param $x v128) (result i64) (local $ret i64) + (v128.store8_lane offset=6 6 (i32.const 0) (local.get $x)) + (local.set $ret (i64.load offset=6 (i32.const 0))) + (v128.store offset=6 (i32.const 0) (global.get $zero)) + (local.get $ret)) + (func (export "v128.store8_lane_7_offset_7") + (param $x v128) (result i64) (local $ret i64) + (v128.store8_lane offset=7 7 (i32.const 0) (local.get $x)) + (local.set $ret (i64.load offset=7 (i32.const 0))) + (v128.store offset=7 (i32.const 0) (global.get $zero)) + (local.get $ret)) + (func (export "v128.store8_lane_8_offset_8") + (param $x v128) (result i64) (local $ret i64) + (v128.store8_lane offset=8 8 (i32.const 0) (local.get $x)) + (local.set $ret (i64.load offset=8 (i32.const 0))) + (v128.store offset=8 (i32.const 0) (global.get $zero)) + (local.get $ret)) + (func (export "v128.store8_lane_9_offset_9") + (param $x v128) (result i64) (local $ret i64) + (v128.store8_lane offset=9 9 (i32.const 0) (local.get $x)) + (local.set $ret (i64.load offset=9 (i32.const 0))) + (v128.store offset=9 (i32.const 0) (global.get $zero)) + (local.get $ret)) + (func (export "v128.store8_lane_10_offset_10") + (param $x v128) (result i64) (local $ret i64) + (v128.store8_lane offset=10 10 (i32.const 0) (local.get $x)) + (local.set $ret (i64.load offset=10 (i32.const 0))) + (v128.store offset=10 (i32.const 0) (global.get $zero)) + (local.get $ret)) + (func (export "v128.store8_lane_11_offset_11") + (param $x v128) (result i64) (local $ret i64) + (v128.store8_lane offset=11 11 (i32.const 0) (local.get $x)) + (local.set $ret (i64.load offset=11 (i32.const 0))) + (v128.store offset=11 (i32.const 0) (global.get $zero)) + (local.get $ret)) + (func (export "v128.store8_lane_12_offset_12") + (param $x v128) (result i64) (local $ret i64) + (v128.store8_lane offset=12 12 (i32.const 0) (local.get $x)) + (local.set $ret (i64.load offset=12 (i32.const 0))) + (v128.store offset=12 (i32.const 0) (global.get $zero)) + (local.get $ret)) + (func (export "v128.store8_lane_13_offset_13") + (param $x v128) (result i64) (local $ret i64) + (v128.store8_lane offset=13 13 (i32.const 0) (local.get $x)) + (local.set $ret (i64.load offset=13 (i32.const 0))) + (v128.store offset=13 (i32.const 0) (global.get $zero)) + (local.get $ret)) + (func (export "v128.store8_lane_14_offset_14") + (param $x v128) (result i64) (local $ret i64) + (v128.store8_lane offset=14 14 (i32.const 0) (local.get $x)) + (local.set $ret (i64.load offset=14 (i32.const 0))) + (v128.store offset=14 (i32.const 0) (global.get $zero)) + (local.get $ret)) + (func (export "v128.store8_lane_15_offset_15") + (param $x v128) (result i64) (local $ret i64) + (v128.store8_lane offset=15 15 (i32.const 0) (local.get $x)) + (local.set $ret (i64.load offset=15 (i32.const 0))) + (v128.store offset=15 (i32.const 0) (global.get $zero)) + (local.get $ret)) + (func (export "v128.store8_lane_0_align_1") + (param $address i32) (param $x v128) (result i64) (local $ret i64) + (v128.store8_lane align=1 0 (local.get $address) (local.get $x)) + (local.set $ret (i64.load (local.get $address))) + (v128.store offset=0 (i32.const 0) (global.get $zero)) + (local.get $ret)) + (func (export "v128.store8_lane_1_align_1") + (param $address i32) (param $x v128) (result i64) (local $ret i64) + (v128.store8_lane align=1 1 (local.get $address) (local.get $x)) + (local.set $ret (i64.load (local.get $address))) + (v128.store offset=1 (i32.const 0) (global.get $zero)) + (local.get $ret)) + (func (export "v128.store8_lane_2_align_1") + (param $address i32) (param $x v128) (result i64) (local $ret i64) + (v128.store8_lane align=1 2 (local.get $address) (local.get $x)) + (local.set $ret (i64.load (local.get $address))) + (v128.store offset=2 (i32.const 0) (global.get $zero)) + (local.get $ret)) + (func (export "v128.store8_lane_3_align_1") + (param $address i32) (param $x v128) (result i64) (local $ret i64) + (v128.store8_lane align=1 3 (local.get $address) (local.get $x)) + (local.set $ret (i64.load (local.get $address))) + (v128.store offset=3 (i32.const 0) (global.get $zero)) + (local.get $ret)) + (func (export "v128.store8_lane_4_align_1") + (param $address i32) (param $x v128) (result i64) (local $ret i64) + (v128.store8_lane align=1 4 (local.get $address) (local.get $x)) + (local.set $ret (i64.load (local.get $address))) + (v128.store offset=4 (i32.const 0) (global.get $zero)) + (local.get $ret)) + (func (export "v128.store8_lane_5_align_1") + (param $address i32) (param $x v128) (result i64) (local $ret i64) + (v128.store8_lane align=1 5 (local.get $address) (local.get $x)) + (local.set $ret (i64.load (local.get $address))) + (v128.store offset=5 (i32.const 0) (global.get $zero)) + (local.get $ret)) + (func (export "v128.store8_lane_6_align_1") + (param $address i32) (param $x v128) (result i64) (local $ret i64) + (v128.store8_lane align=1 6 (local.get $address) (local.get $x)) + (local.set $ret (i64.load (local.get $address))) + (v128.store offset=6 (i32.const 0) (global.get $zero)) + (local.get $ret)) + (func (export "v128.store8_lane_7_align_1") + (param $address i32) (param $x v128) (result i64) (local $ret i64) + (v128.store8_lane align=1 7 (local.get $address) (local.get $x)) + (local.set $ret (i64.load (local.get $address))) + (v128.store offset=7 (i32.const 0) (global.get $zero)) + (local.get $ret)) + (func (export "v128.store8_lane_8_align_1") + (param $address i32) (param $x v128) (result i64) (local $ret i64) + (v128.store8_lane align=1 8 (local.get $address) (local.get $x)) + (local.set $ret (i64.load (local.get $address))) + (v128.store offset=8 (i32.const 0) (global.get $zero)) + (local.get $ret)) + (func (export "v128.store8_lane_9_align_1") + (param $address i32) (param $x v128) (result i64) (local $ret i64) + (v128.store8_lane align=1 9 (local.get $address) (local.get $x)) + (local.set $ret (i64.load (local.get $address))) + (v128.store offset=9 (i32.const 0) (global.get $zero)) + (local.get $ret)) + (func (export "v128.store8_lane_10_align_1") + (param $address i32) (param $x v128) (result i64) (local $ret i64) + (v128.store8_lane align=1 10 (local.get $address) (local.get $x)) + (local.set $ret (i64.load (local.get $address))) + (v128.store offset=10 (i32.const 0) (global.get $zero)) + (local.get $ret)) + (func (export "v128.store8_lane_11_align_1") + (param $address i32) (param $x v128) (result i64) (local $ret i64) + (v128.store8_lane align=1 11 (local.get $address) (local.get $x)) + (local.set $ret (i64.load (local.get $address))) + (v128.store offset=11 (i32.const 0) (global.get $zero)) + (local.get $ret)) + (func (export "v128.store8_lane_12_align_1") + (param $address i32) (param $x v128) (result i64) (local $ret i64) + (v128.store8_lane align=1 12 (local.get $address) (local.get $x)) + (local.set $ret (i64.load (local.get $address))) + (v128.store offset=12 (i32.const 0) (global.get $zero)) + (local.get $ret)) + (func (export "v128.store8_lane_13_align_1") + (param $address i32) (param $x v128) (result i64) (local $ret i64) + (v128.store8_lane align=1 13 (local.get $address) (local.get $x)) + (local.set $ret (i64.load (local.get $address))) + (v128.store offset=13 (i32.const 0) (global.get $zero)) + (local.get $ret)) + (func (export "v128.store8_lane_14_align_1") + (param $address i32) (param $x v128) (result i64) (local $ret i64) + (v128.store8_lane align=1 14 (local.get $address) (local.get $x)) + (local.set $ret (i64.load (local.get $address))) + (v128.store offset=14 (i32.const 0) (global.get $zero)) + (local.get $ret)) + (func (export "v128.store8_lane_15_align_1") + (param $address i32) (param $x v128) (result i64) (local $ret i64) + (v128.store8_lane align=1 15 (local.get $address) (local.get $x)) + (local.set $ret (i64.load (local.get $address))) + (v128.store offset=15 (i32.const 0) (global.get $zero)) + (local.get $ret)) +) + +(assert_return (invoke "v128.store8_lane_0" (i32.const 0) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + (i64.const 0)) +(assert_return (invoke "v128.store8_lane_1" (i32.const 1) + (v128.const i8x16 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + (i64.const 1)) +(assert_return (invoke "v128.store8_lane_2" (i32.const 2) + (v128.const i8x16 0 0 2 0 0 0 0 0 0 0 0 0 0 0 0 0)) + (i64.const 2)) +(assert_return (invoke "v128.store8_lane_3" (i32.const 3) + (v128.const i8x16 0 0 0 3 0 0 0 0 0 0 0 0 0 0 0 0)) + (i64.const 3)) +(assert_return (invoke "v128.store8_lane_4" (i32.const 4) + (v128.const i8x16 0 0 0 0 4 0 0 0 0 0 0 0 0 0 0 0)) + (i64.const 4)) +(assert_return (invoke "v128.store8_lane_5" (i32.const 5) + (v128.const i8x16 0 0 0 0 0 5 0 0 0 0 0 0 0 0 0 0)) + (i64.const 5)) +(assert_return (invoke "v128.store8_lane_6" (i32.const 6) + (v128.const i8x16 0 0 0 0 0 0 6 0 0 0 0 0 0 0 0 0)) + (i64.const 6)) +(assert_return (invoke "v128.store8_lane_7" (i32.const 7) + (v128.const i8x16 0 0 0 0 0 0 0 7 0 0 0 0 0 0 0 0)) + (i64.const 7)) +(assert_return (invoke "v128.store8_lane_8" (i32.const 8) + (v128.const i8x16 0 0 0 0 0 0 0 0 8 0 0 0 0 0 0 0)) + (i64.const 8)) +(assert_return (invoke "v128.store8_lane_9" (i32.const 9) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 9 0 0 0 0 0 0)) + (i64.const 9)) +(assert_return (invoke "v128.store8_lane_10" (i32.const 10) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 10 0 0 0 0 0)) + (i64.const 10)) +(assert_return (invoke "v128.store8_lane_11" (i32.const 11) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 11 0 0 0 0)) + (i64.const 11)) +(assert_return (invoke "v128.store8_lane_12" (i32.const 12) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 12 0 0 0)) + (i64.const 12)) +(assert_return (invoke "v128.store8_lane_13" (i32.const 13) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 13 0 0)) + (i64.const 13)) +(assert_return (invoke "v128.store8_lane_14" (i32.const 14) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 14 0)) + (i64.const 14)) +(assert_return (invoke "v128.store8_lane_15" (i32.const 15) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 15)) + (i64.const 15)) +(assert_return (invoke "v128.store8_lane_0_offset_0" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + (i64.const 0)) +(assert_return (invoke "v128.store8_lane_1_offset_1" (v128.const i8x16 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + (i64.const 1)) +(assert_return (invoke "v128.store8_lane_2_offset_2" (v128.const i8x16 0 0 2 0 0 0 0 0 0 0 0 0 0 0 0 0)) + (i64.const 2)) +(assert_return (invoke "v128.store8_lane_3_offset_3" (v128.const i8x16 0 0 0 3 0 0 0 0 0 0 0 0 0 0 0 0)) + (i64.const 3)) +(assert_return (invoke "v128.store8_lane_4_offset_4" (v128.const i8x16 0 0 0 0 4 0 0 0 0 0 0 0 0 0 0 0)) + (i64.const 4)) +(assert_return (invoke "v128.store8_lane_5_offset_5" (v128.const i8x16 0 0 0 0 0 5 0 0 0 0 0 0 0 0 0 0)) + (i64.const 5)) +(assert_return (invoke "v128.store8_lane_6_offset_6" (v128.const i8x16 0 0 0 0 0 0 6 0 0 0 0 0 0 0 0 0)) + (i64.const 6)) +(assert_return (invoke "v128.store8_lane_7_offset_7" (v128.const i8x16 0 0 0 0 0 0 0 7 0 0 0 0 0 0 0 0)) + (i64.const 7)) +(assert_return (invoke "v128.store8_lane_8_offset_8" (v128.const i8x16 0 0 0 0 0 0 0 0 8 0 0 0 0 0 0 0)) + (i64.const 8)) +(assert_return (invoke "v128.store8_lane_9_offset_9" (v128.const i8x16 0 0 0 0 0 0 0 0 0 9 0 0 0 0 0 0)) + (i64.const 9)) +(assert_return (invoke "v128.store8_lane_10_offset_10" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 10 0 0 0 0 0)) + (i64.const 10)) +(assert_return (invoke "v128.store8_lane_11_offset_11" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 11 0 0 0 0)) + (i64.const 11)) +(assert_return (invoke "v128.store8_lane_12_offset_12" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 12 0 0 0)) + (i64.const 12)) +(assert_return (invoke "v128.store8_lane_13_offset_13" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 13 0 0)) + (i64.const 13)) +(assert_return (invoke "v128.store8_lane_14_offset_14" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 14 0)) + (i64.const 14)) +(assert_return (invoke "v128.store8_lane_15_offset_15" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 15)) + (i64.const 15)) +(assert_return (invoke "v128.store8_lane_0_align_1" (i32.const 0) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + (i64.const 0)) +(assert_return (invoke "v128.store8_lane_1_align_1" (i32.const 1) + (v128.const i8x16 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) + (i64.const 1)) +(assert_return (invoke "v128.store8_lane_2_align_1" (i32.const 2) + (v128.const i8x16 0 0 2 0 0 0 0 0 0 0 0 0 0 0 0 0)) + (i64.const 2)) +(assert_return (invoke "v128.store8_lane_3_align_1" (i32.const 3) + (v128.const i8x16 0 0 0 3 0 0 0 0 0 0 0 0 0 0 0 0)) + (i64.const 3)) +(assert_return (invoke "v128.store8_lane_4_align_1" (i32.const 4) + (v128.const i8x16 0 0 0 0 4 0 0 0 0 0 0 0 0 0 0 0)) + (i64.const 4)) +(assert_return (invoke "v128.store8_lane_5_align_1" (i32.const 5) + (v128.const i8x16 0 0 0 0 0 5 0 0 0 0 0 0 0 0 0 0)) + (i64.const 5)) +(assert_return (invoke "v128.store8_lane_6_align_1" (i32.const 6) + (v128.const i8x16 0 0 0 0 0 0 6 0 0 0 0 0 0 0 0 0)) + (i64.const 6)) +(assert_return (invoke "v128.store8_lane_7_align_1" (i32.const 7) + (v128.const i8x16 0 0 0 0 0 0 0 7 0 0 0 0 0 0 0 0)) + (i64.const 7)) +(assert_return (invoke "v128.store8_lane_8_align_1" (i32.const 8) + (v128.const i8x16 0 0 0 0 0 0 0 0 8 0 0 0 0 0 0 0)) + (i64.const 8)) +(assert_return (invoke "v128.store8_lane_9_align_1" (i32.const 9) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 9 0 0 0 0 0 0)) + (i64.const 9)) +(assert_return (invoke "v128.store8_lane_10_align_1" (i32.const 10) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 10 0 0 0 0 0)) + (i64.const 10)) +(assert_return (invoke "v128.store8_lane_11_align_1" (i32.const 11) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 11 0 0 0 0)) + (i64.const 11)) +(assert_return (invoke "v128.store8_lane_12_align_1" (i32.const 12) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 12 0 0 0)) + (i64.const 12)) +(assert_return (invoke "v128.store8_lane_13_align_1" (i32.const 13) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 13 0 0)) + (i64.const 13)) +(assert_return (invoke "v128.store8_lane_14_align_1" (i32.const 14) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 14 0)) + (i64.const 14)) +(assert_return (invoke "v128.store8_lane_15_align_1" (i32.const 15) + (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 15)) + (i64.const 15)) + +;; type check +(assert_invalid (module (memory 1) + (func (param $x v128) (result v128) + (v128.store8_lane 0 (local.get $x) (i32.const 0)))) + "type mismatch") + +;; invalid lane index +(assert_invalid (module (memory 1) + (func (param $x v128) (result v128) + (v128.store8_lane 16 (i32.const 0) (local.get $x)))) + "invalid lane index") + +;; invalid memarg alignment +(assert_invalid + (module (memory 1) + (func (param $x v128) (result v128) + (v128.store8_lane align=2 0 (i32.const 0) (local.get $x)))) + "alignment must not be larger than natural") \ No newline at end of file diff --git a/runtime/near-vm/tests/wast/spec/proposals/tail-call/return_call.wast b/runtime/near-vm/tests/wast/spec/proposals/tail-call/return_call.wast new file mode 100644 index 00000000000..2f91f4deac6 --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/proposals/tail-call/return_call.wast @@ -0,0 +1,202 @@ +;; Test `return_call` operator + +(module + ;; Auxiliary definitions + (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)) + + ;; Typing + + (func (export "type-i32") (result i32) (return_call $const-i32)) + (func (export "type-i64") (result i64) (return_call $const-i64)) + (func (export "type-f32") (result f32) (return_call $const-f32)) + (func (export "type-f64") (result f64) (return_call $const-f64)) + + (func (export "type-first-i32") (result i32) (return_call $id-i32 (i32.const 32))) + (func (export "type-first-i64") (result i64) (return_call $id-i64 (i64.const 64))) + (func (export "type-first-f32") (result f32) (return_call $id-f32 (f32.const 1.32))) + (func (export "type-first-f64") (result f64) (return_call $id-f64 (f64.const 1.64))) + + (func (export "type-second-i32") (result i32) + (return_call $f32-i32 (f32.const 32.1) (i32.const 32)) + ) + (func (export "type-second-i64") (result i64) + (return_call $i32-i64 (i32.const 32) (i64.const 64)) + ) + (func (export "type-second-f32") (result f32) + (return_call $f64-f32 (f64.const 64) (f32.const 32)) + ) + (func (export "type-second-f64") (result f64) + (return_call $i64-f64 (i64.const 64) (f64.const 64.1)) + ) + + ;; Recursion + + (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 $fac-acc + (i64.sub (local.get 0) (i64.const 1)) + (i64.mul (local.get 0) (local.get 1)) + ) + ) + ) + ) + + (func $count (export "count") (param i64) (result i64) + (if (result i64) (i64.eqz (local.get 0)) + (then (local.get 0)) + (else (return_call $count (i64.sub (local.get 0) (i64.const 1)))) + ) + ) + + (func $even (export "even") (param i64) (result i32) + (if (result i32) (i64.eqz (local.get 0)) + (then (i32.const 44)) + (else (return_call $odd (i64.sub (local.get 0) (i64.const 1)))) + ) + ) + (func $odd (export "odd") (param i64) (result i32) + (if (result i32) (i64.eqz (local.get 0)) + (then (i32.const 99)) + (else (return_call $even (i64.sub (local.get 0) (i64.const 1)))) + ) + ) +) + +(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_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 1_000_000)) (i64.const 0)) + +(assert_return (invoke "even" (i64.const 0)) (i32.const 44)) +(assert_return (invoke "even" (i64.const 1)) (i32.const 99)) +(assert_return (invoke "even" (i64.const 100)) (i32.const 44)) +(assert_return (invoke "even" (i64.const 77)) (i32.const 99)) +(assert_return (invoke "even" (i64.const 1_000_000)) (i32.const 44)) +(assert_return (invoke "even" (i64.const 1_000_001)) (i32.const 99)) +(assert_return (invoke "odd" (i64.const 0)) (i32.const 99)) +(assert_return (invoke "odd" (i64.const 1)) (i32.const 44)) +(assert_return (invoke "odd" (i64.const 200)) (i32.const 99)) +(assert_return (invoke "odd" (i64.const 77)) (i32.const 44)) +(assert_return (invoke "odd" (i64.const 1_000_000)) (i32.const 99)) +(assert_return (invoke "odd" (i64.const 999_999)) (i32.const 44)) + + +;; Invalid typing + +(assert_invalid + (module + (func $type-void-vs-num (result i32) (return_call 1) (i32.const 0)) + (func) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-num-vs-num (result i32) (return_call 1) (i32.const 0)) + (func (result i64) (i64.const 1)) + ) + "type mismatch" +) + +(assert_invalid + (module + (func $arity-0-vs-1 (return_call 1)) + (func (param i32)) + ) + "type mismatch" +) +(assert_invalid + (module + (func $arity-0-vs-2 (return_call 1)) + (func (param f64 i32)) + ) + "type mismatch" +) + +(module + (func $arity-1-vs-0 (i32.const 1) (return_call 1)) + (func) +) + +(module + (func $arity-2-vs-0 (f64.const 2) (i32.const 1) (return_call 1)) + (func) +) + +(assert_invalid + (module + (func $type-first-void-vs-num (return_call 1 (nop) (i32.const 1))) + (func (param i32 i32)) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-second-void-vs-num (return_call 1 (i32.const 1) (nop))) + (func (param i32 i32)) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-first-num-vs-num (return_call 1 (f64.const 1) (i32.const 1))) + (func (param i32 f64)) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-second-num-vs-num (return_call 1 (i32.const 1) (f64.const 1))) + (func (param f64 i32)) + ) + "type mismatch" +) + + +;; Unbound function + +(assert_invalid + (module (func $unbound-func (return_call 1))) + "unknown function" +) +(assert_invalid + (module (func $large-func (return_call 1012321300))) + "unknown function" +) diff --git a/runtime/near-vm/tests/wast/spec/proposals/tail-call/return_call_indirect.wast b/runtime/near-vm/tests/wast/spec/proposals/tail-call/return_call_indirect.wast new file mode 100644 index 00000000000..acf0a72e06a --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/proposals/tail-call/return_call_indirect.wast @@ -0,0 +1,536 @@ +;; Test `return_call_indirect` operator + +(module + ;; Auxiliary definitions + (type $proc (func)) + (type $out-i32 (func (result i32))) + (type $out-i64 (func (result i64))) + (type $out-f32 (func (result f32))) + (type $out-f64 (func (result f64))) + (type $over-i32 (func (param i32) (result i32))) + (type $over-i64 (func (param i64) (result i64))) + (type $over-f32 (func (param f32) (result f32))) + (type $over-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 $over-i32-duplicate (func (param i32) (result i32))) + (type $over-i64-duplicate (func (param i64) (result i64))) + (type $over-f32-duplicate (func (param f32) (result f32))) + (type $over-f64-duplicate (func (param f64) (result f64))) + + (func $const-i32 (type $out-i32) (i32.const 0x132)) + (func $const-i64 (type $out-i64) (i64.const 0x164)) + (func $const-f32 (type $out-f32) (f32.const 0xf32)) + (func $const-f64 (type $out-f64) (f64.const 0xf64)) + + (func $id-i32 (type $over-i32) (local.get 0)) + (func $id-i64 (type $over-i64) (local.get 0)) + (func $id-f32 (type $over-f32) (local.get 0)) + (func $id-f64 (type $over-f64) (local.get 0)) + + (func $i32-i64 (type $i32-i64) (local.get 1)) + (func $i64-f64 (type $i64-f64) (local.get 1)) + (func $f32-i32 (type $f32-i32) (local.get 1)) + (func $f64-f32 (type $f64-f32) (local.get 1)) + + (func $over-i32-duplicate (type $over-i32-duplicate) (local.get 0)) + (func $over-i64-duplicate (type $over-i64-duplicate) (local.get 0)) + (func $over-f32-duplicate (type $over-f32-duplicate) (local.get 0)) + (func $over-f64-duplicate (type $over-f64-duplicate) (local.get 0)) + + (table funcref + (elem + $const-i32 $const-i64 $const-f32 $const-f64 + $id-i32 $id-i64 $id-f32 $id-f64 + $f32-i32 $i32-i64 $f64-f32 $i64-f64 + $fac $fac-acc $even $odd + $over-i32-duplicate $over-i64-duplicate + $over-f32-duplicate $over-f64-duplicate + ) + ) + + ;; Syntax + + (func + (return_call_indirect (i32.const 0)) + (return_call_indirect (param i64) (i64.const 0) (i32.const 0)) + (return_call_indirect (param i64) (param) (param f64 i32 i64) + (i64.const 0) (f64.const 0) (i32.const 0) (i64.const 0) (i32.const 0) + ) + (return_call_indirect (result) (i32.const 0)) + ) + + (func (result i32) + (return_call_indirect (result i32) (i32.const 0)) + (return_call_indirect (result i32) (result) (i32.const 0)) + (return_call_indirect (param i64) (result i32) (i64.const 0) (i32.const 0)) + (return_call_indirect + (param) (param i64) (param) (param f64 i32 i64) (param) (param) + (result) (result i32) (result) (result) + (i64.const 0) (f64.const 0) (i32.const 0) (i64.const 0) (i32.const 0) + ) + ) + + (func (result i64) + (return_call_indirect (type $over-i64) (param i64) (result i64) + (i64.const 0) (i32.const 0) + ) + ) + + ;; Typing + + (func (export "type-i32") (result i32) + (return_call_indirect (type $out-i32) (i32.const 0)) + ) + (func (export "type-i64") (result i64) + (return_call_indirect (type $out-i64) (i32.const 1)) + ) + (func (export "type-f32") (result f32) + (return_call_indirect (type $out-f32) (i32.const 2)) + ) + (func (export "type-f64") (result f64) + (return_call_indirect (type $out-f64) (i32.const 3)) + ) + + (func (export "type-index") (result i64) + (return_call_indirect (type $over-i64) (i64.const 100) (i32.const 5)) + ) + + (func (export "type-first-i32") (result i32) + (return_call_indirect (type $over-i32) (i32.const 32) (i32.const 4)) + ) + (func (export "type-first-i64") (result i64) + (return_call_indirect (type $over-i64) (i64.const 64) (i32.const 5)) + ) + (func (export "type-first-f32") (result f32) + (return_call_indirect (type $over-f32) (f32.const 1.32) (i32.const 6)) + ) + (func (export "type-first-f64") (result f64) + (return_call_indirect (type $over-f64) (f64.const 1.64) (i32.const 7)) + ) + + (func (export "type-second-i32") (result i32) + (return_call_indirect (type $f32-i32) + (f32.const 32.1) (i32.const 32) (i32.const 8) + ) + ) + (func (export "type-second-i64") (result i64) + (return_call_indirect (type $i32-i64) + (i32.const 32) (i64.const 64) (i32.const 9) + ) + ) + (func (export "type-second-f32") (result f32) + (return_call_indirect (type $f64-f32) + (f64.const 64) (f32.const 32) (i32.const 10) + ) + ) + (func (export "type-second-f64") (result f64) + (return_call_indirect (type $i64-f64) + (i64.const 64) (f64.const 64.1) (i32.const 11) + ) + ) + + ;; Dispatch + + (func (export "dispatch") (param i32 i64) (result i64) + (return_call_indirect (type $over-i64) (local.get 1) (local.get 0)) + ) + + (func (export "dispatch-structural") (param i32) (result i64) + (return_call_indirect (type $over-i64-duplicate) + (i64.const 9) (local.get 0) + ) + ) + + ;; Multiple tables + + (table $tab2 funcref (elem $tab-f1)) + (table $tab3 funcref (elem $tab-f2)) + + (func $tab-f1 (result i32) (i32.const 0x133)) + (func $tab-f2 (result i32) (i32.const 0x134)) + + (func (export "call-tab") (param $i i32) (result i32) + (if (i32.eq (local.get $i) (i32.const 0)) + (then (return_call_indirect (type $out-i32) (i32.const 0))) + ) + (if (i32.eq (local.get $i) (i32.const 1)) + (then (return_call_indirect 1 (type $out-i32) (i32.const 0))) + ) + (if (i32.eq (local.get $i) (i32.const 2)) + (then (return_call_indirect $tab3 (type $out-i32) (i32.const 0))) + ) + (i32.const 0) + ) + + ;; Recursion + + (func $fac (export "fac") (type $over-i64) + (return_call_indirect (param i64 i64) (result i64) + (local.get 0) (i64.const 1) (i32.const 13) + ) + ) + + (func $fac-acc (param i64 i64) (result i64) + (if (result i64) (i64.eqz (local.get 0)) + (then (local.get 1)) + (else + (return_call_indirect (param i64 i64) (result i64) + (i64.sub (local.get 0) (i64.const 1)) + (i64.mul (local.get 0) (local.get 1)) + (i32.const 13) + ) + ) + ) + ) + + (func $even (export "even") (param i32) (result i32) + (if (result i32) (i32.eqz (local.get 0)) + (then (i32.const 44)) + (else + (return_call_indirect (type $over-i32) + (i32.sub (local.get 0) (i32.const 1)) + (i32.const 15) + ) + ) + ) + ) + (func $odd (export "odd") (param i32) (result i32) + (if (result i32) (i32.eqz (local.get 0)) + (then (i32.const 99)) + (else + (return_call_indirect (type $over-i32) + (i32.sub (local.get 0) (i32.const 1)) + (i32.const 14) + ) + ) + ) + ) +) + +(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-index") (i64.const 100)) + +(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_return (invoke "dispatch" (i32.const 5) (i64.const 2)) (i64.const 2)) +(assert_return (invoke "dispatch" (i32.const 5) (i64.const 5)) (i64.const 5)) +(assert_return (invoke "dispatch" (i32.const 12) (i64.const 5)) (i64.const 120)) +(assert_return (invoke "dispatch" (i32.const 17) (i64.const 2)) (i64.const 2)) +(assert_trap (invoke "dispatch" (i32.const 0) (i64.const 2)) "indirect call type mismatch") +(assert_trap (invoke "dispatch" (i32.const 15) (i64.const 2)) "indirect call type mismatch") +(assert_trap (invoke "dispatch" (i32.const 20) (i64.const 2)) "undefined element") +(assert_trap (invoke "dispatch" (i32.const -1) (i64.const 2)) "undefined element") +(assert_trap (invoke "dispatch" (i32.const 1213432423) (i64.const 2)) "undefined element") + +(assert_return (invoke "dispatch-structural" (i32.const 5)) (i64.const 9)) +(assert_return (invoke "dispatch-structural" (i32.const 5)) (i64.const 9)) +(assert_return (invoke "dispatch-structural" (i32.const 12)) (i64.const 362880)) +(assert_return (invoke "dispatch-structural" (i32.const 17)) (i64.const 9)) +(assert_trap (invoke "dispatch-structural" (i32.const 11)) "indirect call type mismatch") +(assert_trap (invoke "dispatch-structural" (i32.const 16)) "indirect call type mismatch") + +(assert_return (invoke "call-tab" (i32.const 0)) (i32.const 0x132)) +(assert_return (invoke "call-tab" (i32.const 1)) (i32.const 0x133)) +(assert_return (invoke "call-tab" (i32.const 2)) (i32.const 0x134)) + +(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 "even" (i32.const 0)) (i32.const 44)) +(assert_return (invoke "even" (i32.const 1)) (i32.const 99)) +(assert_return (invoke "even" (i32.const 100)) (i32.const 44)) +(assert_return (invoke "even" (i32.const 77)) (i32.const 99)) +(assert_return (invoke "even" (i32.const 100_000)) (i32.const 44)) +(assert_return (invoke "even" (i32.const 111_111)) (i32.const 99)) +(assert_return (invoke "odd" (i32.const 0)) (i32.const 99)) +(assert_return (invoke "odd" (i32.const 1)) (i32.const 44)) +(assert_return (invoke "odd" (i32.const 200)) (i32.const 99)) +(assert_return (invoke "odd" (i32.const 77)) (i32.const 44)) +(assert_return (invoke "odd" (i32.const 200_002)) (i32.const 99)) +(assert_return (invoke "odd" (i32.const 300_003)) (i32.const 44)) + + +;; Invalid syntax + +(assert_malformed + (module quote + "(type $sig (func (param i32) (result i32)))" + "(table 0 funcref)" + "(func (result i32)" + " (return_call_indirect (type $sig) (result i32) (param i32)" + " (i32.const 0) (i32.const 0)" + " )" + ")" + ) + "unexpected token" +) +(assert_malformed + (module quote + "(type $sig (func (param i32) (result i32)))" + "(table 0 funcref)" + "(func (result i32)" + " (return_call_indirect (param i32) (type $sig) (result i32)" + " (i32.const 0) (i32.const 0)" + " )" + ")" + ) + "unexpected token" +) +(assert_malformed + (module quote + "(type $sig (func (param i32) (result i32)))" + "(table 0 funcref)" + "(func (result i32)" + " (return_call_indirect (param i32) (result i32) (type $sig)" + " (i32.const 0) (i32.const 0)" + " )" + ")" + ) + "unexpected token" +) +(assert_malformed + (module quote + "(type $sig (func (param i32) (result i32)))" + "(table 0 funcref)" + "(func (result i32)" + " (return_call_indirect (result i32) (type $sig) (param i32)" + " (i32.const 0) (i32.const 0)" + " )" + ")" + ) + "unexpected token" +) +(assert_malformed + (module quote + "(type $sig (func (param i32) (result i32)))" + "(table 0 funcref)" + "(func (result i32)" + " (return_call_indirect (result i32) (param i32) (type $sig)" + " (i32.const 0) (i32.const 0)" + " )" + ")" + ) + "unexpected token" +) +(assert_malformed + (module quote + "(table 0 funcref)" + "(func (result i32)" + " (return_call_indirect (result i32) (param i32)" + " (i32.const 0) (i32.const 0)" + " )" + ")" + ) + "unexpected token" +) + +(assert_malformed + (module quote + "(table 0 funcref)" + "(func (return_call_indirect (param $x i32) (i32.const 0) (i32.const 0)))" + ) + "unexpected token" +) +(assert_malformed + (module quote + "(type $sig (func))" + "(table 0 funcref)" + "(func (result i32)" + " (return_call_indirect (type $sig) (result i32) (i32.const 0))" + ")" + ) + "inline function type" +) +(assert_malformed + (module quote + "(type $sig (func (param i32) (result i32)))" + "(table 0 funcref)" + "(func (result i32)" + " (return_call_indirect (type $sig) (result i32) (i32.const 0))" + ")" + ) + "inline function type" +) +(assert_malformed + (module quote + "(type $sig (func (param i32) (result i32)))" + "(table 0 funcref)" + "(func" + " (return_call_indirect (type $sig) (param i32)" + " (i32.const 0) (i32.const 0)" + " )" + ")" + ) + "inline function type" +) +(assert_malformed + (module quote + "(type $sig (func (param i32 i32) (result i32)))" + "(table 0 funcref)" + "(func (result i32)" + " (return_call_indirect (type $sig) (param i32) (result i32)" + " (i32.const 0) (i32.const 0)" + " )" + ")" + ) + "inline function type" +) + +;; Invalid typing + +(assert_invalid + (module + (type (func)) + (func $no-table (return_call_indirect (type 0) (i32.const 0))) + ) + "unknown table" +) + +(assert_invalid + (module + (type (func)) + (table 0 funcref) + (func $type-void-vs-num (i32.eqz (return_call_indirect (type 0) (i32.const 0)))) + ) + "type mismatch" +) +(assert_invalid + (module + (type (func (result i64))) + (table 0 funcref) + (func $type-num-vs-num (i32.eqz (return_call_indirect (type 0) (i32.const 0)))) + ) + "type mismatch" +) + +(assert_invalid + (module + (type (func (param i32))) + (table 0 funcref) + (func $arity-0-vs-1 (return_call_indirect (type 0) (i32.const 0))) + ) + "type mismatch" +) +(assert_invalid + (module + (type (func (param f64 i32))) + (table 0 funcref) + (func $arity-0-vs-2 (return_call_indirect (type 0) (i32.const 0))) + ) + "type mismatch" +) + +(module + (type (func)) + (table 0 funcref) + (func $arity-1-vs-0 (return_call_indirect (type 0) (i32.const 1) (i32.const 0))) +) + +(module + (type (func)) + (table 0 funcref) + (func $arity-2-vs-0 + (return_call_indirect (type 0) (f64.const 2) (i32.const 1) (i32.const 0)) + ) +) + +(assert_invalid + (module + (type (func (param i32))) + (table 0 funcref) + (func $type-func-void-vs-i32 (return_call_indirect (type 0) (i32.const 1) (nop))) + ) + "type mismatch" +) +(assert_invalid + (module + (type (func (param i32))) + (table 0 funcref) + (func $type-func-num-vs-i32 (return_call_indirect (type 0) (i32.const 0) (i64.const 1))) + ) + "type mismatch" +) + +(assert_invalid + (module + (type (func (param i32 i32))) + (table 0 funcref) + (func $type-first-void-vs-num + (return_call_indirect (type 0) (nop) (i32.const 1) (i32.const 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (type (func (param i32 i32))) + (table 0 funcref) + (func $type-second-void-vs-num + (return_call_indirect (type 0) (i32.const 1) (nop) (i32.const 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (type (func (param i32 f64))) + (table 0 funcref) + (func $type-first-num-vs-num + (return_call_indirect (type 0) (f64.const 1) (i32.const 1) (i32.const 0)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (type (func (param f64 i32))) + (table 0 funcref) + (func $type-second-num-vs-num + (return_call_indirect (type 0) (i32.const 1) (f64.const 1) (i32.const 0)) + ) + ) + "type mismatch" +) + + +;; Unbound type + +(assert_invalid + (module + (table 0 funcref) + (func $unbound-type (return_call_indirect (type 1) (i32.const 0))) + ) + "unknown type" +) +(assert_invalid + (module + (table 0 funcref) + (func $large-type (return_call_indirect (type 1012321300) (i32.const 0))) + ) + "unknown type" +) + + +;; Unbound function in table + +(assert_invalid + (module (table funcref (elem 0 0))) + "unknown function 0" +) diff --git a/runtime/near-vm/tests/wast/spec/proposals/threads/atomic.wast b/runtime/near-vm/tests/wast/spec/proposals/threads/atomic.wast new file mode 100644 index 00000000000..9f3cd65dbb5 --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/proposals/threads/atomic.wast @@ -0,0 +1,539 @@ +;; atomic operations + +(module + (memory 1 1 shared) + + (func (export "init") (param $value i64) (i64.store (i32.const 0) (local.get $value))) + + (func (export "i32.atomic.load") (param $addr i32) (result i32) (i32.atomic.load (local.get $addr))) + (func (export "i64.atomic.load") (param $addr i32) (result i64) (i64.atomic.load (local.get $addr))) + (func (export "i32.atomic.load8_u") (param $addr i32) (result i32) (i32.atomic.load8_u (local.get $addr))) + (func (export "i32.atomic.load16_u") (param $addr i32) (result i32) (i32.atomic.load16_u (local.get $addr))) + (func (export "i64.atomic.load8_u") (param $addr i32) (result i64) (i64.atomic.load8_u (local.get $addr))) + (func (export "i64.atomic.load16_u") (param $addr i32) (result i64) (i64.atomic.load16_u (local.get $addr))) + (func (export "i64.atomic.load32_u") (param $addr i32) (result i64) (i64.atomic.load32_u (local.get $addr))) + + (func (export "i32.atomic.store") (param $addr i32) (param $value i32) (i32.atomic.store (local.get $addr) (local.get $value))) + (func (export "i64.atomic.store") (param $addr i32) (param $value i64) (i64.atomic.store (local.get $addr) (local.get $value))) + (func (export "i32.atomic.store8") (param $addr i32) (param $value i32) (i32.atomic.store8 (local.get $addr) (local.get $value))) + (func (export "i32.atomic.store16") (param $addr i32) (param $value i32) (i32.atomic.store16 (local.get $addr) (local.get $value))) + (func (export "i64.atomic.store8") (param $addr i32) (param $value i64) (i64.atomic.store8 (local.get $addr) (local.get $value))) + (func (export "i64.atomic.store16") (param $addr i32) (param $value i64) (i64.atomic.store16 (local.get $addr) (local.get $value))) + (func (export "i64.atomic.store32") (param $addr i32) (param $value i64) (i64.atomic.store32 (local.get $addr) (local.get $value))) + + (func (export "i32.atomic.rmw.add") (param $addr i32) (param $value i32) (result i32) (i32.atomic.rmw.add (local.get $addr) (local.get $value))) + (func (export "i64.atomic.rmw.add") (param $addr i32) (param $value i64) (result i64) (i64.atomic.rmw.add (local.get $addr) (local.get $value))) + (func (export "i32.atomic.rmw8.add_u") (param $addr i32) (param $value i32) (result i32) (i32.atomic.rmw8.add_u (local.get $addr) (local.get $value))) + (func (export "i32.atomic.rmw16.add_u") (param $addr i32) (param $value i32) (result i32) (i32.atomic.rmw16.add_u (local.get $addr) (local.get $value))) + (func (export "i64.atomic.rmw8.add_u") (param $addr i32) (param $value i64) (result i64) (i64.atomic.rmw8.add_u (local.get $addr) (local.get $value))) + (func (export "i64.atomic.rmw16.add_u") (param $addr i32) (param $value i64) (result i64) (i64.atomic.rmw16.add_u (local.get $addr) (local.get $value))) + (func (export "i64.atomic.rmw32.add_u") (param $addr i32) (param $value i64) (result i64) (i64.atomic.rmw32.add_u (local.get $addr) (local.get $value))) + + (func (export "i32.atomic.rmw.sub") (param $addr i32) (param $value i32) (result i32) (i32.atomic.rmw.sub (local.get $addr) (local.get $value))) + (func (export "i64.atomic.rmw.sub") (param $addr i32) (param $value i64) (result i64) (i64.atomic.rmw.sub (local.get $addr) (local.get $value))) + (func (export "i32.atomic.rmw8.sub_u") (param $addr i32) (param $value i32) (result i32) (i32.atomic.rmw8.sub_u (local.get $addr) (local.get $value))) + (func (export "i32.atomic.rmw16.sub_u") (param $addr i32) (param $value i32) (result i32) (i32.atomic.rmw16.sub_u (local.get $addr) (local.get $value))) + (func (export "i64.atomic.rmw8.sub_u") (param $addr i32) (param $value i64) (result i64) (i64.atomic.rmw8.sub_u (local.get $addr) (local.get $value))) + (func (export "i64.atomic.rmw16.sub_u") (param $addr i32) (param $value i64) (result i64) (i64.atomic.rmw16.sub_u (local.get $addr) (local.get $value))) + (func (export "i64.atomic.rmw32.sub_u") (param $addr i32) (param $value i64) (result i64) (i64.atomic.rmw32.sub_u (local.get $addr) (local.get $value))) + + (func (export "i32.atomic.rmw.and") (param $addr i32) (param $value i32) (result i32) (i32.atomic.rmw.and (local.get $addr) (local.get $value))) + (func (export "i64.atomic.rmw.and") (param $addr i32) (param $value i64) (result i64) (i64.atomic.rmw.and (local.get $addr) (local.get $value))) + (func (export "i32.atomic.rmw8.and_u") (param $addr i32) (param $value i32) (result i32) (i32.atomic.rmw8.and_u (local.get $addr) (local.get $value))) + (func (export "i32.atomic.rmw16.and_u") (param $addr i32) (param $value i32) (result i32) (i32.atomic.rmw16.and_u (local.get $addr) (local.get $value))) + (func (export "i64.atomic.rmw8.and_u") (param $addr i32) (param $value i64) (result i64) (i64.atomic.rmw8.and_u (local.get $addr) (local.get $value))) + (func (export "i64.atomic.rmw16.and_u") (param $addr i32) (param $value i64) (result i64) (i64.atomic.rmw16.and_u (local.get $addr) (local.get $value))) + (func (export "i64.atomic.rmw32.and_u") (param $addr i32) (param $value i64) (result i64) (i64.atomic.rmw32.and_u (local.get $addr) (local.get $value))) + + (func (export "i32.atomic.rmw.or") (param $addr i32) (param $value i32) (result i32) (i32.atomic.rmw.or (local.get $addr) (local.get $value))) + (func (export "i64.atomic.rmw.or") (param $addr i32) (param $value i64) (result i64) (i64.atomic.rmw.or (local.get $addr) (local.get $value))) + (func (export "i32.atomic.rmw8.or_u") (param $addr i32) (param $value i32) (result i32) (i32.atomic.rmw8.or_u (local.get $addr) (local.get $value))) + (func (export "i32.atomic.rmw16.or_u") (param $addr i32) (param $value i32) (result i32) (i32.atomic.rmw16.or_u (local.get $addr) (local.get $value))) + (func (export "i64.atomic.rmw8.or_u") (param $addr i32) (param $value i64) (result i64) (i64.atomic.rmw8.or_u (local.get $addr) (local.get $value))) + (func (export "i64.atomic.rmw16.or_u") (param $addr i32) (param $value i64) (result i64) (i64.atomic.rmw16.or_u (local.get $addr) (local.get $value))) + (func (export "i64.atomic.rmw32.or_u") (param $addr i32) (param $value i64) (result i64) (i64.atomic.rmw32.or_u (local.get $addr) (local.get $value))) + + (func (export "i32.atomic.rmw.xor") (param $addr i32) (param $value i32) (result i32) (i32.atomic.rmw.xor (local.get $addr) (local.get $value))) + (func (export "i64.atomic.rmw.xor") (param $addr i32) (param $value i64) (result i64) (i64.atomic.rmw.xor (local.get $addr) (local.get $value))) + (func (export "i32.atomic.rmw8.xor_u") (param $addr i32) (param $value i32) (result i32) (i32.atomic.rmw8.xor_u (local.get $addr) (local.get $value))) + (func (export "i32.atomic.rmw16.xor_u") (param $addr i32) (param $value i32) (result i32) (i32.atomic.rmw16.xor_u (local.get $addr) (local.get $value))) + (func (export "i64.atomic.rmw8.xor_u") (param $addr i32) (param $value i64) (result i64) (i64.atomic.rmw8.xor_u (local.get $addr) (local.get $value))) + (func (export "i64.atomic.rmw16.xor_u") (param $addr i32) (param $value i64) (result i64) (i64.atomic.rmw16.xor_u (local.get $addr) (local.get $value))) + (func (export "i64.atomic.rmw32.xor_u") (param $addr i32) (param $value i64) (result i64) (i64.atomic.rmw32.xor_u (local.get $addr) (local.get $value))) + + (func (export "i32.atomic.rmw.xchg") (param $addr i32) (param $value i32) (result i32) (i32.atomic.rmw.xchg (local.get $addr) (local.get $value))) + (func (export "i64.atomic.rmw.xchg") (param $addr i32) (param $value i64) (result i64) (i64.atomic.rmw.xchg (local.get $addr) (local.get $value))) + (func (export "i32.atomic.rmw8.xchg_u") (param $addr i32) (param $value i32) (result i32) (i32.atomic.rmw8.xchg_u (local.get $addr) (local.get $value))) + (func (export "i32.atomic.rmw16.xchg_u") (param $addr i32) (param $value i32) (result i32) (i32.atomic.rmw16.xchg_u (local.get $addr) (local.get $value))) + (func (export "i64.atomic.rmw8.xchg_u") (param $addr i32) (param $value i64) (result i64) (i64.atomic.rmw8.xchg_u (local.get $addr) (local.get $value))) + (func (export "i64.atomic.rmw16.xchg_u") (param $addr i32) (param $value i64) (result i64) (i64.atomic.rmw16.xchg_u (local.get $addr) (local.get $value))) + (func (export "i64.atomic.rmw32.xchg_u") (param $addr i32) (param $value i64) (result i64) (i64.atomic.rmw32.xchg_u (local.get $addr) (local.get $value))) + + (func (export "i32.atomic.rmw.cmpxchg") (param $addr i32) (param $expected i32) (param $value i32) (result i32) (i32.atomic.rmw.cmpxchg (local.get $addr) (local.get $expected) (local.get $value))) + (func (export "i64.atomic.rmw.cmpxchg") (param $addr i32) (param $expected i64) (param $value i64) (result i64) (i64.atomic.rmw.cmpxchg (local.get $addr) (local.get $expected) (local.get $value))) + (func (export "i32.atomic.rmw8.cmpxchg_u") (param $addr i32) (param $expected i32) (param $value i32) (result i32) (i32.atomic.rmw8.cmpxchg_u (local.get $addr) (local.get $expected) (local.get $value))) + (func (export "i32.atomic.rmw16.cmpxchg_u") (param $addr i32) (param $expected i32) (param $value i32) (result i32) (i32.atomic.rmw16.cmpxchg_u (local.get $addr) (local.get $expected) (local.get $value))) + (func (export "i64.atomic.rmw8.cmpxchg_u") (param $addr i32) (param $expected i64) (param $value i64) (result i64) (i64.atomic.rmw8.cmpxchg_u (local.get $addr) (local.get $expected) (local.get $value))) + (func (export "i64.atomic.rmw16.cmpxchg_u") (param $addr i32) (param $expected i64) (param $value i64) (result i64) (i64.atomic.rmw16.cmpxchg_u (local.get $addr) (local.get $expected) (local.get $value))) + (func (export "i64.atomic.rmw32.cmpxchg_u") (param $addr i32) (param $expected i64) (param $value i64) (result i64) (i64.atomic.rmw32.cmpxchg_u (local.get $addr) (local.get $expected) (local.get $value))) + +) + +;; *.atomic.load* + +(invoke "init" (i64.const 0x0706050403020100)) + +(assert_return (invoke "i32.atomic.load" (i32.const 0)) (i32.const 0x03020100)) +(assert_return (invoke "i32.atomic.load" (i32.const 4)) (i32.const 0x07060504)) + +(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x0706050403020100)) + +(assert_return (invoke "i32.atomic.load8_u" (i32.const 0)) (i32.const 0x00)) +(assert_return (invoke "i32.atomic.load8_u" (i32.const 5)) (i32.const 0x05)) + +(assert_return (invoke "i32.atomic.load16_u" (i32.const 0)) (i32.const 0x0100)) +(assert_return (invoke "i32.atomic.load16_u" (i32.const 6)) (i32.const 0x0706)) + +(assert_return (invoke "i64.atomic.load8_u" (i32.const 0)) (i64.const 0x00)) +(assert_return (invoke "i64.atomic.load8_u" (i32.const 5)) (i64.const 0x05)) + +(assert_return (invoke "i64.atomic.load16_u" (i32.const 0)) (i64.const 0x0100)) +(assert_return (invoke "i64.atomic.load16_u" (i32.const 6)) (i64.const 0x0706)) + +(assert_return (invoke "i64.atomic.load32_u" (i32.const 0)) (i64.const 0x03020100)) +(assert_return (invoke "i64.atomic.load32_u" (i32.const 4)) (i64.const 0x07060504)) + +;; *.atomic.store* + +(invoke "init" (i64.const 0x0000000000000000)) + +(assert_return (invoke "i32.atomic.store" (i32.const 0) (i32.const 0xffeeddcc))) +(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x00000000ffeeddcc)) + +(assert_return (invoke "i64.atomic.store" (i32.const 0) (i64.const 0x0123456789abcdef))) +(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x0123456789abcdef)) + +(assert_return (invoke "i32.atomic.store8" (i32.const 1) (i32.const 0x42))) +(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x0123456789ab42ef)) + +(assert_return (invoke "i32.atomic.store16" (i32.const 4) (i32.const 0x8844))) +(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x0123884489ab42ef)) + +(assert_return (invoke "i64.atomic.store8" (i32.const 1) (i64.const 0x99))) +(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x0123884489ab99ef)) + +(assert_return (invoke "i64.atomic.store16" (i32.const 4) (i64.const 0xcafe))) +(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x0123cafe89ab99ef)) + +(assert_return (invoke "i64.atomic.store32" (i32.const 4) (i64.const 0xdeadbeef))) +(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0xdeadbeef89ab99ef)) + +;; *.atomic.rmw*.add + +(invoke "init" (i64.const 0x1111111111111111)) +(assert_return (invoke "i32.atomic.rmw.add" (i32.const 0) (i32.const 0x12345678)) (i32.const 0x11111111)) +(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x1111111123456789)) + +(invoke "init" (i64.const 0x1111111111111111)) +(assert_return (invoke "i64.atomic.rmw.add" (i32.const 0) (i64.const 0x0101010102020202)) (i64.const 0x1111111111111111)) +(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x1212121213131313)) + +(invoke "init" (i64.const 0x1111111111111111)) +(assert_return (invoke "i32.atomic.rmw8.add_u" (i32.const 0) (i32.const 0xcdcdcdcd)) (i32.const 0x11)) +(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x11111111111111de)) + +(invoke "init" (i64.const 0x1111111111111111)) +(assert_return (invoke "i32.atomic.rmw16.add_u" (i32.const 0) (i32.const 0xcafecafe)) (i32.const 0x1111)) +(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x111111111111dc0f)) + +(invoke "init" (i64.const 0x1111111111111111)) +(assert_return (invoke "i64.atomic.rmw8.add_u" (i32.const 0) (i64.const 0x4242424242424242)) (i64.const 0x11)) +(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x1111111111111153)) + +(invoke "init" (i64.const 0x1111111111111111)) +(assert_return (invoke "i64.atomic.rmw16.add_u" (i32.const 0) (i64.const 0xbeefbeefbeefbeef)) (i64.const 0x1111)) +(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x111111111111d000)) + +(invoke "init" (i64.const 0x1111111111111111)) +(assert_return (invoke "i64.atomic.rmw32.add_u" (i32.const 0) (i64.const 0xcabba6e5cabba6e5)) (i64.const 0x11111111)) +(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x11111111dbccb7f6)) + +;; *.atomic.rmw*.sub + +(invoke "init" (i64.const 0x1111111111111111)) +(assert_return (invoke "i32.atomic.rmw.sub" (i32.const 0) (i32.const 0x12345678)) (i32.const 0x11111111)) +(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x11111111fedcba99)) + +(invoke "init" (i64.const 0x1111111111111111)) +(assert_return (invoke "i64.atomic.rmw.sub" (i32.const 0) (i64.const 0x0101010102020202)) (i64.const 0x1111111111111111)) +(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x101010100f0f0f0f)) + +(invoke "init" (i64.const 0x1111111111111111)) +(assert_return (invoke "i32.atomic.rmw8.sub_u" (i32.const 0) (i32.const 0xcdcdcdcd)) (i32.const 0x11)) +(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x1111111111111144)) + +(invoke "init" (i64.const 0x1111111111111111)) +(assert_return (invoke "i32.atomic.rmw16.sub_u" (i32.const 0) (i32.const 0xcafecafe)) (i32.const 0x1111)) +(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x1111111111114613)) + +(invoke "init" (i64.const 0x1111111111111111)) +(assert_return (invoke "i64.atomic.rmw8.sub_u" (i32.const 0) (i64.const 0x4242424242424242)) (i64.const 0x11)) +(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x11111111111111cf)) + +(invoke "init" (i64.const 0x1111111111111111)) +(assert_return (invoke "i64.atomic.rmw16.sub_u" (i32.const 0) (i64.const 0xbeefbeefbeefbeef)) (i64.const 0x1111)) +(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x1111111111115222)) + +(invoke "init" (i64.const 0x1111111111111111)) +(assert_return (invoke "i64.atomic.rmw32.sub_u" (i32.const 0) (i64.const 0xcabba6e5cabba6e5)) (i64.const 0x11111111)) +(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x1111111146556a2c)) + +;; *.atomic.rmw*.and + +(invoke "init" (i64.const 0x1111111111111111)) +(assert_return (invoke "i32.atomic.rmw.and" (i32.const 0) (i32.const 0x12345678)) (i32.const 0x11111111)) +(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x1111111110101010)) + +(invoke "init" (i64.const 0x1111111111111111)) +(assert_return (invoke "i64.atomic.rmw.and" (i32.const 0) (i64.const 0x0101010102020202)) (i64.const 0x1111111111111111)) +(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x0101010100000000)) + +(invoke "init" (i64.const 0x1111111111111111)) +(assert_return (invoke "i32.atomic.rmw8.and_u" (i32.const 0) (i32.const 0xcdcdcdcd)) (i32.const 0x11)) +(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x1111111111111101)) + +(invoke "init" (i64.const 0x1111111111111111)) +(assert_return (invoke "i32.atomic.rmw16.and_u" (i32.const 0) (i32.const 0xcafecafe)) (i32.const 0x1111)) +(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x1111111111110010)) + +(invoke "init" (i64.const 0x1111111111111111)) +(assert_return (invoke "i64.atomic.rmw8.and_u" (i32.const 0) (i64.const 0x4242424242424242)) (i64.const 0x11)) +(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x1111111111111100)) + +(invoke "init" (i64.const 0x1111111111111111)) +(assert_return (invoke "i64.atomic.rmw16.and_u" (i32.const 0) (i64.const 0xbeefbeefbeefbeef)) (i64.const 0x1111)) +(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x1111111111111001)) + +(invoke "init" (i64.const 0x1111111111111111)) +(assert_return (invoke "i64.atomic.rmw32.and_u" (i32.const 0) (i64.const 0xcabba6e5cabba6e5)) (i64.const 0x11111111)) +(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x1111111100110001)) + +;; *.atomic.rmw*.or + +(invoke "init" (i64.const 0x1111111111111111)) +(assert_return (invoke "i32.atomic.rmw.or" (i32.const 0) (i32.const 0x12345678)) (i32.const 0x11111111)) +(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x1111111113355779)) + +(invoke "init" (i64.const 0x1111111111111111)) +(assert_return (invoke "i64.atomic.rmw.or" (i32.const 0) (i64.const 0x0101010102020202)) (i64.const 0x1111111111111111)) +(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x1111111113131313)) + +(invoke "init" (i64.const 0x1111111111111111)) +(assert_return (invoke "i32.atomic.rmw8.or_u" (i32.const 0) (i32.const 0xcdcdcdcd)) (i32.const 0x11)) +(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x11111111111111dd)) + +(invoke "init" (i64.const 0x1111111111111111)) +(assert_return (invoke "i32.atomic.rmw16.or_u" (i32.const 0) (i32.const 0xcafecafe)) (i32.const 0x1111)) +(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x111111111111dbff)) + +(invoke "init" (i64.const 0x1111111111111111)) +(assert_return (invoke "i64.atomic.rmw8.or_u" (i32.const 0) (i64.const 0x4242424242424242)) (i64.const 0x11)) +(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x1111111111111153)) + +(invoke "init" (i64.const 0x1111111111111111)) +(assert_return (invoke "i64.atomic.rmw16.or_u" (i32.const 0) (i64.const 0xbeefbeefbeefbeef)) (i64.const 0x1111)) +(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x111111111111bfff)) + +(invoke "init" (i64.const 0x1111111111111111)) +(assert_return (invoke "i64.atomic.rmw32.or_u" (i32.const 0) (i64.const 0xcabba6e5cabba6e5)) (i64.const 0x11111111)) +(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x11111111dbbbb7f5)) + +;; *.atomic.rmw*.xor + +(invoke "init" (i64.const 0x1111111111111111)) +(assert_return (invoke "i32.atomic.rmw.xor" (i32.const 0) (i32.const 0x12345678)) (i32.const 0x11111111)) +(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x1111111103254769)) + +(invoke "init" (i64.const 0x1111111111111111)) +(assert_return (invoke "i64.atomic.rmw.xor" (i32.const 0) (i64.const 0x0101010102020202)) (i64.const 0x1111111111111111)) +(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x1010101013131313)) + +(invoke "init" (i64.const 0x1111111111111111)) +(assert_return (invoke "i32.atomic.rmw8.xor_u" (i32.const 0) (i32.const 0xcdcdcdcd)) (i32.const 0x11)) +(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x11111111111111dc)) + +(invoke "init" (i64.const 0x1111111111111111)) +(assert_return (invoke "i32.atomic.rmw16.xor_u" (i32.const 0) (i32.const 0xcafecafe)) (i32.const 0x1111)) +(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x111111111111dbef)) + +(invoke "init" (i64.const 0x1111111111111111)) +(assert_return (invoke "i64.atomic.rmw8.xor_u" (i32.const 0) (i64.const 0x4242424242424242)) (i64.const 0x11)) +(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x1111111111111153)) + +(invoke "init" (i64.const 0x1111111111111111)) +(assert_return (invoke "i64.atomic.rmw16.xor_u" (i32.const 0) (i64.const 0xbeefbeefbeefbeef)) (i64.const 0x1111)) +(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x111111111111affe)) + +(invoke "init" (i64.const 0x1111111111111111)) +(assert_return (invoke "i64.atomic.rmw32.xor_u" (i32.const 0) (i64.const 0xcabba6e5cabba6e5)) (i64.const 0x11111111)) +(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x11111111dbaab7f4)) + +;; *.atomic.rmw*.xchg + +(invoke "init" (i64.const 0x1111111111111111)) +(assert_return (invoke "i32.atomic.rmw.xchg" (i32.const 0) (i32.const 0x12345678)) (i32.const 0x11111111)) +(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x1111111112345678)) + +(invoke "init" (i64.const 0x1111111111111111)) +(assert_return (invoke "i64.atomic.rmw.xchg" (i32.const 0) (i64.const 0x0101010102020202)) (i64.const 0x1111111111111111)) +(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x0101010102020202)) + +(invoke "init" (i64.const 0x1111111111111111)) +(assert_return (invoke "i32.atomic.rmw8.xchg_u" (i32.const 0) (i32.const 0xcdcdcdcd)) (i32.const 0x11)) +(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x11111111111111cd)) + +(invoke "init" (i64.const 0x1111111111111111)) +(assert_return (invoke "i32.atomic.rmw16.xchg_u" (i32.const 0) (i32.const 0xcafecafe)) (i32.const 0x1111)) +(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x111111111111cafe)) + +(invoke "init" (i64.const 0x1111111111111111)) +(assert_return (invoke "i64.atomic.rmw8.xchg_u" (i32.const 0) (i64.const 0x4242424242424242)) (i64.const 0x11)) +(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x1111111111111142)) + +(invoke "init" (i64.const 0x1111111111111111)) +(assert_return (invoke "i64.atomic.rmw16.xchg_u" (i32.const 0) (i64.const 0xbeefbeefbeefbeef)) (i64.const 0x1111)) +(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x111111111111beef)) + +(invoke "init" (i64.const 0x1111111111111111)) +(assert_return (invoke "i64.atomic.rmw32.xchg_u" (i32.const 0) (i64.const 0xcabba6e5cabba6e5)) (i64.const 0x11111111)) +(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x11111111cabba6e5)) + +;; *.atomic.rmw*.cmpxchg (compare false) + +(invoke "init" (i64.const 0x1111111111111111)) +(assert_return (invoke "i32.atomic.rmw.cmpxchg" (i32.const 0) (i32.const 0) (i32.const 0x12345678)) (i32.const 0x11111111)) +(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x1111111111111111)) + +(invoke "init" (i64.const 0x1111111111111111)) +(assert_return (invoke "i64.atomic.rmw.cmpxchg" (i32.const 0) (i64.const 0) (i64.const 0x0101010102020202)) (i64.const 0x1111111111111111)) +(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x1111111111111111)) + +(invoke "init" (i64.const 0x1111111111111111)) +(assert_return (invoke "i32.atomic.rmw8.cmpxchg_u" (i32.const 0) (i32.const 0) (i32.const 0xcdcdcdcd)) (i32.const 0x11)) +(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x1111111111111111)) + +(invoke "init" (i64.const 0x1111111111111111)) +(assert_return (invoke "i32.atomic.rmw16.cmpxchg_u" (i32.const 0) (i32.const 0) (i32.const 0xcafecafe)) (i32.const 0x1111)) +(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x1111111111111111)) + +(invoke "init" (i64.const 0x1111111111111111)) +(assert_return (invoke "i64.atomic.rmw8.cmpxchg_u" (i32.const 0) (i64.const 0) (i64.const 0x4242424242424242)) (i64.const 0x11)) +(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x1111111111111111)) + +(invoke "init" (i64.const 0x1111111111111111)) +(assert_return (invoke "i64.atomic.rmw16.cmpxchg_u" (i32.const 0) (i64.const 0) (i64.const 0xbeefbeefbeefbeef)) (i64.const 0x1111)) +(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x1111111111111111)) + +(invoke "init" (i64.const 0x1111111111111111)) +(assert_return (invoke "i64.atomic.rmw32.cmpxchg_u" (i32.const 0) (i64.const 0) (i64.const 0xcabba6e5cabba6e5)) (i64.const 0x11111111)) +(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x1111111111111111)) + +;; *.atomic.rmw*.cmpxchg (compare true) + +(invoke "init" (i64.const 0x1111111111111111)) +(assert_return (invoke "i32.atomic.rmw.cmpxchg" (i32.const 0) (i32.const 0x11111111) (i32.const 0x12345678)) (i32.const 0x11111111)) +(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x1111111112345678)) + +(invoke "init" (i64.const 0x1111111111111111)) +(assert_return (invoke "i64.atomic.rmw.cmpxchg" (i32.const 0) (i64.const 0x1111111111111111) (i64.const 0x0101010102020202)) (i64.const 0x1111111111111111)) +(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x0101010102020202)) + +(invoke "init" (i64.const 0x1111111111111111)) +(assert_return (invoke "i32.atomic.rmw8.cmpxchg_u" (i32.const 0) (i32.const 0x11) (i32.const 0xcdcdcdcd)) (i32.const 0x11)) +(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x11111111111111cd)) + +(invoke "init" (i64.const 0x1111111111111111)) +(assert_return (invoke "i32.atomic.rmw16.cmpxchg_u" (i32.const 0) (i32.const 0x1111) (i32.const 0xcafecafe)) (i32.const 0x1111)) +(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x111111111111cafe)) + +(invoke "init" (i64.const 0x1111111111111111)) +(assert_return (invoke "i64.atomic.rmw8.cmpxchg_u" (i32.const 0) (i64.const 0x11) (i64.const 0x4242424242424242)) (i64.const 0x11)) +(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x1111111111111142)) + +(invoke "init" (i64.const 0x1111111111111111)) +(assert_return (invoke "i64.atomic.rmw16.cmpxchg_u" (i32.const 0) (i64.const 0x1111) (i64.const 0xbeefbeefbeefbeef)) (i64.const 0x1111)) +(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x111111111111beef)) + +(invoke "init" (i64.const 0x1111111111111111)) +(assert_return (invoke "i64.atomic.rmw32.cmpxchg_u" (i32.const 0) (i64.const 0x11111111) (i64.const 0xcabba6e5cabba6e5)) (i64.const 0x11111111)) +(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x11111111cabba6e5)) + + +;; unaligned accesses + +(assert_trap (invoke "i32.atomic.load" (i32.const 1)) "unaligned atomic") +(assert_trap (invoke "i64.atomic.load" (i32.const 1)) "unaligned atomic") +(assert_trap (invoke "i32.atomic.load16_u" (i32.const 1)) "unaligned atomic") +(assert_trap (invoke "i64.atomic.load16_u" (i32.const 1)) "unaligned atomic") +(assert_trap (invoke "i64.atomic.load32_u" (i32.const 1)) "unaligned atomic") +(assert_trap (invoke "i32.atomic.store" (i32.const 1) (i32.const 0)) "unaligned atomic") +(assert_trap (invoke "i64.atomic.store" (i32.const 1) (i64.const 0)) "unaligned atomic") +(assert_trap (invoke "i32.atomic.store16" (i32.const 1) (i32.const 0)) "unaligned atomic") +(assert_trap (invoke "i64.atomic.store16" (i32.const 1) (i64.const 0)) "unaligned atomic") +(assert_trap (invoke "i64.atomic.store32" (i32.const 1) (i64.const 0)) "unaligned atomic") +(assert_trap (invoke "i32.atomic.rmw.add" (i32.const 1) (i32.const 0)) "unaligned atomic") +(assert_trap (invoke "i64.atomic.rmw.add" (i32.const 1) (i64.const 0)) "unaligned atomic") +(assert_trap (invoke "i32.atomic.rmw16.add_u" (i32.const 1) (i32.const 0)) "unaligned atomic") +(assert_trap (invoke "i64.atomic.rmw16.add_u" (i32.const 1) (i64.const 0)) "unaligned atomic") +(assert_trap (invoke "i64.atomic.rmw32.add_u" (i32.const 1) (i64.const 0)) "unaligned atomic") +(assert_trap (invoke "i32.atomic.rmw.sub" (i32.const 1) (i32.const 0)) "unaligned atomic") +(assert_trap (invoke "i64.atomic.rmw.sub" (i32.const 1) (i64.const 0)) "unaligned atomic") +(assert_trap (invoke "i32.atomic.rmw16.sub_u" (i32.const 1) (i32.const 0)) "unaligned atomic") +(assert_trap (invoke "i64.atomic.rmw16.sub_u" (i32.const 1) (i64.const 0)) "unaligned atomic") +(assert_trap (invoke "i64.atomic.rmw32.sub_u" (i32.const 1) (i64.const 0)) "unaligned atomic") +(assert_trap (invoke "i32.atomic.rmw.and" (i32.const 1) (i32.const 0)) "unaligned atomic") +(assert_trap (invoke "i64.atomic.rmw.and" (i32.const 1) (i64.const 0)) "unaligned atomic") +(assert_trap (invoke "i32.atomic.rmw16.and_u" (i32.const 1) (i32.const 0)) "unaligned atomic") +(assert_trap (invoke "i64.atomic.rmw16.and_u" (i32.const 1) (i64.const 0)) "unaligned atomic") +(assert_trap (invoke "i64.atomic.rmw32.and_u" (i32.const 1) (i64.const 0)) "unaligned atomic") +(assert_trap (invoke "i32.atomic.rmw.or" (i32.const 1) (i32.const 0)) "unaligned atomic") +(assert_trap (invoke "i64.atomic.rmw.or" (i32.const 1) (i64.const 0)) "unaligned atomic") +(assert_trap (invoke "i32.atomic.rmw16.or_u" (i32.const 1) (i32.const 0)) "unaligned atomic") +(assert_trap (invoke "i64.atomic.rmw16.or_u" (i32.const 1) (i64.const 0)) "unaligned atomic") +(assert_trap (invoke "i64.atomic.rmw32.or_u" (i32.const 1) (i64.const 0)) "unaligned atomic") +(assert_trap (invoke "i32.atomic.rmw.xor" (i32.const 1) (i32.const 0)) "unaligned atomic") +(assert_trap (invoke "i64.atomic.rmw.xor" (i32.const 1) (i64.const 0)) "unaligned atomic") +(assert_trap (invoke "i32.atomic.rmw16.xor_u" (i32.const 1) (i32.const 0)) "unaligned atomic") +(assert_trap (invoke "i64.atomic.rmw16.xor_u" (i32.const 1) (i64.const 0)) "unaligned atomic") +(assert_trap (invoke "i64.atomic.rmw32.xor_u" (i32.const 1) (i64.const 0)) "unaligned atomic") +(assert_trap (invoke "i32.atomic.rmw.xchg" (i32.const 1) (i32.const 0)) "unaligned atomic") +(assert_trap (invoke "i64.atomic.rmw.xchg" (i32.const 1) (i64.const 0)) "unaligned atomic") +(assert_trap (invoke "i32.atomic.rmw16.xchg_u" (i32.const 1) (i32.const 0)) "unaligned atomic") +(assert_trap (invoke "i64.atomic.rmw16.xchg_u" (i32.const 1) (i64.const 0)) "unaligned atomic") +(assert_trap (invoke "i64.atomic.rmw32.xchg_u" (i32.const 1) (i64.const 0)) "unaligned atomic") +(assert_trap (invoke "i32.atomic.rmw.cmpxchg" (i32.const 1) (i32.const 0) (i32.const 0)) "unaligned atomic") +(assert_trap (invoke "i64.atomic.rmw.cmpxchg" (i32.const 1) (i64.const 0) (i64.const 0)) "unaligned atomic") +(assert_trap (invoke "i32.atomic.rmw16.cmpxchg_u" (i32.const 1) (i32.const 0) (i32.const 0)) "unaligned atomic") +(assert_trap (invoke "i64.atomic.rmw16.cmpxchg_u" (i32.const 1) (i64.const 0) (i64.const 0)) "unaligned atomic") +(assert_trap (invoke "i64.atomic.rmw32.cmpxchg_u" (i32.const 1) (i64.const 0) (i64.const 0)) "unaligned atomic") + +(module + (memory 1 1 shared) + + (func (export "init") (param $value i64) (i64.store (i32.const 0) (local.get $value))) + + (func (export "memory.atomic.notify") (param $addr i32) (param $count i32) (result i32) + (memory.atomic.notify (local.get 0) (local.get 1))) + (func (export "memory.atomic.wait32") (param $addr i32) (param $expected i32) (param $timeout i64) (result i32) + (memory.atomic.wait32 (local.get 0) (local.get 1) (local.get 2))) + (func (export "memory.atomic.wait64") (param $addr i32) (param $expected i64) (param $timeout i64) (result i32) + (memory.atomic.wait64 (local.get 0) (local.get 1) (local.get 2))) +) + +(invoke "init" (i64.const 0xffffffffffff)) +(assert_return (invoke "memory.atomic.wait32" (i32.const 0) (i32.const 0) (i64.const 0)) (i32.const 1)) +(assert_return (invoke "memory.atomic.wait64" (i32.const 0) (i64.const 0) (i64.const 0)) (i32.const 1)) +(assert_return (invoke "memory.atomic.notify" (i32.const 0) (i32.const 0)) (i32.const 0)) + +;; unshared memory is OK +(module + (memory 1 1) + (func (drop (memory.atomic.notify (i32.const 0) (i32.const 0)))) + (func (drop (memory.atomic.wait32 (i32.const 0) (i32.const 0) (i64.const 0)))) + (func (drop (memory.atomic.wait64 (i32.const 0) (i64.const 0) (i64.const 0)))) + (func (drop (i32.atomic.load (i32.const 0)))) + (func (drop (i64.atomic.load (i32.const 0)))) + (func (drop (i32.atomic.load16_u (i32.const 0)))) + (func (drop (i64.atomic.load16_u (i32.const 0)))) + (func (drop (i64.atomic.load32_u (i32.const 0)))) + (func (i32.atomic.store (i32.const 0) (i32.const 0))) + (func (i64.atomic.store (i32.const 0) (i64.const 0))) + (func (i32.atomic.store16 (i32.const 0) (i32.const 0))) + (func (i64.atomic.store16 (i32.const 0) (i64.const 0))) + (func (i64.atomic.store32 (i32.const 0) (i64.const 0))) + (func (drop (i32.atomic.rmw.add (i32.const 0) (i32.const 0)))) + (func (drop (i64.atomic.rmw.add (i32.const 0) (i64.const 0)))) + (func (drop (i32.atomic.rmw16.add_u (i32.const 0) (i32.const 0)))) + (func (drop (i64.atomic.rmw16.add_u (i32.const 0) (i64.const 0)))) + (func (drop (i64.atomic.rmw32.add_u (i32.const 0) (i64.const 0)))) + (func (drop (i32.atomic.rmw.sub (i32.const 0) (i32.const 0)))) + (func (drop (i64.atomic.rmw.sub (i32.const 0) (i64.const 0)))) + (func (drop (i32.atomic.rmw16.sub_u (i32.const 0) (i32.const 0)))) + (func (drop (i64.atomic.rmw16.sub_u (i32.const 0) (i64.const 0)))) + (func (drop (i64.atomic.rmw32.sub_u (i32.const 0) (i64.const 0)))) + (func (drop (i32.atomic.rmw.and (i32.const 0) (i32.const 0)))) + (func (drop (i64.atomic.rmw.and (i32.const 0) (i64.const 0)))) + (func (drop (i32.atomic.rmw16.and_u (i32.const 0) (i32.const 0)))) + (func (drop (i64.atomic.rmw16.and_u (i32.const 0) (i64.const 0)))) + (func (drop (i64.atomic.rmw32.and_u (i32.const 0) (i64.const 0)))) + (func (drop (i32.atomic.rmw.or (i32.const 0) (i32.const 0)))) + (func (drop (i64.atomic.rmw.or (i32.const 0) (i64.const 0)))) + (func (drop (i32.atomic.rmw16.or_u (i32.const 0) (i32.const 0)))) + (func (drop (i64.atomic.rmw16.or_u (i32.const 0) (i64.const 0)))) + (func (drop (i64.atomic.rmw32.or_u (i32.const 0) (i64.const 0)))) + (func (drop (i32.atomic.rmw.xor (i32.const 0) (i32.const 0)))) + (func (drop (i64.atomic.rmw.xor (i32.const 0) (i64.const 0)))) + (func (drop (i32.atomic.rmw16.xor_u (i32.const 0) (i32.const 0)))) + (func (drop (i64.atomic.rmw16.xor_u (i32.const 0) (i64.const 0)))) + (func (drop (i64.atomic.rmw32.xor_u (i32.const 0) (i64.const 0)))) + (func (drop (i32.atomic.rmw.xchg (i32.const 0) (i32.const 0)))) + (func (drop (i64.atomic.rmw.xchg (i32.const 0) (i64.const 0)))) + (func (drop (i32.atomic.rmw16.xchg_u (i32.const 0) (i32.const 0)))) + (func (drop (i64.atomic.rmw16.xchg_u (i32.const 0) (i64.const 0)))) + (func (drop (i64.atomic.rmw32.xchg_u (i32.const 0) (i64.const 0)))) + (func (drop (i32.atomic.rmw.cmpxchg (i32.const 0) (i32.const 0) (i32.const 0)))) + (func (drop (i64.atomic.rmw.cmpxchg (i32.const 0) (i64.const 0) (i64.const 0)))) + (func (drop (i32.atomic.rmw16.cmpxchg_u (i32.const 0) (i32.const 0) (i32.const 0)))) + (func (drop (i64.atomic.rmw16.cmpxchg_u (i32.const 0) (i64.const 0) (i64.const 0)))) + (func (drop (i64.atomic.rmw32.cmpxchg_u (i32.const 0) (i64.const 0) (i64.const 0)))) +) + +;; Fails with no memory +(assert_invalid (module (func (drop (memory.atomic.notify (i32.const 0) (i32.const 0))))) "unknown memory") +(assert_invalid (module (func (drop (memory.atomic.wait32 (i32.const 0) (i32.const 0) (i64.const 0))))) "unknown memory") +(assert_invalid (module (func (drop (memory.atomic.wait64 (i32.const 0) (i64.const 0) (i64.const 0))))) "unknown memory") +(assert_invalid (module (func (drop (i32.atomic.load (i32.const 0))))) "unknown memory") +(assert_invalid (module (func (drop (i64.atomic.load (i32.const 0))))) "unknown memory") +(assert_invalid (module (func (drop (i32.atomic.load16_u (i32.const 0))))) "unknown memory") +(assert_invalid (module (func (drop (i64.atomic.load16_u (i32.const 0))))) "unknown memory") +(assert_invalid (module (func (drop (i64.atomic.load32_u (i32.const 0))))) "unknown memory") +(assert_invalid (module (func (i32.atomic.store (i32.const 0) (i32.const 0)))) "unknown memory") +(assert_invalid (module (func (i64.atomic.store (i32.const 0) (i64.const 0)))) "unknown memory") +(assert_invalid (module (func (i32.atomic.store16 (i32.const 0) (i32.const 0)))) "unknown memory") +(assert_invalid (module (func (i64.atomic.store16 (i32.const 0) (i64.const 0)))) "unknown memory") +(assert_invalid (module (func (i64.atomic.store32 (i32.const 0) (i64.const 0)))) "unknown memory") +(assert_invalid (module (func (drop (i32.atomic.rmw.add (i32.const 0) (i32.const 0))))) "unknown memory") +(assert_invalid (module (func (drop (i64.atomic.rmw.add (i32.const 0) (i64.const 0))))) "unknown memory") +(assert_invalid (module (func (drop (i32.atomic.rmw16.add_u (i32.const 0) (i32.const 0))))) "unknown memory") +(assert_invalid (module (func (drop (i64.atomic.rmw16.add_u (i32.const 0) (i64.const 0))))) "unknown memory") +(assert_invalid (module (func (drop (i64.atomic.rmw32.add_u (i32.const 0) (i64.const 0))))) "unknown memory") +(assert_invalid (module (func (drop (i32.atomic.rmw.sub (i32.const 0) (i32.const 0))))) "unknown memory") +(assert_invalid (module (func (drop (i64.atomic.rmw.sub (i32.const 0) (i64.const 0))))) "unknown memory") +(assert_invalid (module (func (drop (i32.atomic.rmw16.sub_u (i32.const 0) (i32.const 0))))) "unknown memory") +(assert_invalid (module (func (drop (i64.atomic.rmw16.sub_u (i32.const 0) (i64.const 0))))) "unknown memory") +(assert_invalid (module (func (drop (i64.atomic.rmw32.sub_u (i32.const 0) (i64.const 0))))) "unknown memory") +(assert_invalid (module (func (drop (i32.atomic.rmw.and (i32.const 0) (i32.const 0))))) "unknown memory") +(assert_invalid (module (func (drop (i64.atomic.rmw.and (i32.const 0) (i64.const 0))))) "unknown memory") +(assert_invalid (module (func (drop (i32.atomic.rmw16.and_u (i32.const 0) (i32.const 0))))) "unknown memory") +(assert_invalid (module (func (drop (i64.atomic.rmw16.and_u (i32.const 0) (i64.const 0))))) "unknown memory") +(assert_invalid (module (func (drop (i64.atomic.rmw32.and_u (i32.const 0) (i64.const 0))))) "unknown memory") +(assert_invalid (module (func (drop (i32.atomic.rmw.or (i32.const 0) (i32.const 0))))) "unknown memory") +(assert_invalid (module (func (drop (i64.atomic.rmw.or (i32.const 0) (i64.const 0))))) "unknown memory") +(assert_invalid (module (func (drop (i32.atomic.rmw16.or_u (i32.const 0) (i32.const 0))))) "unknown memory") +(assert_invalid (module (func (drop (i64.atomic.rmw16.or_u (i32.const 0) (i64.const 0))))) "unknown memory") +(assert_invalid (module (func (drop (i64.atomic.rmw32.or_u (i32.const 0) (i64.const 0))))) "unknown memory") +(assert_invalid (module (func (drop (i32.atomic.rmw.xor (i32.const 0) (i32.const 0))))) "unknown memory") +(assert_invalid (module (func (drop (i64.atomic.rmw.xor (i32.const 0) (i64.const 0))))) "unknown memory") +(assert_invalid (module (func (drop (i32.atomic.rmw16.xor_u (i32.const 0) (i32.const 0))))) "unknown memory") +(assert_invalid (module (func (drop (i64.atomic.rmw16.xor_u (i32.const 0) (i64.const 0))))) "unknown memory") +(assert_invalid (module (func (drop (i64.atomic.rmw32.xor_u (i32.const 0) (i64.const 0))))) "unknown memory") +(assert_invalid (module (func (drop (i32.atomic.rmw.xchg (i32.const 0) (i32.const 0))))) "unknown memory") +(assert_invalid (module (func (drop (i64.atomic.rmw.xchg (i32.const 0) (i64.const 0))))) "unknown memory") +(assert_invalid (module (func (drop (i32.atomic.rmw16.xchg_u (i32.const 0) (i32.const 0))))) "unknown memory") +(assert_invalid (module (func (drop (i64.atomic.rmw16.xchg_u (i32.const 0) (i64.const 0))))) "unknown memory") +(assert_invalid (module (func (drop (i64.atomic.rmw32.xchg_u (i32.const 0) (i64.const 0))))) "unknown memory") +(assert_invalid (module (func (drop (i32.atomic.rmw.cmpxchg (i32.const 0) (i32.const 0) (i32.const 0))))) "unknown memory") +(assert_invalid (module (func (drop (i64.atomic.rmw.cmpxchg (i32.const 0) (i64.const 0) (i64.const 0))))) "unknown memory") +(assert_invalid (module (func (drop (i32.atomic.rmw16.cmpxchg_u (i32.const 0) (i32.const 0) (i32.const 0))))) "unknown memory") +(assert_invalid (module (func (drop (i64.atomic.rmw16.cmpxchg_u (i32.const 0) (i64.const 0) (i64.const 0))))) "unknown memory") +(assert_invalid (module (func (drop (i64.atomic.rmw32.cmpxchg_u (i32.const 0) (i64.const 0) (i64.const 0))))) "unknown memory") diff --git a/runtime/near-vm/tests/wast/spec/proposals/threads/exports.wast b/runtime/near-vm/tests/wast/spec/proposals/threads/exports.wast new file mode 100644 index 00000000000..4a34734b075 --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/proposals/threads/exports.wast @@ -0,0 +1,205 @@ +;; Functions + +(module (func) (export "a" (func 0))) +(module (func) (export "a" (func 0)) (export "b" (func 0))) +(module (func) (func) (export "a" (func 0)) (export "b" (func 1))) + +(module (func (export "a"))) +(module (func (export "a") (export "b") (export "c"))) +(module (func (export "a") (export "b") (param i32))) +(module (func) (export "a" (func 0))) +(module (func $a (export "a"))) +(module (func $a) (export "a" (func $a))) +(module (export "a" (func 0)) (func)) +(module (export "a" (func $a)) (func $a)) + +(module $Func + (export "e" (func $f)) + (func $f (param $n i32) (result i32) + (return (i32.add (local.get $n) (i32.const 1))) + ) +) +(assert_return (invoke "e" (i32.const 42)) (i32.const 43)) +(assert_return (invoke $Func "e" (i32.const 42)) (i32.const 43)) +(module) +(module $Other1) +(assert_return (invoke $Func "e" (i32.const 42)) (i32.const 43)) + +(assert_invalid + (module (func) (export "a" (func 1))) + "unknown function" +) +(assert_invalid + (module (func) (export "a" (func 0)) (export "a" (func 0))) + "duplicate export name" +) +(assert_invalid + (module (func) (func) (export "a" (func 0)) (export "a" (func 1))) + "duplicate export name" +) +(assert_invalid + (module (func) (global i32 (i32.const 0)) (export "a" (func 0)) (export "a" (global 0))) + "duplicate export name" +) +(assert_invalid + (module (func) (table 0 funcref) (export "a" (func 0)) (export "a" (table 0))) + "duplicate export name" +) +(assert_invalid + (module (func) (memory 0) (export "a" (func 0)) (export "a" (memory 0))) + "duplicate export name" +) + + +;; Globals + +(module (global i32 (i32.const 0)) (export "a" (global 0))) +(module (global i32 (i32.const 0)) (export "a" (global 0)) (export "b" (global 0))) +(module (global i32 (i32.const 0)) (global i32 (i32.const 0)) (export "a" (global 0)) (export "b" (global 1))) + +(module (global (export "a") i32 (i32.const 0))) +(module (global i32 (i32.const 0)) (export "a" (global 0))) +(module (global $a (export "a") i32 (i32.const 0))) +(module (global $a i32 (i32.const 0)) (export "a" (global $a))) +(module (export "a" (global 0)) (global i32 (i32.const 0))) +(module (export "a" (global $a)) (global $a i32 (i32.const 0))) + +(module $Global + (export "e" (global $g)) + (global $g i32 (i32.const 42)) +) +(assert_return (get "e") (i32.const 42)) +(assert_return (get $Global "e") (i32.const 42)) +(module) +(module $Other2) +(assert_return (get $Global "e") (i32.const 42)) + +(assert_invalid + (module (global i32 (i32.const 0)) (export "a" (global 1))) + "unknown global" +) +(assert_invalid + (module (global i32 (i32.const 0)) (export "a" (global 0)) (export "a" (global 0))) + "duplicate export name" +) +(assert_invalid + (module (global i32 (i32.const 0)) (global i32 (i32.const 0)) (export "a" (global 0)) (export "a" (global 1))) + "duplicate export name" +) +(assert_invalid + (module (global i32 (i32.const 0)) (func) (export "a" (global 0)) (export "a" (func 0))) + "duplicate export name" +) +(assert_invalid + (module (global i32 (i32.const 0)) (table 0 funcref) (export "a" (global 0)) (export "a" (table 0))) + "duplicate export name" +) +(assert_invalid + (module (global i32 (i32.const 0)) (memory 0) (export "a" (global 0)) (export "a" (memory 0))) + "duplicate export name" +) + + +;; Tables + +(module (table 0 funcref) (export "a" (table 0))) +(module (table 0 funcref) (export "a" (table 0)) (export "b" (table 0))) +;; No multiple tables yet. +;; (module (table 0 funcref) (table 0 funcref) (export "a" (table 0)) (export "b" (table 1))) + +(module (table (export "a") 0 funcref)) +(module (table (export "a") 0 1 funcref)) +(module (table 0 funcref) (export "a" (table 0))) +(module (table 0 1 funcref) (export "a" (table 0))) +(module (table $a (export "a") 0 funcref)) +(module (table $a (export "a") 0 1 funcref)) +(module (table $a 0 funcref) (export "a" (table $a))) +(module (table $a 0 1 funcref) (export "a" (table $a))) +(module (export "a" (table 0)) (table 0 funcref)) +(module (export "a" (table 0)) (table 0 1 funcref)) +(module (export "a" (table $a)) (table $a 0 funcref)) +(module (export "a" (table $a)) (table $a 0 1 funcref)) + +(; TODO: access table ;) + +(assert_invalid + (module (table 0 funcref) (export "a" (table 1))) + "unknown table" +) +(assert_invalid + (module (table 0 funcref) (export "a" (table 0)) (export "a" (table 0))) + "duplicate export name" +) +;; No multiple tables yet. +;; (assert_invalid +;; (module (table 0 funcref) (table 0 funcref) (export "a" (table 0)) (export "a" (table 1))) +;; "duplicate export name" +;; ) +(assert_invalid + (module (table 0 funcref) (func) (export "a" (table 0)) (export "a" (func 0))) + "duplicate export name" +) +(assert_invalid + (module (table 0 funcref) (global i32 (i32.const 0)) (export "a" (table 0)) (export "a" (global 0))) + "duplicate export name" +) +(assert_invalid + (module (table 0 funcref) (memory 0) (export "a" (table 0)) (export "a" (memory 0))) + "duplicate export name" +) + + +;; Memories + +(module (memory 0) (export "a" (memory 0))) +(module (memory 0) (export "a" (memory 0)) (export "b" (memory 0))) +;; No multiple memories yet. +;; (module (memory 0) (memory 0) (export "a" (memory 0)) (export "b" (memory 1))) + +(module (memory (export "a") 0)) +(module (memory (export "a") 0 1)) +(module (memory 0) (export "a" (memory 0))) +(module (memory 0 1) (export "a" (memory 0))) +(module (memory $a (export "a") 0)) +(module (memory $a (export "a") 0 1)) +(module (memory $a 0) (export "a" (memory $a))) +(module (memory $a 0 1) (export "a" (memory $a))) +(module (export "a" (memory 0)) (memory 0)) +(module (export "a" (memory 0)) (memory 0 1)) +(module (export "a" (memory $a)) (memory $a 0)) +(module (export "a" (memory $a)) (memory $a 0 1)) + +(module (memory (export "a") 0 1 shared)) +(module (memory 0 1 shared) (export "a" (memory 0))) +(module (memory $a (export "a") 0 1 shared)) +(module (memory $a 0 1 shared) (export "a" (memory $a))) +(module (export "a" (memory 0)) (memory 0 1 shared)) +(module (export "a" (memory $a)) (memory $a 0 1 shared)) + +(; TODO: access memory ;) + +(assert_invalid + (module (memory 0) (export "a" (memory 1))) + "unknown memory" +) +(assert_invalid + (module (memory 0) (export "a" (memory 0)) (export "a" (memory 0))) + "duplicate export name" +) +;; No multiple memories yet. +;; (assert_invalid +;; (module (memory 0) (memory 0) (export "a" (memory 0)) (export "a" (memory 1))) +;; "duplicate export name" +;; ) +(assert_invalid + (module (memory 0) (func) (export "a" (memory 0)) (export "a" (func 0))) + "duplicate export name" +) +(assert_invalid + (module (memory 0) (global i32 (i32.const 0)) (export "a" (memory 0)) (export "a" (global 0))) + "duplicate export name" +) +(assert_invalid + (module (memory 0) (table 0 funcref) (export "a" (memory 0)) (export "a" (table 0))) + "duplicate export name" +) diff --git a/runtime/near-vm/tests/wast/spec/proposals/threads/imports.wast b/runtime/near-vm/tests/wast/spec/proposals/threads/imports.wast new file mode 100644 index 00000000000..51dfbceaa28 --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/proposals/threads/imports.wast @@ -0,0 +1,605 @@ +;; Auxiliary module to import from + +(module + (func (export "func")) + (func (export "func-i32") (param i32)) + (func (export "func-f32") (param f32)) + (func (export "func->i32") (result i32) (i32.const 22)) + (func (export "func->f32") (result f32) (f32.const 11)) + (func (export "func-i32->i32") (param i32) (result i32) (local.get 0)) + (func (export "func-i64->i64") (param i64) (result i64) (local.get 0)) + (global (export "global-i32") i32 (i32.const 55)) + (global (export "global-f32") f32 (f32.const 44)) + (table (export "table-10-inf") 10 funcref) + ;; (table (export "table-10-20") 10 20 funcref) + (memory (export "memory-2-inf") 2) + ;; (memory (export "memory-2-4") 2 4) +) + +(register "test") + + +;; Functions + +(module + (type $func_i32 (func (param i32))) + (type $func_i64 (func (param i64))) + (type $func_f32 (func (param f32))) + (type $func_f64 (func (param f64))) + + (import "spectest" "print_i32" (func (param i32))) + ;; JavaScript can't handle i64 yet. + ;; (func (import "spectest" "print_i64") (param i64)) + (import "spectest" "print_i32" (func $print_i32 (param i32))) + ;; JavaScript can't handle i64 yet. + ;; (import "spectest" "print_i64" (func $print_i64 (param i64))) + (import "spectest" "print_f32" (func $print_f32 (param f32))) + (import "spectest" "print_f64" (func $print_f64 (param f64))) + (import "spectest" "print_i32_f32" (func $print_i32_f32 (param i32 f32))) + (import "spectest" "print_f64_f64" (func $print_f64_f64 (param f64 f64))) + (func $print_i32-2 (import "spectest" "print_i32") (param i32)) + (func $print_f64-2 (import "spectest" "print_f64") (param f64)) + (import "test" "func-i64->i64" (func $i64->i64 (param i64) (result i64))) + + (func (export "p1") (import "spectest" "print_i32") (param i32)) + (func $p (export "p2") (import "spectest" "print_i32") (param i32)) + (func (export "p3") (export "p4") (import "spectest" "print_i32") (param i32)) + (func (export "p5") (import "spectest" "print_i32") (type 0)) + (func (export "p6") (import "spectest" "print_i32") (type 0) (param i32) (result)) + + (import "spectest" "print_i32" (func (type $forward))) + (func (import "spectest" "print_i32") (type $forward)) + (type $forward (func (param i32))) + + (table funcref (elem $print_i32 $print_f64)) + + (func (export "print32") (param $i i32) + (local $x f32) + (local.set $x (f32.convert_i32_s (local.get $i))) + (call 0 (local.get $i)) + (call $print_i32_f32 + (i32.add (local.get $i) (i32.const 1)) + (f32.const 42) + ) + (call $print_i32 (local.get $i)) + (call $print_i32-2 (local.get $i)) + (call $print_f32 (local.get $x)) + (call_indirect (type $func_i32) (local.get $i) (i32.const 0)) + ) + + (func (export "print64") (param $i i64) + (local $x f64) + (local.set $x (f64.convert_i64_s (call $i64->i64 (local.get $i)))) + ;; JavaScript can't handle i64 yet. + ;; (call 1 (local.get $i)) + (call $print_f64_f64 + (f64.add (local.get $x) (f64.const 1)) + (f64.const 53) + ) + ;; JavaScript can't handle i64 yet. + ;; (call $print_i64 (local.get $i)) + (call $print_f64 (local.get $x)) + (call $print_f64-2 (local.get $x)) + (call_indirect (type $func_f64) (local.get $x) (i32.const 1)) + ) +) + +(assert_return (invoke "print32" (i32.const 13))) +(assert_return (invoke "print64" (i64.const 24))) + +(assert_invalid + (module + (type (func (result i32))) + (import "test" "func" (func (type 1))) + ) + "unknown type" +) + +(module (import "test" "func" (func))) +(module (import "test" "func-i32" (func (param i32)))) +(module (import "test" "func-f32" (func (param f32)))) +(module (import "test" "func->i32" (func (result i32)))) +(module (import "test" "func->f32" (func (result f32)))) +(module (import "test" "func-i32->i32" (func (param i32) (result i32)))) +(module (import "test" "func-i64->i64" (func (param i64) (result i64)))) + +(assert_unlinkable + (module (import "test" "unknown" (func))) + "unknown import" +) +(assert_unlinkable + (module (import "spectest" "unknown" (func))) + "unknown import" +) + +(assert_unlinkable + (module (import "test" "func" (func (param i32)))) + "incompatible import type" +) +(assert_unlinkable + (module (import "test" "func" (func (result i32)))) + "incompatible import type" +) +(assert_unlinkable + (module (import "test" "func" (func (param i32) (result i32)))) + "incompatible import type" +) +(assert_unlinkable + (module (import "test" "func-i32" (func))) + "incompatible import type" +) +(assert_unlinkable + (module (import "test" "func-i32" (func (result i32)))) + "incompatible import type" +) +(assert_unlinkable + (module (import "test" "func-i32" (func (param f32)))) + "incompatible import type" +) +(assert_unlinkable + (module (import "test" "func-i32" (func (param i64)))) + "incompatible import type" +) +(assert_unlinkable + (module (import "test" "func-i32" (func (param i32) (result i32)))) + "incompatible import type" +) +(assert_unlinkable + (module (import "test" "func->i32" (func))) + "incompatible import type" +) +(assert_unlinkable + (module (import "test" "func->i32" (func (param i32)))) + "incompatible import type" +) +(assert_unlinkable + (module (import "test" "func->i32" (func (result f32)))) + "incompatible import type" +) +(assert_unlinkable + (module (import "test" "func->i32" (func (result i64)))) + "incompatible import type" +) +(assert_unlinkable + (module (import "test" "func->i32" (func (param i32) (result i32)))) + "incompatible import type" +) +(assert_unlinkable + (module (import "test" "func-i32->i32" (func))) + "incompatible import type" +) +(assert_unlinkable + (module (import "test" "func-i32->i32" (func (param i32)))) + "incompatible import type" +) +(assert_unlinkable + (module (import "test" "func-i32->i32" (func (result i32)))) + "incompatible import type" +) + +(assert_unlinkable + (module (import "test" "global-i32" (func (result i32)))) + "incompatible import type" +) +(assert_unlinkable + (module (import "test" "table-10-inf" (func))) + "incompatible import type" +) +(assert_unlinkable + (module (import "test" "memory-2-inf" (func))) + "incompatible import type" +) +(assert_unlinkable + (module (import "spectest" "global_i32" (func))) + "incompatible import type" +) +(assert_unlinkable + (module (import "spectest" "table" (func))) + "incompatible import type" +) +(assert_unlinkable + (module (import "spectest" "memory" (func))) + "incompatible import type" +) + + +;; Globals + +(module + (import "spectest" "global_i32" (global i32)) + (global (import "spectest" "global_i32") i32) + + (import "spectest" "global_i32" (global $x i32)) + (global $y (import "spectest" "global_i32") i32) + + ;; JavaScript can't handle i64 yet. + ;; (import "spectest" "global_i64" (global i64)) + (import "spectest" "global_f32" (global f32)) + (import "spectest" "global_f64" (global f64)) + + (func (export "get-0") (result i32) (global.get 0)) + (func (export "get-1") (result i32) (global.get 1)) + (func (export "get-x") (result i32) (global.get $x)) + (func (export "get-y") (result i32) (global.get $y)) +) + +(assert_return (invoke "get-0") (i32.const 666)) +(assert_return (invoke "get-1") (i32.const 666)) +(assert_return (invoke "get-x") (i32.const 666)) +(assert_return (invoke "get-y") (i32.const 666)) + +(module (import "test" "global-i32" (global i32))) +(module (import "test" "global-f32" (global f32))) + +(assert_unlinkable + (module (import "test" "unknown" (global i32))) + "unknown import" +) +(assert_unlinkable + (module (import "spectest" "unknown" (global i32))) + "unknown import" +) + +(assert_unlinkable + (module (import "test" "func" (global i32))) + "incompatible import type" +) +(assert_unlinkable + (module (import "test" "table-10-inf" (global i32))) + "incompatible import type" +) +(assert_unlinkable + (module (import "test" "memory-2-inf" (global i32))) + "incompatible import type" +) +(assert_unlinkable + (module (import "spectest" "print_i32" (global i32))) + "incompatible import type" +) +(assert_unlinkable + (module (import "spectest" "table" (global i32))) + "incompatible import type" +) +(assert_unlinkable + (module (import "spectest" "memory" (global i32))) + "incompatible import type" +) + + +;; Tables + +(module + (type (func (result i32))) + (import "spectest" "table" (table 10 20 funcref)) + (elem 0 (i32.const 1) $f $g) + + (func (export "call") (param i32) (result i32) + (call_indirect (type 0) (local.get 0)) + ) + (func $f (result i32) (i32.const 11)) + (func $g (result i32) (i32.const 22)) +) + +(assert_trap (invoke "call" (i32.const 0)) "uninitialized element") +(assert_return (invoke "call" (i32.const 1)) (i32.const 11)) +(assert_return (invoke "call" (i32.const 2)) (i32.const 22)) +(assert_trap (invoke "call" (i32.const 3)) "uninitialized element") +(assert_trap (invoke "call" (i32.const 100)) "undefined element") + + +(module + (type (func (result i32))) + (table (import "spectest" "table") 10 20 funcref) + (elem 0 (i32.const 1) $f $g) + + (func (export "call") (param i32) (result i32) + (call_indirect (type 0) (local.get 0)) + ) + (func $f (result i32) (i32.const 11)) + (func $g (result i32) (i32.const 22)) +) + +(assert_trap (invoke "call" (i32.const 0)) "uninitialized element") +(assert_return (invoke "call" (i32.const 1)) (i32.const 11)) +(assert_return (invoke "call" (i32.const 2)) (i32.const 22)) +(assert_trap (invoke "call" (i32.const 3)) "uninitialized element") +(assert_trap (invoke "call" (i32.const 100)) "undefined element") + + +(assert_invalid + (module (import "" "" (table 10 funcref)) (import "" "" (table 10 funcref))) + "multiple tables" +) +(assert_invalid + (module (import "" "" (table 10 funcref)) (table 10 funcref)) + "multiple tables" +) +(assert_invalid + (module (table 10 funcref) (table 10 funcref)) + "multiple tables" +) + +(module (import "test" "table-10-inf" (table 10 funcref))) +(module (import "test" "table-10-inf" (table 5 funcref))) +(module (import "test" "table-10-inf" (table 0 funcref))) +(module (import "spectest" "table" (table 10 funcref))) +(module (import "spectest" "table" (table 5 funcref))) +(module (import "spectest" "table" (table 0 funcref))) +(module (import "spectest" "table" (table 10 20 funcref))) +(module (import "spectest" "table" (table 5 20 funcref))) +(module (import "spectest" "table" (table 0 20 funcref))) +(module (import "spectest" "table" (table 10 25 funcref))) +(module (import "spectest" "table" (table 5 25 funcref))) + +(assert_unlinkable + (module (import "test" "unknown" (table 10 funcref))) + "unknown import" +) +(assert_unlinkable + (module (import "spectest" "unknown" (table 10 funcref))) + "unknown import" +) + +(assert_unlinkable + (module (import "test" "table-10-inf" (table 12 funcref))) + "incompatible import type" +) +(assert_unlinkable + (module (import "test" "table-10-inf" (table 10 20 funcref))) + "incompatible import type" +) +(assert_unlinkable + (module (import "spectest" "table" (table 12 funcref))) + "incompatible import type" +) +(assert_unlinkable + (module (import "spectest" "table" (table 10 15 funcref))) + "incompatible import type" +) + +(assert_unlinkable + (module (import "test" "func" (table 10 funcref))) + "incompatible import type" +) +(assert_unlinkable + (module (import "test" "global-i32" (table 10 funcref))) + "incompatible import type" +) +(assert_unlinkable + (module (import "test" "memory-2-inf" (table 10 funcref))) + "incompatible import type" +) +(assert_unlinkable + (module (import "spectest" "print_i32" (table 10 funcref))) + "incompatible import type" +) + + + +;; Memories + +(module + (import "spectest" "memory" (memory 1 2)) + (data 0 (i32.const 10) "\10") + + (func (export "load") (param i32) (result i32) (i32.load (local.get 0))) +) + +(assert_return (invoke "load" (i32.const 0)) (i32.const 0)) +(assert_return (invoke "load" (i32.const 10)) (i32.const 16)) +(assert_return (invoke "load" (i32.const 8)) (i32.const 0x100000)) +(assert_trap (invoke "load" (i32.const 1000000)) "out of bounds memory access") + +(module + (memory (import "spectest" "memory") 1 2) + (data 0 (i32.const 10) "\10") + + (func (export "load") (param i32) (result i32) (i32.load (local.get 0))) +) +(assert_return (invoke "load" (i32.const 0)) (i32.const 0)) +(assert_return (invoke "load" (i32.const 10)) (i32.const 16)) +(assert_return (invoke "load" (i32.const 8)) (i32.const 0x100000)) +(assert_trap (invoke "load" (i32.const 1000000)) "out of bounds memory access") + +(assert_invalid + (module (import "" "" (memory 1)) (import "" "" (memory 1))) + "multiple memories" +) +(assert_invalid + (module (import "" "" (memory 1)) (memory 0)) + "multiple memories" +) +(assert_invalid + (module (memory 0) (memory 0)) + "multiple memories" +) + +(module (import "test" "memory-2-inf" (memory 2))) +(module (import "test" "memory-2-inf" (memory 1))) +(module (import "test" "memory-2-inf" (memory 0))) +(module (import "spectest" "memory" (memory 1))) +(module (import "spectest" "memory" (memory 0))) +(module (import "spectest" "memory" (memory 1 2))) +(module (import "spectest" "memory" (memory 0 2))) +(module (import "spectest" "memory" (memory 1 3))) +(module (import "spectest" "memory" (memory 0 3))) + +(assert_unlinkable + (module (import "test" "unknown" (memory 1))) + "unknown import" +) +(assert_unlinkable + (module (import "spectest" "unknown" (memory 1))) + "unknown import" +) + +(assert_unlinkable + (module (import "test" "memory-2-inf" (memory 3))) + "incompatible import type" +) +(assert_unlinkable + (module (import "test" "memory-2-inf" (memory 2 3))) + "incompatible import type" +) +(assert_unlinkable + (module (import "spectest" "memory" (memory 2))) + "incompatible import type" +) +(assert_unlinkable + (module (import "spectest" "memory" (memory 1 1))) + "incompatible import type" +) + +(assert_unlinkable + (module (import "test" "func-i32" (memory 1))) + "incompatible import type" +) +(assert_unlinkable + (module (import "test" "global-i32" (memory 1))) + "incompatible import type" +) +(assert_unlinkable + (module (import "test" "table-10-inf" (memory 1))) + "incompatible import type" +) +(assert_unlinkable + (module (import "spectest" "print_i32" (memory 1))) + "incompatible import type" +) +(assert_unlinkable + (module (import "spectest" "global_i32" (memory 1))) + "incompatible import type" +) +(assert_unlinkable + (module (import "spectest" "table" (memory 1))) + "incompatible import type" +) + +(assert_unlinkable + (module (import "spectest" "memory" (memory 2))) + "incompatible import type" +) +(assert_unlinkable + (module (import "spectest" "memory" (memory 1 1))) + "incompatible import type" +) + +(module + (import "spectest" "memory" (memory 0 3)) ;; actual has max size 2 + (func (export "grow") (param i32) (result i32) (memory.grow (local.get 0))) +) +(assert_return (invoke "grow" (i32.const 0)) (i32.const 1)) +(assert_return (invoke "grow" (i32.const 1)) (i32.const 1)) +(assert_return (invoke "grow" (i32.const 0)) (i32.const 2)) +(assert_return (invoke "grow" (i32.const 1)) (i32.const -1)) +(assert_return (invoke "grow" (i32.const 0)) (i32.const 2)) + +;; Shared Memory + +(module (import "spectest" "shared_memory" (memory 1 2 shared))) + +(assert_unlinkable + (module (import "spectest" "shared_memory" (memory 1 2))) + "incompatible import type") + +(assert_unlinkable + (module (import "spectest" "memory" (memory 1 2 shared))) + "incompatible import type") + + +;; Syntax errors + +(assert_malformed + (module quote "(func) (import \"\" \"\" (func))") + "import after function" +) +(assert_malformed + (module quote "(func) (import \"\" \"\" (global i64))") + "import after function" +) +(assert_malformed + (module quote "(func) (import \"\" \"\" (table 0 funcref))") + "import after function" +) +(assert_malformed + (module quote "(func) (import \"\" \"\" (memory 0))") + "import after function" +) + +(assert_malformed + (module quote "(global i64 (i64.const 0)) (import \"\" \"\" (func))") + "import after global" +) +(assert_malformed + (module quote "(global i64 (i64.const 0)) (import \"\" \"\" (global f32))") + "import after global" +) +(assert_malformed + (module quote "(global i64 (i64.const 0)) (import \"\" \"\" (table 0 funcref))") + "import after global" +) +(assert_malformed + (module quote "(global i64 (i64.const 0)) (import \"\" \"\" (memory 0))") + "import after global" +) + +(assert_malformed + (module quote "(table 0 funcref) (import \"\" \"\" (func))") + "import after table" +) +(assert_malformed + (module quote "(table 0 funcref) (import \"\" \"\" (global i32))") + "import after table" +) +(assert_malformed + (module quote "(table 0 funcref) (import \"\" \"\" (table 0 funcref))") + "import after table" +) +(assert_malformed + (module quote "(table 0 funcref) (import \"\" \"\" (memory 0))") + "import after table" +) + +(assert_malformed + (module quote "(memory 0) (import \"\" \"\" (func))") + "import after memory" +) +(assert_malformed + (module quote "(memory 0) (import \"\" \"\" (global i32))") + "import after memory" +) +(assert_malformed + (module quote "(memory 0) (import \"\" \"\" (table 1 3 funcref))") + "import after memory" +) +(assert_malformed + (module quote "(memory 0) (import \"\" \"\" (memory 1 2))") + "import after memory" +) + +;; This module is required to validate, regardless of whether it can be +;; linked. Overloading is not possible in wasm itself, but it is possible +;; in modules from which wasm can import. +(module) +(register "not wasm") +(assert_unlinkable + (module + (import "not wasm" "overloaded" (func)) + (import "not wasm" "overloaded" (func (param i32))) + (import "not wasm" "overloaded" (func (param i32 i32))) + (import "not wasm" "overloaded" (func (param i64))) + (import "not wasm" "overloaded" (func (param f32))) + (import "not wasm" "overloaded" (func (param f64))) + (import "not wasm" "overloaded" (func (result i32))) + (import "not wasm" "overloaded" (func (result i64))) + (import "not wasm" "overloaded" (func (result f32))) + (import "not wasm" "overloaded" (func (result f64))) + (import "not wasm" "overloaded" (global i32)) + (import "not wasm" "overloaded" (global i64)) + (import "not wasm" "overloaded" (global f32)) + (import "not wasm" "overloaded" (global f64)) + (import "not wasm" "overloaded" (table 0 funcref)) + (import "not wasm" "overloaded" (memory 0)) + ) + "unknown import" +) diff --git a/runtime/near-vm/tests/wast/spec/proposals/threads/memory.wast b/runtime/near-vm/tests/wast/spec/proposals/threads/memory.wast new file mode 100644 index 00000000000..e10c3497a1d --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/proposals/threads/memory.wast @@ -0,0 +1,246 @@ +;; Test memory section structure + +(module (memory 0)) +(module (memory 1)) +(module (memory 0 0)) +(module (memory 0 1)) +(module (memory 1 256)) +(module (memory 0 65536)) +(module (memory 0 0 shared)) +(module (memory 1 2 shared)) + +(assert_invalid (module (memory 1 shared)) "shared memory must have maximum") + +(assert_invalid (module (memory 0) (memory 0)) "multiple memories") +(assert_invalid (module (memory (import "spectest" "memory") 0) (memory 0)) "multiple memories") + +(module (memory (data)) (func (export "memsize") (result i32) (memory.size))) +(assert_return (invoke "memsize") (i32.const 0)) +(module (memory (data "")) (func (export "memsize") (result i32) (memory.size))) +(assert_return (invoke "memsize") (i32.const 0)) +(module (memory (data "x")) (func (export "memsize") (result i32) (memory.size))) +(assert_return (invoke "memsize") (i32.const 1)) + +(assert_invalid (module (data (i32.const 0))) "unknown memory") +(assert_invalid (module (data (i32.const 0) "")) "unknown memory") +(assert_invalid (module (data (i32.const 0) "x")) "unknown memory") + +(assert_invalid + (module (func (drop (f32.load (i32.const 0))))) + "unknown memory" +) +(assert_invalid + (module (func (f32.store (i32.const 0) (f32.const 0)))) + "unknown memory" +) +(assert_invalid + (module (func (drop (i32.load8_s (i32.const 0))))) + "unknown memory" +) +(assert_invalid + (module (func (i32.store8 (i32.const 0) (i32.const 0)))) + "unknown memory" +) +(assert_invalid + (module (func (drop (memory.size)))) + "unknown memory" +) +(assert_invalid + (module (func (drop (memory.grow (i32.const 0))))) + "unknown memory" +) + + +(assert_invalid + (module (memory 1 0)) + "size minimum must not be greater than maximum" +) +(assert_invalid + (module (memory 65537)) + "memory size must be at most 65536 pages (4GiB)" +) +(assert_invalid + (module (memory 2147483648)) + "memory size must be at most 65536 pages (4GiB)" +) +(assert_invalid + (module (memory 4294967295)) + "memory size must be at most 65536 pages (4GiB)" +) +(assert_invalid + (module (memory 0 65537)) + "memory size must be at most 65536 pages (4GiB)" +) +(assert_invalid + (module (memory 0 2147483648)) + "memory size must be at most 65536 pages (4GiB)" +) +(assert_invalid + (module (memory 0 4294967295)) + "memory size must be at most 65536 pages (4GiB)" +) + +(assert_malformed + (module quote "(memory 0x1_0000_0000)") + "i32 constant out of range" +) +(assert_malformed + (module quote "(memory 0x1_0000_0000 0x1_0000_0000)") + "i32 constant out of range" +) +(assert_malformed + (module quote "(memory 0 0x1_0000_0000)") + "i32 constant out of range" +) + +(module + (memory 1) + (data (i32.const 0) "ABC\a7D") (data (i32.const 20) "WASM") + + ;; Data section + (func (export "data") (result i32) + (i32.and + (i32.and + (i32.and + (i32.eq (i32.load8_u (i32.const 0)) (i32.const 65)) + (i32.eq (i32.load8_u (i32.const 3)) (i32.const 167)) + ) + (i32.and + (i32.eq (i32.load8_u (i32.const 6)) (i32.const 0)) + (i32.eq (i32.load8_u (i32.const 19)) (i32.const 0)) + ) + ) + (i32.and + (i32.and + (i32.eq (i32.load8_u (i32.const 20)) (i32.const 87)) + (i32.eq (i32.load8_u (i32.const 23)) (i32.const 77)) + ) + (i32.and + (i32.eq (i32.load8_u (i32.const 24)) (i32.const 0)) + (i32.eq (i32.load8_u (i32.const 1023)) (i32.const 0)) + ) + ) + ) + ) + + ;; Memory cast + (func (export "cast") (result f64) + (i64.store (i32.const 8) (i64.const -12345)) + (if + (f64.eq + (f64.load (i32.const 8)) + (f64.reinterpret_i64 (i64.const -12345)) + ) + (then (return (f64.const 0))) + ) + (i64.store align=1 (i32.const 9) (i64.const 0)) + (i32.store16 align=1 (i32.const 15) (i32.const 16453)) + (f64.load align=1 (i32.const 9)) + ) + + ;; Sign and zero extending memory loads + (func (export "i32_load8_s") (param $i i32) (result i32) + (i32.store8 (i32.const 8) (local.get $i)) + (i32.load8_s (i32.const 8)) + ) + (func (export "i32_load8_u") (param $i i32) (result i32) + (i32.store8 (i32.const 8) (local.get $i)) + (i32.load8_u (i32.const 8)) + ) + (func (export "i32_load16_s") (param $i i32) (result i32) + (i32.store16 (i32.const 8) (local.get $i)) + (i32.load16_s (i32.const 8)) + ) + (func (export "i32_load16_u") (param $i i32) (result i32) + (i32.store16 (i32.const 8) (local.get $i)) + (i32.load16_u (i32.const 8)) + ) + (func (export "i64_load8_s") (param $i i64) (result i64) + (i64.store8 (i32.const 8) (local.get $i)) + (i64.load8_s (i32.const 8)) + ) + (func (export "i64_load8_u") (param $i i64) (result i64) + (i64.store8 (i32.const 8) (local.get $i)) + (i64.load8_u (i32.const 8)) + ) + (func (export "i64_load16_s") (param $i i64) (result i64) + (i64.store16 (i32.const 8) (local.get $i)) + (i64.load16_s (i32.const 8)) + ) + (func (export "i64_load16_u") (param $i i64) (result i64) + (i64.store16 (i32.const 8) (local.get $i)) + (i64.load16_u (i32.const 8)) + ) + (func (export "i64_load32_s") (param $i i64) (result i64) + (i64.store32 (i32.const 8) (local.get $i)) + (i64.load32_s (i32.const 8)) + ) + (func (export "i64_load32_u") (param $i i64) (result i64) + (i64.store32 (i32.const 8) (local.get $i)) + (i64.load32_u (i32.const 8)) + ) +) + +(assert_return (invoke "data") (i32.const 1)) +(assert_return (invoke "cast") (f64.const 42.0)) + +(assert_return (invoke "i32_load8_s" (i32.const -1)) (i32.const -1)) +(assert_return (invoke "i32_load8_u" (i32.const -1)) (i32.const 255)) +(assert_return (invoke "i32_load16_s" (i32.const -1)) (i32.const -1)) +(assert_return (invoke "i32_load16_u" (i32.const -1)) (i32.const 65535)) + +(assert_return (invoke "i32_load8_s" (i32.const 100)) (i32.const 100)) +(assert_return (invoke "i32_load8_u" (i32.const 200)) (i32.const 200)) +(assert_return (invoke "i32_load16_s" (i32.const 20000)) (i32.const 20000)) +(assert_return (invoke "i32_load16_u" (i32.const 40000)) (i32.const 40000)) + +(assert_return (invoke "i32_load8_s" (i32.const 0xfedc6543)) (i32.const 0x43)) +(assert_return (invoke "i32_load8_s" (i32.const 0x3456cdef)) (i32.const 0xffffffef)) +(assert_return (invoke "i32_load8_u" (i32.const 0xfedc6543)) (i32.const 0x43)) +(assert_return (invoke "i32_load8_u" (i32.const 0x3456cdef)) (i32.const 0xef)) +(assert_return (invoke "i32_load16_s" (i32.const 0xfedc6543)) (i32.const 0x6543)) +(assert_return (invoke "i32_load16_s" (i32.const 0x3456cdef)) (i32.const 0xffffcdef)) +(assert_return (invoke "i32_load16_u" (i32.const 0xfedc6543)) (i32.const 0x6543)) +(assert_return (invoke "i32_load16_u" (i32.const 0x3456cdef)) (i32.const 0xcdef)) + +(assert_return (invoke "i64_load8_s" (i64.const -1)) (i64.const -1)) +(assert_return (invoke "i64_load8_u" (i64.const -1)) (i64.const 255)) +(assert_return (invoke "i64_load16_s" (i64.const -1)) (i64.const -1)) +(assert_return (invoke "i64_load16_u" (i64.const -1)) (i64.const 65535)) +(assert_return (invoke "i64_load32_s" (i64.const -1)) (i64.const -1)) +(assert_return (invoke "i64_load32_u" (i64.const -1)) (i64.const 4294967295)) + +(assert_return (invoke "i64_load8_s" (i64.const 100)) (i64.const 100)) +(assert_return (invoke "i64_load8_u" (i64.const 200)) (i64.const 200)) +(assert_return (invoke "i64_load16_s" (i64.const 20000)) (i64.const 20000)) +(assert_return (invoke "i64_load16_u" (i64.const 40000)) (i64.const 40000)) +(assert_return (invoke "i64_load32_s" (i64.const 20000)) (i64.const 20000)) +(assert_return (invoke "i64_load32_u" (i64.const 40000)) (i64.const 40000)) + +(assert_return (invoke "i64_load8_s" (i64.const 0xfedcba9856346543)) (i64.const 0x43)) +(assert_return (invoke "i64_load8_s" (i64.const 0x3456436598bacdef)) (i64.const 0xffffffffffffffef)) +(assert_return (invoke "i64_load8_u" (i64.const 0xfedcba9856346543)) (i64.const 0x43)) +(assert_return (invoke "i64_load8_u" (i64.const 0x3456436598bacdef)) (i64.const 0xef)) +(assert_return (invoke "i64_load16_s" (i64.const 0xfedcba9856346543)) (i64.const 0x6543)) +(assert_return (invoke "i64_load16_s" (i64.const 0x3456436598bacdef)) (i64.const 0xffffffffffffcdef)) +(assert_return (invoke "i64_load16_u" (i64.const 0xfedcba9856346543)) (i64.const 0x6543)) +(assert_return (invoke "i64_load16_u" (i64.const 0x3456436598bacdef)) (i64.const 0xcdef)) +(assert_return (invoke "i64_load32_s" (i64.const 0xfedcba9856346543)) (i64.const 0x56346543)) +(assert_return (invoke "i64_load32_s" (i64.const 0x3456436598bacdef)) (i64.const 0xffffffff98bacdef)) +(assert_return (invoke "i64_load32_u" (i64.const 0xfedcba9856346543)) (i64.const 0x56346543)) +(assert_return (invoke "i64_load32_u" (i64.const 0x3456436598bacdef)) (i64.const 0x98bacdef)) + +;; Duplicate identifier errors + +(assert_malformed (module quote + "(memory $foo 1)" + "(memory $foo 1)") + "duplicate memory") +(assert_malformed (module quote + "(import \"\" \"\" (memory $foo 1))" + "(memory $foo 1)") + "duplicate memory") +(assert_malformed (module quote + "(import \"\" \"\" (memory $foo 1))" + "(import \"\" \"\" (memory $foo 1))") + "duplicate memory") diff --git a/runtime/near-vm/tests/wast/spec/ref_func.wast b/runtime/near-vm/tests/wast/spec/ref_func.wast new file mode 100644 index 00000000000..adb5cb788d3 --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/ref_func.wast @@ -0,0 +1,115 @@ +(module + (func (export "f") (param $x i32) (result i32) (local.get $x)) +) +(register "M") + +(module + (func $f (import "M" "f") (param i32) (result i32)) + (func $g (param $x i32) (result i32) + (i32.add (local.get $x) (i32.const 1)) + ) + + (global funcref (ref.func $f)) + (global funcref (ref.func $g)) + (global $v (mut funcref) (ref.func $f)) + + (global funcref (ref.func $gf1)) + (global funcref (ref.func $gf2)) + (func (drop (ref.func $ff1)) (drop (ref.func $ff2))) + (elem declare func $gf1 $ff1) + (elem declare funcref (ref.func $gf2) (ref.func $ff2)) + (func $gf1) + (func $gf2) + (func $ff1) + (func $ff2) + + (func (export "is_null-f") (result i32) + (ref.is_null (ref.func $f)) + ) + (func (export "is_null-g") (result i32) + (ref.is_null (ref.func $g)) + ) + (func (export "is_null-v") (result i32) + (ref.is_null (global.get $v)) + ) + + (func (export "set-f") (global.set $v (ref.func $f))) + (func (export "set-g") (global.set $v (ref.func $g))) + + (table $t 1 funcref) + (elem declare func $f $g) + + (func (export "call-f") (param $x i32) (result i32) + (table.set $t (i32.const 0) (ref.func $f)) + (call_indirect $t (param i32) (result i32) (local.get $x) (i32.const 0)) + ) + (func (export "call-g") (param $x i32) (result i32) + (table.set $t (i32.const 0) (ref.func $g)) + (call_indirect $t (param i32) (result i32) (local.get $x) (i32.const 0)) + ) + (func (export "call-v") (param $x i32) (result i32) + (table.set $t (i32.const 0) (global.get $v)) + (call_indirect $t (param i32) (result i32) (local.get $x) (i32.const 0)) + ) +) + +(assert_return (invoke "is_null-f") (i32.const 0)) +(assert_return (invoke "is_null-g") (i32.const 0)) +(assert_return (invoke "is_null-v") (i32.const 0)) + +(assert_return (invoke "call-f" (i32.const 4)) (i32.const 4)) +(assert_return (invoke "call-g" (i32.const 4)) (i32.const 5)) +(assert_return (invoke "call-v" (i32.const 4)) (i32.const 4)) +(invoke "set-g") +(assert_return (invoke "call-v" (i32.const 4)) (i32.const 5)) +(invoke "set-f") +(assert_return (invoke "call-v" (i32.const 4)) (i32.const 4)) + +(assert_invalid + (module + (func $f (import "M" "f") (param i32) (result i32)) + (func $g (import "M" "g") (param i32) (result i32)) + (global funcref (ref.func 7)) + ) + "unknown function 7" +) + + +;; Reference declaration + +(module + (func $f1) + (func $f2) + (func $f3) + (func $f4) + (func $f5) + (func $f6) + + (table $t 1 funcref) + + (global funcref (ref.func $f1)) + (export "f" (func $f2)) + (elem (table $t) (i32.const 0) func $f3) + (elem (table $t) (i32.const 0) funcref (ref.func $f4)) + (elem func $f5) + (elem funcref (ref.func $f6)) + + (func + (ref.func $f1) + (ref.func $f2) + (ref.func $f3) + (ref.func $f4) + (ref.func $f5) + (ref.func $f6) + (return) + ) +) + +(assert_invalid + (module (func $f (drop (ref.func $f)))) + "undeclared function reference" +) +(assert_invalid + (module (start $f) (func $f (drop (ref.func $f)))) + "undeclared function reference" +) diff --git a/runtime/near-vm/tests/wast/spec/ref_is_null.wast b/runtime/near-vm/tests/wast/spec/ref_is_null.wast new file mode 100644 index 00000000000..8396da4a7e1 --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/ref_is_null.wast @@ -0,0 +1,58 @@ +(module + (func $f1 (export "funcref") (param $x funcref) (result i32) + (ref.is_null (local.get $x)) + ) + (func $f2 (export "externref") (param $x externref) (result i32) + (ref.is_null (local.get $x)) + ) + + (table $t1 2 funcref) + (table $t2 2 externref) + (elem (table $t1) (i32.const 1) func $dummy) + (func $dummy) + + (func (export "init") (param $r externref) + (table.set $t2 (i32.const 1) (local.get $r)) + ) + (func (export "deinit") + (table.set $t1 (i32.const 1) (ref.null func)) + (table.set $t2 (i32.const 1) (ref.null extern)) + ) + + (func (export "funcref-elem") (param $x i32) (result i32) + (call $f1 (table.get $t1 (local.get $x))) + ) + (func (export "externref-elem") (param $x i32) (result i32) + (call $f2 (table.get $t2 (local.get $x))) + ) +) + +(assert_return (invoke "funcref" (ref.null func)) (i32.const 1)) +(assert_return (invoke "externref" (ref.null extern)) (i32.const 1)) + +(assert_return (invoke "externref" (ref.extern 1)) (i32.const 0)) + +(invoke "init" (ref.extern 0)) + +(assert_return (invoke "funcref-elem" (i32.const 0)) (i32.const 1)) +(assert_return (invoke "externref-elem" (i32.const 0)) (i32.const 1)) + +(assert_return (invoke "funcref-elem" (i32.const 1)) (i32.const 0)) +(assert_return (invoke "externref-elem" (i32.const 1)) (i32.const 0)) + +(invoke "deinit") + +(assert_return (invoke "funcref-elem" (i32.const 0)) (i32.const 1)) +(assert_return (invoke "externref-elem" (i32.const 0)) (i32.const 1)) + +(assert_return (invoke "funcref-elem" (i32.const 1)) (i32.const 1)) +(assert_return (invoke "externref-elem" (i32.const 1)) (i32.const 1)) + +(assert_invalid + (module (func $ref-vs-num (param i32) (ref.is_null (local.get 0)))) + "type mismatch" +) +(assert_invalid + (module (func $ref-vs-empty (ref.is_null))) + "type mismatch" +) diff --git a/runtime/near-vm/tests/wast/spec/ref_null.wast b/runtime/near-vm/tests/wast/spec/ref_null.wast new file mode 100644 index 00000000000..b88b0888fd8 --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/ref_null.wast @@ -0,0 +1,10 @@ +(module + (func (export "externref") (result externref) (ref.null extern)) + (func (export "funcref") (result funcref) (ref.null func)) + + (global externref (ref.null extern)) + (global funcref (ref.null func)) +) + +(assert_return (invoke "externref") (ref.null extern)) +(assert_return (invoke "funcref") (ref.null func)) diff --git a/runtime/near-vm/tests/wast/spec/return.wast b/runtime/near-vm/tests/wast/spec/return.wast new file mode 100644 index 00000000000..7077f25b696 --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/return.wast @@ -0,0 +1,479 @@ +;; Test `return` operator + +(module + ;; Auxiliary definition + (func $dummy) + + (func (export "type-i32") (drop (i32.ctz (return)))) + (func (export "type-i64") (drop (i64.ctz (return)))) + (func (export "type-f32") (drop (f32.neg (return)))) + (func (export "type-f64") (drop (f64.neg (return)))) + + (func (export "type-i32-value") (result i32) + (block (result i32) (i32.ctz (return (i32.const 1)))) + ) + (func (export "type-i64-value") (result i64) + (block (result i64) (i64.ctz (return (i64.const 2)))) + ) + (func (export "type-f32-value") (result f32) + (block (result f32) (f32.neg (return (f32.const 3)))) + ) + (func (export "type-f64-value") (result f64) + (block (result f64) (f64.neg (return (f64.const 4)))) + ) + + (func (export "nullary") (return)) + (func (export "unary") (result f64) (return (f64.const 3))) + + (func (export "as-func-first") (result i32) + (return (i32.const 1)) (i32.const 2) + ) + (func (export "as-func-mid") (result i32) + (call $dummy) (return (i32.const 2)) (i32.const 3) + ) + (func (export "as-func-last") + (nop) (call $dummy) (return) + ) + (func (export "as-func-value") (result i32) + (nop) (call $dummy) (return (i32.const 3)) + ) + + (func (export "as-block-first") + (block (return) (call $dummy)) + ) + (func (export "as-block-mid") + (block (call $dummy) (return) (call $dummy)) + ) + (func (export "as-block-last") + (block (nop) (call $dummy) (return)) + ) + (func (export "as-block-value") (result i32) + (block (result i32) (nop) (call $dummy) (return (i32.const 2))) + ) + + (func (export "as-loop-first") (result i32) + (loop (result i32) (return (i32.const 3)) (i32.const 2)) + ) + (func (export "as-loop-mid") (result i32) + (loop (result i32) (call $dummy) (return (i32.const 4)) (i32.const 2)) + ) + (func (export "as-loop-last") (result i32) + (loop (result i32) (nop) (call $dummy) (return (i32.const 5))) + ) + + (func (export "as-br-value") (result i32) + (block (result i32) (br 0 (return (i32.const 9)))) + ) + + (func (export "as-br_if-cond") + (block (br_if 0 (return))) + ) + (func (export "as-br_if-value") (result i32) + (block (result i32) + (drop (br_if 0 (return (i32.const 8)) (i32.const 1))) (i32.const 7) + ) + ) + (func (export "as-br_if-value-cond") (result i32) + (block (result i32) + (drop (br_if 0 (i32.const 6) (return (i32.const 9)))) (i32.const 7) + ) + ) + + (func (export "as-br_table-index") (result i64) + (block (br_table 0 0 0 (return (i64.const 9)))) (i64.const -1) + ) + (func (export "as-br_table-value") (result i32) + (block (result i32) + (br_table 0 0 0 (return (i32.const 10)) (i32.const 1)) (i32.const 7) + ) + ) + (func (export "as-br_table-value-index") (result i32) + (block (result i32) + (br_table 0 0 (i32.const 6) (return (i32.const 11))) (i32.const 7) + ) + ) + + (func (export "as-return-value") (result i64) + (return (return (i64.const 7))) + ) + + (func (export "as-if-cond") (result i32) + (if (result i32) + (return (i32.const 2)) (then (i32.const 0)) (else (i32.const 1)) + ) + ) + (func (export "as-if-then") (param i32 i32) (result i32) + (if (result i32) + (local.get 0) (then (return (i32.const 3))) (else (local.get 1)) + ) + ) + (func (export "as-if-else") (param i32 i32) (result i32) + (if (result i32) + (local.get 0) (then (local.get 1)) (else (return (i32.const 4))) + ) + ) + + (func (export "as-select-first") (param i32 i32) (result i32) + (select (return (i32.const 5)) (local.get 0) (local.get 1)) + ) + (func (export "as-select-second") (param i32 i32) (result i32) + (select (local.get 0) (return (i32.const 6)) (local.get 1)) + ) + (func (export "as-select-cond") (result i32) + (select (i32.const 0) (i32.const 1) (return (i32.const 7))) + ) + + (func $f (param i32 i32 i32) (result i32) (i32.const -1)) + (func (export "as-call-first") (result i32) + (call $f (return (i32.const 12)) (i32.const 2) (i32.const 3)) + ) + (func (export "as-call-mid") (result i32) + (call $f (i32.const 1) (return (i32.const 13)) (i32.const 3)) + ) + (func (export "as-call-last") (result i32) + (call $f (i32.const 1) (i32.const 2) (return (i32.const 14))) + ) + + (type $sig (func (param i32 i32 i32) (result i32))) + (table funcref (elem $f)) + (func (export "as-call_indirect-func") (result i32) + (call_indirect (type $sig) + (return (i32.const 20)) (i32.const 1) (i32.const 2) (i32.const 3) + ) + ) + (func (export "as-call_indirect-first") (result i32) + (call_indirect (type $sig) + (i32.const 0) (return (i32.const 21)) (i32.const 2) (i32.const 3) + ) + ) + (func (export "as-call_indirect-mid") (result i32) + (call_indirect (type $sig) + (i32.const 0) (i32.const 1) (return (i32.const 22)) (i32.const 3) + ) + ) + (func (export "as-call_indirect-last") (result i32) + (call_indirect (type $sig) + (i32.const 0) (i32.const 1) (i32.const 2) (return (i32.const 23)) + ) + ) + + (func (export "as-local.set-value") (result i32) (local f32) + (local.set 0 (return (i32.const 17))) (i32.const -1) + ) + (func (export "as-local.tee-value") (result i32) (local i32) + (local.tee 0 (return (i32.const 1))) + ) + (global $a (mut i32) (i32.const 0)) + (func (export "as-global.set-value") (result i32) + (global.set $a (return (i32.const 1))) + ) + + (memory 1) + (func (export "as-load-address") (result f32) + (f32.load (return (f32.const 1.7))) + ) + (func (export "as-loadN-address") (result i64) + (i64.load8_s (return (i64.const 30))) + ) + + (func (export "as-store-address") (result i32) + (f64.store (return (i32.const 30)) (f64.const 7)) (i32.const -1) + ) + (func (export "as-store-value") (result i32) + (i64.store (i32.const 2) (return (i32.const 31))) (i32.const -1) + ) + + (func (export "as-storeN-address") (result i32) + (i32.store8 (return (i32.const 32)) (i32.const 7)) (i32.const -1) + ) + (func (export "as-storeN-value") (result i32) + (i64.store16 (i32.const 2) (return (i32.const 33))) (i32.const -1) + ) + + (func (export "as-unary-operand") (result f32) + (f32.neg (return (f32.const 3.4))) + ) + + (func (export "as-binary-left") (result i32) + (i32.add (return (i32.const 3)) (i32.const 10)) + ) + (func (export "as-binary-right") (result i64) + (i64.sub (i64.const 10) (return (i64.const 45))) + ) + + (func (export "as-test-operand") (result i32) + (i32.eqz (return (i32.const 44))) + ) + + (func (export "as-compare-left") (result i32) + (f64.le (return (i32.const 43)) (f64.const 10)) + ) + (func (export "as-compare-right") (result i32) + (f32.ne (f32.const 10) (return (i32.const 42))) + ) + + (func (export "as-convert-operand") (result i32) + (i32.wrap_i64 (return (i32.const 41))) + ) + + (func (export "as-memory.grow-size") (result i32) + (memory.grow (return (i32.const 40))) + ) +) + +(assert_return (invoke "type-i32")) +(assert_return (invoke "type-i64")) +(assert_return (invoke "type-f32")) +(assert_return (invoke "type-f64")) + +(assert_return (invoke "type-i32-value") (i32.const 1)) +(assert_return (invoke "type-i64-value") (i64.const 2)) +(assert_return (invoke "type-f32-value") (f32.const 3)) +(assert_return (invoke "type-f64-value") (f64.const 4)) + +(assert_return (invoke "nullary")) +(assert_return (invoke "unary") (f64.const 3)) + +(assert_return (invoke "as-func-first") (i32.const 1)) +(assert_return (invoke "as-func-mid") (i32.const 2)) +(assert_return (invoke "as-func-last")) +(assert_return (invoke "as-func-value") (i32.const 3)) + +(assert_return (invoke "as-block-first")) +(assert_return (invoke "as-block-mid")) +(assert_return (invoke "as-block-last")) +(assert_return (invoke "as-block-value") (i32.const 2)) + +(assert_return (invoke "as-loop-first") (i32.const 3)) +(assert_return (invoke "as-loop-mid") (i32.const 4)) +(assert_return (invoke "as-loop-last") (i32.const 5)) + +(assert_return (invoke "as-br-value") (i32.const 9)) + +(assert_return (invoke "as-br_if-cond")) +(assert_return (invoke "as-br_if-value") (i32.const 8)) +(assert_return (invoke "as-br_if-value-cond") (i32.const 9)) + +(assert_return (invoke "as-br_table-index") (i64.const 9)) +(assert_return (invoke "as-br_table-value") (i32.const 10)) +(assert_return (invoke "as-br_table-value-index") (i32.const 11)) + +(assert_return (invoke "as-return-value") (i64.const 7)) + +(assert_return (invoke "as-if-cond") (i32.const 2)) +(assert_return (invoke "as-if-then" (i32.const 1) (i32.const 6)) (i32.const 3)) +(assert_return (invoke "as-if-then" (i32.const 0) (i32.const 6)) (i32.const 6)) +(assert_return (invoke "as-if-else" (i32.const 0) (i32.const 6)) (i32.const 4)) +(assert_return (invoke "as-if-else" (i32.const 1) (i32.const 6)) (i32.const 6)) + +(assert_return (invoke "as-select-first" (i32.const 0) (i32.const 6)) (i32.const 5)) +(assert_return (invoke "as-select-first" (i32.const 1) (i32.const 6)) (i32.const 5)) +(assert_return (invoke "as-select-second" (i32.const 0) (i32.const 6)) (i32.const 6)) +(assert_return (invoke "as-select-second" (i32.const 1) (i32.const 6)) (i32.const 6)) +(assert_return (invoke "as-select-cond") (i32.const 7)) + +(assert_return (invoke "as-call-first") (i32.const 12)) +(assert_return (invoke "as-call-mid") (i32.const 13)) +(assert_return (invoke "as-call-last") (i32.const 14)) + +(assert_return (invoke "as-call_indirect-func") (i32.const 20)) +(assert_return (invoke "as-call_indirect-first") (i32.const 21)) +(assert_return (invoke "as-call_indirect-mid") (i32.const 22)) +(assert_return (invoke "as-call_indirect-last") (i32.const 23)) + +(assert_return (invoke "as-local.set-value") (i32.const 17)) +(assert_return (invoke "as-local.tee-value") (i32.const 1)) +(assert_return (invoke "as-global.set-value") (i32.const 1)) + +(assert_return (invoke "as-load-address") (f32.const 1.7)) +(assert_return (invoke "as-loadN-address") (i64.const 30)) + +(assert_return (invoke "as-store-address") (i32.const 30)) +(assert_return (invoke "as-store-value") (i32.const 31)) +(assert_return (invoke "as-storeN-address") (i32.const 32)) +(assert_return (invoke "as-storeN-value") (i32.const 33)) + +(assert_return (invoke "as-unary-operand") (f32.const 3.4)) + +(assert_return (invoke "as-binary-left") (i32.const 3)) +(assert_return (invoke "as-binary-right") (i64.const 45)) + +(assert_return (invoke "as-test-operand") (i32.const 44)) + +(assert_return (invoke "as-compare-left") (i32.const 43)) +(assert_return (invoke "as-compare-right") (i32.const 42)) + +(assert_return (invoke "as-convert-operand") (i32.const 41)) + +(assert_return (invoke "as-memory.grow-size") (i32.const 40)) + +(assert_invalid + (module (func $type-value-empty-vs-num (result i32) (return))) + "type mismatch" +) +(assert_invalid + (module + (func $type-value-empty-vs-num-in-block (result i32) + (i32.const 0) + (block (return)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-value-empty-vs-num-in-loop (result i32) + (i32.const 0) + (loop (return)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-value-empty-vs-num-in-then (result i32) + (i32.const 0) (i32.const 0) + (if (then (return))) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-value-empty-vs-num-in-else (result i32) + (i32.const 0) (i32.const 0) + (if (result i32) (then (i32.const 0)) (else (return))) (drop) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-value-empty-vs-num-in-br (result i32) + (i32.const 0) + (block (br 0 (return))) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-value-empty-vs-num-in-br_if (result i32) + (i32.const 0) + (block (br_if 0 (return) (i32.const 1))) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-value-empty-vs-num-in-br_table (result i32) + (i32.const 0) + (block (br_table 0 (return))) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-value-empty-vs-num-in-return (result i32) + (return (return)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-value-empty-vs-num-in-select (result i32) + (select (return) (i32.const 1) (i32.const 2)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-value-empty-vs-num-in-call (result i32) + (call 1 (return)) + ) + (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-value-empty-vs-num-in-call_indirect (result i32) + (block (result i32) + (call_indirect (type $sig) + (return) (i32.const 0) + ) + ) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-value-empty-vs-num-in-local.set (result i32) + (local i32) + (local.set 0 (return)) (local.get 0) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (func $type-value-empty-vs-num-in-local.tee (result i32) + (local i32) + (local.tee 0 (return)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (global $x (mut i32) (i32.const 0)) + (func $type-value-empty-vs-num-in-global.set (result i32) + (global.set $x (return)) (global.get $x) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (memory 0) + (func $type-value-empty-vs-num-in-memory.grow (result i32) + (memory.grow (return)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (memory 0) + (func $type-value-empty-vs-num-in-load (result i32) + (i32.load (return)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (memory 1) + (func $type-value-empty-vs-num-in-store (result i32) + (i32.store (return) (i32.const 1)) + ) + ) + "type mismatch" +) +(assert_invalid + (module (func $type-value-void-vs-num (result f64) (return (nop)))) + "type mismatch" +) +(assert_invalid + (module (func $type-value-num-vs-num (result f64) (return (i64.const 1)))) + "type mismatch" +) + diff --git a/runtime/near-vm/tests/wast/spec/select.wast b/runtime/near-vm/tests/wast/spec/select.wast new file mode 100644 index 00000000000..b343bf93cb5 --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/select.wast @@ -0,0 +1,598 @@ +(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)) + ) + + ;; 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))) + ) + ) + + (func (export "unreachable-num") + (unreachable) + (select) + (i32.eqz) + (drop) + ) + (func (export "unreachable-ref") + (unreachable) + (select) + (ref.is_null) + (drop) + ) +) + +(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_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 (func $type-externref-implicit (param $r externref) + (drop (select (local.get $r) (local.get $r) (i32.const 1))) + )) + "type mismatch" +) + +(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" +) + +;; Validation after unreachable + +;; The first two operands should have the same type as each other +(assert_invalid + (module (func (unreachable) (select (i32.const 1) (i64.const 1) (i32.const 1)) (drop))) + "type mismatch" +) + +(assert_invalid + (module (func (unreachable) (select (i64.const 1) (i32.const 1) (i32.const 1)) (drop))) + "type mismatch" +) + +;; Third operand must be i32 +(assert_invalid + (module (func (unreachable) (select (i32.const 1) (i32.const 1) (i64.const 1)) (drop))) + "type mismatch" +) + +(assert_invalid + (module (func (unreachable) (select (i32.const 1) (i64.const 1)) (drop))) + "type mismatch" +) + +(assert_invalid + (module (func (unreachable) (select (i64.const 1)) (drop))) + "type mismatch" +) + +;; Result of select has type of first two operands (type of second operand when first one is omitted) +(assert_invalid + (module (func (result i32) (unreachable) (select (i64.const 1) (i32.const 1)))) + "type mismatch" +) + +;; select always has non-empty result +(assert_invalid + (module (func (unreachable) (select))) + "type mismatch" +) + diff --git a/runtime/near-vm/tests/wast/spec/skip-stack-guard-page.wast b/runtime/near-vm/tests/wast/spec/skip-stack-guard-page.wast new file mode 100644 index 00000000000..a472e681488 --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/skip-stack-guard-page.wast @@ -0,0 +1,2284 @@ +;; This tests that the stack overflow guard page can't be skipped by a function with more than a page of locals. +(module + (memory 1) + (export "test-guard-page-skip" (func $test-guard-page-skip)) + + (func $test-guard-page-skip + (param $depth i32) + (if (i32.eq (local.get $depth) (i32.const 0)) + (then (call $function-with-many-locals)) + (else (call $test-guard-page-skip (i32.sub (local.get $depth) (i32.const 1)))) + ) + ) + + (func $function-with-many-locals + + ;; 1056 i64 = 8448 bytes of locals + (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x000-0x007 + (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x008-0x00f + (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x010-0x017 + (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x018-0x01f + (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x020-0x027 + (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x028-0x02f + (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x030-0x037 + (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x038-0x03f + (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x040-0x047 + (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x048-0x04f + (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x050-0x057 + (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x058-0x05f + (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x060-0x067 + (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x068-0x06f + (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x070-0x077 + (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x078-0x07f + (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x080-0x087 + (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x088-0x08f + (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x090-0x097 + (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x098-0x09f + (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x0a0-0x0a7 + (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x0a8-0x0af + (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x0b0-0x0b7 + (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x0b8-0x0bf + (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x0c0-0x0c7 + (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x0c8-0x0cf + (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x0d0-0x0d7 + (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x0d8-0x0df + (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x0e0-0x0e7 + (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x0e8-0x0ef + (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x0f0-0x0f7 + (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x0f8-0x0ff + + (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x100-0x107 + (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x108-0x10f + (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x110-0x117 + (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x118-0x11f + (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x120-0x127 + (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x128-0x12f + (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x130-0x137 + (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x138-0x13f + (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x140-0x147 + (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x148-0x14f + (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x150-0x157 + (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x158-0x15f + (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x160-0x167 + (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x168-0x16f + (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x170-0x177 + (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x178-0x17f + (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x180-0x187 + (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x188-0x18f + (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x190-0x197 + (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x198-0x19f + (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x1a0-0x1a7 + (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x1a8-0x1af + (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x1b0-0x1b7 + (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x1b8-0x1bf + (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x1c0-0x1c7 + (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x1c8-0x1cf + (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x1d0-0x1d7 + (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x1d8-0x1df + (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x1e0-0x1e7 + (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x1e8-0x1ef + (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x1f0-0x1f7 + (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x1f8-0x1ff + + (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x200-0x207 + (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x208-0x20f + (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x210-0x217 + (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x218-0x21f + (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x220-0x227 + (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x228-0x22f + (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x230-0x237 + (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x238-0x23f + (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x240-0x247 + (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x248-0x24f + (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x250-0x257 + (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x258-0x25f + (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x260-0x267 + (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x268-0x26f + (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x270-0x277 + (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x278-0x27f + (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x280-0x287 + (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x288-0x28f + (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x290-0x297 + (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x298-0x29f + (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x2a0-0x2a7 + (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x2a8-0x2af + (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x2b0-0x2b7 + (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x2b8-0x2bf + (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x2c0-0x2c7 + (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x2c8-0x2cf + (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x2d0-0x2d7 + (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x2d8-0x2df + (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x2e0-0x2e7 + (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x2e8-0x2ef + (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x2f0-0x2f7 + (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x2f8-0x2ff + + (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x300-0x307 + (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x308-0x30f + (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x310-0x317 + (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x318-0x31f + (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x320-0x327 + (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x328-0x32f + (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x330-0x337 + (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x338-0x33f + (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x340-0x347 + (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x348-0x34f + (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x350-0x357 + (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x358-0x35f + (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x360-0x367 + (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x368-0x36f + (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x370-0x377 + (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x378-0x37f + (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x380-0x387 + (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x388-0x38f + (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x390-0x397 + (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x398-0x39f + (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x3a0-0x3a7 + (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x3a8-0x3af + (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x3b0-0x3b7 + (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x3b8-0x3bf + (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x3c0-0x3c7 + (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x3c8-0x3cf + (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x3d0-0x3d7 + (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x3d8-0x3df + (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x3e0-0x3e7 + (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x3e8-0x3ef + (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x3f0-0x3f7 + (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x3f8-0x3ff + + (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x400-0x407 + (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x408-0x40f + (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x410-0x417 + (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x418-0x41f + + ;; recurse first to try to make the callee access the stack below the space allocated for the locals before the locals themselves have been initialized. + (call $function-with-many-locals) + + ;; load from memory into the locals + (local.set 0x000 (i64.load offset=0x000 align=1 (i32.const 0))) + (local.set 0x001 (i64.load offset=0x001 align=1 (i32.const 0))) + (local.set 0x002 (i64.load offset=0x002 align=1 (i32.const 0))) + (local.set 0x003 (i64.load offset=0x003 align=1 (i32.const 0))) + (local.set 0x004 (i64.load offset=0x004 align=1 (i32.const 0))) + (local.set 0x005 (i64.load offset=0x005 align=1 (i32.const 0))) + (local.set 0x006 (i64.load offset=0x006 align=1 (i32.const 0))) + (local.set 0x007 (i64.load offset=0x007 align=1 (i32.const 0))) + (local.set 0x008 (i64.load offset=0x008 align=1 (i32.const 0))) + (local.set 0x009 (i64.load offset=0x009 align=1 (i32.const 0))) + (local.set 0x00a (i64.load offset=0x00a align=1 (i32.const 0))) + (local.set 0x00b (i64.load offset=0x00b align=1 (i32.const 0))) + (local.set 0x00c (i64.load offset=0x00c align=1 (i32.const 0))) + (local.set 0x00d (i64.load offset=0x00d align=1 (i32.const 0))) + (local.set 0x00e (i64.load offset=0x00e align=1 (i32.const 0))) + (local.set 0x00f (i64.load offset=0x00f align=1 (i32.const 0))) + (local.set 0x010 (i64.load offset=0x010 align=1 (i32.const 0))) + (local.set 0x011 (i64.load offset=0x011 align=1 (i32.const 0))) + (local.set 0x012 (i64.load offset=0x012 align=1 (i32.const 0))) + (local.set 0x013 (i64.load offset=0x013 align=1 (i32.const 0))) + (local.set 0x014 (i64.load offset=0x014 align=1 (i32.const 0))) + (local.set 0x015 (i64.load offset=0x015 align=1 (i32.const 0))) + (local.set 0x016 (i64.load offset=0x016 align=1 (i32.const 0))) + (local.set 0x017 (i64.load offset=0x017 align=1 (i32.const 0))) + (local.set 0x018 (i64.load offset=0x018 align=1 (i32.const 0))) + (local.set 0x019 (i64.load offset=0x019 align=1 (i32.const 0))) + (local.set 0x01a (i64.load offset=0x01a align=1 (i32.const 0))) + (local.set 0x01b (i64.load offset=0x01b align=1 (i32.const 0))) + (local.set 0x01c (i64.load offset=0x01c align=1 (i32.const 0))) + (local.set 0x01d (i64.load offset=0x01d align=1 (i32.const 0))) + (local.set 0x01e (i64.load offset=0x01e align=1 (i32.const 0))) + (local.set 0x01f (i64.load offset=0x01f align=1 (i32.const 0))) + (local.set 0x020 (i64.load offset=0x020 align=1 (i32.const 0))) + (local.set 0x021 (i64.load offset=0x021 align=1 (i32.const 0))) + (local.set 0x022 (i64.load offset=0x022 align=1 (i32.const 0))) + (local.set 0x023 (i64.load offset=0x023 align=1 (i32.const 0))) + (local.set 0x024 (i64.load offset=0x024 align=1 (i32.const 0))) + (local.set 0x025 (i64.load offset=0x025 align=1 (i32.const 0))) + (local.set 0x026 (i64.load offset=0x026 align=1 (i32.const 0))) + (local.set 0x027 (i64.load offset=0x027 align=1 (i32.const 0))) + (local.set 0x028 (i64.load offset=0x028 align=1 (i32.const 0))) + (local.set 0x029 (i64.load offset=0x029 align=1 (i32.const 0))) + (local.set 0x02a (i64.load offset=0x02a align=1 (i32.const 0))) + (local.set 0x02b (i64.load offset=0x02b align=1 (i32.const 0))) + (local.set 0x02c (i64.load offset=0x02c align=1 (i32.const 0))) + (local.set 0x02d (i64.load offset=0x02d align=1 (i32.const 0))) + (local.set 0x02e (i64.load offset=0x02e align=1 (i32.const 0))) + (local.set 0x02f (i64.load offset=0x02f align=1 (i32.const 0))) + (local.set 0x030 (i64.load offset=0x030 align=1 (i32.const 0))) + (local.set 0x031 (i64.load offset=0x031 align=1 (i32.const 0))) + (local.set 0x032 (i64.load offset=0x032 align=1 (i32.const 0))) + (local.set 0x033 (i64.load offset=0x033 align=1 (i32.const 0))) + (local.set 0x034 (i64.load offset=0x034 align=1 (i32.const 0))) + (local.set 0x035 (i64.load offset=0x035 align=1 (i32.const 0))) + (local.set 0x036 (i64.load offset=0x036 align=1 (i32.const 0))) + (local.set 0x037 (i64.load offset=0x037 align=1 (i32.const 0))) + (local.set 0x038 (i64.load offset=0x038 align=1 (i32.const 0))) + (local.set 0x039 (i64.load offset=0x039 align=1 (i32.const 0))) + (local.set 0x03a (i64.load offset=0x03a align=1 (i32.const 0))) + (local.set 0x03b (i64.load offset=0x03b align=1 (i32.const 0))) + (local.set 0x03c (i64.load offset=0x03c align=1 (i32.const 0))) + (local.set 0x03d (i64.load offset=0x03d align=1 (i32.const 0))) + (local.set 0x03e (i64.load offset=0x03e align=1 (i32.const 0))) + (local.set 0x03f (i64.load offset=0x03f align=1 (i32.const 0))) + (local.set 0x040 (i64.load offset=0x040 align=1 (i32.const 0))) + (local.set 0x041 (i64.load offset=0x041 align=1 (i32.const 0))) + (local.set 0x042 (i64.load offset=0x042 align=1 (i32.const 0))) + (local.set 0x043 (i64.load offset=0x043 align=1 (i32.const 0))) + (local.set 0x044 (i64.load offset=0x044 align=1 (i32.const 0))) + (local.set 0x045 (i64.load offset=0x045 align=1 (i32.const 0))) + (local.set 0x046 (i64.load offset=0x046 align=1 (i32.const 0))) + (local.set 0x047 (i64.load offset=0x047 align=1 (i32.const 0))) + (local.set 0x048 (i64.load offset=0x048 align=1 (i32.const 0))) + (local.set 0x049 (i64.load offset=0x049 align=1 (i32.const 0))) + (local.set 0x04a (i64.load offset=0x04a align=1 (i32.const 0))) + (local.set 0x04b (i64.load offset=0x04b align=1 (i32.const 0))) + (local.set 0x04c (i64.load offset=0x04c align=1 (i32.const 0))) + (local.set 0x04d (i64.load offset=0x04d align=1 (i32.const 0))) + (local.set 0x04e (i64.load offset=0x04e align=1 (i32.const 0))) + (local.set 0x04f (i64.load offset=0x04f align=1 (i32.const 0))) + (local.set 0x050 (i64.load offset=0x050 align=1 (i32.const 0))) + (local.set 0x051 (i64.load offset=0x051 align=1 (i32.const 0))) + (local.set 0x052 (i64.load offset=0x052 align=1 (i32.const 0))) + (local.set 0x053 (i64.load offset=0x053 align=1 (i32.const 0))) + (local.set 0x054 (i64.load offset=0x054 align=1 (i32.const 0))) + (local.set 0x055 (i64.load offset=0x055 align=1 (i32.const 0))) + (local.set 0x056 (i64.load offset=0x056 align=1 (i32.const 0))) + (local.set 0x057 (i64.load offset=0x057 align=1 (i32.const 0))) + (local.set 0x058 (i64.load offset=0x058 align=1 (i32.const 0))) + (local.set 0x059 (i64.load offset=0x059 align=1 (i32.const 0))) + (local.set 0x05a (i64.load offset=0x05a align=1 (i32.const 0))) + (local.set 0x05b (i64.load offset=0x05b align=1 (i32.const 0))) + (local.set 0x05c (i64.load offset=0x05c align=1 (i32.const 0))) + (local.set 0x05d (i64.load offset=0x05d align=1 (i32.const 0))) + (local.set 0x05e (i64.load offset=0x05e align=1 (i32.const 0))) + (local.set 0x05f (i64.load offset=0x05f align=1 (i32.const 0))) + (local.set 0x060 (i64.load offset=0x060 align=1 (i32.const 0))) + (local.set 0x061 (i64.load offset=0x061 align=1 (i32.const 0))) + (local.set 0x062 (i64.load offset=0x062 align=1 (i32.const 0))) + (local.set 0x063 (i64.load offset=0x063 align=1 (i32.const 0))) + (local.set 0x064 (i64.load offset=0x064 align=1 (i32.const 0))) + (local.set 0x065 (i64.load offset=0x065 align=1 (i32.const 0))) + (local.set 0x066 (i64.load offset=0x066 align=1 (i32.const 0))) + (local.set 0x067 (i64.load offset=0x067 align=1 (i32.const 0))) + (local.set 0x068 (i64.load offset=0x068 align=1 (i32.const 0))) + (local.set 0x069 (i64.load offset=0x069 align=1 (i32.const 0))) + (local.set 0x06a (i64.load offset=0x06a align=1 (i32.const 0))) + (local.set 0x06b (i64.load offset=0x06b align=1 (i32.const 0))) + (local.set 0x06c (i64.load offset=0x06c align=1 (i32.const 0))) + (local.set 0x06d (i64.load offset=0x06d align=1 (i32.const 0))) + (local.set 0x06e (i64.load offset=0x06e align=1 (i32.const 0))) + (local.set 0x06f (i64.load offset=0x06f align=1 (i32.const 0))) + (local.set 0x070 (i64.load offset=0x070 align=1 (i32.const 0))) + (local.set 0x071 (i64.load offset=0x071 align=1 (i32.const 0))) + (local.set 0x072 (i64.load offset=0x072 align=1 (i32.const 0))) + (local.set 0x073 (i64.load offset=0x073 align=1 (i32.const 0))) + (local.set 0x074 (i64.load offset=0x074 align=1 (i32.const 0))) + (local.set 0x075 (i64.load offset=0x075 align=1 (i32.const 0))) + (local.set 0x076 (i64.load offset=0x076 align=1 (i32.const 0))) + (local.set 0x077 (i64.load offset=0x077 align=1 (i32.const 0))) + (local.set 0x078 (i64.load offset=0x078 align=1 (i32.const 0))) + (local.set 0x079 (i64.load offset=0x079 align=1 (i32.const 0))) + (local.set 0x07a (i64.load offset=0x07a align=1 (i32.const 0))) + (local.set 0x07b (i64.load offset=0x07b align=1 (i32.const 0))) + (local.set 0x07c (i64.load offset=0x07c align=1 (i32.const 0))) + (local.set 0x07d (i64.load offset=0x07d align=1 (i32.const 0))) + (local.set 0x07e (i64.load offset=0x07e align=1 (i32.const 0))) + (local.set 0x07f (i64.load offset=0x07f align=1 (i32.const 0))) + (local.set 0x080 (i64.load offset=0x080 align=1 (i32.const 0))) + (local.set 0x081 (i64.load offset=0x081 align=1 (i32.const 0))) + (local.set 0x082 (i64.load offset=0x082 align=1 (i32.const 0))) + (local.set 0x083 (i64.load offset=0x083 align=1 (i32.const 0))) + (local.set 0x084 (i64.load offset=0x084 align=1 (i32.const 0))) + (local.set 0x085 (i64.load offset=0x085 align=1 (i32.const 0))) + (local.set 0x086 (i64.load offset=0x086 align=1 (i32.const 0))) + (local.set 0x087 (i64.load offset=0x087 align=1 (i32.const 0))) + (local.set 0x088 (i64.load offset=0x088 align=1 (i32.const 0))) + (local.set 0x089 (i64.load offset=0x089 align=1 (i32.const 0))) + (local.set 0x08a (i64.load offset=0x08a align=1 (i32.const 0))) + (local.set 0x08b (i64.load offset=0x08b align=1 (i32.const 0))) + (local.set 0x08c (i64.load offset=0x08c align=1 (i32.const 0))) + (local.set 0x08d (i64.load offset=0x08d align=1 (i32.const 0))) + (local.set 0x08e (i64.load offset=0x08e align=1 (i32.const 0))) + (local.set 0x08f (i64.load offset=0x08f align=1 (i32.const 0))) + (local.set 0x090 (i64.load offset=0x090 align=1 (i32.const 0))) + (local.set 0x091 (i64.load offset=0x091 align=1 (i32.const 0))) + (local.set 0x092 (i64.load offset=0x092 align=1 (i32.const 0))) + (local.set 0x093 (i64.load offset=0x093 align=1 (i32.const 0))) + (local.set 0x094 (i64.load offset=0x094 align=1 (i32.const 0))) + (local.set 0x095 (i64.load offset=0x095 align=1 (i32.const 0))) + (local.set 0x096 (i64.load offset=0x096 align=1 (i32.const 0))) + (local.set 0x097 (i64.load offset=0x097 align=1 (i32.const 0))) + (local.set 0x098 (i64.load offset=0x098 align=1 (i32.const 0))) + (local.set 0x099 (i64.load offset=0x099 align=1 (i32.const 0))) + (local.set 0x09a (i64.load offset=0x09a align=1 (i32.const 0))) + (local.set 0x09b (i64.load offset=0x09b align=1 (i32.const 0))) + (local.set 0x09c (i64.load offset=0x09c align=1 (i32.const 0))) + (local.set 0x09d (i64.load offset=0x09d align=1 (i32.const 0))) + (local.set 0x09e (i64.load offset=0x09e align=1 (i32.const 0))) + (local.set 0x09f (i64.load offset=0x09f align=1 (i32.const 0))) + (local.set 0x0a0 (i64.load offset=0x0a0 align=1 (i32.const 0))) + (local.set 0x0a1 (i64.load offset=0x0a1 align=1 (i32.const 0))) + (local.set 0x0a2 (i64.load offset=0x0a2 align=1 (i32.const 0))) + (local.set 0x0a3 (i64.load offset=0x0a3 align=1 (i32.const 0))) + (local.set 0x0a4 (i64.load offset=0x0a4 align=1 (i32.const 0))) + (local.set 0x0a5 (i64.load offset=0x0a5 align=1 (i32.const 0))) + (local.set 0x0a6 (i64.load offset=0x0a6 align=1 (i32.const 0))) + (local.set 0x0a7 (i64.load offset=0x0a7 align=1 (i32.const 0))) + (local.set 0x0a8 (i64.load offset=0x0a8 align=1 (i32.const 0))) + (local.set 0x0a9 (i64.load offset=0x0a9 align=1 (i32.const 0))) + (local.set 0x0aa (i64.load offset=0x0aa align=1 (i32.const 0))) + (local.set 0x0ab (i64.load offset=0x0ab align=1 (i32.const 0))) + (local.set 0x0ac (i64.load offset=0x0ac align=1 (i32.const 0))) + (local.set 0x0ad (i64.load offset=0x0ad align=1 (i32.const 0))) + (local.set 0x0ae (i64.load offset=0x0ae align=1 (i32.const 0))) + (local.set 0x0af (i64.load offset=0x0af align=1 (i32.const 0))) + (local.set 0x0b0 (i64.load offset=0x0b0 align=1 (i32.const 0))) + (local.set 0x0b1 (i64.load offset=0x0b1 align=1 (i32.const 0))) + (local.set 0x0b2 (i64.load offset=0x0b2 align=1 (i32.const 0))) + (local.set 0x0b3 (i64.load offset=0x0b3 align=1 (i32.const 0))) + (local.set 0x0b4 (i64.load offset=0x0b4 align=1 (i32.const 0))) + (local.set 0x0b5 (i64.load offset=0x0b5 align=1 (i32.const 0))) + (local.set 0x0b6 (i64.load offset=0x0b6 align=1 (i32.const 0))) + (local.set 0x0b7 (i64.load offset=0x0b7 align=1 (i32.const 0))) + (local.set 0x0b8 (i64.load offset=0x0b8 align=1 (i32.const 0))) + (local.set 0x0b9 (i64.load offset=0x0b9 align=1 (i32.const 0))) + (local.set 0x0ba (i64.load offset=0x0ba align=1 (i32.const 0))) + (local.set 0x0bb (i64.load offset=0x0bb align=1 (i32.const 0))) + (local.set 0x0bc (i64.load offset=0x0bc align=1 (i32.const 0))) + (local.set 0x0bd (i64.load offset=0x0bd align=1 (i32.const 0))) + (local.set 0x0be (i64.load offset=0x0be align=1 (i32.const 0))) + (local.set 0x0bf (i64.load offset=0x0bf align=1 (i32.const 0))) + (local.set 0x0c0 (i64.load offset=0x0c0 align=1 (i32.const 0))) + (local.set 0x0c1 (i64.load offset=0x0c1 align=1 (i32.const 0))) + (local.set 0x0c2 (i64.load offset=0x0c2 align=1 (i32.const 0))) + (local.set 0x0c3 (i64.load offset=0x0c3 align=1 (i32.const 0))) + (local.set 0x0c4 (i64.load offset=0x0c4 align=1 (i32.const 0))) + (local.set 0x0c5 (i64.load offset=0x0c5 align=1 (i32.const 0))) + (local.set 0x0c6 (i64.load offset=0x0c6 align=1 (i32.const 0))) + (local.set 0x0c7 (i64.load offset=0x0c7 align=1 (i32.const 0))) + (local.set 0x0c8 (i64.load offset=0x0c8 align=1 (i32.const 0))) + (local.set 0x0c9 (i64.load offset=0x0c9 align=1 (i32.const 0))) + (local.set 0x0ca (i64.load offset=0x0ca align=1 (i32.const 0))) + (local.set 0x0cb (i64.load offset=0x0cb align=1 (i32.const 0))) + (local.set 0x0cc (i64.load offset=0x0cc align=1 (i32.const 0))) + (local.set 0x0cd (i64.load offset=0x0cd align=1 (i32.const 0))) + (local.set 0x0ce (i64.load offset=0x0ce align=1 (i32.const 0))) + (local.set 0x0cf (i64.load offset=0x0cf align=1 (i32.const 0))) + (local.set 0x0d0 (i64.load offset=0x0d0 align=1 (i32.const 0))) + (local.set 0x0d1 (i64.load offset=0x0d1 align=1 (i32.const 0))) + (local.set 0x0d2 (i64.load offset=0x0d2 align=1 (i32.const 0))) + (local.set 0x0d3 (i64.load offset=0x0d3 align=1 (i32.const 0))) + (local.set 0x0d4 (i64.load offset=0x0d4 align=1 (i32.const 0))) + (local.set 0x0d5 (i64.load offset=0x0d5 align=1 (i32.const 0))) + (local.set 0x0d6 (i64.load offset=0x0d6 align=1 (i32.const 0))) + (local.set 0x0d7 (i64.load offset=0x0d7 align=1 (i32.const 0))) + (local.set 0x0d8 (i64.load offset=0x0d8 align=1 (i32.const 0))) + (local.set 0x0d9 (i64.load offset=0x0d9 align=1 (i32.const 0))) + (local.set 0x0da (i64.load offset=0x0da align=1 (i32.const 0))) + (local.set 0x0db (i64.load offset=0x0db align=1 (i32.const 0))) + (local.set 0x0dc (i64.load offset=0x0dc align=1 (i32.const 0))) + (local.set 0x0dd (i64.load offset=0x0dd align=1 (i32.const 0))) + (local.set 0x0de (i64.load offset=0x0de align=1 (i32.const 0))) + (local.set 0x0df (i64.load offset=0x0df align=1 (i32.const 0))) + (local.set 0x0e0 (i64.load offset=0x0e0 align=1 (i32.const 0))) + (local.set 0x0e1 (i64.load offset=0x0e1 align=1 (i32.const 0))) + (local.set 0x0e2 (i64.load offset=0x0e2 align=1 (i32.const 0))) + (local.set 0x0e3 (i64.load offset=0x0e3 align=1 (i32.const 0))) + (local.set 0x0e4 (i64.load offset=0x0e4 align=1 (i32.const 0))) + (local.set 0x0e5 (i64.load offset=0x0e5 align=1 (i32.const 0))) + (local.set 0x0e6 (i64.load offset=0x0e6 align=1 (i32.const 0))) + (local.set 0x0e7 (i64.load offset=0x0e7 align=1 (i32.const 0))) + (local.set 0x0e8 (i64.load offset=0x0e8 align=1 (i32.const 0))) + (local.set 0x0e9 (i64.load offset=0x0e9 align=1 (i32.const 0))) + (local.set 0x0ea (i64.load offset=0x0ea align=1 (i32.const 0))) + (local.set 0x0eb (i64.load offset=0x0eb align=1 (i32.const 0))) + (local.set 0x0ec (i64.load offset=0x0ec align=1 (i32.const 0))) + (local.set 0x0ed (i64.load offset=0x0ed align=1 (i32.const 0))) + (local.set 0x0ee (i64.load offset=0x0ee align=1 (i32.const 0))) + (local.set 0x0ef (i64.load offset=0x0ef align=1 (i32.const 0))) + (local.set 0x0f0 (i64.load offset=0x0f0 align=1 (i32.const 0))) + (local.set 0x0f1 (i64.load offset=0x0f1 align=1 (i32.const 0))) + (local.set 0x0f2 (i64.load offset=0x0f2 align=1 (i32.const 0))) + (local.set 0x0f3 (i64.load offset=0x0f3 align=1 (i32.const 0))) + (local.set 0x0f4 (i64.load offset=0x0f4 align=1 (i32.const 0))) + (local.set 0x0f5 (i64.load offset=0x0f5 align=1 (i32.const 0))) + (local.set 0x0f6 (i64.load offset=0x0f6 align=1 (i32.const 0))) + (local.set 0x0f7 (i64.load offset=0x0f7 align=1 (i32.const 0))) + (local.set 0x0f8 (i64.load offset=0x0f8 align=1 (i32.const 0))) + (local.set 0x0f9 (i64.load offset=0x0f9 align=1 (i32.const 0))) + (local.set 0x0fa (i64.load offset=0x0fa align=1 (i32.const 0))) + (local.set 0x0fb (i64.load offset=0x0fb align=1 (i32.const 0))) + (local.set 0x0fc (i64.load offset=0x0fc align=1 (i32.const 0))) + (local.set 0x0fd (i64.load offset=0x0fd align=1 (i32.const 0))) + (local.set 0x0fe (i64.load offset=0x0fe align=1 (i32.const 0))) + (local.set 0x0ff (i64.load offset=0x0ff align=1 (i32.const 0))) + (local.set 0x100 (i64.load offset=0x100 align=1 (i32.const 0))) + (local.set 0x101 (i64.load offset=0x101 align=1 (i32.const 0))) + (local.set 0x102 (i64.load offset=0x102 align=1 (i32.const 0))) + (local.set 0x103 (i64.load offset=0x103 align=1 (i32.const 0))) + (local.set 0x104 (i64.load offset=0x104 align=1 (i32.const 0))) + (local.set 0x105 (i64.load offset=0x105 align=1 (i32.const 0))) + (local.set 0x106 (i64.load offset=0x106 align=1 (i32.const 0))) + (local.set 0x107 (i64.load offset=0x107 align=1 (i32.const 0))) + (local.set 0x108 (i64.load offset=0x108 align=1 (i32.const 0))) + (local.set 0x109 (i64.load offset=0x109 align=1 (i32.const 0))) + (local.set 0x10a (i64.load offset=0x10a align=1 (i32.const 0))) + (local.set 0x10b (i64.load offset=0x10b align=1 (i32.const 0))) + (local.set 0x10c (i64.load offset=0x10c align=1 (i32.const 0))) + (local.set 0x10d (i64.load offset=0x10d align=1 (i32.const 0))) + (local.set 0x10e (i64.load offset=0x10e align=1 (i32.const 0))) + (local.set 0x10f (i64.load offset=0x10f align=1 (i32.const 0))) + (local.set 0x110 (i64.load offset=0x110 align=1 (i32.const 0))) + (local.set 0x111 (i64.load offset=0x111 align=1 (i32.const 0))) + (local.set 0x112 (i64.load offset=0x112 align=1 (i32.const 0))) + (local.set 0x113 (i64.load offset=0x113 align=1 (i32.const 0))) + (local.set 0x114 (i64.load offset=0x114 align=1 (i32.const 0))) + (local.set 0x115 (i64.load offset=0x115 align=1 (i32.const 0))) + (local.set 0x116 (i64.load offset=0x116 align=1 (i32.const 0))) + (local.set 0x117 (i64.load offset=0x117 align=1 (i32.const 0))) + (local.set 0x118 (i64.load offset=0x118 align=1 (i32.const 0))) + (local.set 0x119 (i64.load offset=0x119 align=1 (i32.const 0))) + (local.set 0x11a (i64.load offset=0x11a align=1 (i32.const 0))) + (local.set 0x11b (i64.load offset=0x11b align=1 (i32.const 0))) + (local.set 0x11c (i64.load offset=0x11c align=1 (i32.const 0))) + (local.set 0x11d (i64.load offset=0x11d align=1 (i32.const 0))) + (local.set 0x11e (i64.load offset=0x11e align=1 (i32.const 0))) + (local.set 0x11f (i64.load offset=0x11f align=1 (i32.const 0))) + (local.set 0x120 (i64.load offset=0x120 align=1 (i32.const 0))) + (local.set 0x121 (i64.load offset=0x121 align=1 (i32.const 0))) + (local.set 0x122 (i64.load offset=0x122 align=1 (i32.const 0))) + (local.set 0x123 (i64.load offset=0x123 align=1 (i32.const 0))) + (local.set 0x124 (i64.load offset=0x124 align=1 (i32.const 0))) + (local.set 0x125 (i64.load offset=0x125 align=1 (i32.const 0))) + (local.set 0x126 (i64.load offset=0x126 align=1 (i32.const 0))) + (local.set 0x127 (i64.load offset=0x127 align=1 (i32.const 0))) + (local.set 0x128 (i64.load offset=0x128 align=1 (i32.const 0))) + (local.set 0x129 (i64.load offset=0x129 align=1 (i32.const 0))) + (local.set 0x12a (i64.load offset=0x12a align=1 (i32.const 0))) + (local.set 0x12b (i64.load offset=0x12b align=1 (i32.const 0))) + (local.set 0x12c (i64.load offset=0x12c align=1 (i32.const 0))) + (local.set 0x12d (i64.load offset=0x12d align=1 (i32.const 0))) + (local.set 0x12e (i64.load offset=0x12e align=1 (i32.const 0))) + (local.set 0x12f (i64.load offset=0x12f align=1 (i32.const 0))) + (local.set 0x130 (i64.load offset=0x130 align=1 (i32.const 0))) + (local.set 0x131 (i64.load offset=0x131 align=1 (i32.const 0))) + (local.set 0x132 (i64.load offset=0x132 align=1 (i32.const 0))) + (local.set 0x133 (i64.load offset=0x133 align=1 (i32.const 0))) + (local.set 0x134 (i64.load offset=0x134 align=1 (i32.const 0))) + (local.set 0x135 (i64.load offset=0x135 align=1 (i32.const 0))) + (local.set 0x136 (i64.load offset=0x136 align=1 (i32.const 0))) + (local.set 0x137 (i64.load offset=0x137 align=1 (i32.const 0))) + (local.set 0x138 (i64.load offset=0x138 align=1 (i32.const 0))) + (local.set 0x139 (i64.load offset=0x139 align=1 (i32.const 0))) + (local.set 0x13a (i64.load offset=0x13a align=1 (i32.const 0))) + (local.set 0x13b (i64.load offset=0x13b align=1 (i32.const 0))) + (local.set 0x13c (i64.load offset=0x13c align=1 (i32.const 0))) + (local.set 0x13d (i64.load offset=0x13d align=1 (i32.const 0))) + (local.set 0x13e (i64.load offset=0x13e align=1 (i32.const 0))) + (local.set 0x13f (i64.load offset=0x13f align=1 (i32.const 0))) + (local.set 0x140 (i64.load offset=0x140 align=1 (i32.const 0))) + (local.set 0x141 (i64.load offset=0x141 align=1 (i32.const 0))) + (local.set 0x142 (i64.load offset=0x142 align=1 (i32.const 0))) + (local.set 0x143 (i64.load offset=0x143 align=1 (i32.const 0))) + (local.set 0x144 (i64.load offset=0x144 align=1 (i32.const 0))) + (local.set 0x145 (i64.load offset=0x145 align=1 (i32.const 0))) + (local.set 0x146 (i64.load offset=0x146 align=1 (i32.const 0))) + (local.set 0x147 (i64.load offset=0x147 align=1 (i32.const 0))) + (local.set 0x148 (i64.load offset=0x148 align=1 (i32.const 0))) + (local.set 0x149 (i64.load offset=0x149 align=1 (i32.const 0))) + (local.set 0x14a (i64.load offset=0x14a align=1 (i32.const 0))) + (local.set 0x14b (i64.load offset=0x14b align=1 (i32.const 0))) + (local.set 0x14c (i64.load offset=0x14c align=1 (i32.const 0))) + (local.set 0x14d (i64.load offset=0x14d align=1 (i32.const 0))) + (local.set 0x14e (i64.load offset=0x14e align=1 (i32.const 0))) + (local.set 0x14f (i64.load offset=0x14f align=1 (i32.const 0))) + (local.set 0x150 (i64.load offset=0x150 align=1 (i32.const 0))) + (local.set 0x151 (i64.load offset=0x151 align=1 (i32.const 0))) + (local.set 0x152 (i64.load offset=0x152 align=1 (i32.const 0))) + (local.set 0x153 (i64.load offset=0x153 align=1 (i32.const 0))) + (local.set 0x154 (i64.load offset=0x154 align=1 (i32.const 0))) + (local.set 0x155 (i64.load offset=0x155 align=1 (i32.const 0))) + (local.set 0x156 (i64.load offset=0x156 align=1 (i32.const 0))) + (local.set 0x157 (i64.load offset=0x157 align=1 (i32.const 0))) + (local.set 0x158 (i64.load offset=0x158 align=1 (i32.const 0))) + (local.set 0x159 (i64.load offset=0x159 align=1 (i32.const 0))) + (local.set 0x15a (i64.load offset=0x15a align=1 (i32.const 0))) + (local.set 0x15b (i64.load offset=0x15b align=1 (i32.const 0))) + (local.set 0x15c (i64.load offset=0x15c align=1 (i32.const 0))) + (local.set 0x15d (i64.load offset=0x15d align=1 (i32.const 0))) + (local.set 0x15e (i64.load offset=0x15e align=1 (i32.const 0))) + (local.set 0x15f (i64.load offset=0x15f align=1 (i32.const 0))) + (local.set 0x160 (i64.load offset=0x160 align=1 (i32.const 0))) + (local.set 0x161 (i64.load offset=0x161 align=1 (i32.const 0))) + (local.set 0x162 (i64.load offset=0x162 align=1 (i32.const 0))) + (local.set 0x163 (i64.load offset=0x163 align=1 (i32.const 0))) + (local.set 0x164 (i64.load offset=0x164 align=1 (i32.const 0))) + (local.set 0x165 (i64.load offset=0x165 align=1 (i32.const 0))) + (local.set 0x166 (i64.load offset=0x166 align=1 (i32.const 0))) + (local.set 0x167 (i64.load offset=0x167 align=1 (i32.const 0))) + (local.set 0x168 (i64.load offset=0x168 align=1 (i32.const 0))) + (local.set 0x169 (i64.load offset=0x169 align=1 (i32.const 0))) + (local.set 0x16a (i64.load offset=0x16a align=1 (i32.const 0))) + (local.set 0x16b (i64.load offset=0x16b align=1 (i32.const 0))) + (local.set 0x16c (i64.load offset=0x16c align=1 (i32.const 0))) + (local.set 0x16d (i64.load offset=0x16d align=1 (i32.const 0))) + (local.set 0x16e (i64.load offset=0x16e align=1 (i32.const 0))) + (local.set 0x16f (i64.load offset=0x16f align=1 (i32.const 0))) + (local.set 0x170 (i64.load offset=0x170 align=1 (i32.const 0))) + (local.set 0x171 (i64.load offset=0x171 align=1 (i32.const 0))) + (local.set 0x172 (i64.load offset=0x172 align=1 (i32.const 0))) + (local.set 0x173 (i64.load offset=0x173 align=1 (i32.const 0))) + (local.set 0x174 (i64.load offset=0x174 align=1 (i32.const 0))) + (local.set 0x175 (i64.load offset=0x175 align=1 (i32.const 0))) + (local.set 0x176 (i64.load offset=0x176 align=1 (i32.const 0))) + (local.set 0x177 (i64.load offset=0x177 align=1 (i32.const 0))) + (local.set 0x178 (i64.load offset=0x178 align=1 (i32.const 0))) + (local.set 0x179 (i64.load offset=0x179 align=1 (i32.const 0))) + (local.set 0x17a (i64.load offset=0x17a align=1 (i32.const 0))) + (local.set 0x17b (i64.load offset=0x17b align=1 (i32.const 0))) + (local.set 0x17c (i64.load offset=0x17c align=1 (i32.const 0))) + (local.set 0x17d (i64.load offset=0x17d align=1 (i32.const 0))) + (local.set 0x17e (i64.load offset=0x17e align=1 (i32.const 0))) + (local.set 0x17f (i64.load offset=0x17f align=1 (i32.const 0))) + (local.set 0x180 (i64.load offset=0x180 align=1 (i32.const 0))) + (local.set 0x181 (i64.load offset=0x181 align=1 (i32.const 0))) + (local.set 0x182 (i64.load offset=0x182 align=1 (i32.const 0))) + (local.set 0x183 (i64.load offset=0x183 align=1 (i32.const 0))) + (local.set 0x184 (i64.load offset=0x184 align=1 (i32.const 0))) + (local.set 0x185 (i64.load offset=0x185 align=1 (i32.const 0))) + (local.set 0x186 (i64.load offset=0x186 align=1 (i32.const 0))) + (local.set 0x187 (i64.load offset=0x187 align=1 (i32.const 0))) + (local.set 0x188 (i64.load offset=0x188 align=1 (i32.const 0))) + (local.set 0x189 (i64.load offset=0x189 align=1 (i32.const 0))) + (local.set 0x18a (i64.load offset=0x18a align=1 (i32.const 0))) + (local.set 0x18b (i64.load offset=0x18b align=1 (i32.const 0))) + (local.set 0x18c (i64.load offset=0x18c align=1 (i32.const 0))) + (local.set 0x18d (i64.load offset=0x18d align=1 (i32.const 0))) + (local.set 0x18e (i64.load offset=0x18e align=1 (i32.const 0))) + (local.set 0x18f (i64.load offset=0x18f align=1 (i32.const 0))) + (local.set 0x190 (i64.load offset=0x190 align=1 (i32.const 0))) + (local.set 0x191 (i64.load offset=0x191 align=1 (i32.const 0))) + (local.set 0x192 (i64.load offset=0x192 align=1 (i32.const 0))) + (local.set 0x193 (i64.load offset=0x193 align=1 (i32.const 0))) + (local.set 0x194 (i64.load offset=0x194 align=1 (i32.const 0))) + (local.set 0x195 (i64.load offset=0x195 align=1 (i32.const 0))) + (local.set 0x196 (i64.load offset=0x196 align=1 (i32.const 0))) + (local.set 0x197 (i64.load offset=0x197 align=1 (i32.const 0))) + (local.set 0x198 (i64.load offset=0x198 align=1 (i32.const 0))) + (local.set 0x199 (i64.load offset=0x199 align=1 (i32.const 0))) + (local.set 0x19a (i64.load offset=0x19a align=1 (i32.const 0))) + (local.set 0x19b (i64.load offset=0x19b align=1 (i32.const 0))) + (local.set 0x19c (i64.load offset=0x19c align=1 (i32.const 0))) + (local.set 0x19d (i64.load offset=0x19d align=1 (i32.const 0))) + (local.set 0x19e (i64.load offset=0x19e align=1 (i32.const 0))) + (local.set 0x19f (i64.load offset=0x19f align=1 (i32.const 0))) + (local.set 0x1a0 (i64.load offset=0x1a0 align=1 (i32.const 0))) + (local.set 0x1a1 (i64.load offset=0x1a1 align=1 (i32.const 0))) + (local.set 0x1a2 (i64.load offset=0x1a2 align=1 (i32.const 0))) + (local.set 0x1a3 (i64.load offset=0x1a3 align=1 (i32.const 0))) + (local.set 0x1a4 (i64.load offset=0x1a4 align=1 (i32.const 0))) + (local.set 0x1a5 (i64.load offset=0x1a5 align=1 (i32.const 0))) + (local.set 0x1a6 (i64.load offset=0x1a6 align=1 (i32.const 0))) + (local.set 0x1a7 (i64.load offset=0x1a7 align=1 (i32.const 0))) + (local.set 0x1a8 (i64.load offset=0x1a8 align=1 (i32.const 0))) + (local.set 0x1a9 (i64.load offset=0x1a9 align=1 (i32.const 0))) + (local.set 0x1aa (i64.load offset=0x1aa align=1 (i32.const 0))) + (local.set 0x1ab (i64.load offset=0x1ab align=1 (i32.const 0))) + (local.set 0x1ac (i64.load offset=0x1ac align=1 (i32.const 0))) + (local.set 0x1ad (i64.load offset=0x1ad align=1 (i32.const 0))) + (local.set 0x1ae (i64.load offset=0x1ae align=1 (i32.const 0))) + (local.set 0x1af (i64.load offset=0x1af align=1 (i32.const 0))) + (local.set 0x1b0 (i64.load offset=0x1b0 align=1 (i32.const 0))) + (local.set 0x1b1 (i64.load offset=0x1b1 align=1 (i32.const 0))) + (local.set 0x1b2 (i64.load offset=0x1b2 align=1 (i32.const 0))) + (local.set 0x1b3 (i64.load offset=0x1b3 align=1 (i32.const 0))) + (local.set 0x1b4 (i64.load offset=0x1b4 align=1 (i32.const 0))) + (local.set 0x1b5 (i64.load offset=0x1b5 align=1 (i32.const 0))) + (local.set 0x1b6 (i64.load offset=0x1b6 align=1 (i32.const 0))) + (local.set 0x1b7 (i64.load offset=0x1b7 align=1 (i32.const 0))) + (local.set 0x1b8 (i64.load offset=0x1b8 align=1 (i32.const 0))) + (local.set 0x1b9 (i64.load offset=0x1b9 align=1 (i32.const 0))) + (local.set 0x1ba (i64.load offset=0x1ba align=1 (i32.const 0))) + (local.set 0x1bb (i64.load offset=0x1bb align=1 (i32.const 0))) + (local.set 0x1bc (i64.load offset=0x1bc align=1 (i32.const 0))) + (local.set 0x1bd (i64.load offset=0x1bd align=1 (i32.const 0))) + (local.set 0x1be (i64.load offset=0x1be align=1 (i32.const 0))) + (local.set 0x1bf (i64.load offset=0x1bf align=1 (i32.const 0))) + (local.set 0x1c0 (i64.load offset=0x1c0 align=1 (i32.const 0))) + (local.set 0x1c1 (i64.load offset=0x1c1 align=1 (i32.const 0))) + (local.set 0x1c2 (i64.load offset=0x1c2 align=1 (i32.const 0))) + (local.set 0x1c3 (i64.load offset=0x1c3 align=1 (i32.const 0))) + (local.set 0x1c4 (i64.load offset=0x1c4 align=1 (i32.const 0))) + (local.set 0x1c5 (i64.load offset=0x1c5 align=1 (i32.const 0))) + (local.set 0x1c6 (i64.load offset=0x1c6 align=1 (i32.const 0))) + (local.set 0x1c7 (i64.load offset=0x1c7 align=1 (i32.const 0))) + (local.set 0x1c8 (i64.load offset=0x1c8 align=1 (i32.const 0))) + (local.set 0x1c9 (i64.load offset=0x1c9 align=1 (i32.const 0))) + (local.set 0x1ca (i64.load offset=0x1ca align=1 (i32.const 0))) + (local.set 0x1cb (i64.load offset=0x1cb align=1 (i32.const 0))) + (local.set 0x1cc (i64.load offset=0x1cc align=1 (i32.const 0))) + (local.set 0x1cd (i64.load offset=0x1cd align=1 (i32.const 0))) + (local.set 0x1ce (i64.load offset=0x1ce align=1 (i32.const 0))) + (local.set 0x1cf (i64.load offset=0x1cf align=1 (i32.const 0))) + (local.set 0x1d0 (i64.load offset=0x1d0 align=1 (i32.const 0))) + (local.set 0x1d1 (i64.load offset=0x1d1 align=1 (i32.const 0))) + (local.set 0x1d2 (i64.load offset=0x1d2 align=1 (i32.const 0))) + (local.set 0x1d3 (i64.load offset=0x1d3 align=1 (i32.const 0))) + (local.set 0x1d4 (i64.load offset=0x1d4 align=1 (i32.const 0))) + (local.set 0x1d5 (i64.load offset=0x1d5 align=1 (i32.const 0))) + (local.set 0x1d6 (i64.load offset=0x1d6 align=1 (i32.const 0))) + (local.set 0x1d7 (i64.load offset=0x1d7 align=1 (i32.const 0))) + (local.set 0x1d8 (i64.load offset=0x1d8 align=1 (i32.const 0))) + (local.set 0x1d9 (i64.load offset=0x1d9 align=1 (i32.const 0))) + (local.set 0x1da (i64.load offset=0x1da align=1 (i32.const 0))) + (local.set 0x1db (i64.load offset=0x1db align=1 (i32.const 0))) + (local.set 0x1dc (i64.load offset=0x1dc align=1 (i32.const 0))) + (local.set 0x1dd (i64.load offset=0x1dd align=1 (i32.const 0))) + (local.set 0x1de (i64.load offset=0x1de align=1 (i32.const 0))) + (local.set 0x1df (i64.load offset=0x1df align=1 (i32.const 0))) + (local.set 0x1e0 (i64.load offset=0x1e0 align=1 (i32.const 0))) + (local.set 0x1e1 (i64.load offset=0x1e1 align=1 (i32.const 0))) + (local.set 0x1e2 (i64.load offset=0x1e2 align=1 (i32.const 0))) + (local.set 0x1e3 (i64.load offset=0x1e3 align=1 (i32.const 0))) + (local.set 0x1e4 (i64.load offset=0x1e4 align=1 (i32.const 0))) + (local.set 0x1e5 (i64.load offset=0x1e5 align=1 (i32.const 0))) + (local.set 0x1e6 (i64.load offset=0x1e6 align=1 (i32.const 0))) + (local.set 0x1e7 (i64.load offset=0x1e7 align=1 (i32.const 0))) + (local.set 0x1e8 (i64.load offset=0x1e8 align=1 (i32.const 0))) + (local.set 0x1e9 (i64.load offset=0x1e9 align=1 (i32.const 0))) + (local.set 0x1ea (i64.load offset=0x1ea align=1 (i32.const 0))) + (local.set 0x1eb (i64.load offset=0x1eb align=1 (i32.const 0))) + (local.set 0x1ec (i64.load offset=0x1ec align=1 (i32.const 0))) + (local.set 0x1ed (i64.load offset=0x1ed align=1 (i32.const 0))) + (local.set 0x1ee (i64.load offset=0x1ee align=1 (i32.const 0))) + (local.set 0x1ef (i64.load offset=0x1ef align=1 (i32.const 0))) + (local.set 0x1f0 (i64.load offset=0x1f0 align=1 (i32.const 0))) + (local.set 0x1f1 (i64.load offset=0x1f1 align=1 (i32.const 0))) + (local.set 0x1f2 (i64.load offset=0x1f2 align=1 (i32.const 0))) + (local.set 0x1f3 (i64.load offset=0x1f3 align=1 (i32.const 0))) + (local.set 0x1f4 (i64.load offset=0x1f4 align=1 (i32.const 0))) + (local.set 0x1f5 (i64.load offset=0x1f5 align=1 (i32.const 0))) + (local.set 0x1f6 (i64.load offset=0x1f6 align=1 (i32.const 0))) + (local.set 0x1f7 (i64.load offset=0x1f7 align=1 (i32.const 0))) + (local.set 0x1f8 (i64.load offset=0x1f8 align=1 (i32.const 0))) + (local.set 0x1f9 (i64.load offset=0x1f9 align=1 (i32.const 0))) + (local.set 0x1fa (i64.load offset=0x1fa align=1 (i32.const 0))) + (local.set 0x1fb (i64.load offset=0x1fb align=1 (i32.const 0))) + (local.set 0x1fc (i64.load offset=0x1fc align=1 (i32.const 0))) + (local.set 0x1fd (i64.load offset=0x1fd align=1 (i32.const 0))) + (local.set 0x1fe (i64.load offset=0x1fe align=1 (i32.const 0))) + (local.set 0x1ff (i64.load offset=0x1ff align=1 (i32.const 0))) + (local.set 0x200 (i64.load offset=0x200 align=1 (i32.const 0))) + (local.set 0x201 (i64.load offset=0x201 align=1 (i32.const 0))) + (local.set 0x202 (i64.load offset=0x202 align=1 (i32.const 0))) + (local.set 0x203 (i64.load offset=0x203 align=1 (i32.const 0))) + (local.set 0x204 (i64.load offset=0x204 align=1 (i32.const 0))) + (local.set 0x205 (i64.load offset=0x205 align=1 (i32.const 0))) + (local.set 0x206 (i64.load offset=0x206 align=1 (i32.const 0))) + (local.set 0x207 (i64.load offset=0x207 align=1 (i32.const 0))) + (local.set 0x208 (i64.load offset=0x208 align=1 (i32.const 0))) + (local.set 0x209 (i64.load offset=0x209 align=1 (i32.const 0))) + (local.set 0x20a (i64.load offset=0x20a align=1 (i32.const 0))) + (local.set 0x20b (i64.load offset=0x20b align=1 (i32.const 0))) + (local.set 0x20c (i64.load offset=0x20c align=1 (i32.const 0))) + (local.set 0x20d (i64.load offset=0x20d align=1 (i32.const 0))) + (local.set 0x20e (i64.load offset=0x20e align=1 (i32.const 0))) + (local.set 0x20f (i64.load offset=0x20f align=1 (i32.const 0))) + (local.set 0x210 (i64.load offset=0x210 align=1 (i32.const 0))) + (local.set 0x211 (i64.load offset=0x211 align=1 (i32.const 0))) + (local.set 0x212 (i64.load offset=0x212 align=1 (i32.const 0))) + (local.set 0x213 (i64.load offset=0x213 align=1 (i32.const 0))) + (local.set 0x214 (i64.load offset=0x214 align=1 (i32.const 0))) + (local.set 0x215 (i64.load offset=0x215 align=1 (i32.const 0))) + (local.set 0x216 (i64.load offset=0x216 align=1 (i32.const 0))) + (local.set 0x217 (i64.load offset=0x217 align=1 (i32.const 0))) + (local.set 0x218 (i64.load offset=0x218 align=1 (i32.const 0))) + (local.set 0x219 (i64.load offset=0x219 align=1 (i32.const 0))) + (local.set 0x21a (i64.load offset=0x21a align=1 (i32.const 0))) + (local.set 0x21b (i64.load offset=0x21b align=1 (i32.const 0))) + (local.set 0x21c (i64.load offset=0x21c align=1 (i32.const 0))) + (local.set 0x21d (i64.load offset=0x21d align=1 (i32.const 0))) + (local.set 0x21e (i64.load offset=0x21e align=1 (i32.const 0))) + (local.set 0x21f (i64.load offset=0x21f align=1 (i32.const 0))) + (local.set 0x220 (i64.load offset=0x220 align=1 (i32.const 0))) + (local.set 0x221 (i64.load offset=0x221 align=1 (i32.const 0))) + (local.set 0x222 (i64.load offset=0x222 align=1 (i32.const 0))) + (local.set 0x223 (i64.load offset=0x223 align=1 (i32.const 0))) + (local.set 0x224 (i64.load offset=0x224 align=1 (i32.const 0))) + (local.set 0x225 (i64.load offset=0x225 align=1 (i32.const 0))) + (local.set 0x226 (i64.load offset=0x226 align=1 (i32.const 0))) + (local.set 0x227 (i64.load offset=0x227 align=1 (i32.const 0))) + (local.set 0x228 (i64.load offset=0x228 align=1 (i32.const 0))) + (local.set 0x229 (i64.load offset=0x229 align=1 (i32.const 0))) + (local.set 0x22a (i64.load offset=0x22a align=1 (i32.const 0))) + (local.set 0x22b (i64.load offset=0x22b align=1 (i32.const 0))) + (local.set 0x22c (i64.load offset=0x22c align=1 (i32.const 0))) + (local.set 0x22d (i64.load offset=0x22d align=1 (i32.const 0))) + (local.set 0x22e (i64.load offset=0x22e align=1 (i32.const 0))) + (local.set 0x22f (i64.load offset=0x22f align=1 (i32.const 0))) + (local.set 0x230 (i64.load offset=0x230 align=1 (i32.const 0))) + (local.set 0x231 (i64.load offset=0x231 align=1 (i32.const 0))) + (local.set 0x232 (i64.load offset=0x232 align=1 (i32.const 0))) + (local.set 0x233 (i64.load offset=0x233 align=1 (i32.const 0))) + (local.set 0x234 (i64.load offset=0x234 align=1 (i32.const 0))) + (local.set 0x235 (i64.load offset=0x235 align=1 (i32.const 0))) + (local.set 0x236 (i64.load offset=0x236 align=1 (i32.const 0))) + (local.set 0x237 (i64.load offset=0x237 align=1 (i32.const 0))) + (local.set 0x238 (i64.load offset=0x238 align=1 (i32.const 0))) + (local.set 0x239 (i64.load offset=0x239 align=1 (i32.const 0))) + (local.set 0x23a (i64.load offset=0x23a align=1 (i32.const 0))) + (local.set 0x23b (i64.load offset=0x23b align=1 (i32.const 0))) + (local.set 0x23c (i64.load offset=0x23c align=1 (i32.const 0))) + (local.set 0x23d (i64.load offset=0x23d align=1 (i32.const 0))) + (local.set 0x23e (i64.load offset=0x23e align=1 (i32.const 0))) + (local.set 0x23f (i64.load offset=0x23f align=1 (i32.const 0))) + (local.set 0x240 (i64.load offset=0x240 align=1 (i32.const 0))) + (local.set 0x241 (i64.load offset=0x241 align=1 (i32.const 0))) + (local.set 0x242 (i64.load offset=0x242 align=1 (i32.const 0))) + (local.set 0x243 (i64.load offset=0x243 align=1 (i32.const 0))) + (local.set 0x244 (i64.load offset=0x244 align=1 (i32.const 0))) + (local.set 0x245 (i64.load offset=0x245 align=1 (i32.const 0))) + (local.set 0x246 (i64.load offset=0x246 align=1 (i32.const 0))) + (local.set 0x247 (i64.load offset=0x247 align=1 (i32.const 0))) + (local.set 0x248 (i64.load offset=0x248 align=1 (i32.const 0))) + (local.set 0x249 (i64.load offset=0x249 align=1 (i32.const 0))) + (local.set 0x24a (i64.load offset=0x24a align=1 (i32.const 0))) + (local.set 0x24b (i64.load offset=0x24b align=1 (i32.const 0))) + (local.set 0x24c (i64.load offset=0x24c align=1 (i32.const 0))) + (local.set 0x24d (i64.load offset=0x24d align=1 (i32.const 0))) + (local.set 0x24e (i64.load offset=0x24e align=1 (i32.const 0))) + (local.set 0x24f (i64.load offset=0x24f align=1 (i32.const 0))) + (local.set 0x250 (i64.load offset=0x250 align=1 (i32.const 0))) + (local.set 0x251 (i64.load offset=0x251 align=1 (i32.const 0))) + (local.set 0x252 (i64.load offset=0x252 align=1 (i32.const 0))) + (local.set 0x253 (i64.load offset=0x253 align=1 (i32.const 0))) + (local.set 0x254 (i64.load offset=0x254 align=1 (i32.const 0))) + (local.set 0x255 (i64.load offset=0x255 align=1 (i32.const 0))) + (local.set 0x256 (i64.load offset=0x256 align=1 (i32.const 0))) + (local.set 0x257 (i64.load offset=0x257 align=1 (i32.const 0))) + (local.set 0x258 (i64.load offset=0x258 align=1 (i32.const 0))) + (local.set 0x259 (i64.load offset=0x259 align=1 (i32.const 0))) + (local.set 0x25a (i64.load offset=0x25a align=1 (i32.const 0))) + (local.set 0x25b (i64.load offset=0x25b align=1 (i32.const 0))) + (local.set 0x25c (i64.load offset=0x25c align=1 (i32.const 0))) + (local.set 0x25d (i64.load offset=0x25d align=1 (i32.const 0))) + (local.set 0x25e (i64.load offset=0x25e align=1 (i32.const 0))) + (local.set 0x25f (i64.load offset=0x25f align=1 (i32.const 0))) + (local.set 0x260 (i64.load offset=0x260 align=1 (i32.const 0))) + (local.set 0x261 (i64.load offset=0x261 align=1 (i32.const 0))) + (local.set 0x262 (i64.load offset=0x262 align=1 (i32.const 0))) + (local.set 0x263 (i64.load offset=0x263 align=1 (i32.const 0))) + (local.set 0x264 (i64.load offset=0x264 align=1 (i32.const 0))) + (local.set 0x265 (i64.load offset=0x265 align=1 (i32.const 0))) + (local.set 0x266 (i64.load offset=0x266 align=1 (i32.const 0))) + (local.set 0x267 (i64.load offset=0x267 align=1 (i32.const 0))) + (local.set 0x268 (i64.load offset=0x268 align=1 (i32.const 0))) + (local.set 0x269 (i64.load offset=0x269 align=1 (i32.const 0))) + (local.set 0x26a (i64.load offset=0x26a align=1 (i32.const 0))) + (local.set 0x26b (i64.load offset=0x26b align=1 (i32.const 0))) + (local.set 0x26c (i64.load offset=0x26c align=1 (i32.const 0))) + (local.set 0x26d (i64.load offset=0x26d align=1 (i32.const 0))) + (local.set 0x26e (i64.load offset=0x26e align=1 (i32.const 0))) + (local.set 0x26f (i64.load offset=0x26f align=1 (i32.const 0))) + (local.set 0x270 (i64.load offset=0x270 align=1 (i32.const 0))) + (local.set 0x271 (i64.load offset=0x271 align=1 (i32.const 0))) + (local.set 0x272 (i64.load offset=0x272 align=1 (i32.const 0))) + (local.set 0x273 (i64.load offset=0x273 align=1 (i32.const 0))) + (local.set 0x274 (i64.load offset=0x274 align=1 (i32.const 0))) + (local.set 0x275 (i64.load offset=0x275 align=1 (i32.const 0))) + (local.set 0x276 (i64.load offset=0x276 align=1 (i32.const 0))) + (local.set 0x277 (i64.load offset=0x277 align=1 (i32.const 0))) + (local.set 0x278 (i64.load offset=0x278 align=1 (i32.const 0))) + (local.set 0x279 (i64.load offset=0x279 align=1 (i32.const 0))) + (local.set 0x27a (i64.load offset=0x27a align=1 (i32.const 0))) + (local.set 0x27b (i64.load offset=0x27b align=1 (i32.const 0))) + (local.set 0x27c (i64.load offset=0x27c align=1 (i32.const 0))) + (local.set 0x27d (i64.load offset=0x27d align=1 (i32.const 0))) + (local.set 0x27e (i64.load offset=0x27e align=1 (i32.const 0))) + (local.set 0x27f (i64.load offset=0x27f align=1 (i32.const 0))) + (local.set 0x280 (i64.load offset=0x280 align=1 (i32.const 0))) + (local.set 0x281 (i64.load offset=0x281 align=1 (i32.const 0))) + (local.set 0x282 (i64.load offset=0x282 align=1 (i32.const 0))) + (local.set 0x283 (i64.load offset=0x283 align=1 (i32.const 0))) + (local.set 0x284 (i64.load offset=0x284 align=1 (i32.const 0))) + (local.set 0x285 (i64.load offset=0x285 align=1 (i32.const 0))) + (local.set 0x286 (i64.load offset=0x286 align=1 (i32.const 0))) + (local.set 0x287 (i64.load offset=0x287 align=1 (i32.const 0))) + (local.set 0x288 (i64.load offset=0x288 align=1 (i32.const 0))) + (local.set 0x289 (i64.load offset=0x289 align=1 (i32.const 0))) + (local.set 0x28a (i64.load offset=0x28a align=1 (i32.const 0))) + (local.set 0x28b (i64.load offset=0x28b align=1 (i32.const 0))) + (local.set 0x28c (i64.load offset=0x28c align=1 (i32.const 0))) + (local.set 0x28d (i64.load offset=0x28d align=1 (i32.const 0))) + (local.set 0x28e (i64.load offset=0x28e align=1 (i32.const 0))) + (local.set 0x28f (i64.load offset=0x28f align=1 (i32.const 0))) + (local.set 0x290 (i64.load offset=0x290 align=1 (i32.const 0))) + (local.set 0x291 (i64.load offset=0x291 align=1 (i32.const 0))) + (local.set 0x292 (i64.load offset=0x292 align=1 (i32.const 0))) + (local.set 0x293 (i64.load offset=0x293 align=1 (i32.const 0))) + (local.set 0x294 (i64.load offset=0x294 align=1 (i32.const 0))) + (local.set 0x295 (i64.load offset=0x295 align=1 (i32.const 0))) + (local.set 0x296 (i64.load offset=0x296 align=1 (i32.const 0))) + (local.set 0x297 (i64.load offset=0x297 align=1 (i32.const 0))) + (local.set 0x298 (i64.load offset=0x298 align=1 (i32.const 0))) + (local.set 0x299 (i64.load offset=0x299 align=1 (i32.const 0))) + (local.set 0x29a (i64.load offset=0x29a align=1 (i32.const 0))) + (local.set 0x29b (i64.load offset=0x29b align=1 (i32.const 0))) + (local.set 0x29c (i64.load offset=0x29c align=1 (i32.const 0))) + (local.set 0x29d (i64.load offset=0x29d align=1 (i32.const 0))) + (local.set 0x29e (i64.load offset=0x29e align=1 (i32.const 0))) + (local.set 0x29f (i64.load offset=0x29f align=1 (i32.const 0))) + (local.set 0x2a0 (i64.load offset=0x2a0 align=1 (i32.const 0))) + (local.set 0x2a1 (i64.load offset=0x2a1 align=1 (i32.const 0))) + (local.set 0x2a2 (i64.load offset=0x2a2 align=1 (i32.const 0))) + (local.set 0x2a3 (i64.load offset=0x2a3 align=1 (i32.const 0))) + (local.set 0x2a4 (i64.load offset=0x2a4 align=1 (i32.const 0))) + (local.set 0x2a5 (i64.load offset=0x2a5 align=1 (i32.const 0))) + (local.set 0x2a6 (i64.load offset=0x2a6 align=1 (i32.const 0))) + (local.set 0x2a7 (i64.load offset=0x2a7 align=1 (i32.const 0))) + (local.set 0x2a8 (i64.load offset=0x2a8 align=1 (i32.const 0))) + (local.set 0x2a9 (i64.load offset=0x2a9 align=1 (i32.const 0))) + (local.set 0x2aa (i64.load offset=0x2aa align=1 (i32.const 0))) + (local.set 0x2ab (i64.load offset=0x2ab align=1 (i32.const 0))) + (local.set 0x2ac (i64.load offset=0x2ac align=1 (i32.const 0))) + (local.set 0x2ad (i64.load offset=0x2ad align=1 (i32.const 0))) + (local.set 0x2ae (i64.load offset=0x2ae align=1 (i32.const 0))) + (local.set 0x2af (i64.load offset=0x2af align=1 (i32.const 0))) + (local.set 0x2b0 (i64.load offset=0x2b0 align=1 (i32.const 0))) + (local.set 0x2b1 (i64.load offset=0x2b1 align=1 (i32.const 0))) + (local.set 0x2b2 (i64.load offset=0x2b2 align=1 (i32.const 0))) + (local.set 0x2b3 (i64.load offset=0x2b3 align=1 (i32.const 0))) + (local.set 0x2b4 (i64.load offset=0x2b4 align=1 (i32.const 0))) + (local.set 0x2b5 (i64.load offset=0x2b5 align=1 (i32.const 0))) + (local.set 0x2b6 (i64.load offset=0x2b6 align=1 (i32.const 0))) + (local.set 0x2b7 (i64.load offset=0x2b7 align=1 (i32.const 0))) + (local.set 0x2b8 (i64.load offset=0x2b8 align=1 (i32.const 0))) + (local.set 0x2b9 (i64.load offset=0x2b9 align=1 (i32.const 0))) + (local.set 0x2ba (i64.load offset=0x2ba align=1 (i32.const 0))) + (local.set 0x2bb (i64.load offset=0x2bb align=1 (i32.const 0))) + (local.set 0x2bc (i64.load offset=0x2bc align=1 (i32.const 0))) + (local.set 0x2bd (i64.load offset=0x2bd align=1 (i32.const 0))) + (local.set 0x2be (i64.load offset=0x2be align=1 (i32.const 0))) + (local.set 0x2bf (i64.load offset=0x2bf align=1 (i32.const 0))) + (local.set 0x2c0 (i64.load offset=0x2c0 align=1 (i32.const 0))) + (local.set 0x2c1 (i64.load offset=0x2c1 align=1 (i32.const 0))) + (local.set 0x2c2 (i64.load offset=0x2c2 align=1 (i32.const 0))) + (local.set 0x2c3 (i64.load offset=0x2c3 align=1 (i32.const 0))) + (local.set 0x2c4 (i64.load offset=0x2c4 align=1 (i32.const 0))) + (local.set 0x2c5 (i64.load offset=0x2c5 align=1 (i32.const 0))) + (local.set 0x2c6 (i64.load offset=0x2c6 align=1 (i32.const 0))) + (local.set 0x2c7 (i64.load offset=0x2c7 align=1 (i32.const 0))) + (local.set 0x2c8 (i64.load offset=0x2c8 align=1 (i32.const 0))) + (local.set 0x2c9 (i64.load offset=0x2c9 align=1 (i32.const 0))) + (local.set 0x2ca (i64.load offset=0x2ca align=1 (i32.const 0))) + (local.set 0x2cb (i64.load offset=0x2cb align=1 (i32.const 0))) + (local.set 0x2cc (i64.load offset=0x2cc align=1 (i32.const 0))) + (local.set 0x2cd (i64.load offset=0x2cd align=1 (i32.const 0))) + (local.set 0x2ce (i64.load offset=0x2ce align=1 (i32.const 0))) + (local.set 0x2cf (i64.load offset=0x2cf align=1 (i32.const 0))) + (local.set 0x2d0 (i64.load offset=0x2d0 align=1 (i32.const 0))) + (local.set 0x2d1 (i64.load offset=0x2d1 align=1 (i32.const 0))) + (local.set 0x2d2 (i64.load offset=0x2d2 align=1 (i32.const 0))) + (local.set 0x2d3 (i64.load offset=0x2d3 align=1 (i32.const 0))) + (local.set 0x2d4 (i64.load offset=0x2d4 align=1 (i32.const 0))) + (local.set 0x2d5 (i64.load offset=0x2d5 align=1 (i32.const 0))) + (local.set 0x2d6 (i64.load offset=0x2d6 align=1 (i32.const 0))) + (local.set 0x2d7 (i64.load offset=0x2d7 align=1 (i32.const 0))) + (local.set 0x2d8 (i64.load offset=0x2d8 align=1 (i32.const 0))) + (local.set 0x2d9 (i64.load offset=0x2d9 align=1 (i32.const 0))) + (local.set 0x2da (i64.load offset=0x2da align=1 (i32.const 0))) + (local.set 0x2db (i64.load offset=0x2db align=1 (i32.const 0))) + (local.set 0x2dc (i64.load offset=0x2dc align=1 (i32.const 0))) + (local.set 0x2dd (i64.load offset=0x2dd align=1 (i32.const 0))) + (local.set 0x2de (i64.load offset=0x2de align=1 (i32.const 0))) + (local.set 0x2df (i64.load offset=0x2df align=1 (i32.const 0))) + (local.set 0x2e0 (i64.load offset=0x2e0 align=1 (i32.const 0))) + (local.set 0x2e1 (i64.load offset=0x2e1 align=1 (i32.const 0))) + (local.set 0x2e2 (i64.load offset=0x2e2 align=1 (i32.const 0))) + (local.set 0x2e3 (i64.load offset=0x2e3 align=1 (i32.const 0))) + (local.set 0x2e4 (i64.load offset=0x2e4 align=1 (i32.const 0))) + (local.set 0x2e5 (i64.load offset=0x2e5 align=1 (i32.const 0))) + (local.set 0x2e6 (i64.load offset=0x2e6 align=1 (i32.const 0))) + (local.set 0x2e7 (i64.load offset=0x2e7 align=1 (i32.const 0))) + (local.set 0x2e8 (i64.load offset=0x2e8 align=1 (i32.const 0))) + (local.set 0x2e9 (i64.load offset=0x2e9 align=1 (i32.const 0))) + (local.set 0x2ea (i64.load offset=0x2ea align=1 (i32.const 0))) + (local.set 0x2eb (i64.load offset=0x2eb align=1 (i32.const 0))) + (local.set 0x2ec (i64.load offset=0x2ec align=1 (i32.const 0))) + (local.set 0x2ed (i64.load offset=0x2ed align=1 (i32.const 0))) + (local.set 0x2ee (i64.load offset=0x2ee align=1 (i32.const 0))) + (local.set 0x2ef (i64.load offset=0x2ef align=1 (i32.const 0))) + (local.set 0x2f0 (i64.load offset=0x2f0 align=1 (i32.const 0))) + (local.set 0x2f1 (i64.load offset=0x2f1 align=1 (i32.const 0))) + (local.set 0x2f2 (i64.load offset=0x2f2 align=1 (i32.const 0))) + (local.set 0x2f3 (i64.load offset=0x2f3 align=1 (i32.const 0))) + (local.set 0x2f4 (i64.load offset=0x2f4 align=1 (i32.const 0))) + (local.set 0x2f5 (i64.load offset=0x2f5 align=1 (i32.const 0))) + (local.set 0x2f6 (i64.load offset=0x2f6 align=1 (i32.const 0))) + (local.set 0x2f7 (i64.load offset=0x2f7 align=1 (i32.const 0))) + (local.set 0x2f8 (i64.load offset=0x2f8 align=1 (i32.const 0))) + (local.set 0x2f9 (i64.load offset=0x2f9 align=1 (i32.const 0))) + (local.set 0x2fa (i64.load offset=0x2fa align=1 (i32.const 0))) + (local.set 0x2fb (i64.load offset=0x2fb align=1 (i32.const 0))) + (local.set 0x2fc (i64.load offset=0x2fc align=1 (i32.const 0))) + (local.set 0x2fd (i64.load offset=0x2fd align=1 (i32.const 0))) + (local.set 0x2fe (i64.load offset=0x2fe align=1 (i32.const 0))) + (local.set 0x2ff (i64.load offset=0x2ff align=1 (i32.const 0))) + (local.set 0x300 (i64.load offset=0x300 align=1 (i32.const 0))) + (local.set 0x301 (i64.load offset=0x301 align=1 (i32.const 0))) + (local.set 0x302 (i64.load offset=0x302 align=1 (i32.const 0))) + (local.set 0x303 (i64.load offset=0x303 align=1 (i32.const 0))) + (local.set 0x304 (i64.load offset=0x304 align=1 (i32.const 0))) + (local.set 0x305 (i64.load offset=0x305 align=1 (i32.const 0))) + (local.set 0x306 (i64.load offset=0x306 align=1 (i32.const 0))) + (local.set 0x307 (i64.load offset=0x307 align=1 (i32.const 0))) + (local.set 0x308 (i64.load offset=0x308 align=1 (i32.const 0))) + (local.set 0x309 (i64.load offset=0x309 align=1 (i32.const 0))) + (local.set 0x30a (i64.load offset=0x30a align=1 (i32.const 0))) + (local.set 0x30b (i64.load offset=0x30b align=1 (i32.const 0))) + (local.set 0x30c (i64.load offset=0x30c align=1 (i32.const 0))) + (local.set 0x30d (i64.load offset=0x30d align=1 (i32.const 0))) + (local.set 0x30e (i64.load offset=0x30e align=1 (i32.const 0))) + (local.set 0x30f (i64.load offset=0x30f align=1 (i32.const 0))) + (local.set 0x310 (i64.load offset=0x310 align=1 (i32.const 0))) + (local.set 0x311 (i64.load offset=0x311 align=1 (i32.const 0))) + (local.set 0x312 (i64.load offset=0x312 align=1 (i32.const 0))) + (local.set 0x313 (i64.load offset=0x313 align=1 (i32.const 0))) + (local.set 0x314 (i64.load offset=0x314 align=1 (i32.const 0))) + (local.set 0x315 (i64.load offset=0x315 align=1 (i32.const 0))) + (local.set 0x316 (i64.load offset=0x316 align=1 (i32.const 0))) + (local.set 0x317 (i64.load offset=0x317 align=1 (i32.const 0))) + (local.set 0x318 (i64.load offset=0x318 align=1 (i32.const 0))) + (local.set 0x319 (i64.load offset=0x319 align=1 (i32.const 0))) + (local.set 0x31a (i64.load offset=0x31a align=1 (i32.const 0))) + (local.set 0x31b (i64.load offset=0x31b align=1 (i32.const 0))) + (local.set 0x31c (i64.load offset=0x31c align=1 (i32.const 0))) + (local.set 0x31d (i64.load offset=0x31d align=1 (i32.const 0))) + (local.set 0x31e (i64.load offset=0x31e align=1 (i32.const 0))) + (local.set 0x31f (i64.load offset=0x31f align=1 (i32.const 0))) + (local.set 0x320 (i64.load offset=0x320 align=1 (i32.const 0))) + (local.set 0x321 (i64.load offset=0x321 align=1 (i32.const 0))) + (local.set 0x322 (i64.load offset=0x322 align=1 (i32.const 0))) + (local.set 0x323 (i64.load offset=0x323 align=1 (i32.const 0))) + (local.set 0x324 (i64.load offset=0x324 align=1 (i32.const 0))) + (local.set 0x325 (i64.load offset=0x325 align=1 (i32.const 0))) + (local.set 0x326 (i64.load offset=0x326 align=1 (i32.const 0))) + (local.set 0x327 (i64.load offset=0x327 align=1 (i32.const 0))) + (local.set 0x328 (i64.load offset=0x328 align=1 (i32.const 0))) + (local.set 0x329 (i64.load offset=0x329 align=1 (i32.const 0))) + (local.set 0x32a (i64.load offset=0x32a align=1 (i32.const 0))) + (local.set 0x32b (i64.load offset=0x32b align=1 (i32.const 0))) + (local.set 0x32c (i64.load offset=0x32c align=1 (i32.const 0))) + (local.set 0x32d (i64.load offset=0x32d align=1 (i32.const 0))) + (local.set 0x32e (i64.load offset=0x32e align=1 (i32.const 0))) + (local.set 0x32f (i64.load offset=0x32f align=1 (i32.const 0))) + (local.set 0x330 (i64.load offset=0x330 align=1 (i32.const 0))) + (local.set 0x331 (i64.load offset=0x331 align=1 (i32.const 0))) + (local.set 0x332 (i64.load offset=0x332 align=1 (i32.const 0))) + (local.set 0x333 (i64.load offset=0x333 align=1 (i32.const 0))) + (local.set 0x334 (i64.load offset=0x334 align=1 (i32.const 0))) + (local.set 0x335 (i64.load offset=0x335 align=1 (i32.const 0))) + (local.set 0x336 (i64.load offset=0x336 align=1 (i32.const 0))) + (local.set 0x337 (i64.load offset=0x337 align=1 (i32.const 0))) + (local.set 0x338 (i64.load offset=0x338 align=1 (i32.const 0))) + (local.set 0x339 (i64.load offset=0x339 align=1 (i32.const 0))) + (local.set 0x33a (i64.load offset=0x33a align=1 (i32.const 0))) + (local.set 0x33b (i64.load offset=0x33b align=1 (i32.const 0))) + (local.set 0x33c (i64.load offset=0x33c align=1 (i32.const 0))) + (local.set 0x33d (i64.load offset=0x33d align=1 (i32.const 0))) + (local.set 0x33e (i64.load offset=0x33e align=1 (i32.const 0))) + (local.set 0x33f (i64.load offset=0x33f align=1 (i32.const 0))) + (local.set 0x340 (i64.load offset=0x340 align=1 (i32.const 0))) + (local.set 0x341 (i64.load offset=0x341 align=1 (i32.const 0))) + (local.set 0x342 (i64.load offset=0x342 align=1 (i32.const 0))) + (local.set 0x343 (i64.load offset=0x343 align=1 (i32.const 0))) + (local.set 0x344 (i64.load offset=0x344 align=1 (i32.const 0))) + (local.set 0x345 (i64.load offset=0x345 align=1 (i32.const 0))) + (local.set 0x346 (i64.load offset=0x346 align=1 (i32.const 0))) + (local.set 0x347 (i64.load offset=0x347 align=1 (i32.const 0))) + (local.set 0x348 (i64.load offset=0x348 align=1 (i32.const 0))) + (local.set 0x349 (i64.load offset=0x349 align=1 (i32.const 0))) + (local.set 0x34a (i64.load offset=0x34a align=1 (i32.const 0))) + (local.set 0x34b (i64.load offset=0x34b align=1 (i32.const 0))) + (local.set 0x34c (i64.load offset=0x34c align=1 (i32.const 0))) + (local.set 0x34d (i64.load offset=0x34d align=1 (i32.const 0))) + (local.set 0x34e (i64.load offset=0x34e align=1 (i32.const 0))) + (local.set 0x34f (i64.load offset=0x34f align=1 (i32.const 0))) + (local.set 0x350 (i64.load offset=0x350 align=1 (i32.const 0))) + (local.set 0x351 (i64.load offset=0x351 align=1 (i32.const 0))) + (local.set 0x352 (i64.load offset=0x352 align=1 (i32.const 0))) + (local.set 0x353 (i64.load offset=0x353 align=1 (i32.const 0))) + (local.set 0x354 (i64.load offset=0x354 align=1 (i32.const 0))) + (local.set 0x355 (i64.load offset=0x355 align=1 (i32.const 0))) + (local.set 0x356 (i64.load offset=0x356 align=1 (i32.const 0))) + (local.set 0x357 (i64.load offset=0x357 align=1 (i32.const 0))) + (local.set 0x358 (i64.load offset=0x358 align=1 (i32.const 0))) + (local.set 0x359 (i64.load offset=0x359 align=1 (i32.const 0))) + (local.set 0x35a (i64.load offset=0x35a align=1 (i32.const 0))) + (local.set 0x35b (i64.load offset=0x35b align=1 (i32.const 0))) + (local.set 0x35c (i64.load offset=0x35c align=1 (i32.const 0))) + (local.set 0x35d (i64.load offset=0x35d align=1 (i32.const 0))) + (local.set 0x35e (i64.load offset=0x35e align=1 (i32.const 0))) + (local.set 0x35f (i64.load offset=0x35f align=1 (i32.const 0))) + (local.set 0x360 (i64.load offset=0x360 align=1 (i32.const 0))) + (local.set 0x361 (i64.load offset=0x361 align=1 (i32.const 0))) + (local.set 0x362 (i64.load offset=0x362 align=1 (i32.const 0))) + (local.set 0x363 (i64.load offset=0x363 align=1 (i32.const 0))) + (local.set 0x364 (i64.load offset=0x364 align=1 (i32.const 0))) + (local.set 0x365 (i64.load offset=0x365 align=1 (i32.const 0))) + (local.set 0x366 (i64.load offset=0x366 align=1 (i32.const 0))) + (local.set 0x367 (i64.load offset=0x367 align=1 (i32.const 0))) + (local.set 0x368 (i64.load offset=0x368 align=1 (i32.const 0))) + (local.set 0x369 (i64.load offset=0x369 align=1 (i32.const 0))) + (local.set 0x36a (i64.load offset=0x36a align=1 (i32.const 0))) + (local.set 0x36b (i64.load offset=0x36b align=1 (i32.const 0))) + (local.set 0x36c (i64.load offset=0x36c align=1 (i32.const 0))) + (local.set 0x36d (i64.load offset=0x36d align=1 (i32.const 0))) + (local.set 0x36e (i64.load offset=0x36e align=1 (i32.const 0))) + (local.set 0x36f (i64.load offset=0x36f align=1 (i32.const 0))) + (local.set 0x370 (i64.load offset=0x370 align=1 (i32.const 0))) + (local.set 0x371 (i64.load offset=0x371 align=1 (i32.const 0))) + (local.set 0x372 (i64.load offset=0x372 align=1 (i32.const 0))) + (local.set 0x373 (i64.load offset=0x373 align=1 (i32.const 0))) + (local.set 0x374 (i64.load offset=0x374 align=1 (i32.const 0))) + (local.set 0x375 (i64.load offset=0x375 align=1 (i32.const 0))) + (local.set 0x376 (i64.load offset=0x376 align=1 (i32.const 0))) + (local.set 0x377 (i64.load offset=0x377 align=1 (i32.const 0))) + (local.set 0x378 (i64.load offset=0x378 align=1 (i32.const 0))) + (local.set 0x379 (i64.load offset=0x379 align=1 (i32.const 0))) + (local.set 0x37a (i64.load offset=0x37a align=1 (i32.const 0))) + (local.set 0x37b (i64.load offset=0x37b align=1 (i32.const 0))) + (local.set 0x37c (i64.load offset=0x37c align=1 (i32.const 0))) + (local.set 0x37d (i64.load offset=0x37d align=1 (i32.const 0))) + (local.set 0x37e (i64.load offset=0x37e align=1 (i32.const 0))) + (local.set 0x37f (i64.load offset=0x37f align=1 (i32.const 0))) + (local.set 0x380 (i64.load offset=0x380 align=1 (i32.const 0))) + (local.set 0x381 (i64.load offset=0x381 align=1 (i32.const 0))) + (local.set 0x382 (i64.load offset=0x382 align=1 (i32.const 0))) + (local.set 0x383 (i64.load offset=0x383 align=1 (i32.const 0))) + (local.set 0x384 (i64.load offset=0x384 align=1 (i32.const 0))) + (local.set 0x385 (i64.load offset=0x385 align=1 (i32.const 0))) + (local.set 0x386 (i64.load offset=0x386 align=1 (i32.const 0))) + (local.set 0x387 (i64.load offset=0x387 align=1 (i32.const 0))) + (local.set 0x388 (i64.load offset=0x388 align=1 (i32.const 0))) + (local.set 0x389 (i64.load offset=0x389 align=1 (i32.const 0))) + (local.set 0x38a (i64.load offset=0x38a align=1 (i32.const 0))) + (local.set 0x38b (i64.load offset=0x38b align=1 (i32.const 0))) + (local.set 0x38c (i64.load offset=0x38c align=1 (i32.const 0))) + (local.set 0x38d (i64.load offset=0x38d align=1 (i32.const 0))) + (local.set 0x38e (i64.load offset=0x38e align=1 (i32.const 0))) + (local.set 0x38f (i64.load offset=0x38f align=1 (i32.const 0))) + (local.set 0x390 (i64.load offset=0x390 align=1 (i32.const 0))) + (local.set 0x391 (i64.load offset=0x391 align=1 (i32.const 0))) + (local.set 0x392 (i64.load offset=0x392 align=1 (i32.const 0))) + (local.set 0x393 (i64.load offset=0x393 align=1 (i32.const 0))) + (local.set 0x394 (i64.load offset=0x394 align=1 (i32.const 0))) + (local.set 0x395 (i64.load offset=0x395 align=1 (i32.const 0))) + (local.set 0x396 (i64.load offset=0x396 align=1 (i32.const 0))) + (local.set 0x397 (i64.load offset=0x397 align=1 (i32.const 0))) + (local.set 0x398 (i64.load offset=0x398 align=1 (i32.const 0))) + (local.set 0x399 (i64.load offset=0x399 align=1 (i32.const 0))) + (local.set 0x39a (i64.load offset=0x39a align=1 (i32.const 0))) + (local.set 0x39b (i64.load offset=0x39b align=1 (i32.const 0))) + (local.set 0x39c (i64.load offset=0x39c align=1 (i32.const 0))) + (local.set 0x39d (i64.load offset=0x39d align=1 (i32.const 0))) + (local.set 0x39e (i64.load offset=0x39e align=1 (i32.const 0))) + (local.set 0x39f (i64.load offset=0x39f align=1 (i32.const 0))) + (local.set 0x3a0 (i64.load offset=0x3a0 align=1 (i32.const 0))) + (local.set 0x3a1 (i64.load offset=0x3a1 align=1 (i32.const 0))) + (local.set 0x3a2 (i64.load offset=0x3a2 align=1 (i32.const 0))) + (local.set 0x3a3 (i64.load offset=0x3a3 align=1 (i32.const 0))) + (local.set 0x3a4 (i64.load offset=0x3a4 align=1 (i32.const 0))) + (local.set 0x3a5 (i64.load offset=0x3a5 align=1 (i32.const 0))) + (local.set 0x3a6 (i64.load offset=0x3a6 align=1 (i32.const 0))) + (local.set 0x3a7 (i64.load offset=0x3a7 align=1 (i32.const 0))) + (local.set 0x3a8 (i64.load offset=0x3a8 align=1 (i32.const 0))) + (local.set 0x3a9 (i64.load offset=0x3a9 align=1 (i32.const 0))) + (local.set 0x3aa (i64.load offset=0x3aa align=1 (i32.const 0))) + (local.set 0x3ab (i64.load offset=0x3ab align=1 (i32.const 0))) + (local.set 0x3ac (i64.load offset=0x3ac align=1 (i32.const 0))) + (local.set 0x3ad (i64.load offset=0x3ad align=1 (i32.const 0))) + (local.set 0x3ae (i64.load offset=0x3ae align=1 (i32.const 0))) + (local.set 0x3af (i64.load offset=0x3af align=1 (i32.const 0))) + (local.set 0x3b0 (i64.load offset=0x3b0 align=1 (i32.const 0))) + (local.set 0x3b1 (i64.load offset=0x3b1 align=1 (i32.const 0))) + (local.set 0x3b2 (i64.load offset=0x3b2 align=1 (i32.const 0))) + (local.set 0x3b3 (i64.load offset=0x3b3 align=1 (i32.const 0))) + (local.set 0x3b4 (i64.load offset=0x3b4 align=1 (i32.const 0))) + (local.set 0x3b5 (i64.load offset=0x3b5 align=1 (i32.const 0))) + (local.set 0x3b6 (i64.load offset=0x3b6 align=1 (i32.const 0))) + (local.set 0x3b7 (i64.load offset=0x3b7 align=1 (i32.const 0))) + (local.set 0x3b8 (i64.load offset=0x3b8 align=1 (i32.const 0))) + (local.set 0x3b9 (i64.load offset=0x3b9 align=1 (i32.const 0))) + (local.set 0x3ba (i64.load offset=0x3ba align=1 (i32.const 0))) + (local.set 0x3bb (i64.load offset=0x3bb align=1 (i32.const 0))) + (local.set 0x3bc (i64.load offset=0x3bc align=1 (i32.const 0))) + (local.set 0x3bd (i64.load offset=0x3bd align=1 (i32.const 0))) + (local.set 0x3be (i64.load offset=0x3be align=1 (i32.const 0))) + (local.set 0x3bf (i64.load offset=0x3bf align=1 (i32.const 0))) + (local.set 0x3c0 (i64.load offset=0x3c0 align=1 (i32.const 0))) + (local.set 0x3c1 (i64.load offset=0x3c1 align=1 (i32.const 0))) + (local.set 0x3c2 (i64.load offset=0x3c2 align=1 (i32.const 0))) + (local.set 0x3c3 (i64.load offset=0x3c3 align=1 (i32.const 0))) + (local.set 0x3c4 (i64.load offset=0x3c4 align=1 (i32.const 0))) + (local.set 0x3c5 (i64.load offset=0x3c5 align=1 (i32.const 0))) + (local.set 0x3c6 (i64.load offset=0x3c6 align=1 (i32.const 0))) + (local.set 0x3c7 (i64.load offset=0x3c7 align=1 (i32.const 0))) + (local.set 0x3c8 (i64.load offset=0x3c8 align=1 (i32.const 0))) + (local.set 0x3c9 (i64.load offset=0x3c9 align=1 (i32.const 0))) + (local.set 0x3ca (i64.load offset=0x3ca align=1 (i32.const 0))) + (local.set 0x3cb (i64.load offset=0x3cb align=1 (i32.const 0))) + (local.set 0x3cc (i64.load offset=0x3cc align=1 (i32.const 0))) + (local.set 0x3cd (i64.load offset=0x3cd align=1 (i32.const 0))) + (local.set 0x3ce (i64.load offset=0x3ce align=1 (i32.const 0))) + (local.set 0x3cf (i64.load offset=0x3cf align=1 (i32.const 0))) + (local.set 0x3d0 (i64.load offset=0x3d0 align=1 (i32.const 0))) + (local.set 0x3d1 (i64.load offset=0x3d1 align=1 (i32.const 0))) + (local.set 0x3d2 (i64.load offset=0x3d2 align=1 (i32.const 0))) + (local.set 0x3d3 (i64.load offset=0x3d3 align=1 (i32.const 0))) + (local.set 0x3d4 (i64.load offset=0x3d4 align=1 (i32.const 0))) + (local.set 0x3d5 (i64.load offset=0x3d5 align=1 (i32.const 0))) + (local.set 0x3d6 (i64.load offset=0x3d6 align=1 (i32.const 0))) + (local.set 0x3d7 (i64.load offset=0x3d7 align=1 (i32.const 0))) + (local.set 0x3d8 (i64.load offset=0x3d8 align=1 (i32.const 0))) + (local.set 0x3d9 (i64.load offset=0x3d9 align=1 (i32.const 0))) + (local.set 0x3da (i64.load offset=0x3da align=1 (i32.const 0))) + (local.set 0x3db (i64.load offset=0x3db align=1 (i32.const 0))) + (local.set 0x3dc (i64.load offset=0x3dc align=1 (i32.const 0))) + (local.set 0x3dd (i64.load offset=0x3dd align=1 (i32.const 0))) + (local.set 0x3de (i64.load offset=0x3de align=1 (i32.const 0))) + (local.set 0x3df (i64.load offset=0x3df align=1 (i32.const 0))) + (local.set 0x3e0 (i64.load offset=0x3e0 align=1 (i32.const 0))) + (local.set 0x3e1 (i64.load offset=0x3e1 align=1 (i32.const 0))) + (local.set 0x3e2 (i64.load offset=0x3e2 align=1 (i32.const 0))) + (local.set 0x3e3 (i64.load offset=0x3e3 align=1 (i32.const 0))) + (local.set 0x3e4 (i64.load offset=0x3e4 align=1 (i32.const 0))) + (local.set 0x3e5 (i64.load offset=0x3e5 align=1 (i32.const 0))) + (local.set 0x3e6 (i64.load offset=0x3e6 align=1 (i32.const 0))) + (local.set 0x3e7 (i64.load offset=0x3e7 align=1 (i32.const 0))) + (local.set 0x3e8 (i64.load offset=0x3e8 align=1 (i32.const 0))) + (local.set 0x3e9 (i64.load offset=0x3e9 align=1 (i32.const 0))) + (local.set 0x3ea (i64.load offset=0x3ea align=1 (i32.const 0))) + (local.set 0x3eb (i64.load offset=0x3eb align=1 (i32.const 0))) + (local.set 0x3ec (i64.load offset=0x3ec align=1 (i32.const 0))) + (local.set 0x3ed (i64.load offset=0x3ed align=1 (i32.const 0))) + (local.set 0x3ee (i64.load offset=0x3ee align=1 (i32.const 0))) + (local.set 0x3ef (i64.load offset=0x3ef align=1 (i32.const 0))) + (local.set 0x3f0 (i64.load offset=0x3f0 align=1 (i32.const 0))) + (local.set 0x3f1 (i64.load offset=0x3f1 align=1 (i32.const 0))) + (local.set 0x3f2 (i64.load offset=0x3f2 align=1 (i32.const 0))) + (local.set 0x3f3 (i64.load offset=0x3f3 align=1 (i32.const 0))) + (local.set 0x3f4 (i64.load offset=0x3f4 align=1 (i32.const 0))) + (local.set 0x3f5 (i64.load offset=0x3f5 align=1 (i32.const 0))) + (local.set 0x3f6 (i64.load offset=0x3f6 align=1 (i32.const 0))) + (local.set 0x3f7 (i64.load offset=0x3f7 align=1 (i32.const 0))) + (local.set 0x3f8 (i64.load offset=0x3f8 align=1 (i32.const 0))) + (local.set 0x3f9 (i64.load offset=0x3f9 align=1 (i32.const 0))) + (local.set 0x3fa (i64.load offset=0x3fa align=1 (i32.const 0))) + (local.set 0x3fb (i64.load offset=0x3fb align=1 (i32.const 0))) + (local.set 0x3fc (i64.load offset=0x3fc align=1 (i32.const 0))) + (local.set 0x3fd (i64.load offset=0x3fd align=1 (i32.const 0))) + (local.set 0x3fe (i64.load offset=0x3fe align=1 (i32.const 0))) + (local.set 0x3ff (i64.load offset=0x3ff align=1 (i32.const 0))) + (local.set 0x400 (i64.load offset=0x400 align=1 (i32.const 0))) + (local.set 0x401 (i64.load offset=0x401 align=1 (i32.const 0))) + (local.set 0x402 (i64.load offset=0x402 align=1 (i32.const 0))) + (local.set 0x403 (i64.load offset=0x403 align=1 (i32.const 0))) + (local.set 0x404 (i64.load offset=0x404 align=1 (i32.const 0))) + (local.set 0x405 (i64.load offset=0x405 align=1 (i32.const 0))) + (local.set 0x406 (i64.load offset=0x406 align=1 (i32.const 0))) + (local.set 0x407 (i64.load offset=0x407 align=1 (i32.const 0))) + (local.set 0x408 (i64.load offset=0x408 align=1 (i32.const 0))) + (local.set 0x409 (i64.load offset=0x409 align=1 (i32.const 0))) + (local.set 0x40a (i64.load offset=0x40a align=1 (i32.const 0))) + (local.set 0x40b (i64.load offset=0x40b align=1 (i32.const 0))) + (local.set 0x40c (i64.load offset=0x40c align=1 (i32.const 0))) + (local.set 0x40d (i64.load offset=0x40d align=1 (i32.const 0))) + (local.set 0x40e (i64.load offset=0x40e align=1 (i32.const 0))) + (local.set 0x40f (i64.load offset=0x40f align=1 (i32.const 0))) + (local.set 0x410 (i64.load offset=0x410 align=1 (i32.const 0))) + (local.set 0x411 (i64.load offset=0x411 align=1 (i32.const 0))) + (local.set 0x412 (i64.load offset=0x412 align=1 (i32.const 0))) + (local.set 0x413 (i64.load offset=0x413 align=1 (i32.const 0))) + (local.set 0x414 (i64.load offset=0x414 align=1 (i32.const 0))) + (local.set 0x415 (i64.load offset=0x415 align=1 (i32.const 0))) + (local.set 0x416 (i64.load offset=0x416 align=1 (i32.const 0))) + (local.set 0x417 (i64.load offset=0x417 align=1 (i32.const 0))) + (local.set 0x418 (i64.load offset=0x418 align=1 (i32.const 0))) + (local.set 0x419 (i64.load offset=0x419 align=1 (i32.const 0))) + (local.set 0x41a (i64.load offset=0x41a align=1 (i32.const 0))) + (local.set 0x41b (i64.load offset=0x41b align=1 (i32.const 0))) + (local.set 0x41c (i64.load offset=0x41c align=1 (i32.const 0))) + (local.set 0x41d (i64.load offset=0x41d align=1 (i32.const 0))) + (local.set 0x41e (i64.load offset=0x41e align=1 (i32.const 0))) + (local.set 0x41f (i64.load offset=0x41f align=1 (i32.const 0))) + + ;; store the locals back to memory + (i64.store offset=0x000 align=1 (i32.const 0) (local.get 0x000)) + (i64.store offset=0x001 align=1 (i32.const 0) (local.get 0x001)) + (i64.store offset=0x002 align=1 (i32.const 0) (local.get 0x002)) + (i64.store offset=0x003 align=1 (i32.const 0) (local.get 0x003)) + (i64.store offset=0x004 align=1 (i32.const 0) (local.get 0x004)) + (i64.store offset=0x005 align=1 (i32.const 0) (local.get 0x005)) + (i64.store offset=0x006 align=1 (i32.const 0) (local.get 0x006)) + (i64.store offset=0x007 align=1 (i32.const 0) (local.get 0x007)) + (i64.store offset=0x008 align=1 (i32.const 0) (local.get 0x008)) + (i64.store offset=0x009 align=1 (i32.const 0) (local.get 0x009)) + (i64.store offset=0x00a align=1 (i32.const 0) (local.get 0x00a)) + (i64.store offset=0x00b align=1 (i32.const 0) (local.get 0x00b)) + (i64.store offset=0x00c align=1 (i32.const 0) (local.get 0x00c)) + (i64.store offset=0x00d align=1 (i32.const 0) (local.get 0x00d)) + (i64.store offset=0x00e align=1 (i32.const 0) (local.get 0x00e)) + (i64.store offset=0x00f align=1 (i32.const 0) (local.get 0x00f)) + (i64.store offset=0x010 align=1 (i32.const 0) (local.get 0x010)) + (i64.store offset=0x011 align=1 (i32.const 0) (local.get 0x011)) + (i64.store offset=0x012 align=1 (i32.const 0) (local.get 0x012)) + (i64.store offset=0x013 align=1 (i32.const 0) (local.get 0x013)) + (i64.store offset=0x014 align=1 (i32.const 0) (local.get 0x014)) + (i64.store offset=0x015 align=1 (i32.const 0) (local.get 0x015)) + (i64.store offset=0x016 align=1 (i32.const 0) (local.get 0x016)) + (i64.store offset=0x017 align=1 (i32.const 0) (local.get 0x017)) + (i64.store offset=0x018 align=1 (i32.const 0) (local.get 0x018)) + (i64.store offset=0x019 align=1 (i32.const 0) (local.get 0x019)) + (i64.store offset=0x01a align=1 (i32.const 0) (local.get 0x01a)) + (i64.store offset=0x01b align=1 (i32.const 0) (local.get 0x01b)) + (i64.store offset=0x01c align=1 (i32.const 0) (local.get 0x01c)) + (i64.store offset=0x01d align=1 (i32.const 0) (local.get 0x01d)) + (i64.store offset=0x01e align=1 (i32.const 0) (local.get 0x01e)) + (i64.store offset=0x01f align=1 (i32.const 0) (local.get 0x01f)) + (i64.store offset=0x020 align=1 (i32.const 0) (local.get 0x020)) + (i64.store offset=0x021 align=1 (i32.const 0) (local.get 0x021)) + (i64.store offset=0x022 align=1 (i32.const 0) (local.get 0x022)) + (i64.store offset=0x023 align=1 (i32.const 0) (local.get 0x023)) + (i64.store offset=0x024 align=1 (i32.const 0) (local.get 0x024)) + (i64.store offset=0x025 align=1 (i32.const 0) (local.get 0x025)) + (i64.store offset=0x026 align=1 (i32.const 0) (local.get 0x026)) + (i64.store offset=0x027 align=1 (i32.const 0) (local.get 0x027)) + (i64.store offset=0x028 align=1 (i32.const 0) (local.get 0x028)) + (i64.store offset=0x029 align=1 (i32.const 0) (local.get 0x029)) + (i64.store offset=0x02a align=1 (i32.const 0) (local.get 0x02a)) + (i64.store offset=0x02b align=1 (i32.const 0) (local.get 0x02b)) + (i64.store offset=0x02c align=1 (i32.const 0) (local.get 0x02c)) + (i64.store offset=0x02d align=1 (i32.const 0) (local.get 0x02d)) + (i64.store offset=0x02e align=1 (i32.const 0) (local.get 0x02e)) + (i64.store offset=0x02f align=1 (i32.const 0) (local.get 0x02f)) + (i64.store offset=0x030 align=1 (i32.const 0) (local.get 0x030)) + (i64.store offset=0x031 align=1 (i32.const 0) (local.get 0x031)) + (i64.store offset=0x032 align=1 (i32.const 0) (local.get 0x032)) + (i64.store offset=0x033 align=1 (i32.const 0) (local.get 0x033)) + (i64.store offset=0x034 align=1 (i32.const 0) (local.get 0x034)) + (i64.store offset=0x035 align=1 (i32.const 0) (local.get 0x035)) + (i64.store offset=0x036 align=1 (i32.const 0) (local.get 0x036)) + (i64.store offset=0x037 align=1 (i32.const 0) (local.get 0x037)) + (i64.store offset=0x038 align=1 (i32.const 0) (local.get 0x038)) + (i64.store offset=0x039 align=1 (i32.const 0) (local.get 0x039)) + (i64.store offset=0x03a align=1 (i32.const 0) (local.get 0x03a)) + (i64.store offset=0x03b align=1 (i32.const 0) (local.get 0x03b)) + (i64.store offset=0x03c align=1 (i32.const 0) (local.get 0x03c)) + (i64.store offset=0x03d align=1 (i32.const 0) (local.get 0x03d)) + (i64.store offset=0x03e align=1 (i32.const 0) (local.get 0x03e)) + (i64.store offset=0x03f align=1 (i32.const 0) (local.get 0x03f)) + (i64.store offset=0x040 align=1 (i32.const 0) (local.get 0x040)) + (i64.store offset=0x041 align=1 (i32.const 0) (local.get 0x041)) + (i64.store offset=0x042 align=1 (i32.const 0) (local.get 0x042)) + (i64.store offset=0x043 align=1 (i32.const 0) (local.get 0x043)) + (i64.store offset=0x044 align=1 (i32.const 0) (local.get 0x044)) + (i64.store offset=0x045 align=1 (i32.const 0) (local.get 0x045)) + (i64.store offset=0x046 align=1 (i32.const 0) (local.get 0x046)) + (i64.store offset=0x047 align=1 (i32.const 0) (local.get 0x047)) + (i64.store offset=0x048 align=1 (i32.const 0) (local.get 0x048)) + (i64.store offset=0x049 align=1 (i32.const 0) (local.get 0x049)) + (i64.store offset=0x04a align=1 (i32.const 0) (local.get 0x04a)) + (i64.store offset=0x04b align=1 (i32.const 0) (local.get 0x04b)) + (i64.store offset=0x04c align=1 (i32.const 0) (local.get 0x04c)) + (i64.store offset=0x04d align=1 (i32.const 0) (local.get 0x04d)) + (i64.store offset=0x04e align=1 (i32.const 0) (local.get 0x04e)) + (i64.store offset=0x04f align=1 (i32.const 0) (local.get 0x04f)) + (i64.store offset=0x050 align=1 (i32.const 0) (local.get 0x050)) + (i64.store offset=0x051 align=1 (i32.const 0) (local.get 0x051)) + (i64.store offset=0x052 align=1 (i32.const 0) (local.get 0x052)) + (i64.store offset=0x053 align=1 (i32.const 0) (local.get 0x053)) + (i64.store offset=0x054 align=1 (i32.const 0) (local.get 0x054)) + (i64.store offset=0x055 align=1 (i32.const 0) (local.get 0x055)) + (i64.store offset=0x056 align=1 (i32.const 0) (local.get 0x056)) + (i64.store offset=0x057 align=1 (i32.const 0) (local.get 0x057)) + (i64.store offset=0x058 align=1 (i32.const 0) (local.get 0x058)) + (i64.store offset=0x059 align=1 (i32.const 0) (local.get 0x059)) + (i64.store offset=0x05a align=1 (i32.const 0) (local.get 0x05a)) + (i64.store offset=0x05b align=1 (i32.const 0) (local.get 0x05b)) + (i64.store offset=0x05c align=1 (i32.const 0) (local.get 0x05c)) + (i64.store offset=0x05d align=1 (i32.const 0) (local.get 0x05d)) + (i64.store offset=0x05e align=1 (i32.const 0) (local.get 0x05e)) + (i64.store offset=0x05f align=1 (i32.const 0) (local.get 0x05f)) + (i64.store offset=0x060 align=1 (i32.const 0) (local.get 0x060)) + (i64.store offset=0x061 align=1 (i32.const 0) (local.get 0x061)) + (i64.store offset=0x062 align=1 (i32.const 0) (local.get 0x062)) + (i64.store offset=0x063 align=1 (i32.const 0) (local.get 0x063)) + (i64.store offset=0x064 align=1 (i32.const 0) (local.get 0x064)) + (i64.store offset=0x065 align=1 (i32.const 0) (local.get 0x065)) + (i64.store offset=0x066 align=1 (i32.const 0) (local.get 0x066)) + (i64.store offset=0x067 align=1 (i32.const 0) (local.get 0x067)) + (i64.store offset=0x068 align=1 (i32.const 0) (local.get 0x068)) + (i64.store offset=0x069 align=1 (i32.const 0) (local.get 0x069)) + (i64.store offset=0x06a align=1 (i32.const 0) (local.get 0x06a)) + (i64.store offset=0x06b align=1 (i32.const 0) (local.get 0x06b)) + (i64.store offset=0x06c align=1 (i32.const 0) (local.get 0x06c)) + (i64.store offset=0x06d align=1 (i32.const 0) (local.get 0x06d)) + (i64.store offset=0x06e align=1 (i32.const 0) (local.get 0x06e)) + (i64.store offset=0x06f align=1 (i32.const 0) (local.get 0x06f)) + (i64.store offset=0x070 align=1 (i32.const 0) (local.get 0x070)) + (i64.store offset=0x071 align=1 (i32.const 0) (local.get 0x071)) + (i64.store offset=0x072 align=1 (i32.const 0) (local.get 0x072)) + (i64.store offset=0x073 align=1 (i32.const 0) (local.get 0x073)) + (i64.store offset=0x074 align=1 (i32.const 0) (local.get 0x074)) + (i64.store offset=0x075 align=1 (i32.const 0) (local.get 0x075)) + (i64.store offset=0x076 align=1 (i32.const 0) (local.get 0x076)) + (i64.store offset=0x077 align=1 (i32.const 0) (local.get 0x077)) + (i64.store offset=0x078 align=1 (i32.const 0) (local.get 0x078)) + (i64.store offset=0x079 align=1 (i32.const 0) (local.get 0x079)) + (i64.store offset=0x07a align=1 (i32.const 0) (local.get 0x07a)) + (i64.store offset=0x07b align=1 (i32.const 0) (local.get 0x07b)) + (i64.store offset=0x07c align=1 (i32.const 0) (local.get 0x07c)) + (i64.store offset=0x07d align=1 (i32.const 0) (local.get 0x07d)) + (i64.store offset=0x07e align=1 (i32.const 0) (local.get 0x07e)) + (i64.store offset=0x07f align=1 (i32.const 0) (local.get 0x07f)) + (i64.store offset=0x080 align=1 (i32.const 0) (local.get 0x080)) + (i64.store offset=0x081 align=1 (i32.const 0) (local.get 0x081)) + (i64.store offset=0x082 align=1 (i32.const 0) (local.get 0x082)) + (i64.store offset=0x083 align=1 (i32.const 0) (local.get 0x083)) + (i64.store offset=0x084 align=1 (i32.const 0) (local.get 0x084)) + (i64.store offset=0x085 align=1 (i32.const 0) (local.get 0x085)) + (i64.store offset=0x086 align=1 (i32.const 0) (local.get 0x086)) + (i64.store offset=0x087 align=1 (i32.const 0) (local.get 0x087)) + (i64.store offset=0x088 align=1 (i32.const 0) (local.get 0x088)) + (i64.store offset=0x089 align=1 (i32.const 0) (local.get 0x089)) + (i64.store offset=0x08a align=1 (i32.const 0) (local.get 0x08a)) + (i64.store offset=0x08b align=1 (i32.const 0) (local.get 0x08b)) + (i64.store offset=0x08c align=1 (i32.const 0) (local.get 0x08c)) + (i64.store offset=0x08d align=1 (i32.const 0) (local.get 0x08d)) + (i64.store offset=0x08e align=1 (i32.const 0) (local.get 0x08e)) + (i64.store offset=0x08f align=1 (i32.const 0) (local.get 0x08f)) + (i64.store offset=0x090 align=1 (i32.const 0) (local.get 0x090)) + (i64.store offset=0x091 align=1 (i32.const 0) (local.get 0x091)) + (i64.store offset=0x092 align=1 (i32.const 0) (local.get 0x092)) + (i64.store offset=0x093 align=1 (i32.const 0) (local.get 0x093)) + (i64.store offset=0x094 align=1 (i32.const 0) (local.get 0x094)) + (i64.store offset=0x095 align=1 (i32.const 0) (local.get 0x095)) + (i64.store offset=0x096 align=1 (i32.const 0) (local.get 0x096)) + (i64.store offset=0x097 align=1 (i32.const 0) (local.get 0x097)) + (i64.store offset=0x098 align=1 (i32.const 0) (local.get 0x098)) + (i64.store offset=0x099 align=1 (i32.const 0) (local.get 0x099)) + (i64.store offset=0x09a align=1 (i32.const 0) (local.get 0x09a)) + (i64.store offset=0x09b align=1 (i32.const 0) (local.get 0x09b)) + (i64.store offset=0x09c align=1 (i32.const 0) (local.get 0x09c)) + (i64.store offset=0x09d align=1 (i32.const 0) (local.get 0x09d)) + (i64.store offset=0x09e align=1 (i32.const 0) (local.get 0x09e)) + (i64.store offset=0x09f align=1 (i32.const 0) (local.get 0x09f)) + (i64.store offset=0x0a0 align=1 (i32.const 0) (local.get 0x0a0)) + (i64.store offset=0x0a1 align=1 (i32.const 0) (local.get 0x0a1)) + (i64.store offset=0x0a2 align=1 (i32.const 0) (local.get 0x0a2)) + (i64.store offset=0x0a3 align=1 (i32.const 0) (local.get 0x0a3)) + (i64.store offset=0x0a4 align=1 (i32.const 0) (local.get 0x0a4)) + (i64.store offset=0x0a5 align=1 (i32.const 0) (local.get 0x0a5)) + (i64.store offset=0x0a6 align=1 (i32.const 0) (local.get 0x0a6)) + (i64.store offset=0x0a7 align=1 (i32.const 0) (local.get 0x0a7)) + (i64.store offset=0x0a8 align=1 (i32.const 0) (local.get 0x0a8)) + (i64.store offset=0x0a9 align=1 (i32.const 0) (local.get 0x0a9)) + (i64.store offset=0x0aa align=1 (i32.const 0) (local.get 0x0aa)) + (i64.store offset=0x0ab align=1 (i32.const 0) (local.get 0x0ab)) + (i64.store offset=0x0ac align=1 (i32.const 0) (local.get 0x0ac)) + (i64.store offset=0x0ad align=1 (i32.const 0) (local.get 0x0ad)) + (i64.store offset=0x0ae align=1 (i32.const 0) (local.get 0x0ae)) + (i64.store offset=0x0af align=1 (i32.const 0) (local.get 0x0af)) + (i64.store offset=0x0b0 align=1 (i32.const 0) (local.get 0x0b0)) + (i64.store offset=0x0b1 align=1 (i32.const 0) (local.get 0x0b1)) + (i64.store offset=0x0b2 align=1 (i32.const 0) (local.get 0x0b2)) + (i64.store offset=0x0b3 align=1 (i32.const 0) (local.get 0x0b3)) + (i64.store offset=0x0b4 align=1 (i32.const 0) (local.get 0x0b4)) + (i64.store offset=0x0b5 align=1 (i32.const 0) (local.get 0x0b5)) + (i64.store offset=0x0b6 align=1 (i32.const 0) (local.get 0x0b6)) + (i64.store offset=0x0b7 align=1 (i32.const 0) (local.get 0x0b7)) + (i64.store offset=0x0b8 align=1 (i32.const 0) (local.get 0x0b8)) + (i64.store offset=0x0b9 align=1 (i32.const 0) (local.get 0x0b9)) + (i64.store offset=0x0ba align=1 (i32.const 0) (local.get 0x0ba)) + (i64.store offset=0x0bb align=1 (i32.const 0) (local.get 0x0bb)) + (i64.store offset=0x0bc align=1 (i32.const 0) (local.get 0x0bc)) + (i64.store offset=0x0bd align=1 (i32.const 0) (local.get 0x0bd)) + (i64.store offset=0x0be align=1 (i32.const 0) (local.get 0x0be)) + (i64.store offset=0x0bf align=1 (i32.const 0) (local.get 0x0bf)) + (i64.store offset=0x0c0 align=1 (i32.const 0) (local.get 0x0c0)) + (i64.store offset=0x0c1 align=1 (i32.const 0) (local.get 0x0c1)) + (i64.store offset=0x0c2 align=1 (i32.const 0) (local.get 0x0c2)) + (i64.store offset=0x0c3 align=1 (i32.const 0) (local.get 0x0c3)) + (i64.store offset=0x0c4 align=1 (i32.const 0) (local.get 0x0c4)) + (i64.store offset=0x0c5 align=1 (i32.const 0) (local.get 0x0c5)) + (i64.store offset=0x0c6 align=1 (i32.const 0) (local.get 0x0c6)) + (i64.store offset=0x0c7 align=1 (i32.const 0) (local.get 0x0c7)) + (i64.store offset=0x0c8 align=1 (i32.const 0) (local.get 0x0c8)) + (i64.store offset=0x0c9 align=1 (i32.const 0) (local.get 0x0c9)) + (i64.store offset=0x0ca align=1 (i32.const 0) (local.get 0x0ca)) + (i64.store offset=0x0cb align=1 (i32.const 0) (local.get 0x0cb)) + (i64.store offset=0x0cc align=1 (i32.const 0) (local.get 0x0cc)) + (i64.store offset=0x0cd align=1 (i32.const 0) (local.get 0x0cd)) + (i64.store offset=0x0ce align=1 (i32.const 0) (local.get 0x0ce)) + (i64.store offset=0x0cf align=1 (i32.const 0) (local.get 0x0cf)) + (i64.store offset=0x0d0 align=1 (i32.const 0) (local.get 0x0d0)) + (i64.store offset=0x0d1 align=1 (i32.const 0) (local.get 0x0d1)) + (i64.store offset=0x0d2 align=1 (i32.const 0) (local.get 0x0d2)) + (i64.store offset=0x0d3 align=1 (i32.const 0) (local.get 0x0d3)) + (i64.store offset=0x0d4 align=1 (i32.const 0) (local.get 0x0d4)) + (i64.store offset=0x0d5 align=1 (i32.const 0) (local.get 0x0d5)) + (i64.store offset=0x0d6 align=1 (i32.const 0) (local.get 0x0d6)) + (i64.store offset=0x0d7 align=1 (i32.const 0) (local.get 0x0d7)) + (i64.store offset=0x0d8 align=1 (i32.const 0) (local.get 0x0d8)) + (i64.store offset=0x0d9 align=1 (i32.const 0) (local.get 0x0d9)) + (i64.store offset=0x0da align=1 (i32.const 0) (local.get 0x0da)) + (i64.store offset=0x0db align=1 (i32.const 0) (local.get 0x0db)) + (i64.store offset=0x0dc align=1 (i32.const 0) (local.get 0x0dc)) + (i64.store offset=0x0dd align=1 (i32.const 0) (local.get 0x0dd)) + (i64.store offset=0x0de align=1 (i32.const 0) (local.get 0x0de)) + (i64.store offset=0x0df align=1 (i32.const 0) (local.get 0x0df)) + (i64.store offset=0x0e0 align=1 (i32.const 0) (local.get 0x0e0)) + (i64.store offset=0x0e1 align=1 (i32.const 0) (local.get 0x0e1)) + (i64.store offset=0x0e2 align=1 (i32.const 0) (local.get 0x0e2)) + (i64.store offset=0x0e3 align=1 (i32.const 0) (local.get 0x0e3)) + (i64.store offset=0x0e4 align=1 (i32.const 0) (local.get 0x0e4)) + (i64.store offset=0x0e5 align=1 (i32.const 0) (local.get 0x0e5)) + (i64.store offset=0x0e6 align=1 (i32.const 0) (local.get 0x0e6)) + (i64.store offset=0x0e7 align=1 (i32.const 0) (local.get 0x0e7)) + (i64.store offset=0x0e8 align=1 (i32.const 0) (local.get 0x0e8)) + (i64.store offset=0x0e9 align=1 (i32.const 0) (local.get 0x0e9)) + (i64.store offset=0x0ea align=1 (i32.const 0) (local.get 0x0ea)) + (i64.store offset=0x0eb align=1 (i32.const 0) (local.get 0x0eb)) + (i64.store offset=0x0ec align=1 (i32.const 0) (local.get 0x0ec)) + (i64.store offset=0x0ed align=1 (i32.const 0) (local.get 0x0ed)) + (i64.store offset=0x0ee align=1 (i32.const 0) (local.get 0x0ee)) + (i64.store offset=0x0ef align=1 (i32.const 0) (local.get 0x0ef)) + (i64.store offset=0x0f0 align=1 (i32.const 0) (local.get 0x0f0)) + (i64.store offset=0x0f1 align=1 (i32.const 0) (local.get 0x0f1)) + (i64.store offset=0x0f2 align=1 (i32.const 0) (local.get 0x0f2)) + (i64.store offset=0x0f3 align=1 (i32.const 0) (local.get 0x0f3)) + (i64.store offset=0x0f4 align=1 (i32.const 0) (local.get 0x0f4)) + (i64.store offset=0x0f5 align=1 (i32.const 0) (local.get 0x0f5)) + (i64.store offset=0x0f6 align=1 (i32.const 0) (local.get 0x0f6)) + (i64.store offset=0x0f7 align=1 (i32.const 0) (local.get 0x0f7)) + (i64.store offset=0x0f8 align=1 (i32.const 0) (local.get 0x0f8)) + (i64.store offset=0x0f9 align=1 (i32.const 0) (local.get 0x0f9)) + (i64.store offset=0x0fa align=1 (i32.const 0) (local.get 0x0fa)) + (i64.store offset=0x0fb align=1 (i32.const 0) (local.get 0x0fb)) + (i64.store offset=0x0fc align=1 (i32.const 0) (local.get 0x0fc)) + (i64.store offset=0x0fd align=1 (i32.const 0) (local.get 0x0fd)) + (i64.store offset=0x0fe align=1 (i32.const 0) (local.get 0x0fe)) + (i64.store offset=0x0ff align=1 (i32.const 0) (local.get 0x0ff)) + (i64.store offset=0x100 align=1 (i32.const 0) (local.get 0x100)) + (i64.store offset=0x101 align=1 (i32.const 0) (local.get 0x101)) + (i64.store offset=0x102 align=1 (i32.const 0) (local.get 0x102)) + (i64.store offset=0x103 align=1 (i32.const 0) (local.get 0x103)) + (i64.store offset=0x104 align=1 (i32.const 0) (local.get 0x104)) + (i64.store offset=0x105 align=1 (i32.const 0) (local.get 0x105)) + (i64.store offset=0x106 align=1 (i32.const 0) (local.get 0x106)) + (i64.store offset=0x107 align=1 (i32.const 0) (local.get 0x107)) + (i64.store offset=0x108 align=1 (i32.const 0) (local.get 0x108)) + (i64.store offset=0x109 align=1 (i32.const 0) (local.get 0x109)) + (i64.store offset=0x10a align=1 (i32.const 0) (local.get 0x10a)) + (i64.store offset=0x10b align=1 (i32.const 0) (local.get 0x10b)) + (i64.store offset=0x10c align=1 (i32.const 0) (local.get 0x10c)) + (i64.store offset=0x10d align=1 (i32.const 0) (local.get 0x10d)) + (i64.store offset=0x10e align=1 (i32.const 0) (local.get 0x10e)) + (i64.store offset=0x10f align=1 (i32.const 0) (local.get 0x10f)) + (i64.store offset=0x110 align=1 (i32.const 0) (local.get 0x110)) + (i64.store offset=0x111 align=1 (i32.const 0) (local.get 0x111)) + (i64.store offset=0x112 align=1 (i32.const 0) (local.get 0x112)) + (i64.store offset=0x113 align=1 (i32.const 0) (local.get 0x113)) + (i64.store offset=0x114 align=1 (i32.const 0) (local.get 0x114)) + (i64.store offset=0x115 align=1 (i32.const 0) (local.get 0x115)) + (i64.store offset=0x116 align=1 (i32.const 0) (local.get 0x116)) + (i64.store offset=0x117 align=1 (i32.const 0) (local.get 0x117)) + (i64.store offset=0x118 align=1 (i32.const 0) (local.get 0x118)) + (i64.store offset=0x119 align=1 (i32.const 0) (local.get 0x119)) + (i64.store offset=0x11a align=1 (i32.const 0) (local.get 0x11a)) + (i64.store offset=0x11b align=1 (i32.const 0) (local.get 0x11b)) + (i64.store offset=0x11c align=1 (i32.const 0) (local.get 0x11c)) + (i64.store offset=0x11d align=1 (i32.const 0) (local.get 0x11d)) + (i64.store offset=0x11e align=1 (i32.const 0) (local.get 0x11e)) + (i64.store offset=0x11f align=1 (i32.const 0) (local.get 0x11f)) + (i64.store offset=0x120 align=1 (i32.const 0) (local.get 0x120)) + (i64.store offset=0x121 align=1 (i32.const 0) (local.get 0x121)) + (i64.store offset=0x122 align=1 (i32.const 0) (local.get 0x122)) + (i64.store offset=0x123 align=1 (i32.const 0) (local.get 0x123)) + (i64.store offset=0x124 align=1 (i32.const 0) (local.get 0x124)) + (i64.store offset=0x125 align=1 (i32.const 0) (local.get 0x125)) + (i64.store offset=0x126 align=1 (i32.const 0) (local.get 0x126)) + (i64.store offset=0x127 align=1 (i32.const 0) (local.get 0x127)) + (i64.store offset=0x128 align=1 (i32.const 0) (local.get 0x128)) + (i64.store offset=0x129 align=1 (i32.const 0) (local.get 0x129)) + (i64.store offset=0x12a align=1 (i32.const 0) (local.get 0x12a)) + (i64.store offset=0x12b align=1 (i32.const 0) (local.get 0x12b)) + (i64.store offset=0x12c align=1 (i32.const 0) (local.get 0x12c)) + (i64.store offset=0x12d align=1 (i32.const 0) (local.get 0x12d)) + (i64.store offset=0x12e align=1 (i32.const 0) (local.get 0x12e)) + (i64.store offset=0x12f align=1 (i32.const 0) (local.get 0x12f)) + (i64.store offset=0x130 align=1 (i32.const 0) (local.get 0x130)) + (i64.store offset=0x131 align=1 (i32.const 0) (local.get 0x131)) + (i64.store offset=0x132 align=1 (i32.const 0) (local.get 0x132)) + (i64.store offset=0x133 align=1 (i32.const 0) (local.get 0x133)) + (i64.store offset=0x134 align=1 (i32.const 0) (local.get 0x134)) + (i64.store offset=0x135 align=1 (i32.const 0) (local.get 0x135)) + (i64.store offset=0x136 align=1 (i32.const 0) (local.get 0x136)) + (i64.store offset=0x137 align=1 (i32.const 0) (local.get 0x137)) + (i64.store offset=0x138 align=1 (i32.const 0) (local.get 0x138)) + (i64.store offset=0x139 align=1 (i32.const 0) (local.get 0x139)) + (i64.store offset=0x13a align=1 (i32.const 0) (local.get 0x13a)) + (i64.store offset=0x13b align=1 (i32.const 0) (local.get 0x13b)) + (i64.store offset=0x13c align=1 (i32.const 0) (local.get 0x13c)) + (i64.store offset=0x13d align=1 (i32.const 0) (local.get 0x13d)) + (i64.store offset=0x13e align=1 (i32.const 0) (local.get 0x13e)) + (i64.store offset=0x13f align=1 (i32.const 0) (local.get 0x13f)) + (i64.store offset=0x140 align=1 (i32.const 0) (local.get 0x140)) + (i64.store offset=0x141 align=1 (i32.const 0) (local.get 0x141)) + (i64.store offset=0x142 align=1 (i32.const 0) (local.get 0x142)) + (i64.store offset=0x143 align=1 (i32.const 0) (local.get 0x143)) + (i64.store offset=0x144 align=1 (i32.const 0) (local.get 0x144)) + (i64.store offset=0x145 align=1 (i32.const 0) (local.get 0x145)) + (i64.store offset=0x146 align=1 (i32.const 0) (local.get 0x146)) + (i64.store offset=0x147 align=1 (i32.const 0) (local.get 0x147)) + (i64.store offset=0x148 align=1 (i32.const 0) (local.get 0x148)) + (i64.store offset=0x149 align=1 (i32.const 0) (local.get 0x149)) + (i64.store offset=0x14a align=1 (i32.const 0) (local.get 0x14a)) + (i64.store offset=0x14b align=1 (i32.const 0) (local.get 0x14b)) + (i64.store offset=0x14c align=1 (i32.const 0) (local.get 0x14c)) + (i64.store offset=0x14d align=1 (i32.const 0) (local.get 0x14d)) + (i64.store offset=0x14e align=1 (i32.const 0) (local.get 0x14e)) + (i64.store offset=0x14f align=1 (i32.const 0) (local.get 0x14f)) + (i64.store offset=0x150 align=1 (i32.const 0) (local.get 0x150)) + (i64.store offset=0x151 align=1 (i32.const 0) (local.get 0x151)) + (i64.store offset=0x152 align=1 (i32.const 0) (local.get 0x152)) + (i64.store offset=0x153 align=1 (i32.const 0) (local.get 0x153)) + (i64.store offset=0x154 align=1 (i32.const 0) (local.get 0x154)) + (i64.store offset=0x155 align=1 (i32.const 0) (local.get 0x155)) + (i64.store offset=0x156 align=1 (i32.const 0) (local.get 0x156)) + (i64.store offset=0x157 align=1 (i32.const 0) (local.get 0x157)) + (i64.store offset=0x158 align=1 (i32.const 0) (local.get 0x158)) + (i64.store offset=0x159 align=1 (i32.const 0) (local.get 0x159)) + (i64.store offset=0x15a align=1 (i32.const 0) (local.get 0x15a)) + (i64.store offset=0x15b align=1 (i32.const 0) (local.get 0x15b)) + (i64.store offset=0x15c align=1 (i32.const 0) (local.get 0x15c)) + (i64.store offset=0x15d align=1 (i32.const 0) (local.get 0x15d)) + (i64.store offset=0x15e align=1 (i32.const 0) (local.get 0x15e)) + (i64.store offset=0x15f align=1 (i32.const 0) (local.get 0x15f)) + (i64.store offset=0x160 align=1 (i32.const 0) (local.get 0x160)) + (i64.store offset=0x161 align=1 (i32.const 0) (local.get 0x161)) + (i64.store offset=0x162 align=1 (i32.const 0) (local.get 0x162)) + (i64.store offset=0x163 align=1 (i32.const 0) (local.get 0x163)) + (i64.store offset=0x164 align=1 (i32.const 0) (local.get 0x164)) + (i64.store offset=0x165 align=1 (i32.const 0) (local.get 0x165)) + (i64.store offset=0x166 align=1 (i32.const 0) (local.get 0x166)) + (i64.store offset=0x167 align=1 (i32.const 0) (local.get 0x167)) + (i64.store offset=0x168 align=1 (i32.const 0) (local.get 0x168)) + (i64.store offset=0x169 align=1 (i32.const 0) (local.get 0x169)) + (i64.store offset=0x16a align=1 (i32.const 0) (local.get 0x16a)) + (i64.store offset=0x16b align=1 (i32.const 0) (local.get 0x16b)) + (i64.store offset=0x16c align=1 (i32.const 0) (local.get 0x16c)) + (i64.store offset=0x16d align=1 (i32.const 0) (local.get 0x16d)) + (i64.store offset=0x16e align=1 (i32.const 0) (local.get 0x16e)) + (i64.store offset=0x16f align=1 (i32.const 0) (local.get 0x16f)) + (i64.store offset=0x170 align=1 (i32.const 0) (local.get 0x170)) + (i64.store offset=0x171 align=1 (i32.const 0) (local.get 0x171)) + (i64.store offset=0x172 align=1 (i32.const 0) (local.get 0x172)) + (i64.store offset=0x173 align=1 (i32.const 0) (local.get 0x173)) + (i64.store offset=0x174 align=1 (i32.const 0) (local.get 0x174)) + (i64.store offset=0x175 align=1 (i32.const 0) (local.get 0x175)) + (i64.store offset=0x176 align=1 (i32.const 0) (local.get 0x176)) + (i64.store offset=0x177 align=1 (i32.const 0) (local.get 0x177)) + (i64.store offset=0x178 align=1 (i32.const 0) (local.get 0x178)) + (i64.store offset=0x179 align=1 (i32.const 0) (local.get 0x179)) + (i64.store offset=0x17a align=1 (i32.const 0) (local.get 0x17a)) + (i64.store offset=0x17b align=1 (i32.const 0) (local.get 0x17b)) + (i64.store offset=0x17c align=1 (i32.const 0) (local.get 0x17c)) + (i64.store offset=0x17d align=1 (i32.const 0) (local.get 0x17d)) + (i64.store offset=0x17e align=1 (i32.const 0) (local.get 0x17e)) + (i64.store offset=0x17f align=1 (i32.const 0) (local.get 0x17f)) + (i64.store offset=0x180 align=1 (i32.const 0) (local.get 0x180)) + (i64.store offset=0x181 align=1 (i32.const 0) (local.get 0x181)) + (i64.store offset=0x182 align=1 (i32.const 0) (local.get 0x182)) + (i64.store offset=0x183 align=1 (i32.const 0) (local.get 0x183)) + (i64.store offset=0x184 align=1 (i32.const 0) (local.get 0x184)) + (i64.store offset=0x185 align=1 (i32.const 0) (local.get 0x185)) + (i64.store offset=0x186 align=1 (i32.const 0) (local.get 0x186)) + (i64.store offset=0x187 align=1 (i32.const 0) (local.get 0x187)) + (i64.store offset=0x188 align=1 (i32.const 0) (local.get 0x188)) + (i64.store offset=0x189 align=1 (i32.const 0) (local.get 0x189)) + (i64.store offset=0x18a align=1 (i32.const 0) (local.get 0x18a)) + (i64.store offset=0x18b align=1 (i32.const 0) (local.get 0x18b)) + (i64.store offset=0x18c align=1 (i32.const 0) (local.get 0x18c)) + (i64.store offset=0x18d align=1 (i32.const 0) (local.get 0x18d)) + (i64.store offset=0x18e align=1 (i32.const 0) (local.get 0x18e)) + (i64.store offset=0x18f align=1 (i32.const 0) (local.get 0x18f)) + (i64.store offset=0x190 align=1 (i32.const 0) (local.get 0x190)) + (i64.store offset=0x191 align=1 (i32.const 0) (local.get 0x191)) + (i64.store offset=0x192 align=1 (i32.const 0) (local.get 0x192)) + (i64.store offset=0x193 align=1 (i32.const 0) (local.get 0x193)) + (i64.store offset=0x194 align=1 (i32.const 0) (local.get 0x194)) + (i64.store offset=0x195 align=1 (i32.const 0) (local.get 0x195)) + (i64.store offset=0x196 align=1 (i32.const 0) (local.get 0x196)) + (i64.store offset=0x197 align=1 (i32.const 0) (local.get 0x197)) + (i64.store offset=0x198 align=1 (i32.const 0) (local.get 0x198)) + (i64.store offset=0x199 align=1 (i32.const 0) (local.get 0x199)) + (i64.store offset=0x19a align=1 (i32.const 0) (local.get 0x19a)) + (i64.store offset=0x19b align=1 (i32.const 0) (local.get 0x19b)) + (i64.store offset=0x19c align=1 (i32.const 0) (local.get 0x19c)) + (i64.store offset=0x19d align=1 (i32.const 0) (local.get 0x19d)) + (i64.store offset=0x19e align=1 (i32.const 0) (local.get 0x19e)) + (i64.store offset=0x19f align=1 (i32.const 0) (local.get 0x19f)) + (i64.store offset=0x1a0 align=1 (i32.const 0) (local.get 0x1a0)) + (i64.store offset=0x1a1 align=1 (i32.const 0) (local.get 0x1a1)) + (i64.store offset=0x1a2 align=1 (i32.const 0) (local.get 0x1a2)) + (i64.store offset=0x1a3 align=1 (i32.const 0) (local.get 0x1a3)) + (i64.store offset=0x1a4 align=1 (i32.const 0) (local.get 0x1a4)) + (i64.store offset=0x1a5 align=1 (i32.const 0) (local.get 0x1a5)) + (i64.store offset=0x1a6 align=1 (i32.const 0) (local.get 0x1a6)) + (i64.store offset=0x1a7 align=1 (i32.const 0) (local.get 0x1a7)) + (i64.store offset=0x1a8 align=1 (i32.const 0) (local.get 0x1a8)) + (i64.store offset=0x1a9 align=1 (i32.const 0) (local.get 0x1a9)) + (i64.store offset=0x1aa align=1 (i32.const 0) (local.get 0x1aa)) + (i64.store offset=0x1ab align=1 (i32.const 0) (local.get 0x1ab)) + (i64.store offset=0x1ac align=1 (i32.const 0) (local.get 0x1ac)) + (i64.store offset=0x1ad align=1 (i32.const 0) (local.get 0x1ad)) + (i64.store offset=0x1ae align=1 (i32.const 0) (local.get 0x1ae)) + (i64.store offset=0x1af align=1 (i32.const 0) (local.get 0x1af)) + (i64.store offset=0x1b0 align=1 (i32.const 0) (local.get 0x1b0)) + (i64.store offset=0x1b1 align=1 (i32.const 0) (local.get 0x1b1)) + (i64.store offset=0x1b2 align=1 (i32.const 0) (local.get 0x1b2)) + (i64.store offset=0x1b3 align=1 (i32.const 0) (local.get 0x1b3)) + (i64.store offset=0x1b4 align=1 (i32.const 0) (local.get 0x1b4)) + (i64.store offset=0x1b5 align=1 (i32.const 0) (local.get 0x1b5)) + (i64.store offset=0x1b6 align=1 (i32.const 0) (local.get 0x1b6)) + (i64.store offset=0x1b7 align=1 (i32.const 0) (local.get 0x1b7)) + (i64.store offset=0x1b8 align=1 (i32.const 0) (local.get 0x1b8)) + (i64.store offset=0x1b9 align=1 (i32.const 0) (local.get 0x1b9)) + (i64.store offset=0x1ba align=1 (i32.const 0) (local.get 0x1ba)) + (i64.store offset=0x1bb align=1 (i32.const 0) (local.get 0x1bb)) + (i64.store offset=0x1bc align=1 (i32.const 0) (local.get 0x1bc)) + (i64.store offset=0x1bd align=1 (i32.const 0) (local.get 0x1bd)) + (i64.store offset=0x1be align=1 (i32.const 0) (local.get 0x1be)) + (i64.store offset=0x1bf align=1 (i32.const 0) (local.get 0x1bf)) + (i64.store offset=0x1c0 align=1 (i32.const 0) (local.get 0x1c0)) + (i64.store offset=0x1c1 align=1 (i32.const 0) (local.get 0x1c1)) + (i64.store offset=0x1c2 align=1 (i32.const 0) (local.get 0x1c2)) + (i64.store offset=0x1c3 align=1 (i32.const 0) (local.get 0x1c3)) + (i64.store offset=0x1c4 align=1 (i32.const 0) (local.get 0x1c4)) + (i64.store offset=0x1c5 align=1 (i32.const 0) (local.get 0x1c5)) + (i64.store offset=0x1c6 align=1 (i32.const 0) (local.get 0x1c6)) + (i64.store offset=0x1c7 align=1 (i32.const 0) (local.get 0x1c7)) + (i64.store offset=0x1c8 align=1 (i32.const 0) (local.get 0x1c8)) + (i64.store offset=0x1c9 align=1 (i32.const 0) (local.get 0x1c9)) + (i64.store offset=0x1ca align=1 (i32.const 0) (local.get 0x1ca)) + (i64.store offset=0x1cb align=1 (i32.const 0) (local.get 0x1cb)) + (i64.store offset=0x1cc align=1 (i32.const 0) (local.get 0x1cc)) + (i64.store offset=0x1cd align=1 (i32.const 0) (local.get 0x1cd)) + (i64.store offset=0x1ce align=1 (i32.const 0) (local.get 0x1ce)) + (i64.store offset=0x1cf align=1 (i32.const 0) (local.get 0x1cf)) + (i64.store offset=0x1d0 align=1 (i32.const 0) (local.get 0x1d0)) + (i64.store offset=0x1d1 align=1 (i32.const 0) (local.get 0x1d1)) + (i64.store offset=0x1d2 align=1 (i32.const 0) (local.get 0x1d2)) + (i64.store offset=0x1d3 align=1 (i32.const 0) (local.get 0x1d3)) + (i64.store offset=0x1d4 align=1 (i32.const 0) (local.get 0x1d4)) + (i64.store offset=0x1d5 align=1 (i32.const 0) (local.get 0x1d5)) + (i64.store offset=0x1d6 align=1 (i32.const 0) (local.get 0x1d6)) + (i64.store offset=0x1d7 align=1 (i32.const 0) (local.get 0x1d7)) + (i64.store offset=0x1d8 align=1 (i32.const 0) (local.get 0x1d8)) + (i64.store offset=0x1d9 align=1 (i32.const 0) (local.get 0x1d9)) + (i64.store offset=0x1da align=1 (i32.const 0) (local.get 0x1da)) + (i64.store offset=0x1db align=1 (i32.const 0) (local.get 0x1db)) + (i64.store offset=0x1dc align=1 (i32.const 0) (local.get 0x1dc)) + (i64.store offset=0x1dd align=1 (i32.const 0) (local.get 0x1dd)) + (i64.store offset=0x1de align=1 (i32.const 0) (local.get 0x1de)) + (i64.store offset=0x1df align=1 (i32.const 0) (local.get 0x1df)) + (i64.store offset=0x1e0 align=1 (i32.const 0) (local.get 0x1e0)) + (i64.store offset=0x1e1 align=1 (i32.const 0) (local.get 0x1e1)) + (i64.store offset=0x1e2 align=1 (i32.const 0) (local.get 0x1e2)) + (i64.store offset=0x1e3 align=1 (i32.const 0) (local.get 0x1e3)) + (i64.store offset=0x1e4 align=1 (i32.const 0) (local.get 0x1e4)) + (i64.store offset=0x1e5 align=1 (i32.const 0) (local.get 0x1e5)) + (i64.store offset=0x1e6 align=1 (i32.const 0) (local.get 0x1e6)) + (i64.store offset=0x1e7 align=1 (i32.const 0) (local.get 0x1e7)) + (i64.store offset=0x1e8 align=1 (i32.const 0) (local.get 0x1e8)) + (i64.store offset=0x1e9 align=1 (i32.const 0) (local.get 0x1e9)) + (i64.store offset=0x1ea align=1 (i32.const 0) (local.get 0x1ea)) + (i64.store offset=0x1eb align=1 (i32.const 0) (local.get 0x1eb)) + (i64.store offset=0x1ec align=1 (i32.const 0) (local.get 0x1ec)) + (i64.store offset=0x1ed align=1 (i32.const 0) (local.get 0x1ed)) + (i64.store offset=0x1ee align=1 (i32.const 0) (local.get 0x1ee)) + (i64.store offset=0x1ef align=1 (i32.const 0) (local.get 0x1ef)) + (i64.store offset=0x1f0 align=1 (i32.const 0) (local.get 0x1f0)) + (i64.store offset=0x1f1 align=1 (i32.const 0) (local.get 0x1f1)) + (i64.store offset=0x1f2 align=1 (i32.const 0) (local.get 0x1f2)) + (i64.store offset=0x1f3 align=1 (i32.const 0) (local.get 0x1f3)) + (i64.store offset=0x1f4 align=1 (i32.const 0) (local.get 0x1f4)) + (i64.store offset=0x1f5 align=1 (i32.const 0) (local.get 0x1f5)) + (i64.store offset=0x1f6 align=1 (i32.const 0) (local.get 0x1f6)) + (i64.store offset=0x1f7 align=1 (i32.const 0) (local.get 0x1f7)) + (i64.store offset=0x1f8 align=1 (i32.const 0) (local.get 0x1f8)) + (i64.store offset=0x1f9 align=1 (i32.const 0) (local.get 0x1f9)) + (i64.store offset=0x1fa align=1 (i32.const 0) (local.get 0x1fa)) + (i64.store offset=0x1fb align=1 (i32.const 0) (local.get 0x1fb)) + (i64.store offset=0x1fc align=1 (i32.const 0) (local.get 0x1fc)) + (i64.store offset=0x1fd align=1 (i32.const 0) (local.get 0x1fd)) + (i64.store offset=0x1fe align=1 (i32.const 0) (local.get 0x1fe)) + (i64.store offset=0x1ff align=1 (i32.const 0) (local.get 0x1ff)) + (i64.store offset=0x200 align=1 (i32.const 0) (local.get 0x200)) + (i64.store offset=0x201 align=1 (i32.const 0) (local.get 0x201)) + (i64.store offset=0x202 align=1 (i32.const 0) (local.get 0x202)) + (i64.store offset=0x203 align=1 (i32.const 0) (local.get 0x203)) + (i64.store offset=0x204 align=1 (i32.const 0) (local.get 0x204)) + (i64.store offset=0x205 align=1 (i32.const 0) (local.get 0x205)) + (i64.store offset=0x206 align=1 (i32.const 0) (local.get 0x206)) + (i64.store offset=0x207 align=1 (i32.const 0) (local.get 0x207)) + (i64.store offset=0x208 align=1 (i32.const 0) (local.get 0x208)) + (i64.store offset=0x209 align=1 (i32.const 0) (local.get 0x209)) + (i64.store offset=0x20a align=1 (i32.const 0) (local.get 0x20a)) + (i64.store offset=0x20b align=1 (i32.const 0) (local.get 0x20b)) + (i64.store offset=0x20c align=1 (i32.const 0) (local.get 0x20c)) + (i64.store offset=0x20d align=1 (i32.const 0) (local.get 0x20d)) + (i64.store offset=0x20e align=1 (i32.const 0) (local.get 0x20e)) + (i64.store offset=0x20f align=1 (i32.const 0) (local.get 0x20f)) + (i64.store offset=0x210 align=1 (i32.const 0) (local.get 0x210)) + (i64.store offset=0x211 align=1 (i32.const 0) (local.get 0x211)) + (i64.store offset=0x212 align=1 (i32.const 0) (local.get 0x212)) + (i64.store offset=0x213 align=1 (i32.const 0) (local.get 0x213)) + (i64.store offset=0x214 align=1 (i32.const 0) (local.get 0x214)) + (i64.store offset=0x215 align=1 (i32.const 0) (local.get 0x215)) + (i64.store offset=0x216 align=1 (i32.const 0) (local.get 0x216)) + (i64.store offset=0x217 align=1 (i32.const 0) (local.get 0x217)) + (i64.store offset=0x218 align=1 (i32.const 0) (local.get 0x218)) + (i64.store offset=0x219 align=1 (i32.const 0) (local.get 0x219)) + (i64.store offset=0x21a align=1 (i32.const 0) (local.get 0x21a)) + (i64.store offset=0x21b align=1 (i32.const 0) (local.get 0x21b)) + (i64.store offset=0x21c align=1 (i32.const 0) (local.get 0x21c)) + (i64.store offset=0x21d align=1 (i32.const 0) (local.get 0x21d)) + (i64.store offset=0x21e align=1 (i32.const 0) (local.get 0x21e)) + (i64.store offset=0x21f align=1 (i32.const 0) (local.get 0x21f)) + (i64.store offset=0x220 align=1 (i32.const 0) (local.get 0x220)) + (i64.store offset=0x221 align=1 (i32.const 0) (local.get 0x221)) + (i64.store offset=0x222 align=1 (i32.const 0) (local.get 0x222)) + (i64.store offset=0x223 align=1 (i32.const 0) (local.get 0x223)) + (i64.store offset=0x224 align=1 (i32.const 0) (local.get 0x224)) + (i64.store offset=0x225 align=1 (i32.const 0) (local.get 0x225)) + (i64.store offset=0x226 align=1 (i32.const 0) (local.get 0x226)) + (i64.store offset=0x227 align=1 (i32.const 0) (local.get 0x227)) + (i64.store offset=0x228 align=1 (i32.const 0) (local.get 0x228)) + (i64.store offset=0x229 align=1 (i32.const 0) (local.get 0x229)) + (i64.store offset=0x22a align=1 (i32.const 0) (local.get 0x22a)) + (i64.store offset=0x22b align=1 (i32.const 0) (local.get 0x22b)) + (i64.store offset=0x22c align=1 (i32.const 0) (local.get 0x22c)) + (i64.store offset=0x22d align=1 (i32.const 0) (local.get 0x22d)) + (i64.store offset=0x22e align=1 (i32.const 0) (local.get 0x22e)) + (i64.store offset=0x22f align=1 (i32.const 0) (local.get 0x22f)) + (i64.store offset=0x230 align=1 (i32.const 0) (local.get 0x230)) + (i64.store offset=0x231 align=1 (i32.const 0) (local.get 0x231)) + (i64.store offset=0x232 align=1 (i32.const 0) (local.get 0x232)) + (i64.store offset=0x233 align=1 (i32.const 0) (local.get 0x233)) + (i64.store offset=0x234 align=1 (i32.const 0) (local.get 0x234)) + (i64.store offset=0x235 align=1 (i32.const 0) (local.get 0x235)) + (i64.store offset=0x236 align=1 (i32.const 0) (local.get 0x236)) + (i64.store offset=0x237 align=1 (i32.const 0) (local.get 0x237)) + (i64.store offset=0x238 align=1 (i32.const 0) (local.get 0x238)) + (i64.store offset=0x239 align=1 (i32.const 0) (local.get 0x239)) + (i64.store offset=0x23a align=1 (i32.const 0) (local.get 0x23a)) + (i64.store offset=0x23b align=1 (i32.const 0) (local.get 0x23b)) + (i64.store offset=0x23c align=1 (i32.const 0) (local.get 0x23c)) + (i64.store offset=0x23d align=1 (i32.const 0) (local.get 0x23d)) + (i64.store offset=0x23e align=1 (i32.const 0) (local.get 0x23e)) + (i64.store offset=0x23f align=1 (i32.const 0) (local.get 0x23f)) + (i64.store offset=0x240 align=1 (i32.const 0) (local.get 0x240)) + (i64.store offset=0x241 align=1 (i32.const 0) (local.get 0x241)) + (i64.store offset=0x242 align=1 (i32.const 0) (local.get 0x242)) + (i64.store offset=0x243 align=1 (i32.const 0) (local.get 0x243)) + (i64.store offset=0x244 align=1 (i32.const 0) (local.get 0x244)) + (i64.store offset=0x245 align=1 (i32.const 0) (local.get 0x245)) + (i64.store offset=0x246 align=1 (i32.const 0) (local.get 0x246)) + (i64.store offset=0x247 align=1 (i32.const 0) (local.get 0x247)) + (i64.store offset=0x248 align=1 (i32.const 0) (local.get 0x248)) + (i64.store offset=0x249 align=1 (i32.const 0) (local.get 0x249)) + (i64.store offset=0x24a align=1 (i32.const 0) (local.get 0x24a)) + (i64.store offset=0x24b align=1 (i32.const 0) (local.get 0x24b)) + (i64.store offset=0x24c align=1 (i32.const 0) (local.get 0x24c)) + (i64.store offset=0x24d align=1 (i32.const 0) (local.get 0x24d)) + (i64.store offset=0x24e align=1 (i32.const 0) (local.get 0x24e)) + (i64.store offset=0x24f align=1 (i32.const 0) (local.get 0x24f)) + (i64.store offset=0x250 align=1 (i32.const 0) (local.get 0x250)) + (i64.store offset=0x251 align=1 (i32.const 0) (local.get 0x251)) + (i64.store offset=0x252 align=1 (i32.const 0) (local.get 0x252)) + (i64.store offset=0x253 align=1 (i32.const 0) (local.get 0x253)) + (i64.store offset=0x254 align=1 (i32.const 0) (local.get 0x254)) + (i64.store offset=0x255 align=1 (i32.const 0) (local.get 0x255)) + (i64.store offset=0x256 align=1 (i32.const 0) (local.get 0x256)) + (i64.store offset=0x257 align=1 (i32.const 0) (local.get 0x257)) + (i64.store offset=0x258 align=1 (i32.const 0) (local.get 0x258)) + (i64.store offset=0x259 align=1 (i32.const 0) (local.get 0x259)) + (i64.store offset=0x25a align=1 (i32.const 0) (local.get 0x25a)) + (i64.store offset=0x25b align=1 (i32.const 0) (local.get 0x25b)) + (i64.store offset=0x25c align=1 (i32.const 0) (local.get 0x25c)) + (i64.store offset=0x25d align=1 (i32.const 0) (local.get 0x25d)) + (i64.store offset=0x25e align=1 (i32.const 0) (local.get 0x25e)) + (i64.store offset=0x25f align=1 (i32.const 0) (local.get 0x25f)) + (i64.store offset=0x260 align=1 (i32.const 0) (local.get 0x260)) + (i64.store offset=0x261 align=1 (i32.const 0) (local.get 0x261)) + (i64.store offset=0x262 align=1 (i32.const 0) (local.get 0x262)) + (i64.store offset=0x263 align=1 (i32.const 0) (local.get 0x263)) + (i64.store offset=0x264 align=1 (i32.const 0) (local.get 0x264)) + (i64.store offset=0x265 align=1 (i32.const 0) (local.get 0x265)) + (i64.store offset=0x266 align=1 (i32.const 0) (local.get 0x266)) + (i64.store offset=0x267 align=1 (i32.const 0) (local.get 0x267)) + (i64.store offset=0x268 align=1 (i32.const 0) (local.get 0x268)) + (i64.store offset=0x269 align=1 (i32.const 0) (local.get 0x269)) + (i64.store offset=0x26a align=1 (i32.const 0) (local.get 0x26a)) + (i64.store offset=0x26b align=1 (i32.const 0) (local.get 0x26b)) + (i64.store offset=0x26c align=1 (i32.const 0) (local.get 0x26c)) + (i64.store offset=0x26d align=1 (i32.const 0) (local.get 0x26d)) + (i64.store offset=0x26e align=1 (i32.const 0) (local.get 0x26e)) + (i64.store offset=0x26f align=1 (i32.const 0) (local.get 0x26f)) + (i64.store offset=0x270 align=1 (i32.const 0) (local.get 0x270)) + (i64.store offset=0x271 align=1 (i32.const 0) (local.get 0x271)) + (i64.store offset=0x272 align=1 (i32.const 0) (local.get 0x272)) + (i64.store offset=0x273 align=1 (i32.const 0) (local.get 0x273)) + (i64.store offset=0x274 align=1 (i32.const 0) (local.get 0x274)) + (i64.store offset=0x275 align=1 (i32.const 0) (local.get 0x275)) + (i64.store offset=0x276 align=1 (i32.const 0) (local.get 0x276)) + (i64.store offset=0x277 align=1 (i32.const 0) (local.get 0x277)) + (i64.store offset=0x278 align=1 (i32.const 0) (local.get 0x278)) + (i64.store offset=0x279 align=1 (i32.const 0) (local.get 0x279)) + (i64.store offset=0x27a align=1 (i32.const 0) (local.get 0x27a)) + (i64.store offset=0x27b align=1 (i32.const 0) (local.get 0x27b)) + (i64.store offset=0x27c align=1 (i32.const 0) (local.get 0x27c)) + (i64.store offset=0x27d align=1 (i32.const 0) (local.get 0x27d)) + (i64.store offset=0x27e align=1 (i32.const 0) (local.get 0x27e)) + (i64.store offset=0x27f align=1 (i32.const 0) (local.get 0x27f)) + (i64.store offset=0x280 align=1 (i32.const 0) (local.get 0x280)) + (i64.store offset=0x281 align=1 (i32.const 0) (local.get 0x281)) + (i64.store offset=0x282 align=1 (i32.const 0) (local.get 0x282)) + (i64.store offset=0x283 align=1 (i32.const 0) (local.get 0x283)) + (i64.store offset=0x284 align=1 (i32.const 0) (local.get 0x284)) + (i64.store offset=0x285 align=1 (i32.const 0) (local.get 0x285)) + (i64.store offset=0x286 align=1 (i32.const 0) (local.get 0x286)) + (i64.store offset=0x287 align=1 (i32.const 0) (local.get 0x287)) + (i64.store offset=0x288 align=1 (i32.const 0) (local.get 0x288)) + (i64.store offset=0x289 align=1 (i32.const 0) (local.get 0x289)) + (i64.store offset=0x28a align=1 (i32.const 0) (local.get 0x28a)) + (i64.store offset=0x28b align=1 (i32.const 0) (local.get 0x28b)) + (i64.store offset=0x28c align=1 (i32.const 0) (local.get 0x28c)) + (i64.store offset=0x28d align=1 (i32.const 0) (local.get 0x28d)) + (i64.store offset=0x28e align=1 (i32.const 0) (local.get 0x28e)) + (i64.store offset=0x28f align=1 (i32.const 0) (local.get 0x28f)) + (i64.store offset=0x290 align=1 (i32.const 0) (local.get 0x290)) + (i64.store offset=0x291 align=1 (i32.const 0) (local.get 0x291)) + (i64.store offset=0x292 align=1 (i32.const 0) (local.get 0x292)) + (i64.store offset=0x293 align=1 (i32.const 0) (local.get 0x293)) + (i64.store offset=0x294 align=1 (i32.const 0) (local.get 0x294)) + (i64.store offset=0x295 align=1 (i32.const 0) (local.get 0x295)) + (i64.store offset=0x296 align=1 (i32.const 0) (local.get 0x296)) + (i64.store offset=0x297 align=1 (i32.const 0) (local.get 0x297)) + (i64.store offset=0x298 align=1 (i32.const 0) (local.get 0x298)) + (i64.store offset=0x299 align=1 (i32.const 0) (local.get 0x299)) + (i64.store offset=0x29a align=1 (i32.const 0) (local.get 0x29a)) + (i64.store offset=0x29b align=1 (i32.const 0) (local.get 0x29b)) + (i64.store offset=0x29c align=1 (i32.const 0) (local.get 0x29c)) + (i64.store offset=0x29d align=1 (i32.const 0) (local.get 0x29d)) + (i64.store offset=0x29e align=1 (i32.const 0) (local.get 0x29e)) + (i64.store offset=0x29f align=1 (i32.const 0) (local.get 0x29f)) + (i64.store offset=0x2a0 align=1 (i32.const 0) (local.get 0x2a0)) + (i64.store offset=0x2a1 align=1 (i32.const 0) (local.get 0x2a1)) + (i64.store offset=0x2a2 align=1 (i32.const 0) (local.get 0x2a2)) + (i64.store offset=0x2a3 align=1 (i32.const 0) (local.get 0x2a3)) + (i64.store offset=0x2a4 align=1 (i32.const 0) (local.get 0x2a4)) + (i64.store offset=0x2a5 align=1 (i32.const 0) (local.get 0x2a5)) + (i64.store offset=0x2a6 align=1 (i32.const 0) (local.get 0x2a6)) + (i64.store offset=0x2a7 align=1 (i32.const 0) (local.get 0x2a7)) + (i64.store offset=0x2a8 align=1 (i32.const 0) (local.get 0x2a8)) + (i64.store offset=0x2a9 align=1 (i32.const 0) (local.get 0x2a9)) + (i64.store offset=0x2aa align=1 (i32.const 0) (local.get 0x2aa)) + (i64.store offset=0x2ab align=1 (i32.const 0) (local.get 0x2ab)) + (i64.store offset=0x2ac align=1 (i32.const 0) (local.get 0x2ac)) + (i64.store offset=0x2ad align=1 (i32.const 0) (local.get 0x2ad)) + (i64.store offset=0x2ae align=1 (i32.const 0) (local.get 0x2ae)) + (i64.store offset=0x2af align=1 (i32.const 0) (local.get 0x2af)) + (i64.store offset=0x2b0 align=1 (i32.const 0) (local.get 0x2b0)) + (i64.store offset=0x2b1 align=1 (i32.const 0) (local.get 0x2b1)) + (i64.store offset=0x2b2 align=1 (i32.const 0) (local.get 0x2b2)) + (i64.store offset=0x2b3 align=1 (i32.const 0) (local.get 0x2b3)) + (i64.store offset=0x2b4 align=1 (i32.const 0) (local.get 0x2b4)) + (i64.store offset=0x2b5 align=1 (i32.const 0) (local.get 0x2b5)) + (i64.store offset=0x2b6 align=1 (i32.const 0) (local.get 0x2b6)) + (i64.store offset=0x2b7 align=1 (i32.const 0) (local.get 0x2b7)) + (i64.store offset=0x2b8 align=1 (i32.const 0) (local.get 0x2b8)) + (i64.store offset=0x2b9 align=1 (i32.const 0) (local.get 0x2b9)) + (i64.store offset=0x2ba align=1 (i32.const 0) (local.get 0x2ba)) + (i64.store offset=0x2bb align=1 (i32.const 0) (local.get 0x2bb)) + (i64.store offset=0x2bc align=1 (i32.const 0) (local.get 0x2bc)) + (i64.store offset=0x2bd align=1 (i32.const 0) (local.get 0x2bd)) + (i64.store offset=0x2be align=1 (i32.const 0) (local.get 0x2be)) + (i64.store offset=0x2bf align=1 (i32.const 0) (local.get 0x2bf)) + (i64.store offset=0x2c0 align=1 (i32.const 0) (local.get 0x2c0)) + (i64.store offset=0x2c1 align=1 (i32.const 0) (local.get 0x2c1)) + (i64.store offset=0x2c2 align=1 (i32.const 0) (local.get 0x2c2)) + (i64.store offset=0x2c3 align=1 (i32.const 0) (local.get 0x2c3)) + (i64.store offset=0x2c4 align=1 (i32.const 0) (local.get 0x2c4)) + (i64.store offset=0x2c5 align=1 (i32.const 0) (local.get 0x2c5)) + (i64.store offset=0x2c6 align=1 (i32.const 0) (local.get 0x2c6)) + (i64.store offset=0x2c7 align=1 (i32.const 0) (local.get 0x2c7)) + (i64.store offset=0x2c8 align=1 (i32.const 0) (local.get 0x2c8)) + (i64.store offset=0x2c9 align=1 (i32.const 0) (local.get 0x2c9)) + (i64.store offset=0x2ca align=1 (i32.const 0) (local.get 0x2ca)) + (i64.store offset=0x2cb align=1 (i32.const 0) (local.get 0x2cb)) + (i64.store offset=0x2cc align=1 (i32.const 0) (local.get 0x2cc)) + (i64.store offset=0x2cd align=1 (i32.const 0) (local.get 0x2cd)) + (i64.store offset=0x2ce align=1 (i32.const 0) (local.get 0x2ce)) + (i64.store offset=0x2cf align=1 (i32.const 0) (local.get 0x2cf)) + (i64.store offset=0x2d0 align=1 (i32.const 0) (local.get 0x2d0)) + (i64.store offset=0x2d1 align=1 (i32.const 0) (local.get 0x2d1)) + (i64.store offset=0x2d2 align=1 (i32.const 0) (local.get 0x2d2)) + (i64.store offset=0x2d3 align=1 (i32.const 0) (local.get 0x2d3)) + (i64.store offset=0x2d4 align=1 (i32.const 0) (local.get 0x2d4)) + (i64.store offset=0x2d5 align=1 (i32.const 0) (local.get 0x2d5)) + (i64.store offset=0x2d6 align=1 (i32.const 0) (local.get 0x2d6)) + (i64.store offset=0x2d7 align=1 (i32.const 0) (local.get 0x2d7)) + (i64.store offset=0x2d8 align=1 (i32.const 0) (local.get 0x2d8)) + (i64.store offset=0x2d9 align=1 (i32.const 0) (local.get 0x2d9)) + (i64.store offset=0x2da align=1 (i32.const 0) (local.get 0x2da)) + (i64.store offset=0x2db align=1 (i32.const 0) (local.get 0x2db)) + (i64.store offset=0x2dc align=1 (i32.const 0) (local.get 0x2dc)) + (i64.store offset=0x2dd align=1 (i32.const 0) (local.get 0x2dd)) + (i64.store offset=0x2de align=1 (i32.const 0) (local.get 0x2de)) + (i64.store offset=0x2df align=1 (i32.const 0) (local.get 0x2df)) + (i64.store offset=0x2e0 align=1 (i32.const 0) (local.get 0x2e0)) + (i64.store offset=0x2e1 align=1 (i32.const 0) (local.get 0x2e1)) + (i64.store offset=0x2e2 align=1 (i32.const 0) (local.get 0x2e2)) + (i64.store offset=0x2e3 align=1 (i32.const 0) (local.get 0x2e3)) + (i64.store offset=0x2e4 align=1 (i32.const 0) (local.get 0x2e4)) + (i64.store offset=0x2e5 align=1 (i32.const 0) (local.get 0x2e5)) + (i64.store offset=0x2e6 align=1 (i32.const 0) (local.get 0x2e6)) + (i64.store offset=0x2e7 align=1 (i32.const 0) (local.get 0x2e7)) + (i64.store offset=0x2e8 align=1 (i32.const 0) (local.get 0x2e8)) + (i64.store offset=0x2e9 align=1 (i32.const 0) (local.get 0x2e9)) + (i64.store offset=0x2ea align=1 (i32.const 0) (local.get 0x2ea)) + (i64.store offset=0x2eb align=1 (i32.const 0) (local.get 0x2eb)) + (i64.store offset=0x2ec align=1 (i32.const 0) (local.get 0x2ec)) + (i64.store offset=0x2ed align=1 (i32.const 0) (local.get 0x2ed)) + (i64.store offset=0x2ee align=1 (i32.const 0) (local.get 0x2ee)) + (i64.store offset=0x2ef align=1 (i32.const 0) (local.get 0x2ef)) + (i64.store offset=0x2f0 align=1 (i32.const 0) (local.get 0x2f0)) + (i64.store offset=0x2f1 align=1 (i32.const 0) (local.get 0x2f1)) + (i64.store offset=0x2f2 align=1 (i32.const 0) (local.get 0x2f2)) + (i64.store offset=0x2f3 align=1 (i32.const 0) (local.get 0x2f3)) + (i64.store offset=0x2f4 align=1 (i32.const 0) (local.get 0x2f4)) + (i64.store offset=0x2f5 align=1 (i32.const 0) (local.get 0x2f5)) + (i64.store offset=0x2f6 align=1 (i32.const 0) (local.get 0x2f6)) + (i64.store offset=0x2f7 align=1 (i32.const 0) (local.get 0x2f7)) + (i64.store offset=0x2f8 align=1 (i32.const 0) (local.get 0x2f8)) + (i64.store offset=0x2f9 align=1 (i32.const 0) (local.get 0x2f9)) + (i64.store offset=0x2fa align=1 (i32.const 0) (local.get 0x2fa)) + (i64.store offset=0x2fb align=1 (i32.const 0) (local.get 0x2fb)) + (i64.store offset=0x2fc align=1 (i32.const 0) (local.get 0x2fc)) + (i64.store offset=0x2fd align=1 (i32.const 0) (local.get 0x2fd)) + (i64.store offset=0x2fe align=1 (i32.const 0) (local.get 0x2fe)) + (i64.store offset=0x2ff align=1 (i32.const 0) (local.get 0x2ff)) + (i64.store offset=0x300 align=1 (i32.const 0) (local.get 0x300)) + (i64.store offset=0x301 align=1 (i32.const 0) (local.get 0x301)) + (i64.store offset=0x302 align=1 (i32.const 0) (local.get 0x302)) + (i64.store offset=0x303 align=1 (i32.const 0) (local.get 0x303)) + (i64.store offset=0x304 align=1 (i32.const 0) (local.get 0x304)) + (i64.store offset=0x305 align=1 (i32.const 0) (local.get 0x305)) + (i64.store offset=0x306 align=1 (i32.const 0) (local.get 0x306)) + (i64.store offset=0x307 align=1 (i32.const 0) (local.get 0x307)) + (i64.store offset=0x308 align=1 (i32.const 0) (local.get 0x308)) + (i64.store offset=0x309 align=1 (i32.const 0) (local.get 0x309)) + (i64.store offset=0x30a align=1 (i32.const 0) (local.get 0x30a)) + (i64.store offset=0x30b align=1 (i32.const 0) (local.get 0x30b)) + (i64.store offset=0x30c align=1 (i32.const 0) (local.get 0x30c)) + (i64.store offset=0x30d align=1 (i32.const 0) (local.get 0x30d)) + (i64.store offset=0x30e align=1 (i32.const 0) (local.get 0x30e)) + (i64.store offset=0x30f align=1 (i32.const 0) (local.get 0x30f)) + (i64.store offset=0x310 align=1 (i32.const 0) (local.get 0x310)) + (i64.store offset=0x311 align=1 (i32.const 0) (local.get 0x311)) + (i64.store offset=0x312 align=1 (i32.const 0) (local.get 0x312)) + (i64.store offset=0x313 align=1 (i32.const 0) (local.get 0x313)) + (i64.store offset=0x314 align=1 (i32.const 0) (local.get 0x314)) + (i64.store offset=0x315 align=1 (i32.const 0) (local.get 0x315)) + (i64.store offset=0x316 align=1 (i32.const 0) (local.get 0x316)) + (i64.store offset=0x317 align=1 (i32.const 0) (local.get 0x317)) + (i64.store offset=0x318 align=1 (i32.const 0) (local.get 0x318)) + (i64.store offset=0x319 align=1 (i32.const 0) (local.get 0x319)) + (i64.store offset=0x31a align=1 (i32.const 0) (local.get 0x31a)) + (i64.store offset=0x31b align=1 (i32.const 0) (local.get 0x31b)) + (i64.store offset=0x31c align=1 (i32.const 0) (local.get 0x31c)) + (i64.store offset=0x31d align=1 (i32.const 0) (local.get 0x31d)) + (i64.store offset=0x31e align=1 (i32.const 0) (local.get 0x31e)) + (i64.store offset=0x31f align=1 (i32.const 0) (local.get 0x31f)) + (i64.store offset=0x320 align=1 (i32.const 0) (local.get 0x320)) + (i64.store offset=0x321 align=1 (i32.const 0) (local.get 0x321)) + (i64.store offset=0x322 align=1 (i32.const 0) (local.get 0x322)) + (i64.store offset=0x323 align=1 (i32.const 0) (local.get 0x323)) + (i64.store offset=0x324 align=1 (i32.const 0) (local.get 0x324)) + (i64.store offset=0x325 align=1 (i32.const 0) (local.get 0x325)) + (i64.store offset=0x326 align=1 (i32.const 0) (local.get 0x326)) + (i64.store offset=0x327 align=1 (i32.const 0) (local.get 0x327)) + (i64.store offset=0x328 align=1 (i32.const 0) (local.get 0x328)) + (i64.store offset=0x329 align=1 (i32.const 0) (local.get 0x329)) + (i64.store offset=0x32a align=1 (i32.const 0) (local.get 0x32a)) + (i64.store offset=0x32b align=1 (i32.const 0) (local.get 0x32b)) + (i64.store offset=0x32c align=1 (i32.const 0) (local.get 0x32c)) + (i64.store offset=0x32d align=1 (i32.const 0) (local.get 0x32d)) + (i64.store offset=0x32e align=1 (i32.const 0) (local.get 0x32e)) + (i64.store offset=0x32f align=1 (i32.const 0) (local.get 0x32f)) + (i64.store offset=0x330 align=1 (i32.const 0) (local.get 0x330)) + (i64.store offset=0x331 align=1 (i32.const 0) (local.get 0x331)) + (i64.store offset=0x332 align=1 (i32.const 0) (local.get 0x332)) + (i64.store offset=0x333 align=1 (i32.const 0) (local.get 0x333)) + (i64.store offset=0x334 align=1 (i32.const 0) (local.get 0x334)) + (i64.store offset=0x335 align=1 (i32.const 0) (local.get 0x335)) + (i64.store offset=0x336 align=1 (i32.const 0) (local.get 0x336)) + (i64.store offset=0x337 align=1 (i32.const 0) (local.get 0x337)) + (i64.store offset=0x338 align=1 (i32.const 0) (local.get 0x338)) + (i64.store offset=0x339 align=1 (i32.const 0) (local.get 0x339)) + (i64.store offset=0x33a align=1 (i32.const 0) (local.get 0x33a)) + (i64.store offset=0x33b align=1 (i32.const 0) (local.get 0x33b)) + (i64.store offset=0x33c align=1 (i32.const 0) (local.get 0x33c)) + (i64.store offset=0x33d align=1 (i32.const 0) (local.get 0x33d)) + (i64.store offset=0x33e align=1 (i32.const 0) (local.get 0x33e)) + (i64.store offset=0x33f align=1 (i32.const 0) (local.get 0x33f)) + (i64.store offset=0x340 align=1 (i32.const 0) (local.get 0x340)) + (i64.store offset=0x341 align=1 (i32.const 0) (local.get 0x341)) + (i64.store offset=0x342 align=1 (i32.const 0) (local.get 0x342)) + (i64.store offset=0x343 align=1 (i32.const 0) (local.get 0x343)) + (i64.store offset=0x344 align=1 (i32.const 0) (local.get 0x344)) + (i64.store offset=0x345 align=1 (i32.const 0) (local.get 0x345)) + (i64.store offset=0x346 align=1 (i32.const 0) (local.get 0x346)) + (i64.store offset=0x347 align=1 (i32.const 0) (local.get 0x347)) + (i64.store offset=0x348 align=1 (i32.const 0) (local.get 0x348)) + (i64.store offset=0x349 align=1 (i32.const 0) (local.get 0x349)) + (i64.store offset=0x34a align=1 (i32.const 0) (local.get 0x34a)) + (i64.store offset=0x34b align=1 (i32.const 0) (local.get 0x34b)) + (i64.store offset=0x34c align=1 (i32.const 0) (local.get 0x34c)) + (i64.store offset=0x34d align=1 (i32.const 0) (local.get 0x34d)) + (i64.store offset=0x34e align=1 (i32.const 0) (local.get 0x34e)) + (i64.store offset=0x34f align=1 (i32.const 0) (local.get 0x34f)) + (i64.store offset=0x350 align=1 (i32.const 0) (local.get 0x350)) + (i64.store offset=0x351 align=1 (i32.const 0) (local.get 0x351)) + (i64.store offset=0x352 align=1 (i32.const 0) (local.get 0x352)) + (i64.store offset=0x353 align=1 (i32.const 0) (local.get 0x353)) + (i64.store offset=0x354 align=1 (i32.const 0) (local.get 0x354)) + (i64.store offset=0x355 align=1 (i32.const 0) (local.get 0x355)) + (i64.store offset=0x356 align=1 (i32.const 0) (local.get 0x356)) + (i64.store offset=0x357 align=1 (i32.const 0) (local.get 0x357)) + (i64.store offset=0x358 align=1 (i32.const 0) (local.get 0x358)) + (i64.store offset=0x359 align=1 (i32.const 0) (local.get 0x359)) + (i64.store offset=0x35a align=1 (i32.const 0) (local.get 0x35a)) + (i64.store offset=0x35b align=1 (i32.const 0) (local.get 0x35b)) + (i64.store offset=0x35c align=1 (i32.const 0) (local.get 0x35c)) + (i64.store offset=0x35d align=1 (i32.const 0) (local.get 0x35d)) + (i64.store offset=0x35e align=1 (i32.const 0) (local.get 0x35e)) + (i64.store offset=0x35f align=1 (i32.const 0) (local.get 0x35f)) + (i64.store offset=0x360 align=1 (i32.const 0) (local.get 0x360)) + (i64.store offset=0x361 align=1 (i32.const 0) (local.get 0x361)) + (i64.store offset=0x362 align=1 (i32.const 0) (local.get 0x362)) + (i64.store offset=0x363 align=1 (i32.const 0) (local.get 0x363)) + (i64.store offset=0x364 align=1 (i32.const 0) (local.get 0x364)) + (i64.store offset=0x365 align=1 (i32.const 0) (local.get 0x365)) + (i64.store offset=0x366 align=1 (i32.const 0) (local.get 0x366)) + (i64.store offset=0x367 align=1 (i32.const 0) (local.get 0x367)) + (i64.store offset=0x368 align=1 (i32.const 0) (local.get 0x368)) + (i64.store offset=0x369 align=1 (i32.const 0) (local.get 0x369)) + (i64.store offset=0x36a align=1 (i32.const 0) (local.get 0x36a)) + (i64.store offset=0x36b align=1 (i32.const 0) (local.get 0x36b)) + (i64.store offset=0x36c align=1 (i32.const 0) (local.get 0x36c)) + (i64.store offset=0x36d align=1 (i32.const 0) (local.get 0x36d)) + (i64.store offset=0x36e align=1 (i32.const 0) (local.get 0x36e)) + (i64.store offset=0x36f align=1 (i32.const 0) (local.get 0x36f)) + (i64.store offset=0x370 align=1 (i32.const 0) (local.get 0x370)) + (i64.store offset=0x371 align=1 (i32.const 0) (local.get 0x371)) + (i64.store offset=0x372 align=1 (i32.const 0) (local.get 0x372)) + (i64.store offset=0x373 align=1 (i32.const 0) (local.get 0x373)) + (i64.store offset=0x374 align=1 (i32.const 0) (local.get 0x374)) + (i64.store offset=0x375 align=1 (i32.const 0) (local.get 0x375)) + (i64.store offset=0x376 align=1 (i32.const 0) (local.get 0x376)) + (i64.store offset=0x377 align=1 (i32.const 0) (local.get 0x377)) + (i64.store offset=0x378 align=1 (i32.const 0) (local.get 0x378)) + (i64.store offset=0x379 align=1 (i32.const 0) (local.get 0x379)) + (i64.store offset=0x37a align=1 (i32.const 0) (local.get 0x37a)) + (i64.store offset=0x37b align=1 (i32.const 0) (local.get 0x37b)) + (i64.store offset=0x37c align=1 (i32.const 0) (local.get 0x37c)) + (i64.store offset=0x37d align=1 (i32.const 0) (local.get 0x37d)) + (i64.store offset=0x37e align=1 (i32.const 0) (local.get 0x37e)) + (i64.store offset=0x37f align=1 (i32.const 0) (local.get 0x37f)) + (i64.store offset=0x380 align=1 (i32.const 0) (local.get 0x380)) + (i64.store offset=0x381 align=1 (i32.const 0) (local.get 0x381)) + (i64.store offset=0x382 align=1 (i32.const 0) (local.get 0x382)) + (i64.store offset=0x383 align=1 (i32.const 0) (local.get 0x383)) + (i64.store offset=0x384 align=1 (i32.const 0) (local.get 0x384)) + (i64.store offset=0x385 align=1 (i32.const 0) (local.get 0x385)) + (i64.store offset=0x386 align=1 (i32.const 0) (local.get 0x386)) + (i64.store offset=0x387 align=1 (i32.const 0) (local.get 0x387)) + (i64.store offset=0x388 align=1 (i32.const 0) (local.get 0x388)) + (i64.store offset=0x389 align=1 (i32.const 0) (local.get 0x389)) + (i64.store offset=0x38a align=1 (i32.const 0) (local.get 0x38a)) + (i64.store offset=0x38b align=1 (i32.const 0) (local.get 0x38b)) + (i64.store offset=0x38c align=1 (i32.const 0) (local.get 0x38c)) + (i64.store offset=0x38d align=1 (i32.const 0) (local.get 0x38d)) + (i64.store offset=0x38e align=1 (i32.const 0) (local.get 0x38e)) + (i64.store offset=0x38f align=1 (i32.const 0) (local.get 0x38f)) + (i64.store offset=0x390 align=1 (i32.const 0) (local.get 0x390)) + (i64.store offset=0x391 align=1 (i32.const 0) (local.get 0x391)) + (i64.store offset=0x392 align=1 (i32.const 0) (local.get 0x392)) + (i64.store offset=0x393 align=1 (i32.const 0) (local.get 0x393)) + (i64.store offset=0x394 align=1 (i32.const 0) (local.get 0x394)) + (i64.store offset=0x395 align=1 (i32.const 0) (local.get 0x395)) + (i64.store offset=0x396 align=1 (i32.const 0) (local.get 0x396)) + (i64.store offset=0x397 align=1 (i32.const 0) (local.get 0x397)) + (i64.store offset=0x398 align=1 (i32.const 0) (local.get 0x398)) + (i64.store offset=0x399 align=1 (i32.const 0) (local.get 0x399)) + (i64.store offset=0x39a align=1 (i32.const 0) (local.get 0x39a)) + (i64.store offset=0x39b align=1 (i32.const 0) (local.get 0x39b)) + (i64.store offset=0x39c align=1 (i32.const 0) (local.get 0x39c)) + (i64.store offset=0x39d align=1 (i32.const 0) (local.get 0x39d)) + (i64.store offset=0x39e align=1 (i32.const 0) (local.get 0x39e)) + (i64.store offset=0x39f align=1 (i32.const 0) (local.get 0x39f)) + (i64.store offset=0x3a0 align=1 (i32.const 0) (local.get 0x3a0)) + (i64.store offset=0x3a1 align=1 (i32.const 0) (local.get 0x3a1)) + (i64.store offset=0x3a2 align=1 (i32.const 0) (local.get 0x3a2)) + (i64.store offset=0x3a3 align=1 (i32.const 0) (local.get 0x3a3)) + (i64.store offset=0x3a4 align=1 (i32.const 0) (local.get 0x3a4)) + (i64.store offset=0x3a5 align=1 (i32.const 0) (local.get 0x3a5)) + (i64.store offset=0x3a6 align=1 (i32.const 0) (local.get 0x3a6)) + (i64.store offset=0x3a7 align=1 (i32.const 0) (local.get 0x3a7)) + (i64.store offset=0x3a8 align=1 (i32.const 0) (local.get 0x3a8)) + (i64.store offset=0x3a9 align=1 (i32.const 0) (local.get 0x3a9)) + (i64.store offset=0x3aa align=1 (i32.const 0) (local.get 0x3aa)) + (i64.store offset=0x3ab align=1 (i32.const 0) (local.get 0x3ab)) + (i64.store offset=0x3ac align=1 (i32.const 0) (local.get 0x3ac)) + (i64.store offset=0x3ad align=1 (i32.const 0) (local.get 0x3ad)) + (i64.store offset=0x3ae align=1 (i32.const 0) (local.get 0x3ae)) + (i64.store offset=0x3af align=1 (i32.const 0) (local.get 0x3af)) + (i64.store offset=0x3b0 align=1 (i32.const 0) (local.get 0x3b0)) + (i64.store offset=0x3b1 align=1 (i32.const 0) (local.get 0x3b1)) + (i64.store offset=0x3b2 align=1 (i32.const 0) (local.get 0x3b2)) + (i64.store offset=0x3b3 align=1 (i32.const 0) (local.get 0x3b3)) + (i64.store offset=0x3b4 align=1 (i32.const 0) (local.get 0x3b4)) + (i64.store offset=0x3b5 align=1 (i32.const 0) (local.get 0x3b5)) + (i64.store offset=0x3b6 align=1 (i32.const 0) (local.get 0x3b6)) + (i64.store offset=0x3b7 align=1 (i32.const 0) (local.get 0x3b7)) + (i64.store offset=0x3b8 align=1 (i32.const 0) (local.get 0x3b8)) + (i64.store offset=0x3b9 align=1 (i32.const 0) (local.get 0x3b9)) + (i64.store offset=0x3ba align=1 (i32.const 0) (local.get 0x3ba)) + (i64.store offset=0x3bb align=1 (i32.const 0) (local.get 0x3bb)) + (i64.store offset=0x3bc align=1 (i32.const 0) (local.get 0x3bc)) + (i64.store offset=0x3bd align=1 (i32.const 0) (local.get 0x3bd)) + (i64.store offset=0x3be align=1 (i32.const 0) (local.get 0x3be)) + (i64.store offset=0x3bf align=1 (i32.const 0) (local.get 0x3bf)) + (i64.store offset=0x3c0 align=1 (i32.const 0) (local.get 0x3c0)) + (i64.store offset=0x3c1 align=1 (i32.const 0) (local.get 0x3c1)) + (i64.store offset=0x3c2 align=1 (i32.const 0) (local.get 0x3c2)) + (i64.store offset=0x3c3 align=1 (i32.const 0) (local.get 0x3c3)) + (i64.store offset=0x3c4 align=1 (i32.const 0) (local.get 0x3c4)) + (i64.store offset=0x3c5 align=1 (i32.const 0) (local.get 0x3c5)) + (i64.store offset=0x3c6 align=1 (i32.const 0) (local.get 0x3c6)) + (i64.store offset=0x3c7 align=1 (i32.const 0) (local.get 0x3c7)) + (i64.store offset=0x3c8 align=1 (i32.const 0) (local.get 0x3c8)) + (i64.store offset=0x3c9 align=1 (i32.const 0) (local.get 0x3c9)) + (i64.store offset=0x3ca align=1 (i32.const 0) (local.get 0x3ca)) + (i64.store offset=0x3cb align=1 (i32.const 0) (local.get 0x3cb)) + (i64.store offset=0x3cc align=1 (i32.const 0) (local.get 0x3cc)) + (i64.store offset=0x3cd align=1 (i32.const 0) (local.get 0x3cd)) + (i64.store offset=0x3ce align=1 (i32.const 0) (local.get 0x3ce)) + (i64.store offset=0x3cf align=1 (i32.const 0) (local.get 0x3cf)) + (i64.store offset=0x3d0 align=1 (i32.const 0) (local.get 0x3d0)) + (i64.store offset=0x3d1 align=1 (i32.const 0) (local.get 0x3d1)) + (i64.store offset=0x3d2 align=1 (i32.const 0) (local.get 0x3d2)) + (i64.store offset=0x3d3 align=1 (i32.const 0) (local.get 0x3d3)) + (i64.store offset=0x3d4 align=1 (i32.const 0) (local.get 0x3d4)) + (i64.store offset=0x3d5 align=1 (i32.const 0) (local.get 0x3d5)) + (i64.store offset=0x3d6 align=1 (i32.const 0) (local.get 0x3d6)) + (i64.store offset=0x3d7 align=1 (i32.const 0) (local.get 0x3d7)) + (i64.store offset=0x3d8 align=1 (i32.const 0) (local.get 0x3d8)) + (i64.store offset=0x3d9 align=1 (i32.const 0) (local.get 0x3d9)) + (i64.store offset=0x3da align=1 (i32.const 0) (local.get 0x3da)) + (i64.store offset=0x3db align=1 (i32.const 0) (local.get 0x3db)) + (i64.store offset=0x3dc align=1 (i32.const 0) (local.get 0x3dc)) + (i64.store offset=0x3dd align=1 (i32.const 0) (local.get 0x3dd)) + (i64.store offset=0x3de align=1 (i32.const 0) (local.get 0x3de)) + (i64.store offset=0x3df align=1 (i32.const 0) (local.get 0x3df)) + (i64.store offset=0x3e0 align=1 (i32.const 0) (local.get 0x3e0)) + (i64.store offset=0x3e1 align=1 (i32.const 0) (local.get 0x3e1)) + (i64.store offset=0x3e2 align=1 (i32.const 0) (local.get 0x3e2)) + (i64.store offset=0x3e3 align=1 (i32.const 0) (local.get 0x3e3)) + (i64.store offset=0x3e4 align=1 (i32.const 0) (local.get 0x3e4)) + (i64.store offset=0x3e5 align=1 (i32.const 0) (local.get 0x3e5)) + (i64.store offset=0x3e6 align=1 (i32.const 0) (local.get 0x3e6)) + (i64.store offset=0x3e7 align=1 (i32.const 0) (local.get 0x3e7)) + (i64.store offset=0x3e8 align=1 (i32.const 0) (local.get 0x3e8)) + (i64.store offset=0x3e9 align=1 (i32.const 0) (local.get 0x3e9)) + (i64.store offset=0x3ea align=1 (i32.const 0) (local.get 0x3ea)) + (i64.store offset=0x3eb align=1 (i32.const 0) (local.get 0x3eb)) + (i64.store offset=0x3ec align=1 (i32.const 0) (local.get 0x3ec)) + (i64.store offset=0x3ed align=1 (i32.const 0) (local.get 0x3ed)) + (i64.store offset=0x3ee align=1 (i32.const 0) (local.get 0x3ee)) + (i64.store offset=0x3ef align=1 (i32.const 0) (local.get 0x3ef)) + (i64.store offset=0x3f0 align=1 (i32.const 0) (local.get 0x3f0)) + (i64.store offset=0x3f1 align=1 (i32.const 0) (local.get 0x3f1)) + (i64.store offset=0x3f2 align=1 (i32.const 0) (local.get 0x3f2)) + (i64.store offset=0x3f3 align=1 (i32.const 0) (local.get 0x3f3)) + (i64.store offset=0x3f4 align=1 (i32.const 0) (local.get 0x3f4)) + (i64.store offset=0x3f5 align=1 (i32.const 0) (local.get 0x3f5)) + (i64.store offset=0x3f6 align=1 (i32.const 0) (local.get 0x3f6)) + (i64.store offset=0x3f7 align=1 (i32.const 0) (local.get 0x3f7)) + (i64.store offset=0x3f8 align=1 (i32.const 0) (local.get 0x3f8)) + (i64.store offset=0x3f9 align=1 (i32.const 0) (local.get 0x3f9)) + (i64.store offset=0x3fa align=1 (i32.const 0) (local.get 0x3fa)) + (i64.store offset=0x3fb align=1 (i32.const 0) (local.get 0x3fb)) + (i64.store offset=0x3fc align=1 (i32.const 0) (local.get 0x3fc)) + (i64.store offset=0x3fd align=1 (i32.const 0) (local.get 0x3fd)) + (i64.store offset=0x3fe align=1 (i32.const 0) (local.get 0x3fe)) + (i64.store offset=0x3ff align=1 (i32.const 0) (local.get 0x3ff)) + (i64.store offset=0x400 align=1 (i32.const 0) (local.get 0x400)) + (i64.store offset=0x401 align=1 (i32.const 0) (local.get 0x401)) + (i64.store offset=0x402 align=1 (i32.const 0) (local.get 0x402)) + (i64.store offset=0x403 align=1 (i32.const 0) (local.get 0x403)) + (i64.store offset=0x404 align=1 (i32.const 0) (local.get 0x404)) + (i64.store offset=0x405 align=1 (i32.const 0) (local.get 0x405)) + (i64.store offset=0x406 align=1 (i32.const 0) (local.get 0x406)) + (i64.store offset=0x407 align=1 (i32.const 0) (local.get 0x407)) + (i64.store offset=0x408 align=1 (i32.const 0) (local.get 0x408)) + (i64.store offset=0x409 align=1 (i32.const 0) (local.get 0x409)) + (i64.store offset=0x40a align=1 (i32.const 0) (local.get 0x40a)) + (i64.store offset=0x40b align=1 (i32.const 0) (local.get 0x40b)) + (i64.store offset=0x40c align=1 (i32.const 0) (local.get 0x40c)) + (i64.store offset=0x40d align=1 (i32.const 0) (local.get 0x40d)) + (i64.store offset=0x40e align=1 (i32.const 0) (local.get 0x40e)) + (i64.store offset=0x40f align=1 (i32.const 0) (local.get 0x40f)) + (i64.store offset=0x410 align=1 (i32.const 0) (local.get 0x410)) + (i64.store offset=0x411 align=1 (i32.const 0) (local.get 0x411)) + (i64.store offset=0x412 align=1 (i32.const 0) (local.get 0x412)) + (i64.store offset=0x413 align=1 (i32.const 0) (local.get 0x413)) + (i64.store offset=0x414 align=1 (i32.const 0) (local.get 0x414)) + (i64.store offset=0x415 align=1 (i32.const 0) (local.get 0x415)) + (i64.store offset=0x416 align=1 (i32.const 0) (local.get 0x416)) + (i64.store offset=0x417 align=1 (i32.const 0) (local.get 0x417)) + (i64.store offset=0x418 align=1 (i32.const 0) (local.get 0x418)) + (i64.store offset=0x419 align=1 (i32.const 0) (local.get 0x419)) + (i64.store offset=0x41a align=1 (i32.const 0) (local.get 0x41a)) + (i64.store offset=0x41b align=1 (i32.const 0) (local.get 0x41b)) + (i64.store offset=0x41c align=1 (i32.const 0) (local.get 0x41c)) + (i64.store offset=0x41d align=1 (i32.const 0) (local.get 0x41d)) + (i64.store offset=0x41e align=1 (i32.const 0) (local.get 0x41e)) + (i64.store offset=0x41f align=1 (i32.const 0) (local.get 0x41f)) + ) +) + +(assert_exhaustion (invoke "test-guard-page-skip" (i32.const 0)) "call stack exhausted") +(assert_exhaustion (invoke "test-guard-page-skip" (i32.const 100)) "call stack exhausted") +(assert_exhaustion (invoke "test-guard-page-skip" (i32.const 200)) "call stack exhausted") +(assert_exhaustion (invoke "test-guard-page-skip" (i32.const 300)) "call stack exhausted") +(assert_exhaustion (invoke "test-guard-page-skip" (i32.const 400)) "call stack exhausted") +(assert_exhaustion (invoke "test-guard-page-skip" (i32.const 500)) "call stack exhausted") +(assert_exhaustion (invoke "test-guard-page-skip" (i32.const 600)) "call stack exhausted") +(assert_exhaustion (invoke "test-guard-page-skip" (i32.const 700)) "call stack exhausted") +(assert_exhaustion (invoke "test-guard-page-skip" (i32.const 800)) "call stack exhausted") +(assert_exhaustion (invoke "test-guard-page-skip" (i32.const 900)) "call stack exhausted") diff --git a/runtime/near-vm/tests/wast/spec/stack.wast b/runtime/near-vm/tests/wast/spec/stack.wast new file mode 100644 index 00000000000..5da5043c8e9 --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/stack.wast @@ -0,0 +1,239 @@ +(module + (func (export "fac-expr") (param $n i64) (result i64) + (local $i i64) + (local $res i64) + (local.set $i (local.get $n)) + (local.set $res (i64.const 1)) + (block $done + (loop $loop + (if + (i64.eq (local.get $i) (i64.const 0)) + (then (br $done)) + (else + (local.set $res (i64.mul (local.get $i) (local.get $res))) + (local.set $i (i64.sub (local.get $i) (i64.const 1))) + ) + ) + (br $loop) + ) + ) + (local.get $res) + ) + + (func (export "fac-stack") (param $n i64) (result i64) + (local $i i64) + (local $res i64) + (local.get $n) + (local.set $i) + (i64.const 1) + (local.set $res) + (block $done + (loop $loop + (local.get $i) + (i64.const 0) + (i64.eq) + (if + (then (br $done)) + (else + (local.get $i) + (local.get $res) + (i64.mul) + (local.set $res) + (local.get $i) + (i64.const 1) + (i64.sub) + (local.set $i) + ) + ) + (br $loop) + ) + ) + (local.get $res) + ) + + (func (export "fac-stack-raw") (param $n i64) (result i64) + (local $i i64) + (local $res i64) + local.get $n + local.set $i + i64.const 1 + local.set $res + block $done + loop $loop + local.get $i + i64.const 0 + i64.eq + if $body + br $done + else $body + local.get $i + local.get $res + i64.mul + local.set $res + local.get $i + i64.const 1 + i64.sub + local.set $i + end $body + br $loop + end $loop + end $done + local.get $res + ) + + (func (export "fac-mixed") (param $n i64) (result i64) + (local $i i64) + (local $res i64) + (local.set $i (local.get $n)) + (local.set $res (i64.const 1)) + (block $done + (loop $loop + (i64.eq (local.get $i) (i64.const 0)) + (if + (then (br $done)) + (else + (i64.mul (local.get $i) (local.get $res)) + (local.set $res) + (i64.sub (local.get $i) (i64.const 1)) + (local.set $i) + ) + ) + (br $loop) + ) + ) + (local.get $res) + ) + + (func (export "fac-mixed-raw") (param $n i64) (result i64) + (local $i i64) + (local $res i64) + (local.set $i (local.get $n)) + (local.set $res (i64.const 1)) + block $done + loop $loop + (i64.eq (local.get $i) (i64.const 0)) + if + br $done + else + (i64.mul (local.get $i) (local.get $res)) + local.set $res + (i64.sub (local.get $i) (i64.const 1)) + local.set $i + end + br $loop + end + end + local.get $res + ) + + (global $temp (mut i32) (i32.const 0)) + (func $add_one_to_global (result i32) + (local i32) + (global.set $temp (i32.add (i32.const 1) (global.get $temp))) + (global.get $temp) + ) + (func $add_one_to_global_and_drop + (drop (call $add_one_to_global)) + ) + (func (export "not-quite-a-tree") (result i32) + call $add_one_to_global + call $add_one_to_global + call $add_one_to_global_and_drop + i32.add + ) +) + +(assert_return (invoke "fac-expr" (i64.const 25)) (i64.const 7034535277573963776)) +(assert_return (invoke "fac-stack" (i64.const 25)) (i64.const 7034535277573963776)) +(assert_return (invoke "fac-mixed" (i64.const 25)) (i64.const 7034535277573963776)) + +(assert_return (invoke "not-quite-a-tree") (i32.const 3)) +(assert_return (invoke "not-quite-a-tree") (i32.const 9)) + + +;; Syntax of flat call_indirect + +(module + (type $proc (func)) + (table 1 funcref) + + (func + (block i32.const 0 call_indirect) + (loop i32.const 0 call_indirect) + (if (i32.const 0) (then i32.const 0 call_indirect)) + (if (i32.const 0) + (then i32.const 0 call_indirect) + (else i32.const 0 call_indirect) + ) + (block i32.const 0 call_indirect (type $proc)) + (loop i32.const 0 call_indirect (type $proc)) + (if (i32.const 0) (then i32.const 0 call_indirect (type $proc))) + (if (i32.const 0) + (then i32.const 0 call_indirect (type $proc)) + (else i32.const 0 call_indirect (type $proc)) + ) + (block i32.const 0 i32.const 0 call_indirect (param i32)) + (loop i32.const 0 i32.const 0 call_indirect (param i32)) + (if (i32.const 0) (then i32.const 0 i32.const 0 call_indirect (param i32))) + (if (i32.const 0) + (then i32.const 0 i32.const 0 call_indirect (param i32)) + (else i32.const 0 i32.const 0 call_indirect (param i32)) + ) + (block (result i32) i32.const 0 call_indirect (result i32)) (drop) + (loop (result i32) i32.const 0 call_indirect (result i32)) (drop) + (if (result i32) (i32.const 0) + (then i32.const 0 call_indirect (result i32)) + (else i32.const 0 call_indirect (result i32)) + ) (drop) + (block i32.const 0 call_indirect (type $proc) (param) (result)) + (loop i32.const 0 call_indirect (type $proc) (param) (result)) + (if (i32.const 0) + (then i32.const 0 call_indirect (type $proc) (param) (result)) + ) + (if (i32.const 0) + (then i32.const 0 call_indirect (type $proc) (param) (param) (result)) + (else i32.const 0 call_indirect (type $proc) (param) (result) (result)) + ) + + block i32.const 0 call_indirect end + loop i32.const 0 call_indirect end + i32.const 0 if i32.const 0 call_indirect end + i32.const 0 if i32.const 0 call_indirect else i32.const 0 call_indirect end + block i32.const 0 call_indirect (type $proc) end + loop i32.const 0 call_indirect (type $proc) end + i32.const 0 if i32.const 0 call_indirect (type $proc) end + i32.const 0 + if + i32.const 0 call_indirect (type $proc) + else + i32.const 0 call_indirect (type $proc) + end + block i32.const 0 i32.const 0 call_indirect (param i32) end + loop i32.const 0 i32.const 0 call_indirect (param i32) end + i32.const 0 if i32.const 0 i32.const 0 call_indirect (param i32) end + i32.const 0 + if + i32.const 0 i32.const 0 call_indirect (param i32) + else + i32.const 0 i32.const 0 call_indirect (param i32) + end + block (result i32) i32.const 0 call_indirect (result i32) end drop + loop (result i32) i32.const 0 call_indirect (result i32) end drop + i32.const 0 + if (result i32) + i32.const 0 call_indirect (result i32) + else + i32.const 0 call_indirect (result i32) + end drop + block i32.const 0 call_indirect (type $proc) (param) (result) end + loop i32.const 0 call_indirect (type $proc) (param) (result) end + i32.const 0 if i32.const 0 call_indirect (type $proc) (param) (result) end + i32.const 0 + if + i32.const 0 call_indirect (type $proc) (param) (result) + else + i32.const 0 call_indirect (type $proc) (param) (param) (result) (result) + end + i32.const 0 call_indirect + ) +) diff --git a/runtime/near-vm/tests/wast/spec/start.wast b/runtime/near-vm/tests/wast/spec/start.wast new file mode 100644 index 00000000000..bf88a6a4a48 --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/start.wast @@ -0,0 +1,105 @@ +(assert_invalid + (module (func) (start 1)) + "unknown function" +) + +(assert_invalid + (module + (func $main (result i32) (return (i32.const 0))) + (start $main) + ) + "start function" +) +(assert_invalid + (module + (func $main (param $a i32)) + (start $main) + ) + "start function" +) + +(module + (memory (data "A")) + (func $inc + (i32.store8 + (i32.const 0) + (i32.add + (i32.load8_u (i32.const 0)) + (i32.const 1) + ) + ) + ) + (func $get (result i32) + (return (i32.load8_u (i32.const 0))) + ) + (func $main + (call $inc) + (call $inc) + (call $inc) + ) + + (start $main) + (export "inc" (func $inc)) + (export "get" (func $get)) +) +(assert_return (invoke "get") (i32.const 68)) +(invoke "inc") +(assert_return (invoke "get") (i32.const 69)) +(invoke "inc") +(assert_return (invoke "get") (i32.const 70)) + +(module + (memory (data "A")) + (func $inc + (i32.store8 + (i32.const 0) + (i32.add + (i32.load8_u (i32.const 0)) + (i32.const 1) + ) + ) + ) + (func $get (result i32) + (return (i32.load8_u (i32.const 0))) + ) + (func $main + (call $inc) + (call $inc) + (call $inc) + ) + (start 2) + (export "inc" (func $inc)) + (export "get" (func $get)) +) +(assert_return (invoke "get") (i32.const 68)) +(invoke "inc") +(assert_return (invoke "get") (i32.const 69)) +(invoke "inc") +(assert_return (invoke "get") (i32.const 70)) + +(module + (func $print_i32 (import "spectest" "print_i32") (param i32)) + (func $main (call $print_i32 (i32.const 1))) + (start 1) +) + +(module + (func $print_i32 (import "spectest" "print_i32") (param i32)) + (func $main (call $print_i32 (i32.const 2))) + (start $main) +) + +(module + (func $print (import "spectest" "print")) + (start $print) +) + +(assert_trap + (module (func $main (unreachable)) (start $main)) + "unreachable" +) + +(assert_malformed + (module quote "(module (func $a (unreachable)) (func $b (unreachable)) (start $a) (start $b))") + "multiple start sections" +) diff --git a/runtime/near-vm/tests/wast/spec/store.wast b/runtime/near-vm/tests/wast/spec/store.wast new file mode 100644 index 00000000000..01c3a2dd648 --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/store.wast @@ -0,0 +1,417 @@ +;; Store operator as the argument of control constructs and instructions + +(module + (memory 1) + + (func (export "as-block-value") + (block (i32.store (i32.const 0) (i32.const 1))) + ) + (func (export "as-loop-value") + (loop (i32.store (i32.const 0) (i32.const 1))) + ) + + (func (export "as-br-value") + (block (br 0 (i32.store (i32.const 0) (i32.const 1)))) + ) + (func (export "as-br_if-value") + (block + (br_if 0 (i32.store (i32.const 0) (i32.const 1)) (i32.const 1)) + ) + ) + (func (export "as-br_if-value-cond") + (block + (br_if 0 (i32.const 6) (i32.store (i32.const 0) (i32.const 1))) + ) + ) + (func (export "as-br_table-value") + (block + (br_table 0 (i32.store (i32.const 0) (i32.const 1)) (i32.const 1)) + ) + ) + + (func (export "as-return-value") + (return (i32.store (i32.const 0) (i32.const 1))) + ) + + (func (export "as-if-then") + (if (i32.const 1) (then (i32.store (i32.const 0) (i32.const 1)))) + ) + (func (export "as-if-else") + (if (i32.const 0) (then) (else (i32.store (i32.const 0) (i32.const 1)))) + ) +) + +(assert_return (invoke "as-block-value")) +(assert_return (invoke "as-loop-value")) + +(assert_return (invoke "as-br-value")) +(assert_return (invoke "as-br_if-value")) +(assert_return (invoke "as-br_if-value-cond")) +(assert_return (invoke "as-br_table-value")) + +(assert_return (invoke "as-return-value")) + +(assert_return (invoke "as-if-then")) +(assert_return (invoke "as-if-else")) + +(assert_malformed + (module quote + "(memory 1)" + "(func (param i32) (i32.store32 (local.get 0) (i32.const 0)))" + ) + "unknown operator" +) +(assert_malformed + (module quote + "(memory 1)" + "(func (param i32) (i32.store64 (local.get 0) (i64.const 0)))" + ) + "unknown operator" +) + +(assert_malformed + (module quote + "(memory 1)" + "(func (param i32) (i64.store64 (local.get 0) (i64.const 0)))" + ) + "unknown operator" +) + +(assert_malformed + (module quote + "(memory 1)" + "(func (param i32) (f32.store32 (local.get 0) (f32.const 0)))" + ) + "unknown operator" +) +(assert_malformed + (module quote + "(memory 1)" + "(func (param i32) (f32.store64 (local.get 0) (f64.const 0)))" + ) + "unknown operator" +) + +(assert_malformed + (module quote + "(memory 1)" + "(func (param i32) (f64.store32 (local.get 0) (f32.const 0)))" + ) + "unknown operator" +) +(assert_malformed + (module quote + "(memory 1)" + "(func (param i32) (f64.store64 (local.get 0) (f64.const 0)))" + ) + "unknown operator" +) +;; store should have no retval + +(assert_invalid + (module (memory 1) (func (param i32) (result i32) (i32.store (i32.const 0) (i32.const 1)))) + "type mismatch" +) +(assert_invalid + (module (memory 1) (func (param i64) (result i64) (i64.store (i32.const 0) (i64.const 1)))) + "type mismatch" +) +(assert_invalid + (module (memory 1) (func (param f32) (result f32) (f32.store (i32.const 0) (f32.const 1)))) + "type mismatch" +) +(assert_invalid + (module (memory 1) (func (param f64) (result f64) (f64.store (i32.const 0) (f64.const 1)))) + "type mismatch" +) +(assert_invalid + (module (memory 1) (func (param i32) (result i32) (i32.store8 (i32.const 0) (i32.const 1)))) + "type mismatch" +) +(assert_invalid + (module (memory 1) (func (param i32) (result i32) (i32.store16 (i32.const 0) (i32.const 1)))) + "type mismatch" +) +(assert_invalid + (module (memory 1) (func (param i64) (result i64) (i64.store8 (i32.const 0) (i64.const 1)))) + "type mismatch" +) +(assert_invalid + (module (memory 1) (func (param i64) (result i64) (i64.store16 (i32.const 0) (i64.const 1)))) + "type mismatch" +) +(assert_invalid + (module (memory 1) (func (param i64) (result i64) (i64.store32 (i32.const 0) (i64.const 1)))) + "type mismatch" +) + + +(assert_invalid + (module + (memory 1) + (func $type-address-empty + (i32.store) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (memory 1) + (func $type-value-empty + (i32.const 0) (i32.store) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (memory 1) + (func $type-address-empty-in-block + (i32.const 0) (i32.const 0) + (block (i32.store)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (memory 1) + (func $type-value-empty-in-block + (i32.const 0) + (block (i32.const 0) (i32.store)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (memory 1) + (func $type-address-empty-in-loop + (i32.const 0) (i32.const 0) + (loop (i32.store)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (memory 1) + (func $type-value-empty-in-loop + (i32.const 0) + (loop (i32.const 0) (i32.store)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (memory 1) + (func $type-address-empty-in-then + (i32.const 0) (i32.const 0) + (if (then (i32.store))) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (memory 1) + (func $type-value-empty-in-then + (i32.const 0) + (if (then (i32.const 0) (i32.store))) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (memory 1) + (func $type-address-empty-in-else + (i32.const 0) (i32.const 0) + (if (result i32) (then (i32.const 0)) (else (i32.store))) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (memory 1) + (func $type-value-empty-in-else + (i32.const 0) + (if (result i32) (then (i32.const 0)) (else (i32.const 0) (i32.store))) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (memory 1) + (func $type-address-empty-in-br + (i32.const 0) (i32.const 0) + (block (br 0 (i32.store))) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (memory 1) + (func $type-value-empty-in-br + (i32.const 0) + (block (br 0 (i32.const 0) (i32.store))) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (memory 1) + (func $type-address-empty-in-br_if + (i32.const 0) (i32.const 0) + (block (br_if 0 (i32.store) (i32.const 1)) ) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (memory 1) + (func $type-value-empty-in-br_if + (i32.const 0) + (block (br_if 0 (i32.const 0) (i32.store) (i32.const 1)) ) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (memory 1) + (func $type-address-empty-in-br_table + (i32.const 0) (i32.const 0) + (block (br_table 0 (i32.store))) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (memory 1) + (func $type-value-empty-in-br_table + (i32.const 0) + (block (br_table 0 (i32.const 0) (i32.store))) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (memory 1) + (func $type-address-empty-in-return + (return (i32.store)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (memory 1) + (func $type-value-empty-in-return + (return (i32.const 0) (i32.store)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (memory 1) + (func $type-address-empty-in-select + (select (i32.store) (i32.const 1) (i32.const 2)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (memory 1) + (func $type-value-empty-in-select + (select (i32.const 0) (i32.store) (i32.const 1) (i32.const 2)) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (memory 1) + (func $type-address-empty-in-call + (call 1 (i32.store)) + ) + (func (param i32) (result i32) (local.get 0)) + ) + "type mismatch" +) +(assert_invalid + (module + (memory 1) + (func $type-value-empty-in-call + (call 1 (i32.const 0) (i32.store)) + ) + (func (param i32) (result i32) (local.get 0)) + ) + "type mismatch" +) +(assert_invalid + (module + (memory 1) + (func $f (param i32) (result i32) (local.get 0)) + (type $sig (func (param i32) (result i32))) + (table funcref (elem $f)) + (func $type-address-empty-in-call_indirect + (block (result i32) + (call_indirect (type $sig) + (i32.store) (i32.const 0) + ) + ) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (memory 1) + (func $f (param i32) (result i32) (local.get 0)) + (type $sig (func (param i32) (result i32))) + (table funcref (elem $f)) + (func $type-value-empty-in-call_indirect + (block (result i32) + (call_indirect (type $sig) + (i32.const 0) (i32.store) (i32.const 0) + ) + ) + ) + ) + "type mismatch" +) + + +;; Type check + +(assert_invalid (module (memory 1) (func (i32.store (f32.const 0) (i32.const 0)))) "type mismatch") +(assert_invalid (module (memory 1) (func (i32.store8 (f32.const 0) (i32.const 0)))) "type mismatch") +(assert_invalid (module (memory 1) (func (i32.store16 (f32.const 0) (i32.const 0)))) "type mismatch") +(assert_invalid (module (memory 1) (func (i64.store (f32.const 0) (i32.const 0)))) "type mismatch") +(assert_invalid (module (memory 1) (func (i64.store8 (f32.const 0) (i64.const 0)))) "type mismatch") +(assert_invalid (module (memory 1) (func (i64.store16 (f32.const 0) (i64.const 0)))) "type mismatch") +(assert_invalid (module (memory 1) (func (i64.store32 (f32.const 0) (i64.const 0)))) "type mismatch") +(assert_invalid (module (memory 1) (func (f32.store (f32.const 0) (f32.const 0)))) "type mismatch") +(assert_invalid (module (memory 1) (func (f64.store (f32.const 0) (f64.const 0)))) "type mismatch") + +(assert_invalid (module (memory 1) (func (i32.store (i32.const 0) (f32.const 0)))) "type mismatch") +(assert_invalid (module (memory 1) (func (i32.store8 (i32.const 0) (f32.const 0)))) "type mismatch") +(assert_invalid (module (memory 1) (func (i32.store16 (i32.const 0) (f32.const 0)))) "type mismatch") +(assert_invalid (module (memory 1) (func (i64.store (i32.const 0) (f32.const 0)))) "type mismatch") +(assert_invalid (module (memory 1) (func (i64.store8 (i32.const 0) (f64.const 0)))) "type mismatch") +(assert_invalid (module (memory 1) (func (i64.store16 (i32.const 0) (f64.const 0)))) "type mismatch") +(assert_invalid (module (memory 1) (func (i64.store32 (i32.const 0) (f64.const 0)))) "type mismatch") +(assert_invalid (module (memory 1) (func (f32.store (i32.const 0) (i32.const 0)))) "type mismatch") +(assert_invalid (module (memory 1) (func (f64.store (i32.const 0) (i64.const 0)))) "type mismatch") diff --git a/runtime/near-vm/tests/wast/spec/switch.wast b/runtime/near-vm/tests/wast/spec/switch.wast new file mode 100644 index 00000000000..e9ae24dc151 --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/switch.wast @@ -0,0 +1,150 @@ +(module + ;; Statement switch + (func (export "stmt") (param $i i32) (result i32) + (local $j i32) + (local.set $j (i32.const 100)) + (block $switch + (block $7 + (block $default + (block $6 + (block $5 + (block $4 + (block $3 + (block $2 + (block $1 + (block $0 + (br_table $0 $1 $2 $3 $4 $5 $6 $7 $default + (local.get $i) + ) + ) ;; 0 + (return (local.get $i)) + ) ;; 1 + (nop) + ;; fallthrough + ) ;; 2 + ;; fallthrough + ) ;; 3 + (local.set $j (i32.sub (i32.const 0) (local.get $i))) + (br $switch) + ) ;; 4 + (br $switch) + ) ;; 5 + (local.set $j (i32.const 101)) + (br $switch) + ) ;; 6 + (local.set $j (i32.const 101)) + ;; fallthrough + ) ;; default + (local.set $j (i32.const 102)) + ) ;; 7 + ;; fallthrough + ) + (return (local.get $j)) + ) + + ;; Expression switch + (func (export "expr") (param $i i64) (result i64) + (local $j i64) + (local.set $j (i64.const 100)) + (return + (block $switch (result i64) + (block $7 + (block $default + (block $4 + (block $5 + (block $6 + (block $3 + (block $2 + (block $1 + (block $0 + (br_table $0 $1 $2 $3 $4 $5 $6 $7 $default + (i32.wrap_i64 (local.get $i)) + ) + ) ;; 0 + (return (local.get $i)) + ) ;; 1 + (nop) + ;; fallthrough + ) ;; 2 + ;; fallthrough + ) ;; 3 + (br $switch (i64.sub (i64.const 0) (local.get $i))) + ) ;; 6 + (local.set $j (i64.const 101)) + ;; fallthrough + ) ;; 4 + ;; fallthrough + ) ;; 5 + ;; fallthrough + ) ;; default + (br $switch (local.get $j)) + ) ;; 7 + (i64.const -5) + ) + ) + ) + + ;; Argument switch + (func (export "arg") (param $i i32) (result i32) + (return + (block $2 (result i32) + (i32.add (i32.const 10) + (block $1 (result i32) + (i32.add (i32.const 100) + (block $0 (result i32) + (i32.add (i32.const 1000) + (block $default (result i32) + (br_table $0 $1 $2 $default + (i32.mul (i32.const 2) (local.get $i)) + (i32.and (i32.const 3) (local.get $i)) + ) + ) + ) + ) + ) + ) + ) + ) + ) + ) + + ;; Corner cases + (func (export "corner") (result i32) + (block + (br_table 0 (i32.const 0)) + ) + (i32.const 1) + ) +) + +(assert_return (invoke "stmt" (i32.const 0)) (i32.const 0)) +(assert_return (invoke "stmt" (i32.const 1)) (i32.const -1)) +(assert_return (invoke "stmt" (i32.const 2)) (i32.const -2)) +(assert_return (invoke "stmt" (i32.const 3)) (i32.const -3)) +(assert_return (invoke "stmt" (i32.const 4)) (i32.const 100)) +(assert_return (invoke "stmt" (i32.const 5)) (i32.const 101)) +(assert_return (invoke "stmt" (i32.const 6)) (i32.const 102)) +(assert_return (invoke "stmt" (i32.const 7)) (i32.const 100)) +(assert_return (invoke "stmt" (i32.const -10)) (i32.const 102)) + +(assert_return (invoke "expr" (i64.const 0)) (i64.const 0)) +(assert_return (invoke "expr" (i64.const 1)) (i64.const -1)) +(assert_return (invoke "expr" (i64.const 2)) (i64.const -2)) +(assert_return (invoke "expr" (i64.const 3)) (i64.const -3)) +(assert_return (invoke "expr" (i64.const 6)) (i64.const 101)) +(assert_return (invoke "expr" (i64.const 7)) (i64.const -5)) +(assert_return (invoke "expr" (i64.const -10)) (i64.const 100)) + +(assert_return (invoke "arg" (i32.const 0)) (i32.const 110)) +(assert_return (invoke "arg" (i32.const 1)) (i32.const 12)) +(assert_return (invoke "arg" (i32.const 2)) (i32.const 4)) +(assert_return (invoke "arg" (i32.const 3)) (i32.const 1116)) +(assert_return (invoke "arg" (i32.const 4)) (i32.const 118)) +(assert_return (invoke "arg" (i32.const 5)) (i32.const 20)) +(assert_return (invoke "arg" (i32.const 6)) (i32.const 12)) +(assert_return (invoke "arg" (i32.const 7)) (i32.const 1124)) +(assert_return (invoke "arg" (i32.const 8)) (i32.const 126)) + +(assert_return (invoke "corner") (i32.const 1)) + +(assert_invalid (module (func (br_table 3 (i32.const 0)))) "unknown label") diff --git a/runtime/near-vm/tests/wast/spec/table-sub.wast b/runtime/near-vm/tests/wast/spec/table-sub.wast new file mode 100644 index 00000000000..08787bddd27 --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/table-sub.wast @@ -0,0 +1,21 @@ +(assert_invalid + (module + (table $t1 10 funcref) + (table $t2 10 externref) + (func $f + (table.copy $t1 $t2 (i32.const 0) (i32.const 1) (i32.const 2)) + ) + ) + "type mismatch" +) + +(assert_invalid + (module + (table $t 10 funcref) + (elem $el externref) + (func $f + (table.init $t $el (i32.const 0) (i32.const 1) (i32.const 2)) + ) + ) + "type mismatch" +) diff --git a/runtime/near-vm/tests/wast/spec/table.wast b/runtime/near-vm/tests/wast/spec/table.wast new file mode 100644 index 00000000000..0bd04f5cc44 --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/table.wast @@ -0,0 +1,54 @@ +;; Test table section structure + +(module (table 0 funcref)) +(module (table 1 funcref)) +(module (table 0 0 funcref)) +(module (table 0 1 funcref)) +(module (table 1 256 funcref)) +(module (table 0 65536 funcref)) +(module (table 0 0xffff_ffff funcref)) + +(module (table 0 funcref) (table 0 funcref)) +(module (table (import "spectest" "table") 0 funcref) (table 0 funcref)) + +(assert_invalid (module (elem (i32.const 0))) "unknown table") +(assert_invalid (module (elem (i32.const 0) $f) (func $f)) "unknown table") + + +(assert_invalid + (module (table 1 0 funcref)) + "size minimum must not be greater than maximum" +) +(assert_invalid + (module (table 0xffff_ffff 0 funcref)) + "size minimum must not be greater than maximum" +) + +(assert_malformed + (module quote "(table 0x1_0000_0000 funcref)") + "i32 constant out of range" +) +(assert_malformed + (module quote "(table 0x1_0000_0000 0x1_0000_0000 funcref)") + "i32 constant out of range" +) +(assert_malformed + (module quote "(table 0 0x1_0000_0000 funcref)") + "i32 constant out of range" +) + + +;; Duplicate table identifiers + +(assert_malformed (module quote + "(table $foo 1 funcref)" + "(table $foo 1 funcref)") + "duplicate table") +(assert_malformed (module quote + "(import \"\" \"\" (table $foo 1 funcref))" + "(table $foo 1 funcref)") + "duplicate table") +(assert_malformed (module quote + "(import \"\" \"\" (table $foo 1 funcref))" + "(import \"\" \"\" (table $foo 1 funcref))") + "duplicate table") diff --git a/runtime/near-vm/tests/wast/spec/table_copy.wast b/runtime/near-vm/tests/wast/spec/table_copy.wast new file mode 100644 index 00000000000..380e84ee594 --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/table_copy.wast @@ -0,0 +1,3082 @@ +;; +;; Generated by ../meta/generate_table_copy.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 + (import "a" "ef0" (func (result i32))) ;; index 0 + (import "a" "ef1" (func (result i32))) + (import "a" "ef2" (func (result i32))) + (import "a" "ef3" (func (result i32))) + (import "a" "ef4" (func (result i32))) ;; 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)) + (elem (table $t1) (i32.const 3) func 1 3 1 4) + (elem (table $t1) (i32.const 11) func 6 3 2 5 7) + (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") + (nop)) + (func (export "check_t0") (param i32) (result i32) + (call_indirect $t0 (type 0) (local.get 0))) + (func (export "check_t1") (param i32) (result i32) + (call_indirect $t1 (type 0) (local.get 0))) +) + +(invoke "test") +(assert_trap (invoke "check_t0" (i32.const 0)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 1)) "uninitialized element") +(assert_return (invoke "check_t0" (i32.const 2)) (i32.const 3)) +(assert_return (invoke "check_t0" (i32.const 3)) (i32.const 1)) +(assert_return (invoke "check_t0" (i32.const 4)) (i32.const 4)) +(assert_return (invoke "check_t0" (i32.const 5)) (i32.const 1)) +(assert_trap (invoke "check_t0" (i32.const 6)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 7)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 8)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 9)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 10)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 11)) "uninitialized element") +(assert_return (invoke "check_t0" (i32.const 12)) (i32.const 7)) +(assert_return (invoke "check_t0" (i32.const 13)) (i32.const 5)) +(assert_return (invoke "check_t0" (i32.const 14)) (i32.const 2)) +(assert_return (invoke "check_t0" (i32.const 15)) (i32.const 3)) +(assert_return (invoke "check_t0" (i32.const 16)) (i32.const 6)) +(assert_trap (invoke "check_t0" (i32.const 17)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 18)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 19)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 20)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 21)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 22)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 23)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 24)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 25)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 26)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 27)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 28)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 29)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 0)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 1)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 2)) "uninitialized element") +(assert_return (invoke "check_t1" (i32.const 3)) (i32.const 1)) +(assert_return (invoke "check_t1" (i32.const 4)) (i32.const 3)) +(assert_return (invoke "check_t1" (i32.const 5)) (i32.const 1)) +(assert_return (invoke "check_t1" (i32.const 6)) (i32.const 4)) +(assert_trap (invoke "check_t1" (i32.const 7)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 8)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 9)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 10)) "uninitialized element") +(assert_return (invoke "check_t1" (i32.const 11)) (i32.const 6)) +(assert_return (invoke "check_t1" (i32.const 12)) (i32.const 3)) +(assert_return (invoke "check_t1" (i32.const 13)) (i32.const 2)) +(assert_return (invoke "check_t1" (i32.const 14)) (i32.const 5)) +(assert_return (invoke "check_t1" (i32.const 15)) (i32.const 7)) +(assert_trap (invoke "check_t1" (i32.const 16)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 17)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 18)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 19)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 20)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 21)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 22)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 23)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 24)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 25)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 26)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 27)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 28)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 29)) "uninitialized element") + +(module + (type (func (result i32))) ;; type #0 + (import "a" "ef0" (func (result i32))) ;; index 0 + (import "a" "ef1" (func (result i32))) + (import "a" "ef2" (func (result i32))) + (import "a" "ef3" (func (result i32))) + (import "a" "ef4" (func (result i32))) ;; 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)) + (elem (table $t1) (i32.const 3) func 1 3 1 4) + (elem (table $t1) (i32.const 11) func 6 3 2 5 7) + (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.copy $t0 $t0 (i32.const 13) (i32.const 2) (i32.const 3))) + (func (export "check_t0") (param i32) (result i32) + (call_indirect $t0 (type 0) (local.get 0))) + (func (export "check_t1") (param i32) (result i32) + (call_indirect $t1 (type 0) (local.get 0))) +) + +(invoke "test") +(assert_trap (invoke "check_t0" (i32.const 0)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 1)) "uninitialized element") +(assert_return (invoke "check_t0" (i32.const 2)) (i32.const 3)) +(assert_return (invoke "check_t0" (i32.const 3)) (i32.const 1)) +(assert_return (invoke "check_t0" (i32.const 4)) (i32.const 4)) +(assert_return (invoke "check_t0" (i32.const 5)) (i32.const 1)) +(assert_trap (invoke "check_t0" (i32.const 6)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 7)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 8)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 9)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 10)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 11)) "uninitialized element") +(assert_return (invoke "check_t0" (i32.const 12)) (i32.const 7)) +(assert_return (invoke "check_t0" (i32.const 13)) (i32.const 3)) +(assert_return (invoke "check_t0" (i32.const 14)) (i32.const 1)) +(assert_return (invoke "check_t0" (i32.const 15)) (i32.const 4)) +(assert_return (invoke "check_t0" (i32.const 16)) (i32.const 6)) +(assert_trap (invoke "check_t0" (i32.const 17)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 18)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 19)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 20)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 21)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 22)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 23)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 24)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 25)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 26)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 27)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 28)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 29)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 0)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 1)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 2)) "uninitialized element") +(assert_return (invoke "check_t1" (i32.const 3)) (i32.const 1)) +(assert_return (invoke "check_t1" (i32.const 4)) (i32.const 3)) +(assert_return (invoke "check_t1" (i32.const 5)) (i32.const 1)) +(assert_return (invoke "check_t1" (i32.const 6)) (i32.const 4)) +(assert_trap (invoke "check_t1" (i32.const 7)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 8)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 9)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 10)) "uninitialized element") +(assert_return (invoke "check_t1" (i32.const 11)) (i32.const 6)) +(assert_return (invoke "check_t1" (i32.const 12)) (i32.const 3)) +(assert_return (invoke "check_t1" (i32.const 13)) (i32.const 2)) +(assert_return (invoke "check_t1" (i32.const 14)) (i32.const 5)) +(assert_return (invoke "check_t1" (i32.const 15)) (i32.const 7)) +(assert_trap (invoke "check_t1" (i32.const 16)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 17)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 18)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 19)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 20)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 21)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 22)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 23)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 24)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 25)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 26)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 27)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 28)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 29)) "uninitialized element") + +(module + (type (func (result i32))) ;; type #0 + (import "a" "ef0" (func (result i32))) ;; index 0 + (import "a" "ef1" (func (result i32))) + (import "a" "ef2" (func (result i32))) + (import "a" "ef3" (func (result i32))) + (import "a" "ef4" (func (result i32))) ;; 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)) + (elem (table $t1) (i32.const 3) func 1 3 1 4) + (elem (table $t1) (i32.const 11) func 6 3 2 5 7) + (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.copy $t0 $t0 (i32.const 25) (i32.const 15) (i32.const 2))) + (func (export "check_t0") (param i32) (result i32) + (call_indirect $t0 (type 0) (local.get 0))) + (func (export "check_t1") (param i32) (result i32) + (call_indirect $t1 (type 0) (local.get 0))) +) + +(invoke "test") +(assert_trap (invoke "check_t0" (i32.const 0)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 1)) "uninitialized element") +(assert_return (invoke "check_t0" (i32.const 2)) (i32.const 3)) +(assert_return (invoke "check_t0" (i32.const 3)) (i32.const 1)) +(assert_return (invoke "check_t0" (i32.const 4)) (i32.const 4)) +(assert_return (invoke "check_t0" (i32.const 5)) (i32.const 1)) +(assert_trap (invoke "check_t0" (i32.const 6)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 7)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 8)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 9)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 10)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 11)) "uninitialized element") +(assert_return (invoke "check_t0" (i32.const 12)) (i32.const 7)) +(assert_return (invoke "check_t0" (i32.const 13)) (i32.const 5)) +(assert_return (invoke "check_t0" (i32.const 14)) (i32.const 2)) +(assert_return (invoke "check_t0" (i32.const 15)) (i32.const 3)) +(assert_return (invoke "check_t0" (i32.const 16)) (i32.const 6)) +(assert_trap (invoke "check_t0" (i32.const 17)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 18)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 19)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 20)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 21)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 22)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 23)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 24)) "uninitialized element") +(assert_return (invoke "check_t0" (i32.const 25)) (i32.const 3)) +(assert_return (invoke "check_t0" (i32.const 26)) (i32.const 6)) +(assert_trap (invoke "check_t0" (i32.const 27)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 28)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 29)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 0)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 1)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 2)) "uninitialized element") +(assert_return (invoke "check_t1" (i32.const 3)) (i32.const 1)) +(assert_return (invoke "check_t1" (i32.const 4)) (i32.const 3)) +(assert_return (invoke "check_t1" (i32.const 5)) (i32.const 1)) +(assert_return (invoke "check_t1" (i32.const 6)) (i32.const 4)) +(assert_trap (invoke "check_t1" (i32.const 7)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 8)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 9)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 10)) "uninitialized element") +(assert_return (invoke "check_t1" (i32.const 11)) (i32.const 6)) +(assert_return (invoke "check_t1" (i32.const 12)) (i32.const 3)) +(assert_return (invoke "check_t1" (i32.const 13)) (i32.const 2)) +(assert_return (invoke "check_t1" (i32.const 14)) (i32.const 5)) +(assert_return (invoke "check_t1" (i32.const 15)) (i32.const 7)) +(assert_trap (invoke "check_t1" (i32.const 16)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 17)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 18)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 19)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 20)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 21)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 22)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 23)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 24)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 25)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 26)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 27)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 28)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 29)) "uninitialized element") + +(module + (type (func (result i32))) ;; type #0 + (import "a" "ef0" (func (result i32))) ;; index 0 + (import "a" "ef1" (func (result i32))) + (import "a" "ef2" (func (result i32))) + (import "a" "ef3" (func (result i32))) + (import "a" "ef4" (func (result i32))) ;; 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)) + (elem (table $t1) (i32.const 3) func 1 3 1 4) + (elem (table $t1) (i32.const 11) func 6 3 2 5 7) + (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.copy $t0 $t0 (i32.const 13) (i32.const 25) (i32.const 3))) + (func (export "check_t0") (param i32) (result i32) + (call_indirect $t0 (type 0) (local.get 0))) + (func (export "check_t1") (param i32) (result i32) + (call_indirect $t1 (type 0) (local.get 0))) +) + +(invoke "test") +(assert_trap (invoke "check_t0" (i32.const 0)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 1)) "uninitialized element") +(assert_return (invoke "check_t0" (i32.const 2)) (i32.const 3)) +(assert_return (invoke "check_t0" (i32.const 3)) (i32.const 1)) +(assert_return (invoke "check_t0" (i32.const 4)) (i32.const 4)) +(assert_return (invoke "check_t0" (i32.const 5)) (i32.const 1)) +(assert_trap (invoke "check_t0" (i32.const 6)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 7)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 8)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 9)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 10)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 11)) "uninitialized element") +(assert_return (invoke "check_t0" (i32.const 12)) (i32.const 7)) +(assert_trap (invoke "check_t0" (i32.const 13)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 14)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 15)) "uninitialized element") +(assert_return (invoke "check_t0" (i32.const 16)) (i32.const 6)) +(assert_trap (invoke "check_t0" (i32.const 17)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 18)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 19)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 20)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 21)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 22)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 23)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 24)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 25)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 26)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 27)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 28)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 29)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 0)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 1)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 2)) "uninitialized element") +(assert_return (invoke "check_t1" (i32.const 3)) (i32.const 1)) +(assert_return (invoke "check_t1" (i32.const 4)) (i32.const 3)) +(assert_return (invoke "check_t1" (i32.const 5)) (i32.const 1)) +(assert_return (invoke "check_t1" (i32.const 6)) (i32.const 4)) +(assert_trap (invoke "check_t1" (i32.const 7)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 8)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 9)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 10)) "uninitialized element") +(assert_return (invoke "check_t1" (i32.const 11)) (i32.const 6)) +(assert_return (invoke "check_t1" (i32.const 12)) (i32.const 3)) +(assert_return (invoke "check_t1" (i32.const 13)) (i32.const 2)) +(assert_return (invoke "check_t1" (i32.const 14)) (i32.const 5)) +(assert_return (invoke "check_t1" (i32.const 15)) (i32.const 7)) +(assert_trap (invoke "check_t1" (i32.const 16)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 17)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 18)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 19)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 20)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 21)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 22)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 23)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 24)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 25)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 26)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 27)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 28)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 29)) "uninitialized element") + +(module + (type (func (result i32))) ;; type #0 + (import "a" "ef0" (func (result i32))) ;; index 0 + (import "a" "ef1" (func (result i32))) + (import "a" "ef2" (func (result i32))) + (import "a" "ef3" (func (result i32))) + (import "a" "ef4" (func (result i32))) ;; 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)) + (elem (table $t1) (i32.const 3) func 1 3 1 4) + (elem (table $t1) (i32.const 11) func 6 3 2 5 7) + (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.copy $t0 $t0 (i32.const 20) (i32.const 22) (i32.const 4))) + (func (export "check_t0") (param i32) (result i32) + (call_indirect $t0 (type 0) (local.get 0))) + (func (export "check_t1") (param i32) (result i32) + (call_indirect $t1 (type 0) (local.get 0))) +) + +(invoke "test") +(assert_trap (invoke "check_t0" (i32.const 0)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 1)) "uninitialized element") +(assert_return (invoke "check_t0" (i32.const 2)) (i32.const 3)) +(assert_return (invoke "check_t0" (i32.const 3)) (i32.const 1)) +(assert_return (invoke "check_t0" (i32.const 4)) (i32.const 4)) +(assert_return (invoke "check_t0" (i32.const 5)) (i32.const 1)) +(assert_trap (invoke "check_t0" (i32.const 6)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 7)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 8)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 9)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 10)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 11)) "uninitialized element") +(assert_return (invoke "check_t0" (i32.const 12)) (i32.const 7)) +(assert_return (invoke "check_t0" (i32.const 13)) (i32.const 5)) +(assert_return (invoke "check_t0" (i32.const 14)) (i32.const 2)) +(assert_return (invoke "check_t0" (i32.const 15)) (i32.const 3)) +(assert_return (invoke "check_t0" (i32.const 16)) (i32.const 6)) +(assert_trap (invoke "check_t0" (i32.const 17)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 18)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 19)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 20)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 21)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 22)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 23)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 24)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 25)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 26)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 27)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 28)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 29)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 0)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 1)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 2)) "uninitialized element") +(assert_return (invoke "check_t1" (i32.const 3)) (i32.const 1)) +(assert_return (invoke "check_t1" (i32.const 4)) (i32.const 3)) +(assert_return (invoke "check_t1" (i32.const 5)) (i32.const 1)) +(assert_return (invoke "check_t1" (i32.const 6)) (i32.const 4)) +(assert_trap (invoke "check_t1" (i32.const 7)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 8)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 9)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 10)) "uninitialized element") +(assert_return (invoke "check_t1" (i32.const 11)) (i32.const 6)) +(assert_return (invoke "check_t1" (i32.const 12)) (i32.const 3)) +(assert_return (invoke "check_t1" (i32.const 13)) (i32.const 2)) +(assert_return (invoke "check_t1" (i32.const 14)) (i32.const 5)) +(assert_return (invoke "check_t1" (i32.const 15)) (i32.const 7)) +(assert_trap (invoke "check_t1" (i32.const 16)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 17)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 18)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 19)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 20)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 21)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 22)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 23)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 24)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 25)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 26)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 27)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 28)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 29)) "uninitialized element") + +(module + (type (func (result i32))) ;; type #0 + (import "a" "ef0" (func (result i32))) ;; index 0 + (import "a" "ef1" (func (result i32))) + (import "a" "ef2" (func (result i32))) + (import "a" "ef3" (func (result i32))) + (import "a" "ef4" (func (result i32))) ;; 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)) + (elem (table $t1) (i32.const 3) func 1 3 1 4) + (elem (table $t1) (i32.const 11) func 6 3 2 5 7) + (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.copy $t0 $t0 (i32.const 25) (i32.const 1) (i32.const 3))) + (func (export "check_t0") (param i32) (result i32) + (call_indirect $t0 (type 0) (local.get 0))) + (func (export "check_t1") (param i32) (result i32) + (call_indirect $t1 (type 0) (local.get 0))) +) + +(invoke "test") +(assert_trap (invoke "check_t0" (i32.const 0)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 1)) "uninitialized element") +(assert_return (invoke "check_t0" (i32.const 2)) (i32.const 3)) +(assert_return (invoke "check_t0" (i32.const 3)) (i32.const 1)) +(assert_return (invoke "check_t0" (i32.const 4)) (i32.const 4)) +(assert_return (invoke "check_t0" (i32.const 5)) (i32.const 1)) +(assert_trap (invoke "check_t0" (i32.const 6)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 7)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 8)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 9)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 10)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 11)) "uninitialized element") +(assert_return (invoke "check_t0" (i32.const 12)) (i32.const 7)) +(assert_return (invoke "check_t0" (i32.const 13)) (i32.const 5)) +(assert_return (invoke "check_t0" (i32.const 14)) (i32.const 2)) +(assert_return (invoke "check_t0" (i32.const 15)) (i32.const 3)) +(assert_return (invoke "check_t0" (i32.const 16)) (i32.const 6)) +(assert_trap (invoke "check_t0" (i32.const 17)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 18)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 19)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 20)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 21)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 22)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 23)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 24)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 25)) "uninitialized element") +(assert_return (invoke "check_t0" (i32.const 26)) (i32.const 3)) +(assert_return (invoke "check_t0" (i32.const 27)) (i32.const 1)) +(assert_trap (invoke "check_t0" (i32.const 28)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 29)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 0)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 1)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 2)) "uninitialized element") +(assert_return (invoke "check_t1" (i32.const 3)) (i32.const 1)) +(assert_return (invoke "check_t1" (i32.const 4)) (i32.const 3)) +(assert_return (invoke "check_t1" (i32.const 5)) (i32.const 1)) +(assert_return (invoke "check_t1" (i32.const 6)) (i32.const 4)) +(assert_trap (invoke "check_t1" (i32.const 7)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 8)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 9)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 10)) "uninitialized element") +(assert_return (invoke "check_t1" (i32.const 11)) (i32.const 6)) +(assert_return (invoke "check_t1" (i32.const 12)) (i32.const 3)) +(assert_return (invoke "check_t1" (i32.const 13)) (i32.const 2)) +(assert_return (invoke "check_t1" (i32.const 14)) (i32.const 5)) +(assert_return (invoke "check_t1" (i32.const 15)) (i32.const 7)) +(assert_trap (invoke "check_t1" (i32.const 16)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 17)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 18)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 19)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 20)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 21)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 22)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 23)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 24)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 25)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 26)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 27)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 28)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 29)) "uninitialized element") + +(module + (type (func (result i32))) ;; type #0 + (import "a" "ef0" (func (result i32))) ;; index 0 + (import "a" "ef1" (func (result i32))) + (import "a" "ef2" (func (result i32))) + (import "a" "ef3" (func (result i32))) + (import "a" "ef4" (func (result i32))) ;; 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)) + (elem (table $t1) (i32.const 3) func 1 3 1 4) + (elem (table $t1) (i32.const 11) func 6 3 2 5 7) + (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.copy $t0 $t0 (i32.const 10) (i32.const 12) (i32.const 7))) + (func (export "check_t0") (param i32) (result i32) + (call_indirect $t0 (type 0) (local.get 0))) + (func (export "check_t1") (param i32) (result i32) + (call_indirect $t1 (type 0) (local.get 0))) +) + +(invoke "test") +(assert_trap (invoke "check_t0" (i32.const 0)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 1)) "uninitialized element") +(assert_return (invoke "check_t0" (i32.const 2)) (i32.const 3)) +(assert_return (invoke "check_t0" (i32.const 3)) (i32.const 1)) +(assert_return (invoke "check_t0" (i32.const 4)) (i32.const 4)) +(assert_return (invoke "check_t0" (i32.const 5)) (i32.const 1)) +(assert_trap (invoke "check_t0" (i32.const 6)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 7)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 8)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 9)) "uninitialized element") +(assert_return (invoke "check_t0" (i32.const 10)) (i32.const 7)) +(assert_return (invoke "check_t0" (i32.const 11)) (i32.const 5)) +(assert_return (invoke "check_t0" (i32.const 12)) (i32.const 2)) +(assert_return (invoke "check_t0" (i32.const 13)) (i32.const 3)) +(assert_return (invoke "check_t0" (i32.const 14)) (i32.const 6)) +(assert_trap (invoke "check_t0" (i32.const 15)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 16)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 17)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 18)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 19)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 20)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 21)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 22)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 23)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 24)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 25)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 26)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 27)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 28)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 29)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 0)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 1)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 2)) "uninitialized element") +(assert_return (invoke "check_t1" (i32.const 3)) (i32.const 1)) +(assert_return (invoke "check_t1" (i32.const 4)) (i32.const 3)) +(assert_return (invoke "check_t1" (i32.const 5)) (i32.const 1)) +(assert_return (invoke "check_t1" (i32.const 6)) (i32.const 4)) +(assert_trap (invoke "check_t1" (i32.const 7)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 8)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 9)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 10)) "uninitialized element") +(assert_return (invoke "check_t1" (i32.const 11)) (i32.const 6)) +(assert_return (invoke "check_t1" (i32.const 12)) (i32.const 3)) +(assert_return (invoke "check_t1" (i32.const 13)) (i32.const 2)) +(assert_return (invoke "check_t1" (i32.const 14)) (i32.const 5)) +(assert_return (invoke "check_t1" (i32.const 15)) (i32.const 7)) +(assert_trap (invoke "check_t1" (i32.const 16)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 17)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 18)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 19)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 20)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 21)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 22)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 23)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 24)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 25)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 26)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 27)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 28)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 29)) "uninitialized element") + +(module + (type (func (result i32))) ;; type #0 + (import "a" "ef0" (func (result i32))) ;; index 0 + (import "a" "ef1" (func (result i32))) + (import "a" "ef2" (func (result i32))) + (import "a" "ef3" (func (result i32))) + (import "a" "ef4" (func (result i32))) ;; 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)) + (elem (table $t1) (i32.const 3) func 1 3 1 4) + (elem (table $t1) (i32.const 11) func 6 3 2 5 7) + (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.copy $t0 $t0 (i32.const 12) (i32.const 10) (i32.const 7))) + (func (export "check_t0") (param i32) (result i32) + (call_indirect $t0 (type 0) (local.get 0))) + (func (export "check_t1") (param i32) (result i32) + (call_indirect $t1 (type 0) (local.get 0))) +) + +(invoke "test") +(assert_trap (invoke "check_t0" (i32.const 0)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 1)) "uninitialized element") +(assert_return (invoke "check_t0" (i32.const 2)) (i32.const 3)) +(assert_return (invoke "check_t0" (i32.const 3)) (i32.const 1)) +(assert_return (invoke "check_t0" (i32.const 4)) (i32.const 4)) +(assert_return (invoke "check_t0" (i32.const 5)) (i32.const 1)) +(assert_trap (invoke "check_t0" (i32.const 6)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 7)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 8)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 9)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 10)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 11)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 12)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 13)) "uninitialized element") +(assert_return (invoke "check_t0" (i32.const 14)) (i32.const 7)) +(assert_return (invoke "check_t0" (i32.const 15)) (i32.const 5)) +(assert_return (invoke "check_t0" (i32.const 16)) (i32.const 2)) +(assert_return (invoke "check_t0" (i32.const 17)) (i32.const 3)) +(assert_return (invoke "check_t0" (i32.const 18)) (i32.const 6)) +(assert_trap (invoke "check_t0" (i32.const 19)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 20)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 21)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 22)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 23)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 24)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 25)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 26)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 27)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 28)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 29)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 0)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 1)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 2)) "uninitialized element") +(assert_return (invoke "check_t1" (i32.const 3)) (i32.const 1)) +(assert_return (invoke "check_t1" (i32.const 4)) (i32.const 3)) +(assert_return (invoke "check_t1" (i32.const 5)) (i32.const 1)) +(assert_return (invoke "check_t1" (i32.const 6)) (i32.const 4)) +(assert_trap (invoke "check_t1" (i32.const 7)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 8)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 9)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 10)) "uninitialized element") +(assert_return (invoke "check_t1" (i32.const 11)) (i32.const 6)) +(assert_return (invoke "check_t1" (i32.const 12)) (i32.const 3)) +(assert_return (invoke "check_t1" (i32.const 13)) (i32.const 2)) +(assert_return (invoke "check_t1" (i32.const 14)) (i32.const 5)) +(assert_return (invoke "check_t1" (i32.const 15)) (i32.const 7)) +(assert_trap (invoke "check_t1" (i32.const 16)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 17)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 18)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 19)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 20)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 21)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 22)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 23)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 24)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 25)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 26)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 27)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 28)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 29)) "uninitialized element") + +(module + (type (func (result i32))) ;; type #0 + (import "a" "ef0" (func (result i32))) ;; index 0 + (import "a" "ef1" (func (result i32))) + (import "a" "ef2" (func (result i32))) + (import "a" "ef3" (func (result i32))) + (import "a" "ef4" (func (result i32))) ;; 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)) + (elem (table $t1) (i32.const 3) func 1 3 1 4) + (elem (table $t1) (i32.const 11) func 6 3 2 5 7) + (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.copy $t1 $t0 (i32.const 10) (i32.const 0) (i32.const 20))) + (func (export "check_t0") (param i32) (result i32) + (call_indirect $t0 (type 0) (local.get 0))) + (func (export "check_t1") (param i32) (result i32) + (call_indirect $t1 (type 0) (local.get 0))) +) + +(invoke "test") +(assert_trap (invoke "check_t0" (i32.const 0)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 1)) "uninitialized element") +(assert_return (invoke "check_t0" (i32.const 2)) (i32.const 3)) +(assert_return (invoke "check_t0" (i32.const 3)) (i32.const 1)) +(assert_return (invoke "check_t0" (i32.const 4)) (i32.const 4)) +(assert_return (invoke "check_t0" (i32.const 5)) (i32.const 1)) +(assert_trap (invoke "check_t0" (i32.const 6)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 7)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 8)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 9)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 10)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 11)) "uninitialized element") +(assert_return (invoke "check_t0" (i32.const 12)) (i32.const 7)) +(assert_return (invoke "check_t0" (i32.const 13)) (i32.const 5)) +(assert_return (invoke "check_t0" (i32.const 14)) (i32.const 2)) +(assert_return (invoke "check_t0" (i32.const 15)) (i32.const 3)) +(assert_return (invoke "check_t0" (i32.const 16)) (i32.const 6)) +(assert_trap (invoke "check_t0" (i32.const 17)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 18)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 19)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 20)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 21)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 22)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 23)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 24)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 25)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 26)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 27)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 28)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 29)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 0)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 1)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 2)) "uninitialized element") +(assert_return (invoke "check_t1" (i32.const 3)) (i32.const 1)) +(assert_return (invoke "check_t1" (i32.const 4)) (i32.const 3)) +(assert_return (invoke "check_t1" (i32.const 5)) (i32.const 1)) +(assert_return (invoke "check_t1" (i32.const 6)) (i32.const 4)) +(assert_trap (invoke "check_t1" (i32.const 7)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 8)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 9)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 10)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 11)) "uninitialized element") +(assert_return (invoke "check_t1" (i32.const 12)) (i32.const 3)) +(assert_return (invoke "check_t1" (i32.const 13)) (i32.const 1)) +(assert_return (invoke "check_t1" (i32.const 14)) (i32.const 4)) +(assert_return (invoke "check_t1" (i32.const 15)) (i32.const 1)) +(assert_trap (invoke "check_t1" (i32.const 16)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 17)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 18)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 19)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 20)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 21)) "uninitialized element") +(assert_return (invoke "check_t1" (i32.const 22)) (i32.const 7)) +(assert_return (invoke "check_t1" (i32.const 23)) (i32.const 5)) +(assert_return (invoke "check_t1" (i32.const 24)) (i32.const 2)) +(assert_return (invoke "check_t1" (i32.const 25)) (i32.const 3)) +(assert_return (invoke "check_t1" (i32.const 26)) (i32.const 6)) +(assert_trap (invoke "check_t1" (i32.const 27)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 28)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 29)) "uninitialized element") + +(module + (type (func (result i32))) ;; type #0 + (import "a" "ef0" (func (result i32))) ;; index 0 + (import "a" "ef1" (func (result i32))) + (import "a" "ef2" (func (result i32))) + (import "a" "ef3" (func (result i32))) + (import "a" "ef4" (func (result i32))) ;; 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)) + (elem (table $t0) (i32.const 3) func 1 3 1 4) + (elem (table $t0) (i32.const 11) func 6 3 2 5 7) + (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") + (nop)) + (func (export "check_t0") (param i32) (result i32) + (call_indirect $t1 (type 0) (local.get 0))) + (func (export "check_t1") (param i32) (result i32) + (call_indirect $t0 (type 0) (local.get 0))) +) + +(invoke "test") +(assert_trap (invoke "check_t0" (i32.const 0)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 1)) "uninitialized element") +(assert_return (invoke "check_t0" (i32.const 2)) (i32.const 3)) +(assert_return (invoke "check_t0" (i32.const 3)) (i32.const 1)) +(assert_return (invoke "check_t0" (i32.const 4)) (i32.const 4)) +(assert_return (invoke "check_t0" (i32.const 5)) (i32.const 1)) +(assert_trap (invoke "check_t0" (i32.const 6)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 7)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 8)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 9)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 10)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 11)) "uninitialized element") +(assert_return (invoke "check_t0" (i32.const 12)) (i32.const 7)) +(assert_return (invoke "check_t0" (i32.const 13)) (i32.const 5)) +(assert_return (invoke "check_t0" (i32.const 14)) (i32.const 2)) +(assert_return (invoke "check_t0" (i32.const 15)) (i32.const 3)) +(assert_return (invoke "check_t0" (i32.const 16)) (i32.const 6)) +(assert_trap (invoke "check_t0" (i32.const 17)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 18)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 19)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 20)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 21)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 22)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 23)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 24)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 25)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 26)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 27)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 28)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 29)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 0)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 1)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 2)) "uninitialized element") +(assert_return (invoke "check_t1" (i32.const 3)) (i32.const 1)) +(assert_return (invoke "check_t1" (i32.const 4)) (i32.const 3)) +(assert_return (invoke "check_t1" (i32.const 5)) (i32.const 1)) +(assert_return (invoke "check_t1" (i32.const 6)) (i32.const 4)) +(assert_trap (invoke "check_t1" (i32.const 7)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 8)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 9)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 10)) "uninitialized element") +(assert_return (invoke "check_t1" (i32.const 11)) (i32.const 6)) +(assert_return (invoke "check_t1" (i32.const 12)) (i32.const 3)) +(assert_return (invoke "check_t1" (i32.const 13)) (i32.const 2)) +(assert_return (invoke "check_t1" (i32.const 14)) (i32.const 5)) +(assert_return (invoke "check_t1" (i32.const 15)) (i32.const 7)) +(assert_trap (invoke "check_t1" (i32.const 16)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 17)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 18)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 19)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 20)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 21)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 22)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 23)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 24)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 25)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 26)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 27)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 28)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 29)) "uninitialized element") + +(module + (type (func (result i32))) ;; type #0 + (import "a" "ef0" (func (result i32))) ;; index 0 + (import "a" "ef1" (func (result i32))) + (import "a" "ef2" (func (result i32))) + (import "a" "ef3" (func (result i32))) + (import "a" "ef4" (func (result i32))) ;; 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)) + (elem (table $t0) (i32.const 3) func 1 3 1 4) + (elem (table $t0) (i32.const 11) func 6 3 2 5 7) + (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.copy $t1 $t1 (i32.const 13) (i32.const 2) (i32.const 3))) + (func (export "check_t0") (param i32) (result i32) + (call_indirect $t1 (type 0) (local.get 0))) + (func (export "check_t1") (param i32) (result i32) + (call_indirect $t0 (type 0) (local.get 0))) +) + +(invoke "test") +(assert_trap (invoke "check_t0" (i32.const 0)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 1)) "uninitialized element") +(assert_return (invoke "check_t0" (i32.const 2)) (i32.const 3)) +(assert_return (invoke "check_t0" (i32.const 3)) (i32.const 1)) +(assert_return (invoke "check_t0" (i32.const 4)) (i32.const 4)) +(assert_return (invoke "check_t0" (i32.const 5)) (i32.const 1)) +(assert_trap (invoke "check_t0" (i32.const 6)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 7)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 8)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 9)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 10)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 11)) "uninitialized element") +(assert_return (invoke "check_t0" (i32.const 12)) (i32.const 7)) +(assert_return (invoke "check_t0" (i32.const 13)) (i32.const 3)) +(assert_return (invoke "check_t0" (i32.const 14)) (i32.const 1)) +(assert_return (invoke "check_t0" (i32.const 15)) (i32.const 4)) +(assert_return (invoke "check_t0" (i32.const 16)) (i32.const 6)) +(assert_trap (invoke "check_t0" (i32.const 17)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 18)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 19)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 20)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 21)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 22)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 23)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 24)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 25)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 26)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 27)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 28)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 29)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 0)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 1)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 2)) "uninitialized element") +(assert_return (invoke "check_t1" (i32.const 3)) (i32.const 1)) +(assert_return (invoke "check_t1" (i32.const 4)) (i32.const 3)) +(assert_return (invoke "check_t1" (i32.const 5)) (i32.const 1)) +(assert_return (invoke "check_t1" (i32.const 6)) (i32.const 4)) +(assert_trap (invoke "check_t1" (i32.const 7)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 8)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 9)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 10)) "uninitialized element") +(assert_return (invoke "check_t1" (i32.const 11)) (i32.const 6)) +(assert_return (invoke "check_t1" (i32.const 12)) (i32.const 3)) +(assert_return (invoke "check_t1" (i32.const 13)) (i32.const 2)) +(assert_return (invoke "check_t1" (i32.const 14)) (i32.const 5)) +(assert_return (invoke "check_t1" (i32.const 15)) (i32.const 7)) +(assert_trap (invoke "check_t1" (i32.const 16)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 17)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 18)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 19)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 20)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 21)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 22)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 23)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 24)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 25)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 26)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 27)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 28)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 29)) "uninitialized element") + +(module + (type (func (result i32))) ;; type #0 + (import "a" "ef0" (func (result i32))) ;; index 0 + (import "a" "ef1" (func (result i32))) + (import "a" "ef2" (func (result i32))) + (import "a" "ef3" (func (result i32))) + (import "a" "ef4" (func (result i32))) ;; 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)) + (elem (table $t0) (i32.const 3) func 1 3 1 4) + (elem (table $t0) (i32.const 11) func 6 3 2 5 7) + (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.copy $t1 $t1 (i32.const 25) (i32.const 15) (i32.const 2))) + (func (export "check_t0") (param i32) (result i32) + (call_indirect $t1 (type 0) (local.get 0))) + (func (export "check_t1") (param i32) (result i32) + (call_indirect $t0 (type 0) (local.get 0))) +) + +(invoke "test") +(assert_trap (invoke "check_t0" (i32.const 0)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 1)) "uninitialized element") +(assert_return (invoke "check_t0" (i32.const 2)) (i32.const 3)) +(assert_return (invoke "check_t0" (i32.const 3)) (i32.const 1)) +(assert_return (invoke "check_t0" (i32.const 4)) (i32.const 4)) +(assert_return (invoke "check_t0" (i32.const 5)) (i32.const 1)) +(assert_trap (invoke "check_t0" (i32.const 6)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 7)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 8)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 9)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 10)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 11)) "uninitialized element") +(assert_return (invoke "check_t0" (i32.const 12)) (i32.const 7)) +(assert_return (invoke "check_t0" (i32.const 13)) (i32.const 5)) +(assert_return (invoke "check_t0" (i32.const 14)) (i32.const 2)) +(assert_return (invoke "check_t0" (i32.const 15)) (i32.const 3)) +(assert_return (invoke "check_t0" (i32.const 16)) (i32.const 6)) +(assert_trap (invoke "check_t0" (i32.const 17)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 18)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 19)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 20)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 21)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 22)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 23)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 24)) "uninitialized element") +(assert_return (invoke "check_t0" (i32.const 25)) (i32.const 3)) +(assert_return (invoke "check_t0" (i32.const 26)) (i32.const 6)) +(assert_trap (invoke "check_t0" (i32.const 27)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 28)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 29)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 0)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 1)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 2)) "uninitialized element") +(assert_return (invoke "check_t1" (i32.const 3)) (i32.const 1)) +(assert_return (invoke "check_t1" (i32.const 4)) (i32.const 3)) +(assert_return (invoke "check_t1" (i32.const 5)) (i32.const 1)) +(assert_return (invoke "check_t1" (i32.const 6)) (i32.const 4)) +(assert_trap (invoke "check_t1" (i32.const 7)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 8)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 9)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 10)) "uninitialized element") +(assert_return (invoke "check_t1" (i32.const 11)) (i32.const 6)) +(assert_return (invoke "check_t1" (i32.const 12)) (i32.const 3)) +(assert_return (invoke "check_t1" (i32.const 13)) (i32.const 2)) +(assert_return (invoke "check_t1" (i32.const 14)) (i32.const 5)) +(assert_return (invoke "check_t1" (i32.const 15)) (i32.const 7)) +(assert_trap (invoke "check_t1" (i32.const 16)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 17)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 18)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 19)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 20)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 21)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 22)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 23)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 24)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 25)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 26)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 27)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 28)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 29)) "uninitialized element") + +(module + (type (func (result i32))) ;; type #0 + (import "a" "ef0" (func (result i32))) ;; index 0 + (import "a" "ef1" (func (result i32))) + (import "a" "ef2" (func (result i32))) + (import "a" "ef3" (func (result i32))) + (import "a" "ef4" (func (result i32))) ;; 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)) + (elem (table $t0) (i32.const 3) func 1 3 1 4) + (elem (table $t0) (i32.const 11) func 6 3 2 5 7) + (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.copy $t1 $t1 (i32.const 13) (i32.const 25) (i32.const 3))) + (func (export "check_t0") (param i32) (result i32) + (call_indirect $t1 (type 0) (local.get 0))) + (func (export "check_t1") (param i32) (result i32) + (call_indirect $t0 (type 0) (local.get 0))) +) + +(invoke "test") +(assert_trap (invoke "check_t0" (i32.const 0)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 1)) "uninitialized element") +(assert_return (invoke "check_t0" (i32.const 2)) (i32.const 3)) +(assert_return (invoke "check_t0" (i32.const 3)) (i32.const 1)) +(assert_return (invoke "check_t0" (i32.const 4)) (i32.const 4)) +(assert_return (invoke "check_t0" (i32.const 5)) (i32.const 1)) +(assert_trap (invoke "check_t0" (i32.const 6)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 7)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 8)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 9)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 10)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 11)) "uninitialized element") +(assert_return (invoke "check_t0" (i32.const 12)) (i32.const 7)) +(assert_trap (invoke "check_t0" (i32.const 13)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 14)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 15)) "uninitialized element") +(assert_return (invoke "check_t0" (i32.const 16)) (i32.const 6)) +(assert_trap (invoke "check_t0" (i32.const 17)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 18)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 19)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 20)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 21)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 22)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 23)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 24)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 25)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 26)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 27)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 28)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 29)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 0)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 1)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 2)) "uninitialized element") +(assert_return (invoke "check_t1" (i32.const 3)) (i32.const 1)) +(assert_return (invoke "check_t1" (i32.const 4)) (i32.const 3)) +(assert_return (invoke "check_t1" (i32.const 5)) (i32.const 1)) +(assert_return (invoke "check_t1" (i32.const 6)) (i32.const 4)) +(assert_trap (invoke "check_t1" (i32.const 7)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 8)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 9)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 10)) "uninitialized element") +(assert_return (invoke "check_t1" (i32.const 11)) (i32.const 6)) +(assert_return (invoke "check_t1" (i32.const 12)) (i32.const 3)) +(assert_return (invoke "check_t1" (i32.const 13)) (i32.const 2)) +(assert_return (invoke "check_t1" (i32.const 14)) (i32.const 5)) +(assert_return (invoke "check_t1" (i32.const 15)) (i32.const 7)) +(assert_trap (invoke "check_t1" (i32.const 16)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 17)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 18)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 19)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 20)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 21)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 22)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 23)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 24)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 25)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 26)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 27)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 28)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 29)) "uninitialized element") + +(module + (type (func (result i32))) ;; type #0 + (import "a" "ef0" (func (result i32))) ;; index 0 + (import "a" "ef1" (func (result i32))) + (import "a" "ef2" (func (result i32))) + (import "a" "ef3" (func (result i32))) + (import "a" "ef4" (func (result i32))) ;; 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)) + (elem (table $t0) (i32.const 3) func 1 3 1 4) + (elem (table $t0) (i32.const 11) func 6 3 2 5 7) + (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.copy $t1 $t1 (i32.const 20) (i32.const 22) (i32.const 4))) + (func (export "check_t0") (param i32) (result i32) + (call_indirect $t1 (type 0) (local.get 0))) + (func (export "check_t1") (param i32) (result i32) + (call_indirect $t0 (type 0) (local.get 0))) +) + +(invoke "test") +(assert_trap (invoke "check_t0" (i32.const 0)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 1)) "uninitialized element") +(assert_return (invoke "check_t0" (i32.const 2)) (i32.const 3)) +(assert_return (invoke "check_t0" (i32.const 3)) (i32.const 1)) +(assert_return (invoke "check_t0" (i32.const 4)) (i32.const 4)) +(assert_return (invoke "check_t0" (i32.const 5)) (i32.const 1)) +(assert_trap (invoke "check_t0" (i32.const 6)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 7)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 8)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 9)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 10)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 11)) "uninitialized element") +(assert_return (invoke "check_t0" (i32.const 12)) (i32.const 7)) +(assert_return (invoke "check_t0" (i32.const 13)) (i32.const 5)) +(assert_return (invoke "check_t0" (i32.const 14)) (i32.const 2)) +(assert_return (invoke "check_t0" (i32.const 15)) (i32.const 3)) +(assert_return (invoke "check_t0" (i32.const 16)) (i32.const 6)) +(assert_trap (invoke "check_t0" (i32.const 17)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 18)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 19)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 20)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 21)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 22)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 23)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 24)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 25)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 26)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 27)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 28)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 29)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 0)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 1)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 2)) "uninitialized element") +(assert_return (invoke "check_t1" (i32.const 3)) (i32.const 1)) +(assert_return (invoke "check_t1" (i32.const 4)) (i32.const 3)) +(assert_return (invoke "check_t1" (i32.const 5)) (i32.const 1)) +(assert_return (invoke "check_t1" (i32.const 6)) (i32.const 4)) +(assert_trap (invoke "check_t1" (i32.const 7)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 8)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 9)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 10)) "uninitialized element") +(assert_return (invoke "check_t1" (i32.const 11)) (i32.const 6)) +(assert_return (invoke "check_t1" (i32.const 12)) (i32.const 3)) +(assert_return (invoke "check_t1" (i32.const 13)) (i32.const 2)) +(assert_return (invoke "check_t1" (i32.const 14)) (i32.const 5)) +(assert_return (invoke "check_t1" (i32.const 15)) (i32.const 7)) +(assert_trap (invoke "check_t1" (i32.const 16)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 17)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 18)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 19)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 20)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 21)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 22)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 23)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 24)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 25)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 26)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 27)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 28)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 29)) "uninitialized element") + +(module + (type (func (result i32))) ;; type #0 + (import "a" "ef0" (func (result i32))) ;; index 0 + (import "a" "ef1" (func (result i32))) + (import "a" "ef2" (func (result i32))) + (import "a" "ef3" (func (result i32))) + (import "a" "ef4" (func (result i32))) ;; 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)) + (elem (table $t0) (i32.const 3) func 1 3 1 4) + (elem (table $t0) (i32.const 11) func 6 3 2 5 7) + (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.copy $t1 $t1 (i32.const 25) (i32.const 1) (i32.const 3))) + (func (export "check_t0") (param i32) (result i32) + (call_indirect $t1 (type 0) (local.get 0))) + (func (export "check_t1") (param i32) (result i32) + (call_indirect $t0 (type 0) (local.get 0))) +) + +(invoke "test") +(assert_trap (invoke "check_t0" (i32.const 0)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 1)) "uninitialized element") +(assert_return (invoke "check_t0" (i32.const 2)) (i32.const 3)) +(assert_return (invoke "check_t0" (i32.const 3)) (i32.const 1)) +(assert_return (invoke "check_t0" (i32.const 4)) (i32.const 4)) +(assert_return (invoke "check_t0" (i32.const 5)) (i32.const 1)) +(assert_trap (invoke "check_t0" (i32.const 6)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 7)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 8)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 9)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 10)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 11)) "uninitialized element") +(assert_return (invoke "check_t0" (i32.const 12)) (i32.const 7)) +(assert_return (invoke "check_t0" (i32.const 13)) (i32.const 5)) +(assert_return (invoke "check_t0" (i32.const 14)) (i32.const 2)) +(assert_return (invoke "check_t0" (i32.const 15)) (i32.const 3)) +(assert_return (invoke "check_t0" (i32.const 16)) (i32.const 6)) +(assert_trap (invoke "check_t0" (i32.const 17)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 18)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 19)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 20)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 21)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 22)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 23)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 24)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 25)) "uninitialized element") +(assert_return (invoke "check_t0" (i32.const 26)) (i32.const 3)) +(assert_return (invoke "check_t0" (i32.const 27)) (i32.const 1)) +(assert_trap (invoke "check_t0" (i32.const 28)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 29)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 0)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 1)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 2)) "uninitialized element") +(assert_return (invoke "check_t1" (i32.const 3)) (i32.const 1)) +(assert_return (invoke "check_t1" (i32.const 4)) (i32.const 3)) +(assert_return (invoke "check_t1" (i32.const 5)) (i32.const 1)) +(assert_return (invoke "check_t1" (i32.const 6)) (i32.const 4)) +(assert_trap (invoke "check_t1" (i32.const 7)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 8)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 9)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 10)) "uninitialized element") +(assert_return (invoke "check_t1" (i32.const 11)) (i32.const 6)) +(assert_return (invoke "check_t1" (i32.const 12)) (i32.const 3)) +(assert_return (invoke "check_t1" (i32.const 13)) (i32.const 2)) +(assert_return (invoke "check_t1" (i32.const 14)) (i32.const 5)) +(assert_return (invoke "check_t1" (i32.const 15)) (i32.const 7)) +(assert_trap (invoke "check_t1" (i32.const 16)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 17)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 18)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 19)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 20)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 21)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 22)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 23)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 24)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 25)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 26)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 27)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 28)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 29)) "uninitialized element") + +(module + (type (func (result i32))) ;; type #0 + (import "a" "ef0" (func (result i32))) ;; index 0 + (import "a" "ef1" (func (result i32))) + (import "a" "ef2" (func (result i32))) + (import "a" "ef3" (func (result i32))) + (import "a" "ef4" (func (result i32))) ;; 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)) + (elem (table $t0) (i32.const 3) func 1 3 1 4) + (elem (table $t0) (i32.const 11) func 6 3 2 5 7) + (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.copy $t1 $t1 (i32.const 10) (i32.const 12) (i32.const 7))) + (func (export "check_t0") (param i32) (result i32) + (call_indirect $t1 (type 0) (local.get 0))) + (func (export "check_t1") (param i32) (result i32) + (call_indirect $t0 (type 0) (local.get 0))) +) + +(invoke "test") +(assert_trap (invoke "check_t0" (i32.const 0)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 1)) "uninitialized element") +(assert_return (invoke "check_t0" (i32.const 2)) (i32.const 3)) +(assert_return (invoke "check_t0" (i32.const 3)) (i32.const 1)) +(assert_return (invoke "check_t0" (i32.const 4)) (i32.const 4)) +(assert_return (invoke "check_t0" (i32.const 5)) (i32.const 1)) +(assert_trap (invoke "check_t0" (i32.const 6)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 7)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 8)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 9)) "uninitialized element") +(assert_return (invoke "check_t0" (i32.const 10)) (i32.const 7)) +(assert_return (invoke "check_t0" (i32.const 11)) (i32.const 5)) +(assert_return (invoke "check_t0" (i32.const 12)) (i32.const 2)) +(assert_return (invoke "check_t0" (i32.const 13)) (i32.const 3)) +(assert_return (invoke "check_t0" (i32.const 14)) (i32.const 6)) +(assert_trap (invoke "check_t0" (i32.const 15)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 16)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 17)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 18)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 19)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 20)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 21)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 22)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 23)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 24)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 25)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 26)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 27)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 28)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 29)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 0)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 1)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 2)) "uninitialized element") +(assert_return (invoke "check_t1" (i32.const 3)) (i32.const 1)) +(assert_return (invoke "check_t1" (i32.const 4)) (i32.const 3)) +(assert_return (invoke "check_t1" (i32.const 5)) (i32.const 1)) +(assert_return (invoke "check_t1" (i32.const 6)) (i32.const 4)) +(assert_trap (invoke "check_t1" (i32.const 7)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 8)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 9)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 10)) "uninitialized element") +(assert_return (invoke "check_t1" (i32.const 11)) (i32.const 6)) +(assert_return (invoke "check_t1" (i32.const 12)) (i32.const 3)) +(assert_return (invoke "check_t1" (i32.const 13)) (i32.const 2)) +(assert_return (invoke "check_t1" (i32.const 14)) (i32.const 5)) +(assert_return (invoke "check_t1" (i32.const 15)) (i32.const 7)) +(assert_trap (invoke "check_t1" (i32.const 16)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 17)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 18)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 19)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 20)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 21)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 22)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 23)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 24)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 25)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 26)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 27)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 28)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 29)) "uninitialized element") + +(module + (type (func (result i32))) ;; type #0 + (import "a" "ef0" (func (result i32))) ;; index 0 + (import "a" "ef1" (func (result i32))) + (import "a" "ef2" (func (result i32))) + (import "a" "ef3" (func (result i32))) + (import "a" "ef4" (func (result i32))) ;; 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)) + (elem (table $t0) (i32.const 3) func 1 3 1 4) + (elem (table $t0) (i32.const 11) func 6 3 2 5 7) + (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.copy $t1 $t1 (i32.const 12) (i32.const 10) (i32.const 7))) + (func (export "check_t0") (param i32) (result i32) + (call_indirect $t1 (type 0) (local.get 0))) + (func (export "check_t1") (param i32) (result i32) + (call_indirect $t0 (type 0) (local.get 0))) +) + +(invoke "test") +(assert_trap (invoke "check_t0" (i32.const 0)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 1)) "uninitialized element") +(assert_return (invoke "check_t0" (i32.const 2)) (i32.const 3)) +(assert_return (invoke "check_t0" (i32.const 3)) (i32.const 1)) +(assert_return (invoke "check_t0" (i32.const 4)) (i32.const 4)) +(assert_return (invoke "check_t0" (i32.const 5)) (i32.const 1)) +(assert_trap (invoke "check_t0" (i32.const 6)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 7)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 8)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 9)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 10)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 11)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 12)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 13)) "uninitialized element") +(assert_return (invoke "check_t0" (i32.const 14)) (i32.const 7)) +(assert_return (invoke "check_t0" (i32.const 15)) (i32.const 5)) +(assert_return (invoke "check_t0" (i32.const 16)) (i32.const 2)) +(assert_return (invoke "check_t0" (i32.const 17)) (i32.const 3)) +(assert_return (invoke "check_t0" (i32.const 18)) (i32.const 6)) +(assert_trap (invoke "check_t0" (i32.const 19)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 20)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 21)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 22)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 23)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 24)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 25)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 26)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 27)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 28)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 29)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 0)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 1)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 2)) "uninitialized element") +(assert_return (invoke "check_t1" (i32.const 3)) (i32.const 1)) +(assert_return (invoke "check_t1" (i32.const 4)) (i32.const 3)) +(assert_return (invoke "check_t1" (i32.const 5)) (i32.const 1)) +(assert_return (invoke "check_t1" (i32.const 6)) (i32.const 4)) +(assert_trap (invoke "check_t1" (i32.const 7)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 8)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 9)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 10)) "uninitialized element") +(assert_return (invoke "check_t1" (i32.const 11)) (i32.const 6)) +(assert_return (invoke "check_t1" (i32.const 12)) (i32.const 3)) +(assert_return (invoke "check_t1" (i32.const 13)) (i32.const 2)) +(assert_return (invoke "check_t1" (i32.const 14)) (i32.const 5)) +(assert_return (invoke "check_t1" (i32.const 15)) (i32.const 7)) +(assert_trap (invoke "check_t1" (i32.const 16)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 17)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 18)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 19)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 20)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 21)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 22)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 23)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 24)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 25)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 26)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 27)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 28)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 29)) "uninitialized element") + +(module + (type (func (result i32))) ;; type #0 + (import "a" "ef0" (func (result i32))) ;; index 0 + (import "a" "ef1" (func (result i32))) + (import "a" "ef2" (func (result i32))) + (import "a" "ef3" (func (result i32))) + (import "a" "ef4" (func (result i32))) ;; 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)) + (elem (table $t0) (i32.const 3) func 1 3 1 4) + (elem (table $t0) (i32.const 11) func 6 3 2 5 7) + (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.copy $t0 $t1 (i32.const 10) (i32.const 0) (i32.const 20))) + (func (export "check_t0") (param i32) (result i32) + (call_indirect $t1 (type 0) (local.get 0))) + (func (export "check_t1") (param i32) (result i32) + (call_indirect $t0 (type 0) (local.get 0))) +) + +(invoke "test") +(assert_trap (invoke "check_t0" (i32.const 0)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 1)) "uninitialized element") +(assert_return (invoke "check_t0" (i32.const 2)) (i32.const 3)) +(assert_return (invoke "check_t0" (i32.const 3)) (i32.const 1)) +(assert_return (invoke "check_t0" (i32.const 4)) (i32.const 4)) +(assert_return (invoke "check_t0" (i32.const 5)) (i32.const 1)) +(assert_trap (invoke "check_t0" (i32.const 6)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 7)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 8)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 9)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 10)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 11)) "uninitialized element") +(assert_return (invoke "check_t0" (i32.const 12)) (i32.const 7)) +(assert_return (invoke "check_t0" (i32.const 13)) (i32.const 5)) +(assert_return (invoke "check_t0" (i32.const 14)) (i32.const 2)) +(assert_return (invoke "check_t0" (i32.const 15)) (i32.const 3)) +(assert_return (invoke "check_t0" (i32.const 16)) (i32.const 6)) +(assert_trap (invoke "check_t0" (i32.const 17)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 18)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 19)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 20)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 21)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 22)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 23)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 24)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 25)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 26)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 27)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 28)) "uninitialized element") +(assert_trap (invoke "check_t0" (i32.const 29)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 0)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 1)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 2)) "uninitialized element") +(assert_return (invoke "check_t1" (i32.const 3)) (i32.const 1)) +(assert_return (invoke "check_t1" (i32.const 4)) (i32.const 3)) +(assert_return (invoke "check_t1" (i32.const 5)) (i32.const 1)) +(assert_return (invoke "check_t1" (i32.const 6)) (i32.const 4)) +(assert_trap (invoke "check_t1" (i32.const 7)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 8)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 9)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 10)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 11)) "uninitialized element") +(assert_return (invoke "check_t1" (i32.const 12)) (i32.const 3)) +(assert_return (invoke "check_t1" (i32.const 13)) (i32.const 1)) +(assert_return (invoke "check_t1" (i32.const 14)) (i32.const 4)) +(assert_return (invoke "check_t1" (i32.const 15)) (i32.const 1)) +(assert_trap (invoke "check_t1" (i32.const 16)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 17)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 18)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 19)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 20)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 21)) "uninitialized element") +(assert_return (invoke "check_t1" (i32.const 22)) (i32.const 7)) +(assert_return (invoke "check_t1" (i32.const 23)) (i32.const 5)) +(assert_return (invoke "check_t1" (i32.const 24)) (i32.const 2)) +(assert_return (invoke "check_t1" (i32.const 25)) (i32.const 3)) +(assert_return (invoke "check_t1" (i32.const 26)) (i32.const 6)) +(assert_trap (invoke "check_t1" (i32.const 27)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 28)) "uninitialized element") +(assert_trap (invoke "check_t1" (i32.const 29)) "uninitialized element") + +(module + (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 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.copy $t0 $t0 (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 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 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.copy $t0 $t0 (i32.const 0xFFFFFFFE) (i32.const 1) (i32.const 2)) + )) + +(assert_trap (invoke "test") "out of bounds table access") + +(module + (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 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.copy $t0 $t0 (i32.const 15) (i32.const 25) (i32.const 6)) + )) + +(assert_trap (invoke "test") "out of bounds table access") + +(module + (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 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.copy $t0 $t0 (i32.const 15) (i32.const 0xFFFFFFFE) (i32.const 2)) + )) + +(assert_trap (invoke "test") "out of bounds table access") + +(module + (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 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.copy $t0 $t0 (i32.const 15) (i32.const 25) (i32.const 0)) + )) + +(invoke "test") + +(module + (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 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.copy $t0 $t0 (i32.const 30) (i32.const 15) (i32.const 0)) + )) + +(invoke "test") + +(module + (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 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.copy $t0 $t0 (i32.const 31) (i32.const 15) (i32.const 0)) + )) + +(assert_trap (invoke "test") "out of bounds table access") + +(module + (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 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.copy $t0 $t0 (i32.const 15) (i32.const 30) (i32.const 0)) + )) + +(invoke "test") + +(module + (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 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.copy $t0 $t0 (i32.const 15) (i32.const 31) (i32.const 0)) + )) + +(assert_trap (invoke "test") "out of bounds table access") + +(module + (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 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.copy $t0 $t0 (i32.const 30) (i32.const 30) (i32.const 0)) + )) + +(invoke "test") + +(module + (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 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.copy $t0 $t0 (i32.const 31) (i32.const 31) (i32.const 0)) + )) + +(assert_trap (invoke "test") "out of bounds table access") + +(module + (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 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.copy $t1 $t0 (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 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 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.copy $t1 $t0 (i32.const 0xFFFFFFFE) (i32.const 1) (i32.const 2)) + )) + +(assert_trap (invoke "test") "out of bounds table access") + +(module + (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 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.copy $t1 $t0 (i32.const 15) (i32.const 25) (i32.const 6)) + )) + +(assert_trap (invoke "test") "out of bounds table access") + +(module + (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 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.copy $t1 $t0 (i32.const 15) (i32.const 0xFFFFFFFE) (i32.const 2)) + )) + +(assert_trap (invoke "test") "out of bounds table access") + +(module + (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 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.copy $t1 $t0 (i32.const 15) (i32.const 25) (i32.const 0)) + )) + +(invoke "test") + +(module + (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 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.copy $t1 $t0 (i32.const 30) (i32.const 15) (i32.const 0)) + )) + +(invoke "test") + +(module + (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 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.copy $t1 $t0 (i32.const 31) (i32.const 15) (i32.const 0)) + )) + +(assert_trap (invoke "test") "out of bounds table access") + +(module + (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 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.copy $t1 $t0 (i32.const 15) (i32.const 30) (i32.const 0)) + )) + +(invoke "test") + +(module + (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 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.copy $t1 $t0 (i32.const 15) (i32.const 31) (i32.const 0)) + )) + +(assert_trap (invoke "test") "out of bounds table access") + +(module + (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 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.copy $t1 $t0 (i32.const 30) (i32.const 30) (i32.const 0)) + )) + +(invoke "test") + +(module + (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 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.copy $t1 $t0 (i32.const 31) (i32.const 31) (i32.const 0)) + )) + +(assert_trap (invoke "test") "out of bounds table access") + +(module + (type (func (result i32))) + (table 32 64 funcref) + (elem (i32.const 0) + $f0 $f1 $f2 $f3 $f4 $f5 $f6 $f7) + (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 $targetOffs i32) (param $srcOffs i32) (param $len i32) + (table.copy (local.get $targetOffs) (local.get $srcOffs) (local.get $len)))) + +(assert_trap (invoke "run" (i32.const 24) (i32.const 0) (i32.const 16)) + "out of bounds table access") +(assert_return (invoke "test" (i32.const 0)) (i32.const 0)) +(assert_return (invoke "test" (i32.const 1)) (i32.const 1)) +(assert_return (invoke "test" (i32.const 2)) (i32.const 2)) +(assert_return (invoke "test" (i32.const 3)) (i32.const 3)) +(assert_return (invoke "test" (i32.const 4)) (i32.const 4)) +(assert_return (invoke "test" (i32.const 5)) (i32.const 5)) +(assert_return (invoke "test" (i32.const 6)) (i32.const 6)) +(assert_return (invoke "test" (i32.const 7)) (i32.const 7)) +(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 (i32.const 0) + $f0 $f1 $f2 $f3 $f4 $f5 $f6 $f7 $f8) + (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 $targetOffs i32) (param $srcOffs i32) (param $len i32) + (table.copy (local.get $targetOffs) (local.get $srcOffs) (local.get $len)))) + +(assert_trap (invoke "run" (i32.const 23) (i32.const 0) (i32.const 15)) + "out of bounds table access") +(assert_return (invoke "test" (i32.const 0)) (i32.const 0)) +(assert_return (invoke "test" (i32.const 1)) (i32.const 1)) +(assert_return (invoke "test" (i32.const 2)) (i32.const 2)) +(assert_return (invoke "test" (i32.const 3)) (i32.const 3)) +(assert_return (invoke "test" (i32.const 4)) (i32.const 4)) +(assert_return (invoke "test" (i32.const 5)) (i32.const 5)) +(assert_return (invoke "test" (i32.const 6)) (i32.const 6)) +(assert_return (invoke "test" (i32.const 7)) (i32.const 7)) +(assert_return (invoke "test" (i32.const 8)) (i32.const 8)) +(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 (i32.const 24) + $f0 $f1 $f2 $f3 $f4 $f5 $f6 $f7) + (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 $targetOffs i32) (param $srcOffs i32) (param $len i32) + (table.copy (local.get $targetOffs) (local.get $srcOffs) (local.get $len)))) + +(assert_trap (invoke "run" (i32.const 0) (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_return (invoke "test" (i32.const 24)) (i32.const 0)) +(assert_return (invoke "test" (i32.const 25)) (i32.const 1)) +(assert_return (invoke "test" (i32.const 26)) (i32.const 2)) +(assert_return (invoke "test" (i32.const 27)) (i32.const 3)) +(assert_return (invoke "test" (i32.const 28)) (i32.const 4)) +(assert_return (invoke "test" (i32.const 29)) (i32.const 5)) +(assert_return (invoke "test" (i32.const 30)) (i32.const 6)) +(assert_return (invoke "test" (i32.const 31)) (i32.const 7)) + +(module + (type (func (result i32))) + (table 32 64 funcref) + (elem (i32.const 23) + $f0 $f1 $f2 $f3 $f4 $f5 $f6 $f7 $f8) + (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 $targetOffs i32) (param $srcOffs i32) (param $len i32) + (table.copy (local.get $targetOffs) (local.get $srcOffs) (local.get $len)))) + +(assert_trap (invoke "run" (i32.const 0) (i32.const 23) (i32.const 15)) + "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_return (invoke "test" (i32.const 23)) (i32.const 0)) +(assert_return (invoke "test" (i32.const 24)) (i32.const 1)) +(assert_return (invoke "test" (i32.const 25)) (i32.const 2)) +(assert_return (invoke "test" (i32.const 26)) (i32.const 3)) +(assert_return (invoke "test" (i32.const 27)) (i32.const 4)) +(assert_return (invoke "test" (i32.const 28)) (i32.const 5)) +(assert_return (invoke "test" (i32.const 29)) (i32.const 6)) +(assert_return (invoke "test" (i32.const 30)) (i32.const 7)) +(assert_return (invoke "test" (i32.const 31)) (i32.const 8)) + +(module + (type (func (result i32))) + (table 32 64 funcref) + (elem (i32.const 11) + $f0 $f1 $f2 $f3 $f4 $f5 $f6 $f7) + (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 $targetOffs i32) (param $srcOffs i32) (param $len i32) + (table.copy (local.get $targetOffs) (local.get $srcOffs) (local.get $len)))) + +(assert_trap (invoke "run" (i32.const 24) (i32.const 11) (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_return (invoke "test" (i32.const 11)) (i32.const 0)) +(assert_return (invoke "test" (i32.const 12)) (i32.const 1)) +(assert_return (invoke "test" (i32.const 13)) (i32.const 2)) +(assert_return (invoke "test" (i32.const 14)) (i32.const 3)) +(assert_return (invoke "test" (i32.const 15)) (i32.const 4)) +(assert_return (invoke "test" (i32.const 16)) (i32.const 5)) +(assert_return (invoke "test" (i32.const 17)) (i32.const 6)) +(assert_return (invoke "test" (i32.const 18)) (i32.const 7)) +(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 (i32.const 24) + $f0 $f1 $f2 $f3 $f4 $f5 $f6 $f7) + (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 $targetOffs i32) (param $srcOffs i32) (param $len i32) + (table.copy (local.get $targetOffs) (local.get $srcOffs) (local.get $len)))) + +(assert_trap (invoke "run" (i32.const 11) (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_return (invoke "test" (i32.const 24)) (i32.const 0)) +(assert_return (invoke "test" (i32.const 25)) (i32.const 1)) +(assert_return (invoke "test" (i32.const 26)) (i32.const 2)) +(assert_return (invoke "test" (i32.const 27)) (i32.const 3)) +(assert_return (invoke "test" (i32.const 28)) (i32.const 4)) +(assert_return (invoke "test" (i32.const 29)) (i32.const 5)) +(assert_return (invoke "test" (i32.const 30)) (i32.const 6)) +(assert_return (invoke "test" (i32.const 31)) (i32.const 7)) + +(module + (type (func (result i32))) + (table 32 64 funcref) + (elem (i32.const 21) + $f0 $f1 $f2 $f3 $f4 $f5 $f6 $f7) + (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 $targetOffs i32) (param $srcOffs i32) (param $len i32) + (table.copy (local.get $targetOffs) (local.get $srcOffs) (local.get $len)))) + +(assert_trap (invoke "run" (i32.const 24) (i32.const 21) (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_return (invoke "test" (i32.const 21)) (i32.const 0)) +(assert_return (invoke "test" (i32.const 22)) (i32.const 1)) +(assert_return (invoke "test" (i32.const 23)) (i32.const 2)) +(assert_return (invoke "test" (i32.const 24)) (i32.const 3)) +(assert_return (invoke "test" (i32.const 25)) (i32.const 4)) +(assert_return (invoke "test" (i32.const 26)) (i32.const 5)) +(assert_return (invoke "test" (i32.const 27)) (i32.const 6)) +(assert_return (invoke "test" (i32.const 28)) (i32.const 7)) +(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 (i32.const 24) + $f0 $f1 $f2 $f3 $f4 $f5 $f6 $f7) + (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 $targetOffs i32) (param $srcOffs i32) (param $len i32) + (table.copy (local.get $targetOffs) (local.get $srcOffs) (local.get $len)))) + +(assert_trap (invoke "run" (i32.const 21) (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_return (invoke "test" (i32.const 24)) (i32.const 0)) +(assert_return (invoke "test" (i32.const 25)) (i32.const 1)) +(assert_return (invoke "test" (i32.const 26)) (i32.const 2)) +(assert_return (invoke "test" (i32.const 27)) (i32.const 3)) +(assert_return (invoke "test" (i32.const 28)) (i32.const 4)) +(assert_return (invoke "test" (i32.const 29)) (i32.const 5)) +(assert_return (invoke "test" (i32.const 30)) (i32.const 6)) +(assert_return (invoke "test" (i32.const 31)) (i32.const 7)) + +(module + (type (func (result i32))) + (table 32 64 funcref) + (elem (i32.const 21) + $f0 $f1 $f2 $f3 $f4 $f5 $f6 $f7 $f8 $f9 $f10) + (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 $targetOffs i32) (param $srcOffs i32) (param $len i32) + (table.copy (local.get $targetOffs) (local.get $srcOffs) (local.get $len)))) + +(assert_trap (invoke "run" (i32.const 21) (i32.const 21) (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_return (invoke "test" (i32.const 21)) (i32.const 0)) +(assert_return (invoke "test" (i32.const 22)) (i32.const 1)) +(assert_return (invoke "test" (i32.const 23)) (i32.const 2)) +(assert_return (invoke "test" (i32.const 24)) (i32.const 3)) +(assert_return (invoke "test" (i32.const 25)) (i32.const 4)) +(assert_return (invoke "test" (i32.const 26)) (i32.const 5)) +(assert_return (invoke "test" (i32.const 27)) (i32.const 6)) +(assert_return (invoke "test" (i32.const 28)) (i32.const 7)) +(assert_return (invoke "test" (i32.const 29)) (i32.const 8)) +(assert_return (invoke "test" (i32.const 30)) (i32.const 9)) +(assert_return (invoke "test" (i32.const 31)) (i32.const 10)) + +(module + (type (func (result i32))) + (table 128 128 funcref) + (elem (i32.const 112) + $f0 $f1 $f2 $f3 $f4 $f5 $f6 $f7 $f8 $f9 $f10 $f11 $f12 $f13 $f14 $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 $targetOffs i32) (param $srcOffs i32) (param $len i32) + (table.copy (local.get $targetOffs) (local.get $srcOffs) (local.get $len)))) + +(assert_trap (invoke "run" (i32.const 0) (i32.const 112) (i32.const 4294967264)) + "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_return (invoke "test" (i32.const 112)) (i32.const 0)) +(assert_return (invoke "test" (i32.const 113)) (i32.const 1)) +(assert_return (invoke "test" (i32.const 114)) (i32.const 2)) +(assert_return (invoke "test" (i32.const 115)) (i32.const 3)) +(assert_return (invoke "test" (i32.const 116)) (i32.const 4)) +(assert_return (invoke "test" (i32.const 117)) (i32.const 5)) +(assert_return (invoke "test" (i32.const 118)) (i32.const 6)) +(assert_return (invoke "test" (i32.const 119)) (i32.const 7)) +(assert_return (invoke "test" (i32.const 120)) (i32.const 8)) +(assert_return (invoke "test" (i32.const 121)) (i32.const 9)) +(assert_return (invoke "test" (i32.const 122)) (i32.const 10)) +(assert_return (invoke "test" (i32.const 123)) (i32.const 11)) +(assert_return (invoke "test" (i32.const 124)) (i32.const 12)) +(assert_return (invoke "test" (i32.const 125)) (i32.const 13)) +(assert_return (invoke "test" (i32.const 126)) (i32.const 14)) +(assert_return (invoke "test" (i32.const 127)) (i32.const 15)) + +(module + (type (func (result i32))) + (table 128 128 funcref) + (elem (i32.const 0) + $f0 $f1 $f2 $f3 $f4 $f5 $f6 $f7 $f8 $f9 $f10 $f11 $f12 $f13 $f14 $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 $targetOffs i32) (param $srcOffs i32) (param $len i32) + (table.copy (local.get $targetOffs) (local.get $srcOffs) (local.get $len)))) + +(assert_trap (invoke "run" (i32.const 112) (i32.const 0) (i32.const 4294967264)) + "out of bounds table access") +(assert_return (invoke "test" (i32.const 0)) (i32.const 0)) +(assert_return (invoke "test" (i32.const 1)) (i32.const 1)) +(assert_return (invoke "test" (i32.const 2)) (i32.const 2)) +(assert_return (invoke "test" (i32.const 3)) (i32.const 3)) +(assert_return (invoke "test" (i32.const 4)) (i32.const 4)) +(assert_return (invoke "test" (i32.const 5)) (i32.const 5)) +(assert_return (invoke "test" (i32.const 6)) (i32.const 6)) +(assert_return (invoke "test" (i32.const 7)) (i32.const 7)) +(assert_return (invoke "test" (i32.const 8)) (i32.const 8)) +(assert_return (invoke "test" (i32.const 9)) (i32.const 9)) +(assert_return (invoke "test" (i32.const 10)) (i32.const 10)) +(assert_return (invoke "test" (i32.const 11)) (i32.const 11)) +(assert_return (invoke "test" (i32.const 12)) (i32.const 12)) +(assert_return (invoke "test" (i32.const 13)) (i32.const 13)) +(assert_return (invoke "test" (i32.const 14)) (i32.const 14)) +(assert_return (invoke "test" (i32.const 15)) (i32.const 15)) +(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") diff --git a/runtime/near-vm/tests/wast/spec/table_fill.wast b/runtime/near-vm/tests/wast/spec/table_fill.wast new file mode 100644 index 00000000000..3df64da1ab0 --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/table_fill.wast @@ -0,0 +1,153 @@ +(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 "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" (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/runtime/near-vm/tests/wast/spec/table_get.wast b/runtime/near-vm/tests/wast/spec/table_get.wast new file mode 100644 index 00000000000..5d57c31983b --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/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 $t2 (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/runtime/near-vm/tests/wast/spec/table_grow.wast b/runtime/near-vm/tests/wast/spec/table_grow.wast new file mode 100644 index 00000000000..7d5b5630fce --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/table_grow.wast @@ -0,0 +1,173 @@ +(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 "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" (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/runtime/near-vm/tests/wast/spec/table_init.wast b/runtime/near-vm/tests/wast/spec/table_init.wast new file mode 100644 index 00000000000..0b2d26f7724 --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/table_init.wast @@ -0,0 +1,2143 @@ +;; +;; 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 + (import "a" "ef0" (func (result i32))) ;; index 0 + (import "a" "ef1" (func (result i32))) + (import "a" "ef2" (func (result i32))) + (import "a" "ef3" (func (result i32))) + (import "a" "ef4" (func (result i32))) ;; 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 + (import "a" "ef0" (func (result i32))) ;; index 0 + (import "a" "ef1" (func (result i32))) + (import "a" "ef2" (func (result i32))) + (import "a" "ef3" (func (result i32))) + (import "a" "ef4" (func (result i32))) ;; 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 + (import "a" "ef0" (func (result i32))) ;; index 0 + (import "a" "ef1" (func (result i32))) + (import "a" "ef2" (func (result i32))) + (import "a" "ef3" (func (result i32))) + (import "a" "ef4" (func (result i32))) ;; 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 + (import "a" "ef0" (func (result i32))) ;; index 0 + (import "a" "ef1" (func (result i32))) + (import "a" "ef2" (func (result i32))) + (import "a" "ef3" (func (result i32))) + (import "a" "ef4" (func (result i32))) ;; 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 + (import "a" "ef0" (func (result i32))) ;; index 0 + (import "a" "ef1" (func (result i32))) + (import "a" "ef2" (func (result i32))) + (import "a" "ef3" (func (result i32))) + (import "a" "ef4" (func (result i32))) ;; 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 + (import "a" "ef0" (func (result i32))) ;; index 0 + (import "a" "ef1" (func (result i32))) + (import "a" "ef2" (func (result i32))) + (import "a" "ef3" (func (result i32))) + (import "a" "ef4" (func (result i32))) ;; 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/runtime/near-vm/tests/wast/spec/table_set.wast b/runtime/near-vm/tests/wast/spec/table_set.wast new file mode 100644 index 00000000000..5a9cfa3715c --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/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 $t2 (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/runtime/near-vm/tests/wast/spec/table_size.wast b/runtime/near-vm/tests/wast/spec/table_size.wast new file mode 100644 index 00000000000..ad293b5ee43 --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/table_size.wast @@ -0,0 +1,86 @@ +(module + (table $t0 0 externref) + (table $t1 1 externref) + (table $t2 0 2 externref) + (table $t3 3 8 externref) + + (func (export "size-t0") (result i32) (table.size $t0)) + (func (export "size-t1") (result i32) (table.size $t1)) + (func (export "size-t2") (result i32) (table.size $t2)) + (func (export "size-t3") (result i32) (table.size $t3)) + + (func (export "grow-t0") (param $sz i32) + (drop (table.grow $t0 (ref.null extern) (local.get $sz))) + ) + (func (export "grow-t1") (param $sz i32) + (drop (table.grow $t1 (ref.null extern) (local.get $sz))) + ) + (func (export "grow-t2") (param $sz i32) + (drop (table.grow $t2 (ref.null extern) (local.get $sz))) + ) + (func (export "grow-t3") (param $sz i32) + (drop (table.grow $t3 (ref.null extern) (local.get $sz))) + ) +) + +(assert_return (invoke "size-t0") (i32.const 0)) +(assert_return (invoke "grow-t0" (i32.const 1))) +(assert_return (invoke "size-t0") (i32.const 1)) +(assert_return (invoke "grow-t0" (i32.const 4))) +(assert_return (invoke "size-t0") (i32.const 5)) +(assert_return (invoke "grow-t0" (i32.const 0))) +(assert_return (invoke "size-t0") (i32.const 5)) + +(assert_return (invoke "size-t1") (i32.const 1)) +(assert_return (invoke "grow-t1" (i32.const 1))) +(assert_return (invoke "size-t1") (i32.const 2)) +(assert_return (invoke "grow-t1" (i32.const 4))) +(assert_return (invoke "size-t1") (i32.const 6)) +(assert_return (invoke "grow-t1" (i32.const 0))) +(assert_return (invoke "size-t1") (i32.const 6)) + +(assert_return (invoke "size-t2") (i32.const 0)) +(assert_return (invoke "grow-t2" (i32.const 3))) +(assert_return (invoke "size-t2") (i32.const 0)) +(assert_return (invoke "grow-t2" (i32.const 1))) +(assert_return (invoke "size-t2") (i32.const 1)) +(assert_return (invoke "grow-t2" (i32.const 0))) +(assert_return (invoke "size-t2") (i32.const 1)) +(assert_return (invoke "grow-t2" (i32.const 4))) +(assert_return (invoke "size-t2") (i32.const 1)) +(assert_return (invoke "grow-t2" (i32.const 1))) +(assert_return (invoke "size-t2") (i32.const 2)) + +(assert_return (invoke "size-t3") (i32.const 3)) +(assert_return (invoke "grow-t3" (i32.const 1))) +(assert_return (invoke "size-t3") (i32.const 4)) +(assert_return (invoke "grow-t3" (i32.const 3))) +(assert_return (invoke "size-t3") (i32.const 7)) +(assert_return (invoke "grow-t3" (i32.const 0))) +(assert_return (invoke "size-t3") (i32.const 7)) +(assert_return (invoke "grow-t3" (i32.const 2))) +(assert_return (invoke "size-t3") (i32.const 7)) +(assert_return (invoke "grow-t3" (i32.const 1))) +(assert_return (invoke "size-t3") (i32.const 8)) + + +;; Type errors + +(assert_invalid + (module + (table $t 1 externref) + (func $type-result-i32-vs-empty + (table.size $t) + ) + ) + "type mismatch" +) +(assert_invalid + (module + (table $t 1 externref) + (func $type-result-i32-vs-f32 (result f32) + (table.size $t) + ) + ) + "type mismatch" +) diff --git a/runtime/near-vm/tests/wast/spec/token.wast b/runtime/near-vm/tests/wast/spec/token.wast new file mode 100644 index 00000000000..1dcd32e7f75 --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/token.wast @@ -0,0 +1,10 @@ +;; Test tokenization + +(assert_malformed + (module quote "(func (drop (i32.const0)))") + "unknown operator" +) +(assert_malformed + (module quote "(func br 0drop)") + "unknown operator" +) diff --git a/runtime/near-vm/tests/wast/spec/traps.wast b/runtime/near-vm/tests/wast/spec/traps.wast new file mode 100644 index 00000000000..142fa22b2b9 --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/traps.wast @@ -0,0 +1,91 @@ +;; Test that traps are preserved even in instructions which might otherwise +;; be dead-code-eliminated. These functions all perform an operation and +;; discard its return value. + +(module + (func (export "no_dce.i32.div_s") (param $x i32) (param $y i32) + (drop (i32.div_s (local.get $x) (local.get $y)))) + (func (export "no_dce.i32.div_u") (param $x i32) (param $y i32) + (drop (i32.div_u (local.get $x) (local.get $y)))) + (func (export "no_dce.i64.div_s") (param $x i64) (param $y i64) + (drop (i64.div_s (local.get $x) (local.get $y)))) + (func (export "no_dce.i64.div_u") (param $x i64) (param $y i64) + (drop (i64.div_u (local.get $x) (local.get $y)))) +) + +(assert_trap (invoke "no_dce.i32.div_s" (i32.const 1) (i32.const 0)) "integer divide by zero") +(assert_trap (invoke "no_dce.i32.div_u" (i32.const 1) (i32.const 0)) "integer divide by zero") +(assert_trap (invoke "no_dce.i64.div_s" (i64.const 1) (i64.const 0)) "integer divide by zero") +(assert_trap (invoke "no_dce.i64.div_u" (i64.const 1) (i64.const 0)) "integer divide by zero") +(assert_trap (invoke "no_dce.i32.div_s" (i32.const 0x80000000) (i32.const -1)) "integer overflow") +(assert_trap (invoke "no_dce.i64.div_s" (i64.const 0x8000000000000000) (i64.const -1)) "integer overflow") + +(module + (func (export "no_dce.i32.rem_s") (param $x i32) (param $y i32) + (drop (i32.rem_s (local.get $x) (local.get $y)))) + (func (export "no_dce.i32.rem_u") (param $x i32) (param $y i32) + (drop (i32.rem_u (local.get $x) (local.get $y)))) + (func (export "no_dce.i64.rem_s") (param $x i64) (param $y i64) + (drop (i64.rem_s (local.get $x) (local.get $y)))) + (func (export "no_dce.i64.rem_u") (param $x i64) (param $y i64) + (drop (i64.rem_u (local.get $x) (local.get $y)))) +) + +(assert_trap (invoke "no_dce.i32.rem_s" (i32.const 1) (i32.const 0)) "integer divide by zero") +(assert_trap (invoke "no_dce.i32.rem_u" (i32.const 1) (i32.const 0)) "integer divide by zero") +(assert_trap (invoke "no_dce.i64.rem_s" (i64.const 1) (i64.const 0)) "integer divide by zero") +(assert_trap (invoke "no_dce.i64.rem_u" (i64.const 1) (i64.const 0)) "integer divide by zero") + +(module + (func (export "no_dce.i32.trunc_f32_s") (param $x f32) (drop (i32.trunc_f32_s (local.get $x)))) + (func (export "no_dce.i32.trunc_f32_u") (param $x f32) (drop (i32.trunc_f32_u (local.get $x)))) + (func (export "no_dce.i32.trunc_f64_s") (param $x f64) (drop (i32.trunc_f64_s (local.get $x)))) + (func (export "no_dce.i32.trunc_f64_u") (param $x f64) (drop (i32.trunc_f64_u (local.get $x)))) + (func (export "no_dce.i64.trunc_f32_s") (param $x f32) (drop (i64.trunc_f32_s (local.get $x)))) + (func (export "no_dce.i64.trunc_f32_u") (param $x f32) (drop (i64.trunc_f32_u (local.get $x)))) + (func (export "no_dce.i64.trunc_f64_s") (param $x f64) (drop (i64.trunc_f64_s (local.get $x)))) + (func (export "no_dce.i64.trunc_f64_u") (param $x f64) (drop (i64.trunc_f64_u (local.get $x)))) +) + +(assert_trap (invoke "no_dce.i32.trunc_f32_s" (f32.const nan)) "invalid conversion to integer") +(assert_trap (invoke "no_dce.i32.trunc_f32_u" (f32.const nan)) "invalid conversion to integer") +(assert_trap (invoke "no_dce.i32.trunc_f64_s" (f64.const nan)) "invalid conversion to integer") +(assert_trap (invoke "no_dce.i32.trunc_f64_u" (f64.const nan)) "invalid conversion to integer") +(assert_trap (invoke "no_dce.i64.trunc_f32_s" (f32.const nan)) "invalid conversion to integer") +(assert_trap (invoke "no_dce.i64.trunc_f32_u" (f32.const nan)) "invalid conversion to integer") +(assert_trap (invoke "no_dce.i64.trunc_f64_s" (f64.const nan)) "invalid conversion to integer") +(assert_trap (invoke "no_dce.i64.trunc_f64_u" (f64.const nan)) "invalid conversion to integer") + +(module + (memory 1) + + (func (export "no_dce.i32.load") (param $i i32) (drop (i32.load (local.get $i)))) + (func (export "no_dce.i32.load16_s") (param $i i32) (drop (i32.load16_s (local.get $i)))) + (func (export "no_dce.i32.load16_u") (param $i i32) (drop (i32.load16_u (local.get $i)))) + (func (export "no_dce.i32.load8_s") (param $i i32) (drop (i32.load8_s (local.get $i)))) + (func (export "no_dce.i32.load8_u") (param $i i32) (drop (i32.load8_u (local.get $i)))) + (func (export "no_dce.i64.load") (param $i i32) (drop (i64.load (local.get $i)))) + (func (export "no_dce.i64.load32_s") (param $i i32) (drop (i64.load32_s (local.get $i)))) + (func (export "no_dce.i64.load32_u") (param $i i32) (drop (i64.load32_u (local.get $i)))) + (func (export "no_dce.i64.load16_s") (param $i i32) (drop (i64.load16_s (local.get $i)))) + (func (export "no_dce.i64.load16_u") (param $i i32) (drop (i64.load16_u (local.get $i)))) + (func (export "no_dce.i64.load8_s") (param $i i32) (drop (i64.load8_s (local.get $i)))) + (func (export "no_dce.i64.load8_u") (param $i i32) (drop (i64.load8_u (local.get $i)))) + (func (export "no_dce.f32.load") (param $i i32) (drop (f32.load (local.get $i)))) + (func (export "no_dce.f64.load") (param $i i32) (drop (f64.load (local.get $i)))) +) + +(assert_trap (invoke "no_dce.i32.load" (i32.const 65536)) "out of bounds memory access") +(assert_trap (invoke "no_dce.i32.load16_s" (i32.const 65536)) "out of bounds memory access") +(assert_trap (invoke "no_dce.i32.load16_u" (i32.const 65536)) "out of bounds memory access") +(assert_trap (invoke "no_dce.i32.load8_s" (i32.const 65536)) "out of bounds memory access") +(assert_trap (invoke "no_dce.i32.load8_u" (i32.const 65536)) "out of bounds memory access") +(assert_trap (invoke "no_dce.i64.load" (i32.const 65536)) "out of bounds memory access") +(assert_trap (invoke "no_dce.i64.load32_s" (i32.const 65536)) "out of bounds memory access") +(assert_trap (invoke "no_dce.i64.load32_u" (i32.const 65536)) "out of bounds memory access") +(assert_trap (invoke "no_dce.i64.load16_s" (i32.const 65536)) "out of bounds memory access") +(assert_trap (invoke "no_dce.i64.load16_u" (i32.const 65536)) "out of bounds memory access") +(assert_trap (invoke "no_dce.i64.load8_s" (i32.const 65536)) "out of bounds memory access") +(assert_trap (invoke "no_dce.i64.load8_u" (i32.const 65536)) "out of bounds memory access") +(assert_trap (invoke "no_dce.f32.load" (i32.const 65536)) "out of bounds memory access") +(assert_trap (invoke "no_dce.f64.load" (i32.const 65536)) "out of bounds memory access") diff --git a/runtime/near-vm/tests/wast/spec/type.wast b/runtime/near-vm/tests/wast/spec/type.wast new file mode 100644 index 00000000000..b94063e6a04 --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/type.wast @@ -0,0 +1,50 @@ +;; Test type definitions + +(module + (type (func)) + (type $t (func)) + + (type (func (param i32))) + (type (func (param $x i32))) + (type (func (result i32))) + (type (func (param i32) (result i32))) + (type (func (param $x i32) (result i32))) + + (type (func (param f32 f64))) + (type (func (result i64 f32))) + (type (func (param i32 i64) (result f32 f64))) + + (type (func (param f32) (param f64))) + (type (func (param $x f32) (param f64))) + (type (func (param f32) (param $y f64))) + (type (func (param $x f32) (param $y f64))) + (type (func (result i64) (result f32))) + (type (func (param i32) (param i64) (result f32) (result f64))) + (type (func (param $x i32) (param $y i64) (result f32) (result f64))) + + (type (func (param f32 f64) (param $x i32) (param f64 i32 i32))) + (type (func (result i64 i64 f32) (result f32 i32))) + (type + (func (param i32 i32) (param i64 i32) (result f32 f64) (result f64 i32)) + ) + + (type (func (param) (param $x f32) (param) (param) (param f64 i32) (param))) + (type + (func (result) (result) (result i64 i64) (result) (result f32) (result)) + ) + (type + (func + (param i32 i32) (param i64 i32) (param) (param $x i32) (param) + (result) (result f32 f64) (result f64 i32) (result) + ) + ) +) + +(assert_malformed + (module quote "(type (func (result i32) (param i32)))") + "result before parameter" +) +(assert_malformed + (module quote "(type (func (result $x i32)))") + "unexpected token" +) diff --git a/runtime/near-vm/tests/wast/spec/unreachable.wast b/runtime/near-vm/tests/wast/spec/unreachable.wast new file mode 100644 index 00000000000..3074847a3e1 --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/unreachable.wast @@ -0,0 +1,304 @@ +;; Test `unreachable` operator + +(module + ;; Auxiliary definitions + (func $dummy) + (func $dummy3 (param i32 i32 i32)) + + (func (export "type-i32") (result i32) (unreachable)) + (func (export "type-i64") (result i32) (unreachable)) + (func (export "type-f32") (result f64) (unreachable)) + (func (export "type-f64") (result f64) (unreachable)) + + (func (export "as-func-first") (result i32) + (unreachable) (i32.const -1) + ) + (func (export "as-func-mid") (result i32) + (call $dummy) (unreachable) (i32.const -1) + ) + (func (export "as-func-last") + (call $dummy) (unreachable) + ) + (func (export "as-func-value") (result i32) + (call $dummy) (unreachable) + ) + + (func (export "as-block-first") (result i32) + (block (result i32) (unreachable) (i32.const 2)) + ) + (func (export "as-block-mid") (result i32) + (block (result i32) (call $dummy) (unreachable) (i32.const 2)) + ) + (func (export "as-block-last") + (block (nop) (call $dummy) (unreachable)) + ) + (func (export "as-block-value") (result i32) + (block (result i32) (nop) (call $dummy) (unreachable)) + ) + (func (export "as-block-broke") (result i32) + (block (result i32) (call $dummy) (br 0 (i32.const 1)) (unreachable)) + ) + + (func (export "as-loop-first") (result i32) + (loop (result i32) (unreachable) (i32.const 2)) + ) + (func (export "as-loop-mid") (result i32) + (loop (result i32) (call $dummy) (unreachable) (i32.const 2)) + ) + (func (export "as-loop-last") + (loop (nop) (call $dummy) (unreachable)) + ) + (func (export "as-loop-broke") (result i32) + (block (result i32) + (loop (result i32) (call $dummy) (br 1 (i32.const 1)) (unreachable)) + ) + ) + + (func (export "as-br-value") (result i32) + (block (result i32) (br 0 (unreachable))) + ) + + (func (export "as-br_if-cond") + (block (br_if 0 (unreachable))) + ) + (func (export "as-br_if-value") (result i32) + (block (result i32) + (drop (br_if 0 (unreachable) (i32.const 1))) (i32.const 7) + ) + ) + (func (export "as-br_if-value-cond") (result i32) + (block (result i32) + (drop (br_if 0 (i32.const 6) (unreachable))) (i32.const 7) + ) + ) + + (func (export "as-br_table-index") + (block (br_table 0 0 0 (unreachable))) + ) + (func (export "as-br_table-value") (result i32) + (block (result i32) + (br_table 0 0 0 (unreachable) (i32.const 1)) (i32.const 7) + ) + ) + (func (export "as-br_table-value-2") (result i32) + (block (result i32) + (block (result i32) (br_table 0 1 (unreachable) (i32.const 1))) + ) + ) + (func (export "as-br_table-value-index") (result i32) + (block (result i32) + (br_table 0 0 (i32.const 6) (unreachable)) (i32.const 7) + ) + ) + (func (export "as-br_table-value-and-index") (result i32) + (block (result i32) (br_table 0 0 (unreachable)) (i32.const 8)) + ) + + (func (export "as-return-value") (result i64) + (return (unreachable)) + ) + + (func (export "as-if-cond") (result i32) + (if (result i32) (unreachable) (then (i32.const 0)) (else (i32.const 1))) + ) + (func (export "as-if-then") (param i32 i32) (result i32) + (if (result i32) (local.get 0) (then (unreachable)) (else (local.get 1))) + ) + (func (export "as-if-else") (param i32 i32) (result i32) + (if (result i32) (local.get 0) (then (local.get 1)) (else (unreachable))) + ) + (func (export "as-if-then-no-else") (param i32 i32) (result i32) + (if (local.get 0) (then (unreachable))) (local.get 1) + ) + + (func (export "as-select-first") (param i32 i32) (result i32) + (select (unreachable) (local.get 0) (local.get 1)) + ) + (func (export "as-select-second") (param i32 i32) (result i32) + (select (local.get 0) (unreachable) (local.get 1)) + ) + (func (export "as-select-cond") (result i32) + (select (i32.const 0) (i32.const 1) (unreachable)) + ) + + (func (export "as-call-first") + (call $dummy3 (unreachable) (i32.const 2) (i32.const 3)) + ) + (func (export "as-call-mid") + (call $dummy3 (i32.const 1) (unreachable) (i32.const 3)) + ) + (func (export "as-call-last") + (call $dummy3 (i32.const 1) (i32.const 2) (unreachable)) + ) + + (type $sig (func (param i32 i32 i32))) + (table funcref (elem $dummy3)) + (func (export "as-call_indirect-func") + (call_indirect (type $sig) + (unreachable) (i32.const 1) (i32.const 2) (i32.const 3) + ) + ) + (func (export "as-call_indirect-first") + (call_indirect (type $sig) + (i32.const 0) (unreachable) (i32.const 2) (i32.const 3) + ) + ) + (func (export "as-call_indirect-mid") + (call_indirect (type $sig) + (i32.const 0) (i32.const 1) (unreachable) (i32.const 3) + ) + ) + (func (export "as-call_indirect-last") + (call_indirect (type $sig) + (i32.const 0) (i32.const 1) (i32.const 2) (unreachable) + ) + ) + + (func (export "as-local.set-value") (local f32) + (local.set 0 (unreachable)) + ) + (func (export "as-local.tee-value") (result f32) (local f32) + (local.tee 0 (unreachable)) + ) + (global $a (mut f32) (f32.const 0)) + (func (export "as-global.set-value") (result f32) + (global.set $a (unreachable)) + ) + + (memory 1) + (func (export "as-load-address") (result f32) + (f32.load (unreachable)) + ) + (func (export "as-loadN-address") (result i64) + (i64.load8_s (unreachable)) + ) + + (func (export "as-store-address") + (f64.store (unreachable) (f64.const 7)) + ) + (func (export "as-store-value") + (i64.store (i32.const 2) (unreachable)) + ) + + (func (export "as-storeN-address") + (i32.store8 (unreachable) (i32.const 7)) + ) + (func (export "as-storeN-value") + (i64.store16 (i32.const 2) (unreachable)) + ) + + (func (export "as-unary-operand") (result f32) + (f32.neg (unreachable)) + ) + + (func (export "as-binary-left") (result i32) + (i32.add (unreachable) (i32.const 10)) + ) + (func (export "as-binary-right") (result i64) + (i64.sub (i64.const 10) (unreachable)) + ) + + (func (export "as-test-operand") (result i32) + (i32.eqz (unreachable)) + ) + + (func (export "as-compare-left") (result i32) + (f64.le (unreachable) (f64.const 10)) + ) + (func (export "as-compare-right") (result i32) + (f32.ne (f32.const 10) (unreachable)) + ) + + (func (export "as-convert-operand") (result i32) + (i32.wrap_i64 (unreachable)) + ) + + (func (export "as-memory.grow-size") (result i32) + (memory.grow (unreachable)) + ) +) + +(assert_trap (invoke "type-i32") "unreachable") +(assert_trap (invoke "type-i64") "unreachable") +(assert_trap (invoke "type-f32") "unreachable") +(assert_trap (invoke "type-f64") "unreachable") + +(assert_trap (invoke "as-func-first") "unreachable") +(assert_trap (invoke "as-func-mid") "unreachable") +(assert_trap (invoke "as-func-last") "unreachable") +(assert_trap (invoke "as-func-value") "unreachable") + +(assert_trap (invoke "as-block-first") "unreachable") +(assert_trap (invoke "as-block-mid") "unreachable") +(assert_trap (invoke "as-block-last") "unreachable") +(assert_trap (invoke "as-block-value") "unreachable") +(assert_return (invoke "as-block-broke") (i32.const 1)) + +(assert_trap (invoke "as-loop-first") "unreachable") +(assert_trap (invoke "as-loop-mid") "unreachable") +(assert_trap (invoke "as-loop-last") "unreachable") +(assert_return (invoke "as-loop-broke") (i32.const 1)) + +(assert_trap (invoke "as-br-value") "unreachable") + +(assert_trap (invoke "as-br_if-cond") "unreachable") +(assert_trap (invoke "as-br_if-value") "unreachable") +(assert_trap (invoke "as-br_if-value-cond") "unreachable") + +(assert_trap (invoke "as-br_table-index") "unreachable") +(assert_trap (invoke "as-br_table-value") "unreachable") +(assert_trap (invoke "as-br_table-value-2") "unreachable") +(assert_trap (invoke "as-br_table-value-index") "unreachable") +(assert_trap (invoke "as-br_table-value-and-index") "unreachable") + +(assert_trap (invoke "as-return-value") "unreachable") + +(assert_trap (invoke "as-if-cond") "unreachable") +(assert_trap (invoke "as-if-then" (i32.const 1) (i32.const 6)) "unreachable") +(assert_return (invoke "as-if-then" (i32.const 0) (i32.const 6)) (i32.const 6)) +(assert_trap (invoke "as-if-else" (i32.const 0) (i32.const 6)) "unreachable") +(assert_return (invoke "as-if-else" (i32.const 1) (i32.const 6)) (i32.const 6)) +(assert_trap (invoke "as-if-then-no-else" (i32.const 1) (i32.const 6)) "unreachable") +(assert_return (invoke "as-if-then-no-else" (i32.const 0) (i32.const 6)) (i32.const 6)) + +(assert_trap (invoke "as-select-first" (i32.const 0) (i32.const 6)) "unreachable") +(assert_trap (invoke "as-select-first" (i32.const 1) (i32.const 6)) "unreachable") +(assert_trap (invoke "as-select-second" (i32.const 0) (i32.const 6)) "unreachable") +(assert_trap (invoke "as-select-second" (i32.const 1) (i32.const 6)) "unreachable") +(assert_trap (invoke "as-select-cond") "unreachable") + +(assert_trap (invoke "as-call-first") "unreachable") +(assert_trap (invoke "as-call-mid") "unreachable") +(assert_trap (invoke "as-call-last") "unreachable") + +(assert_trap (invoke "as-call_indirect-func") "unreachable") +(assert_trap (invoke "as-call_indirect-first") "unreachable") +(assert_trap (invoke "as-call_indirect-mid") "unreachable") +(assert_trap (invoke "as-call_indirect-last") "unreachable") + +(assert_trap (invoke "as-local.set-value") "unreachable") +(assert_trap (invoke "as-local.tee-value") "unreachable") +(assert_trap (invoke "as-global.set-value") "unreachable") + +(assert_trap (invoke "as-load-address") "unreachable") +(assert_trap (invoke "as-loadN-address") "unreachable") + +(assert_trap (invoke "as-store-address") "unreachable") +(assert_trap (invoke "as-store-value") "unreachable") +(assert_trap (invoke "as-storeN-address") "unreachable") +(assert_trap (invoke "as-storeN-value") "unreachable") + +(assert_trap (invoke "as-unary-operand") "unreachable") + +(assert_trap (invoke "as-binary-left") "unreachable") +(assert_trap (invoke "as-binary-right") "unreachable") + +(assert_trap (invoke "as-test-operand") "unreachable") + +(assert_trap (invoke "as-compare-left") "unreachable") +(assert_trap (invoke "as-compare-right") "unreachable") + +(assert_trap (invoke "as-convert-operand") "unreachable") + +(assert_trap (invoke "as-memory.grow-size") "unreachable") + diff --git a/runtime/near-vm/tests/wast/spec/unreached-invalid.wast b/runtime/near-vm/tests/wast/spec/unreached-invalid.wast new file mode 100644 index 00000000000..3ddd77385f3 --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/unreached-invalid.wast @@ -0,0 +1,695 @@ +;; Failures in unreachable code. + +(assert_invalid + (module (func $local-index (unreachable) (drop (local.get 0)))) + "unknown local" +) +(assert_invalid + (module (func $global-index (unreachable) (drop (global.get 0)))) + "unknown global" +) +(assert_invalid + (module (func $func-index (unreachable) (call 1))) + "unknown function" +) +(assert_invalid + (module (func $label-index (unreachable) (br 1))) + "unknown label" +) + +(assert_invalid + (module (func $type-num-vs-num + (unreachable) (drop (i64.eqz (i32.const 0)))) + ) + "type mismatch" +) +(assert_invalid + (module (func $type-poly-num-vs-num (result i32) + (unreachable) (i64.const 0) (i32.const 0) (select) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-poly-transitive-num-vs-num (result i32) + (unreachable) + (i64.const 0) (i32.const 0) (select) + (i32.const 0) (i32.const 0) (select) + )) + "type mismatch" +) + +(assert_invalid + (module (func $type-unconsumed-const (unreachable) (i32.const 0))) + "type mismatch" +) +(assert_invalid + (module (func $type-unconsumed-result (unreachable) (i32.eqz))) + "type mismatch" +) +(assert_invalid + (module (func $type-unconsumed-result2 + (unreachable) (i32.const 0) (i32.add) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-unconsumed-poly0 (unreachable) (select))) + "type mismatch" +) +(assert_invalid + (module (func $type-unconsumed-poly1 (unreachable) (i32.const 0) (select))) + "type mismatch" +) +(assert_invalid + (module (func $type-unconsumed-poly2 + (unreachable) (i32.const 0) (i32.const 0) (select) + )) + "type mismatch" +) + +(assert_invalid + (module (func $type-unary-num-vs-void-after-break + (block (br 0) (block (drop (i32.eqz (nop))))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-unary-num-vs-num-after-break + (block (br 0) (drop (i32.eqz (f32.const 1)))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-binary-num-vs-void-after-break + (block (br 0) (block (drop (f32.eq (i32.const 1))))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-binary-num-vs-num-after-break + (block (br 0) (drop (f32.eq (i32.const 1) (f32.const 0)))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-block-value-num-vs-void-after-break + (block (br 0) (i32.const 1)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-block-value-num-vs-num-after-break (result i32) + (block (result i32) (i32.const 1) (br 0) (f32.const 0)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-loop-value-num-vs-void-after-break + (block (loop (br 1) (i32.const 1))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-loop-value-num-vs-num-after-break (result i32) + (loop (result i32) (br 1 (i32.const 1)) (f32.const 0)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-func-value-num-vs-void-after-break + (br 0) (i32.const 1) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-func-value-num-vs-num-after-break (result i32) + (br 0 (i32.const 1)) (f32.const 0) + )) + "type mismatch" +) + +(assert_invalid + (module (func $type-unary-num-vs-void-after-return + (return) (block (drop (i32.eqz (nop)))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-unary-num-vs-num-after-return + (return) (drop (i32.eqz (f32.const 1))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-binary-num-vs-void-after-return + (return) (block (drop (f32.eq (i32.const 1)))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-binary-num-vs-num-after-return + (return) (drop (f32.eq (i32.const 1) (f32.const 0))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-block-value-num-vs-void-after-return + (block (return) (i32.const 1)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-block-value-num-vs-num-after-return (result i32) + (block (result i32) (i32.const 1) (return (i32.const 0)) (f32.const 0)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-loop-value-num-vs-void-after-return + (block (loop (return) (i32.const 1))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-loop-value-num-vs-num-after-return (result i32) + (loop (result i32) (return (i32.const 1)) (f32.const 0)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-func-value-num-vs-void-after-return + (return) (i32.const 1) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-func-value-num-vs-num-after-return (result i32) + (return (i32.const 1)) (f32.const 0) + )) + "type mismatch" +) + +(assert_invalid + (module (func $type-unary-num-vs-void-after-unreachable + (unreachable) (block (drop (i32.eqz (nop)))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-unary-num-vs-void-in-loop-after-unreachable + (unreachable) (loop (drop (i32.eqz (nop)))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-unary-num-vs-void-in-i32-loop-after-unreachable + (unreachable) (loop (result i32) (i32.eqz (nop))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-unary-num-vs-num-after-unreachable + (unreachable) (drop (i32.eqz (f32.const 1))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-binary-num-vs-void-after-unreachable + (unreachable) (block (drop (f32.eq (i32.const 1)))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-binary-num-vs-num-after-unreachable + (unreachable) (drop (f32.eq (i32.const 1) (f32.const 0))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-block-value-num-vs-void-after-unreachable + (block (unreachable) (i32.const 1)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-block-value-num-vs-num-after-unreachable (result i32) + (block (result i32) (i32.const 1) (unreachable) (f32.const 0)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-loop-value-num-vs-void-after-unreachable + (block (loop (unreachable) (i32.const 1))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-loop-value-num-vs-num-after-unreachable (result i32) + (loop (result i32) (unreachable) (f32.const 0)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-func-value-num-vs-void-after-unreachable + (unreachable) (i32.const 1) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-func-value-num-vs-num-after-unreachable (result i32) + (unreachable) (f32.const 0) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-unary-num-vs-void-in-if-after-unreachable + (unreachable) (if (i32.const 0) (then (drop (i32.eqz (nop))))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-unary-num-vs-void-in-else-after-unreachable + (unreachable) (if (i32.const 0) (then (nop)) (else (drop (i32.eqz (nop))))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-unary-num-vs-void-in-else-after-unreachable-if + (if (i32.const 0) (then (unreachable)) (else (drop (i32.eqz (nop))))) + )) + "type mismatch" +) + +(assert_invalid + (module (func $type-unary-num-vs-void-after-nested-unreachable + (block (unreachable)) (block (drop (i32.eqz (nop)))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-unary-num-vs-num-after-nested-unreachable + (block (unreachable)) (drop (i32.eqz (f32.const 1))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-binary-num-vs-void-after-nested-unreachable + (block (unreachable)) (block (drop (f32.eq (i32.const 1)))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-binary-num-vs-num-after-nested-unreachable + (block (unreachable)) (drop (f32.eq (i32.const 1) (f32.const 0))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-block-value-num-vs-void-after-nested-unreachable + (block (block (unreachable)) (i32.const 1)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-block-value-num-vs-num-after-nested-unreachable + (result i32) + (block (result i32) (i32.const 1) (block (unreachable)) (f32.const 0)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-loop-value-num-vs-void-after-nested-unreachable + (block (loop (block (unreachable)) (i32.const 1))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-loop-value-num-vs-num-after-nested-unreachable + (result i32) + (loop (result i32) (block (unreachable)) (f32.const 0)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-func-value-num-vs-void-after-nested-unreachable + (block (unreachable)) (i32.const 1) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-func-value-num-vs-num-after-nested-unreachable + (result i32) + (block (unreachable)) (f32.const 0) + )) + "type mismatch" +) + +(assert_invalid + (module (func $type-unary-num-vs-void-after-infinite-loop + (loop (br 0)) (block (drop (i32.eqz (nop)))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-unary-num-vs-num-after-infinite-loop + (loop (br 0)) (drop (i32.eqz (f32.const 1))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-binary-num-vs-void-after-infinite-loop + (loop (br 0)) (block (drop (f32.eq (i32.const 1)))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-binary-num-vs-num-after-infinite-loop + (loop (br 0)) (drop (f32.eq (i32.const 1) (f32.const 0))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-block-value-num-vs-void-after-infinite-loop + (block (loop (br 0)) (i32.const 1)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-block-value-num-vs-num-after-infinite-loop (result i32) + (block (result i32) (i32.const 1) (loop (br 0)) (f32.const 0)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-loop-value-num-vs-void-after-infinite-loop + (block (loop (loop (br 0)) (i32.const 1))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-loop-value-num-vs-num-after-infinite-loop (result i32) + (loop (result i32) (loop (br 0)) (f32.const 0)) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-func-value-num-vs-void-after-infinite-loop + (loop (br 0)) (i32.const 1) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-func-value-num-vs-num-after-infinite-loop (result i32) + (loop (br 0)) (f32.const 0) + )) + "type mismatch" +) + +(assert_invalid + (module (func $type-unary-num-vs-void-in-dead-body + (if (i32.const 0) (then (drop (i32.eqz (nop))))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-unary-num-vs-num-in-dead-body + (if (i32.const 0) (then (drop (i32.eqz (f32.const 1))))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-binary-num-vs-void-in-dead-body + (if (i32.const 0) (then (drop (f32.eq (i32.const 1))))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-binary-num-vs-num-in-dead-body + (if (i32.const 0) (then (drop (f32.eq (i32.const 1) (f32.const 0))))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-if-value-num-vs-void-in-dead-body + (if (i32.const 0) (then (i32.const 1))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-if-value-num-vs-num-in-dead-body (result i32) + (if (result i32) (i32.const 0) (then (f32.const 0))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-block-value-num-vs-void-in-dead-body + (if (i32.const 0) (then (block (i32.const 1)))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-block-value-num-vs-num-in-dead-body (result i32) + (if (result i32) (i32.const 0) (then (block (result i32) (f32.const 0)))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-block-value-num-vs-void-in-dead-body + (if (i32.const 0) (then (loop (i32.const 1)))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-block-value-num-vs-num-in-dead-body (result i32) + (if (result i32) (i32.const 0) (then (loop (result i32) (f32.const 0)))) + )) + "type mismatch" +) + +(assert_invalid + (module (func $type-return-second-num-vs-num (result i32) + (return (i32.const 1)) (return (f64.const 1)) + )) + "type mismatch" +) + +(assert_invalid + (module (func $type-br-second-num-vs-num (result i32) + (block (result i32) (br 0 (i32.const 1)) (br 0 (f64.const 1))) + )) + "type mismatch" +) + +(assert_invalid + (module (func $type-br_if-cond-num-vs-num-after-unreachable + (block (br_if 0 (unreachable) (f32.const 0))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-br_if-num-vs-void-after-unreachable (result i32) + (block (result i32) + (block (unreachable) (br_if 1 (i32.const 0) (i32.const 0))) + ) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-br_if-num-vs-num-after-unreachable (result i32) + (block (result i32) + (block (result f32) (unreachable) (br_if 1 (i32.const 0) (i32.const 0))) + (drop) (i32.const 0) + ) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-br_if-num2-vs-num-after-unreachable (result i32) + (block (result i32) + (unreachable) (br_if 0 (i32.const 0) (i32.const 0)) (i32.const 0) + ) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-br_table-num-vs-num-after-unreachable + (block (br_table 0 (unreachable) (f32.const 1))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-br_table-label-num-vs-num-after-unreachable (result i32) + (block (result i32) (unreachable) (br_table 0 (f32.const 0) (i32.const 1))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-br_table-label-num-vs-label-void-after-unreachable + (block + (block (result f32) + (unreachable) + (br_table 0 1 0 (i32.const 1)) + ) + (drop) + ) + )) + "type mismatch" +) + +(assert_invalid + (module (func $type-block-value-nested-unreachable-num-vs-void + (block (i32.const 3) (block (unreachable))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-block-value-nested-unreachable-void-vs-num (result i32) + (block (block (unreachable))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-block-value-nested-unreachable-num-vs-num (result i32) + (block (result i64) (i64.const 0) (block (unreachable))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-block-value-nested-unreachable-num2-vs-void (result i32) + (block (i32.const 3) (block (i64.const 1) (unreachable))) (i32.const 9) + )) + "type mismatch" +) + +(assert_invalid + (module (func $type-block-value-nested-br-num-vs-void + (block (i32.const 3) (block (br 1))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-block-value-nested-br-void-vs-num (result i32) + (block (result i32) (block (br 1 (i32.const 0)))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-block-value-nested-br-num-vs-num (result i32) + (block (result i32) (i64.const 0) (block (br 1 (i32.const 0)))) + )) + "type mismatch" +) + +(assert_invalid + (module (func $type-block-value-nested2-br-num-vs-void + (block (block (i32.const 3) (block (br 2)))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-block-value-nested2-br-void-vs-num (result i32) + (block (result i32) (block (block (br 2 (i32.const 0))))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-block-value-nested2-br-num-vs-num (result i32) + (block (result i32) + (block (result i64) (i64.const 0) (block (br 2 (i32.const 0)))) + ) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-block-value-nested2-br-num2-vs-void (result i32) + (block (i32.const 3) (block (i64.const 1) (br 1))) (i32.const 9) + )) + "type mismatch" +) + +(assert_invalid + (module (func $type-block-value-nested-return-num-vs-void + (block (i32.const 3) (block (return))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-block-value-nested-return-void-vs-num (result i32) + (block (block (return (i32.const 0)))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-block-value-nested-return-num-vs-num (result i32) + (block (result i64) (i64.const 0) (block (return (i32.const 0)))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-block-value-nested-return-num2-vs-void (result i32) + (block (i32.const 3) (block (i64.const 1) (return (i32.const 0)))) + (i32.const 9) + )) + "type mismatch" +) + +(assert_invalid + (module (func $type-loop-value-nested-unreachable-num-vs-void + (loop (i32.const 3) (block (unreachable))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-loop-value-nested-unreachable-void-vs-num (result i32) + (loop (block (unreachable))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-loop-value-nested-unreachable-num-vs-num (result i32) + (loop (result i64) (i64.const 0) (block (unreachable))) + )) + "type mismatch" +) + +(assert_invalid + (module (func $type-cont-last-void-vs-empty (result i32) + (loop (br 0 (nop))) + )) + "type mismatch" +) +(assert_invalid + (module (func $type-cont-last-num-vs-empty (result i32) + (loop (br 0 (i32.const 0))) + )) + "type mismatch" +) + +(assert_invalid + (module (func $tee-local-unreachable-value + (local i32) + (local.tee 0 (unreachable)) + )) + "type mismatch" +) +(assert_invalid + (module (func $br_if-unreachable (result i32) + (block (result i32) + (block + (br_if 1 (unreachable) (i32.const 0)) + ) + (i32.const 0) + ) + )) + "type mismatch" +) +(assert_invalid + (module + (func $type-br_if-after-unreachable (result i64) + unreachable + br_if 0 + i64.extend_i32_u + ) + ) + "type mismatch" +) diff --git a/runtime/near-vm/tests/wast/spec/unwind.wast b/runtime/near-vm/tests/wast/spec/unwind.wast new file mode 100644 index 00000000000..85db60b595e --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/unwind.wast @@ -0,0 +1,267 @@ +;; Test that control-flow transfer unwinds stack and it can be anything after. + +(module + (func (export "func-unwind-by-unreachable") + (i32.const 3) (i64.const 1) (unreachable) + ) + (func (export "func-unwind-by-br") + (i32.const 3) (i64.const 1) (br 0) + ) + (func (export "func-unwind-by-br-value") (result i32) + (i32.const 3) (i64.const 1) (br 0 (i32.const 9)) + ) + (func (export "func-unwind-by-br_if") + (i32.const 3) (i64.const 1) (drop (drop (br_if 0 (i32.const 1)))) + ) + (func (export "func-unwind-by-br_if-value") (result i32) + (i32.const 3) (i64.const 1) (drop (drop (br_if 0 (i32.const 9) (i32.const 1)))) + ) + (func (export "func-unwind-by-br_table") + (i32.const 3) (i64.const 1) (br_table 0 (i32.const 0)) + ) + (func (export "func-unwind-by-br_table-value") (result i32) + (i32.const 3) (i64.const 1) (br_table 0 (i32.const 9) (i32.const 0)) + ) + (func (export "func-unwind-by-return") (result i32) + (i32.const 3) (i64.const 1) (return (i32.const 9)) + ) + + (func (export "block-unwind-by-unreachable") + (block (i32.const 3) (i64.const 1) (unreachable)) + ) + (func (export "block-unwind-by-br") (result i32) + (block (i32.const 3) (i64.const 1) (br 0)) (i32.const 9) + ) + (func (export "block-unwind-by-br-value") (result i32) + (block (result i32) (i32.const 3) (i64.const 1) (br 0 (i32.const 9))) + ) + (func (export "block-unwind-by-br_if") (result i32) + (block (i32.const 3) (i64.const 1) (drop (drop (br_if 0 (i32.const 1))))) (i32.const 9) + ) + (func (export "block-unwind-by-br_if-value") (result i32) + (block (result i32) + (i32.const 3) (i64.const 1) (drop (drop (br_if 0 (i32.const 9) (i32.const 1)))) + ) + ) + (func (export "block-unwind-by-br_table") (result i32) + (block (i32.const 3) (i64.const 1) (br_table 0 (i32.const 0))) (i32.const 9) + ) + (func (export "block-unwind-by-br_table-value") (result i32) + (block (result i32) + (i32.const 3) (i64.const 1) (br_table 0 (i32.const 9) (i32.const 0)) + ) + ) + (func (export "block-unwind-by-return") (result i32) + (block (result i32) (i32.const 3) (i64.const 1) (return (i32.const 9))) + ) + + (func (export "block-nested-unwind-by-unreachable") (result i32) + (block (result i32) (i32.const 3) (block (i64.const 1) (unreachable))) + ) + (func (export "block-nested-unwind-by-br") (result i32) + (block (i32.const 3) (block (i64.const 1) (br 1)) (drop)) (i32.const 9) + ) + (func (export "block-nested-unwind-by-br-value") (result i32) + (block (result i32) + (i32.const 3) (block (i64.const 1) (br 1 (i32.const 9))) + ) + ) + (func (export "block-nested-unwind-by-br_if") (result i32) + (block (i32.const 3) (block (i64.const 1) (drop (br_if 1 (i32.const 1)))) (drop)) (i32.const 9) + ) + (func (export "block-nested-unwind-by-br_if-value") (result i32) + (block (result i32) + (i32.const 3) (block (i64.const 1) (drop (drop (br_if 1 (i32.const 9) (i32.const 1))))) + ) + ) + (func (export "block-nested-unwind-by-br_table") (result i32) + (block + (i32.const 3) (block (i64.const 1) (br_table 1 (i32.const 1))) + (drop) + ) + (i32.const 9) + ) + (func (export "block-nested-unwind-by-br_table-value") (result i32) + (block (result i32) + (i32.const 3) + (block (i64.const 1) (br_table 1 (i32.const 9) (i32.const 1))) + ) + ) + (func (export "block-nested-unwind-by-return") (result i32) + (block (result i32) + (i32.const 3) (block (i64.const 1) (return (i32.const 9))) + ) + ) + + (func (export "unary-after-unreachable") (result i32) + (f32.const 0) (unreachable) (i64.eqz) + ) + (func (export "unary-after-br") (result i32) + (block (result i32) (f32.const 0) (br 0 (i32.const 9)) (i64.eqz)) + ) + (func (export "unary-after-br_if") (result i32) + (block (result i32) + (i64.const 0) (drop (br_if 0 (i32.const 9) (i32.const 1))) (i64.eqz) + ) + ) + (func (export "unary-after-br_table") (result i32) + (block (result i32) + (f32.const 0) (br_table 0 0 (i32.const 9) (i32.const 0)) (i64.eqz) + ) + ) + (func (export "unary-after-return") (result i32) + (f32.const 0) (return (i32.const 9)) (i64.eqz) + ) + + (func (export "binary-after-unreachable") (result i32) + (f32.const 0) (f64.const 1) (unreachable) (i64.eq) + ) + (func (export "binary-after-br") (result i32) + (block (result i32) + (f32.const 0) (f64.const 1) (br 0 (i32.const 9)) (i64.eq) + ) + ) + (func (export "binary-after-br_if") (result i32) + (block (result i32) + (i64.const 0) (i64.const 1) (drop (br_if 0 (i32.const 9) (i32.const 1))) + (i64.eq) + ) + ) + (func (export "binary-after-br_table") (result i32) + (block (result i32) + (f32.const 0) (f64.const 1) (br_table 0 (i32.const 9) (i32.const 0)) + (i64.eq) + ) + ) + (func (export "binary-after-return") (result i32) + (f32.const 0) (f64.const 1) (return (i32.const 9)) (i64.eq) + ) + + (func (export "select-after-unreachable") (result i32) + (f32.const 0) (f64.const 1) (i64.const 0) (unreachable) (select) + ) + (func (export "select-after-br") (result i32) + (block (result i32) + (f32.const 0) (f64.const 1) (i64.const 0) (br 0 (i32.const 9)) (select) + ) + ) + (func (export "select-after-br_if") (result i32) + (block (result i32) + (i32.const 0) (i32.const 1) (i32.const 0) + (drop (br_if 0 (i32.const 9) (i32.const 1))) + (select) + ) + ) + (func (export "select-after-br_table") (result i32) + (block (result i32) + (f32.const 0) (f64.const 1) (i64.const 0) + (br_table 0 (i32.const 9) (i32.const 0)) + (select) + ) + ) + (func (export "select-after-return") (result i32) + (f32.const 0) (f64.const 1) (i64.const 1) (return (i32.const 9)) (select) + ) + + (func (export "block-value-after-unreachable") (result i32) + (block (result i32) (f32.const 0) (unreachable)) + ) + (func (export "block-value-after-br") (result i32) + (block (result i32) (f32.const 0) (br 0 (i32.const 9))) + ) + (func (export "block-value-after-br_if") (result i32) + (block (result i32) + (i32.const 0) (drop (br_if 0 (i32.const 9) (i32.const 1))) + ) + ) + (func (export "block-value-after-br_table") (result i32) + (block (result i32) + (f32.const 0) (br_table 0 0 (i32.const 9) (i32.const 0)) + ) + ) + (func (export "block-value-after-return") (result i32) + (block (result i32) (f32.const 0) (return (i32.const 9))) + ) + + (func (export "loop-value-after-unreachable") (result i32) + (loop (result i32) (f32.const 0) (unreachable)) + ) + (func (export "loop-value-after-br") (result i32) + (block (result i32) (loop (result i32) (f32.const 0) (br 1 (i32.const 9)))) + ) + (func (export "loop-value-after-br_if") (result i32) + (block (result i32) + (loop (result i32) + (i32.const 0) (drop (br_if 1 (i32.const 9) (i32.const 1))) + ) + ) + ) + + (func (export "loop-value-after-br_table") (result i32) + (block (result i32) + (loop (result i32) + (f32.const 0) (br_table 1 1 (i32.const 9) (i32.const 0)) + ) + ) + ) + (func (export "loop-value-after-return") (result i32) + (loop (result i32) (f32.const 0) (return (i32.const 9))) + ) +) + +(assert_trap (invoke "func-unwind-by-unreachable") "unreachable") +(assert_return (invoke "func-unwind-by-br")) +(assert_return (invoke "func-unwind-by-br-value") (i32.const 9)) +(assert_return (invoke "func-unwind-by-br_if")) +(assert_return (invoke "func-unwind-by-br_if-value") (i32.const 9)) +(assert_return (invoke "func-unwind-by-br_table")) +(assert_return (invoke "func-unwind-by-br_table-value") (i32.const 9)) +(assert_return (invoke "func-unwind-by-return") (i32.const 9)) + +(assert_trap (invoke "block-unwind-by-unreachable") "unreachable") +(assert_return (invoke "block-unwind-by-br") (i32.const 9)) +(assert_return (invoke "block-unwind-by-br-value") (i32.const 9)) +(assert_return (invoke "block-unwind-by-br_if") (i32.const 9)) +(assert_return (invoke "block-unwind-by-br_if-value") (i32.const 9)) +(assert_return (invoke "block-unwind-by-br_table") (i32.const 9)) +(assert_return (invoke "block-unwind-by-br_table-value") (i32.const 9)) +(assert_return (invoke "block-unwind-by-return") (i32.const 9)) + +(assert_trap (invoke "block-nested-unwind-by-unreachable") "unreachable") +(assert_return (invoke "block-nested-unwind-by-br") (i32.const 9)) +(assert_return (invoke "block-nested-unwind-by-br-value") (i32.const 9)) +(assert_return (invoke "block-nested-unwind-by-br_if") (i32.const 9)) +(assert_return (invoke "block-nested-unwind-by-br_if-value") (i32.const 9)) +(assert_return (invoke "block-nested-unwind-by-br_table") (i32.const 9)) +(assert_return (invoke "block-nested-unwind-by-br_table-value") (i32.const 9)) +(assert_return (invoke "block-nested-unwind-by-return") (i32.const 9)) + +(assert_trap (invoke "unary-after-unreachable") "unreachable") +(assert_return (invoke "unary-after-br") (i32.const 9)) +(assert_return (invoke "unary-after-br_if") (i32.const 9)) +(assert_return (invoke "unary-after-br_table") (i32.const 9)) +(assert_return (invoke "unary-after-return") (i32.const 9)) + +(assert_trap (invoke "binary-after-unreachable") "unreachable") +(assert_return (invoke "binary-after-br") (i32.const 9)) +(assert_return (invoke "binary-after-br_if") (i32.const 9)) +(assert_return (invoke "binary-after-br_table") (i32.const 9)) +(assert_return (invoke "binary-after-return") (i32.const 9)) + +(assert_trap (invoke "select-after-unreachable") "unreachable") +(assert_return (invoke "select-after-br") (i32.const 9)) +(assert_return (invoke "select-after-br_if") (i32.const 9)) +(assert_return (invoke "select-after-br_table") (i32.const 9)) +(assert_return (invoke "select-after-return") (i32.const 9)) + +(assert_trap (invoke "block-value-after-unreachable") "unreachable") +(assert_return (invoke "block-value-after-br") (i32.const 9)) +(assert_return (invoke "block-value-after-br_if") (i32.const 9)) +(assert_return (invoke "block-value-after-br_table") (i32.const 9)) +(assert_return (invoke "block-value-after-return") (i32.const 9)) + +(assert_trap (invoke "loop-value-after-unreachable") "unreachable") +(assert_return (invoke "loop-value-after-br") (i32.const 9)) +(assert_return (invoke "loop-value-after-br_if") (i32.const 9)) +(assert_return (invoke "loop-value-after-br_table") (i32.const 9)) +(assert_return (invoke "loop-value-after-return") (i32.const 9)) diff --git a/runtime/near-vm/tests/wast/spec/update-testsuite.sh b/runtime/near-vm/tests/wast/spec/update-testsuite.sh new file mode 100755 index 00000000000..8f4a819a7a3 --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/update-testsuite.sh @@ -0,0 +1,152 @@ +#!/bin/bash +# Update tests based on upstream repositories. +set -e +set -u +set -o pipefail + +repos=' + spec + threads + simd + exception-handling + gc + bulk-memory-operations + tail-call + nontrapping-float-to-int-conversions + multi-value + host-bindings + sign-extension-ops + reference-types + annotations +' + +log_and_run() { + echo ">>" $* + if ! $*; then + echo "sub-command failed: $*" + exit + fi +} + +try_log_and_run() { + echo ">>" $* + $* +} + +pushdir() { + pushd $1 >/dev/null || exit +} + +popdir() { + popd >/dev/null || exit +} + +update_repo() { + local repo=$1 + pushdir repos + if [ -d ${repo} ]; then + log_and_run git -C ${repo} fetch origin + log_and_run git -C ${repo} reset origin/master --hard + else + log_and_run git clone https://github.com/WebAssembly/${repo} + fi + + # Add upstream spec as "spec" remote. + if [ "${repo}" != "spec" ]; then + pushdir ${repo} + if ! git remote | grep spec >/dev/null; then + log_and_run git remote add spec https://github.com/WebAssembly/spec + fi + + log_and_run git fetch spec + popdir + fi + popdir +} + +merge_with_spec() { + local repo=$1 + + [ "${repo}" == "spec" ] && return + + pushdir repos/${repo} + # Create and checkout "try-merge" branch. + if ! git branch | grep try-merge >/dev/null; then + log_and_run git branch try-merge origin/master + fi + log_and_run git checkout try-merge + + # Attempt to merge with spec/master. + log_and_run git reset origin/master --hard + try_log_and_run git merge -q spec/master -m "merged" + if [ $? -ne 0 ]; then + # Ignore merge conflicts in non-test directories. + # We don't care about those changes. + try_log_and_run git checkout --ours document interpreter + try_log_and_run git add document interpreter + try_log_and_run git -c core.editor=true merge --continue + if [ $? -ne 0 ]; then + git merge --abort + popdir + return 1 + fi + fi + popdir + return 0 +} + + +echo -e "Update repos\n" > commit_message + +failed_repos= + +for repo in ${repos}; do + echo "++ updating ${repo}" + update_repo ${repo} + + if ! merge_with_spec ${repo}; then + echo -e "!! error merging ${repo}, skipping\n" + failed_repos="${failed_repos} ${repo}" + continue + fi + + if [ "${repo}" = "spec" ]; then + wast_dir=. + log_and_run cp $(find repos/${repo}/test/core -name \*.wast) ${wast_dir} + else + wast_dir=proposals/${repo} + mkdir -p ${wast_dir} + + # Don't add tests from propsoal that are the same as spec. + pushdir repos/${repo} + for new in $(find test/core -name \*.wast); do + old=../../repos/spec/${new} + if [[ ! -f ${old} ]] || ! diff ${old} ${new} >/dev/null; then + log_and_run cp ${new} ../../${wast_dir} + fi + done + popdir + fi + + # Check whether any files were updated. + if [ $(git status -s ${wast_dir}/*.wast | wc -l) -ne 0 ]; then + log_and_run git add ${wast_dir}/*.wast + + repo_sha=$(git -C repos/${repo} log --max-count=1 --oneline origin/master| sed -e 's/ .*//') + echo " ${repo}:" >> commit_message + echo " https://github.com/WebAssembly/${repo}/commit/${repo_sha}" >> commit_message + fi + + echo -e "-- ${repo}\n" +done + +echo "" >> commit_message +echo "This change was automatically generated by \`update-testsuite.sh\`" >> commit_message +git commit -a -F commit_message +# git push + +echo "done" + +if [ -n "${failed_repos}" ]; then + echo "!! failed to update repos: ${failed_repos}" +fi diff --git a/runtime/near-vm/tests/wast/spec/utf8-custom-section-id.wast b/runtime/near-vm/tests/wast/spec/utf8-custom-section-id.wast new file mode 100644 index 00000000000..ee5fd7ccb71 --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/utf8-custom-section-id.wast @@ -0,0 +1,1792 @@ +;;;;;; Invalid UTF-8 custom section names + +;;;; Continuation bytes not preceded by prefixes + +;; encoding starts with (first) continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\02" ;; custom section + "\01\80" ;; "\80" + ) + "malformed UTF-8 encoding" +) + +;; encoding starts with (0x8f) continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\02" ;; custom section + "\01\8f" ;; "\8f" + ) + "malformed UTF-8 encoding" +) + +;; encoding starts with (0x90) continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\02" ;; custom section + "\01\90" ;; "\90" + ) + "malformed UTF-8 encoding" +) + +;; encoding starts with (0x9f) continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\02" ;; custom section + "\01\9f" ;; "\9f" + ) + "malformed UTF-8 encoding" +) + +;; encoding starts with (0xa0) continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\02" ;; custom section + "\01\a0" ;; "\a0" + ) + "malformed UTF-8 encoding" +) + +;; encoding starts with (last) continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\02" ;; custom section + "\01\bf" ;; "\bf" + ) + "malformed UTF-8 encoding" +) + +;;;; 2-byte sequences + +;; 2-byte sequence contains 3 bytes +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\04" ;; custom section + "\03\c2\80\80" ;; "\c2\80\80" + ) + "malformed UTF-8 encoding" +) + +;; 2-byte sequence contains 1 byte at end of string +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\02" ;; custom section + "\01\c2" ;; "\c2" + ) + "malformed UTF-8 encoding" +) + +;; 2-byte sequence contains 1 byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\03" ;; custom section + "\02\c2\2e" ;; "\c2." + ) + "malformed UTF-8 encoding" +) + +;;;; 2-byte sequence contents + +;; overlong encoding after 0xc0 prefix +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\03" ;; custom section + "\02\c0\80" ;; "\c0\80" + ) + "malformed UTF-8 encoding" +) + +;; overlong encoding after 0xc0 prefix +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\03" ;; custom section + "\02\c0\bf" ;; "\c0\bf" + ) + "malformed UTF-8 encoding" +) + +;; overlong encoding after 0xc1 prefix +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\03" ;; custom section + "\02\c1\80" ;; "\c1\80" + ) + "malformed UTF-8 encoding" +) + +;; overlong encoding after 0xc1 prefix +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\03" ;; custom section + "\02\c1\bf" ;; "\c1\bf" + ) + "malformed UTF-8 encoding" +) + +;; byte after (first) 2-byte prefix not a contination byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\03" ;; custom section + "\02\c2\00" ;; "\c2\00" + ) + "malformed UTF-8 encoding" +) + +;; byte after (first) 2-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\03" ;; custom section + "\02\c2\7f" ;; "\c2\7f" + ) + "malformed UTF-8 encoding" +) + +;; byte after (first) 2-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\03" ;; custom section + "\02\c2\c0" ;; "\c2\c0" + ) + "malformed UTF-8 encoding" +) + +;; byte after (first) 2-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\03" ;; custom section + "\02\c2\fd" ;; "\c2\fd" + ) + "malformed UTF-8 encoding" +) + +;; byte after (last) 2-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\03" ;; custom section + "\02\df\00" ;; "\df\00" + ) + "malformed UTF-8 encoding" +) + +;; byte after (last) 2-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\03" ;; custom section + "\02\df\7f" ;; "\df\7f" + ) + "malformed UTF-8 encoding" +) + +;; byte after (last) 2-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\03" ;; custom section + "\02\df\c0" ;; "\df\c0" + ) + "malformed UTF-8 encoding" +) + +;; byte after (last) 2-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\03" ;; custom section + "\02\df\fd" ;; "\df\fd" + ) + "malformed UTF-8 encoding" +) + +;;;; 3-byte sequences + +;; 3-byte sequence contains 4 bytes +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\05" ;; custom section + "\04\e1\80\80\80" ;; "\e1\80\80\80" + ) + "malformed UTF-8 encoding" +) + +;; 3-byte sequence contains 2 bytes at end of string +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\03" ;; custom section + "\02\e1\80" ;; "\e1\80" + ) + "malformed UTF-8 encoding" +) + +;; 3-byte sequence contains 2 bytes +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\04" ;; custom section + "\03\e1\80\2e" ;; "\e1\80." + ) + "malformed UTF-8 encoding" +) + +;; 3-byte sequence contains 1 byte at end of string +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\02" ;; custom section + "\01\e1" ;; "\e1" + ) + "malformed UTF-8 encoding" +) + +;; 3-byte sequence contains 1 byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\03" ;; custom section + "\02\e1\2e" ;; "\e1." + ) + "malformed UTF-8 encoding" +) + +;;;; 3-byte sequence contents + +;; first byte after (0xe0) 3-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\04" ;; custom section + "\03\e0\00\a0" ;; "\e0\00\a0" + ) + "malformed UTF-8 encoding" +) + +;; first byte after (0xe0) 3-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\04" ;; custom section + "\03\e0\7f\a0" ;; "\e0\7f\a0" + ) + "malformed UTF-8 encoding" +) + +;; overlong encoding after 0xe0 prefix +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\04" ;; custom section + "\03\e0\80\80" ;; "\e0\80\80" + ) + "malformed UTF-8 encoding" +) + +;; overlong encoding after 0xe0 prefix +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\04" ;; custom section + "\03\e0\80\a0" ;; "\e0\80\a0" + ) + "malformed UTF-8 encoding" +) + +;; overlong encoding after 0xe0 prefix +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\04" ;; custom section + "\03\e0\9f\a0" ;; "\e0\9f\a0" + ) + "malformed UTF-8 encoding" +) + +;; overlong encoding after 0xe0 prefix +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\04" ;; custom section + "\03\e0\9f\bf" ;; "\e0\9f\bf" + ) + "malformed UTF-8 encoding" +) + +;; first byte after (0xe0) 3-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\04" ;; custom section + "\03\e0\c0\a0" ;; "\e0\c0\a0" + ) + "malformed UTF-8 encoding" +) + +;; first byte after (0xe0) 3-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\04" ;; custom section + "\03\e0\fd\a0" ;; "\e0\fd\a0" + ) + "malformed UTF-8 encoding" +) + +;; first byte after (first normal) 3-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\04" ;; custom section + "\03\e1\00\80" ;; "\e1\00\80" + ) + "malformed UTF-8 encoding" +) + +;; first byte after (first normal) 3-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\04" ;; custom section + "\03\e1\7f\80" ;; "\e1\7f\80" + ) + "malformed UTF-8 encoding" +) + +;; first byte after (first normal) 3-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\04" ;; custom section + "\03\e1\c0\80" ;; "\e1\c0\80" + ) + "malformed UTF-8 encoding" +) + +;; first byte after (first normal) 3-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\04" ;; custom section + "\03\e1\fd\80" ;; "\e1\fd\80" + ) + "malformed UTF-8 encoding" +) + +;; first byte after (normal) 3-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\04" ;; custom section + "\03\ec\00\80" ;; "\ec\00\80" + ) + "malformed UTF-8 encoding" +) + +;; first byte after (normal) 3-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\04" ;; custom section + "\03\ec\7f\80" ;; "\ec\7f\80" + ) + "malformed UTF-8 encoding" +) + +;; first byte after (normal) 3-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\04" ;; custom section + "\03\ec\c0\80" ;; "\ec\c0\80" + ) + "malformed UTF-8 encoding" +) + +;; first byte after (normal) 3-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\04" ;; custom section + "\03\ec\fd\80" ;; "\ec\fd\80" + ) + "malformed UTF-8 encoding" +) + +;; first byte after (0xed) 3-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\04" ;; custom section + "\03\ed\00\80" ;; "\ed\00\80" + ) + "malformed UTF-8 encoding" +) + +;; first byte after (0xed) 3-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\04" ;; custom section + "\03\ed\7f\80" ;; "\ed\7f\80" + ) + "malformed UTF-8 encoding" +) + +;; byte sequence reserved for UTF-16 surrogate half +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\04" ;; custom section + "\03\ed\a0\80" ;; "\ed\a0\80" + ) + "malformed UTF-8 encoding" +) + +;; byte sequence reserved for UTF-16 surrogate half +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\04" ;; custom section + "\03\ed\a0\bf" ;; "\ed\a0\bf" + ) + "malformed UTF-8 encoding" +) + +;; byte sequence reserved for UTF-16 surrogate half +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\04" ;; custom section + "\03\ed\bf\80" ;; "\ed\bf\80" + ) + "malformed UTF-8 encoding" +) + +;; byte sequence reserved for UTF-16 surrogate half +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\04" ;; custom section + "\03\ed\bf\bf" ;; "\ed\bf\bf" + ) + "malformed UTF-8 encoding" +) + +;; first byte after (0xed) 3-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\04" ;; custom section + "\03\ed\c0\80" ;; "\ed\c0\80" + ) + "malformed UTF-8 encoding" +) + +;; first byte after (0xed) 3-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\04" ;; custom section + "\03\ed\fd\80" ;; "\ed\fd\80" + ) + "malformed UTF-8 encoding" +) + +;; first byte after (normal) 3-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\04" ;; custom section + "\03\ee\00\80" ;; "\ee\00\80" + ) + "malformed UTF-8 encoding" +) + +;; first byte after (normal) 3-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\04" ;; custom section + "\03\ee\7f\80" ;; "\ee\7f\80" + ) + "malformed UTF-8 encoding" +) + +;; first byte after (normal) 3-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\04" ;; custom section + "\03\ee\c0\80" ;; "\ee\c0\80" + ) + "malformed UTF-8 encoding" +) + +;; first byte after (normal) 3-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\04" ;; custom section + "\03\ee\fd\80" ;; "\ee\fd\80" + ) + "malformed UTF-8 encoding" +) + +;; first byte after (last normal) 3-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\04" ;; custom section + "\03\ef\00\80" ;; "\ef\00\80" + ) + "malformed UTF-8 encoding" +) + +;; first byte after (last normal) 3-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\04" ;; custom section + "\03\ef\7f\80" ;; "\ef\7f\80" + ) + "malformed UTF-8 encoding" +) + +;; first byte after (last normal) 3-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\04" ;; custom section + "\03\ef\c0\80" ;; "\ef\c0\80" + ) + "malformed UTF-8 encoding" +) + +;; first byte after (last normal) 3-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\04" ;; custom section + "\03\ef\fd\80" ;; "\ef\fd\80" + ) + "malformed UTF-8 encoding" +) + +;;;; 3-byte sequence contents (third byte) + +;; second byte after (0xe0) 3-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\04" ;; custom section + "\03\e0\a0\00" ;; "\e0\a0\00" + ) + "malformed UTF-8 encoding" +) + +;; second byte after (0xe0) 3-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\04" ;; custom section + "\03\e0\a0\7f" ;; "\e0\a0\7f" + ) + "malformed UTF-8 encoding" +) + +;; second byte after (0xe0) 3-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\04" ;; custom section + "\03\e0\a0\c0" ;; "\e0\a0\c0" + ) + "malformed UTF-8 encoding" +) + +;; second byte after (0xe0) 3-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\04" ;; custom section + "\03\e0\a0\fd" ;; "\e0\a0\fd" + ) + "malformed UTF-8 encoding" +) + +;; second byte after (first normal) 3-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\04" ;; custom section + "\03\e1\80\00" ;; "\e1\80\00" + ) + "malformed UTF-8 encoding" +) + +;; second byte after (first normal) 3-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\04" ;; custom section + "\03\e1\80\7f" ;; "\e1\80\7f" + ) + "malformed UTF-8 encoding" +) + +;; second byte after (first normal) 3-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\04" ;; custom section + "\03\e1\80\c0" ;; "\e1\80\c0" + ) + "malformed UTF-8 encoding" +) + +;; second byte after (first normal) 3-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\04" ;; custom section + "\03\e1\80\fd" ;; "\e1\80\fd" + ) + "malformed UTF-8 encoding" +) + +;; second byte after (normal) 3-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\04" ;; custom section + "\03\ec\80\00" ;; "\ec\80\00" + ) + "malformed UTF-8 encoding" +) + +;; second byte after (normal) 3-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\04" ;; custom section + "\03\ec\80\7f" ;; "\ec\80\7f" + ) + "malformed UTF-8 encoding" +) + +;; second byte after (normal) 3-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\04" ;; custom section + "\03\ec\80\c0" ;; "\ec\80\c0" + ) + "malformed UTF-8 encoding" +) + +;; second byte after (normal) 3-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\04" ;; custom section + "\03\ec\80\fd" ;; "\ec\80\fd" + ) + "malformed UTF-8 encoding" +) + +;; second byte after (0xed) 3-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\04" ;; custom section + "\03\ed\80\00" ;; "\ed\80\00" + ) + "malformed UTF-8 encoding" +) + +;; second byte after (0xed) 3-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\04" ;; custom section + "\03\ed\80\7f" ;; "\ed\80\7f" + ) + "malformed UTF-8 encoding" +) + +;; second byte after (0xed) 3-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\04" ;; custom section + "\03\ed\80\c0" ;; "\ed\80\c0" + ) + "malformed UTF-8 encoding" +) + +;; second byte after (0xed) 3-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\04" ;; custom section + "\03\ed\80\fd" ;; "\ed\80\fd" + ) + "malformed UTF-8 encoding" +) + +;; second byte after (normal) 3-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\04" ;; custom section + "\03\ee\80\00" ;; "\ee\80\00" + ) + "malformed UTF-8 encoding" +) + +;; second byte after (normal) 3-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\04" ;; custom section + "\03\ee\80\7f" ;; "\ee\80\7f" + ) + "malformed UTF-8 encoding" +) + +;; second byte after (normal) 3-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\04" ;; custom section + "\03\ee\80\c0" ;; "\ee\80\c0" + ) + "malformed UTF-8 encoding" +) + +;; second byte after (normal) 3-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\04" ;; custom section + "\03\ee\80\fd" ;; "\ee\80\fd" + ) + "malformed UTF-8 encoding" +) + +;; second byte after (last normal) 3-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\04" ;; custom section + "\03\ef\80\00" ;; "\ef\80\00" + ) + "malformed UTF-8 encoding" +) + +;; second byte after (last normal) 3-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\04" ;; custom section + "\03\ef\80\7f" ;; "\ef\80\7f" + ) + "malformed UTF-8 encoding" +) + +;; second byte after (last normal) 3-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\04" ;; custom section + "\03\ef\80\c0" ;; "\ef\80\c0" + ) + "malformed UTF-8 encoding" +) + +;; second byte after (last normal) 3-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\04" ;; custom section + "\03\ef\80\fd" ;; "\ef\80\fd" + ) + "malformed UTF-8 encoding" +) + +;;;; 4-byte sequences + +;; 4-byte sequence contains 5 bytes +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\06" ;; custom section + "\05\f1\80\80\80\80" ;; "\f1\80\80\80\80" + ) + "malformed UTF-8 encoding" +) + +;; 4-byte sequence contains 3 bytes at end of string +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\04" ;; custom section + "\03\f1\80\80" ;; "\f1\80\80" + ) + "malformed UTF-8 encoding" +) + +;; 4-byte sequence contains 3 bytes +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\05" ;; custom section + "\04\f1\80\80\23" ;; "\f1\80\80#" + ) + "malformed UTF-8 encoding" +) + +;; 4-byte sequence contains 2 bytes at end of string +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\03" ;; custom section + "\02\f1\80" ;; "\f1\80" + ) + "malformed UTF-8 encoding" +) + +;; 4-byte sequence contains 2 bytes +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\04" ;; custom section + "\03\f1\80\23" ;; "\f1\80#" + ) + "malformed UTF-8 encoding" +) + +;; 4-byte sequence contains 1 byte at end of string +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\02" ;; custom section + "\01\f1" ;; "\f1" + ) + "malformed UTF-8 encoding" +) + +;; 4-byte sequence contains 1 byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\03" ;; custom section + "\02\f1\23" ;; "\f1#" + ) + "malformed UTF-8 encoding" +) + +;;;; 4-byte sequence contents + +;; first byte after (0xf0) 4-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\05" ;; custom section + "\04\f0\00\90\90" ;; "\f0\00\90\90" + ) + "malformed UTF-8 encoding" +) + +;; first byte after (0xf0) 4-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\05" ;; custom section + "\04\f0\7f\90\90" ;; "\f0\7f\90\90" + ) + "malformed UTF-8 encoding" +) + +;; overlong encoding after 0xf0 prefix +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\05" ;; custom section + "\04\f0\80\80\80" ;; "\f0\80\80\80" + ) + "malformed UTF-8 encoding" +) + +;; overlong encoding after 0xf0 prefix +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\05" ;; custom section + "\04\f0\80\90\90" ;; "\f0\80\90\90" + ) + "malformed UTF-8 encoding" +) + +;; overlong encoding after 0xf0 prefix +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\05" ;; custom section + "\04\f0\8f\90\90" ;; "\f0\8f\90\90" + ) + "malformed UTF-8 encoding" +) + +;; overlong encoding after 0xf0 prefix +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\05" ;; custom section + "\04\f0\8f\bf\bf" ;; "\f0\8f\bf\bf" + ) + "malformed UTF-8 encoding" +) + +;; first byte after (0xf0) 4-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\05" ;; custom section + "\04\f0\c0\90\90" ;; "\f0\c0\90\90" + ) + "malformed UTF-8 encoding" +) + +;; first byte after (0xf0) 4-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\05" ;; custom section + "\04\f0\fd\90\90" ;; "\f0\fd\90\90" + ) + "malformed UTF-8 encoding" +) + +;; first byte after (first normal) 4-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\05" ;; custom section + "\04\f1\00\80\80" ;; "\f1\00\80\80" + ) + "malformed UTF-8 encoding" +) + +;; first byte after (first normal) 4-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\05" ;; custom section + "\04\f1\7f\80\80" ;; "\f1\7f\80\80" + ) + "malformed UTF-8 encoding" +) + +;; first byte after (first normal) 4-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\05" ;; custom section + "\04\f1\c0\80\80" ;; "\f1\c0\80\80" + ) + "malformed UTF-8 encoding" +) + +;; first byte after (first normal) 4-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\05" ;; custom section + "\04\f1\fd\80\80" ;; "\f1\fd\80\80" + ) + "malformed UTF-8 encoding" +) + +;; first byte after (last normal) 4-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\05" ;; custom section + "\04\f3\00\80\80" ;; "\f3\00\80\80" + ) + "malformed UTF-8 encoding" +) + +;; first byte after (last normal) 4-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\05" ;; custom section + "\04\f3\7f\80\80" ;; "\f3\7f\80\80" + ) + "malformed UTF-8 encoding" +) + +;; first byte after (last normal) 4-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\05" ;; custom section + "\04\f3\c0\80\80" ;; "\f3\c0\80\80" + ) + "malformed UTF-8 encoding" +) + +;; first byte after (last normal) 4-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\05" ;; custom section + "\04\f3\fd\80\80" ;; "\f3\fd\80\80" + ) + "malformed UTF-8 encoding" +) + +;; first byte after (0xf4) 4-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\05" ;; custom section + "\04\f4\00\80\80" ;; "\f4\00\80\80" + ) + "malformed UTF-8 encoding" +) + +;; first byte after (0xf4) 4-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\05" ;; custom section + "\04\f4\7f\80\80" ;; "\f4\7f\80\80" + ) + "malformed UTF-8 encoding" +) + +;; (first) malformed code point +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\05" ;; custom section + "\04\f4\90\80\80" ;; "\f4\90\80\80" + ) + "malformed UTF-8 encoding" +) + +;; malformed code point +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\05" ;; custom section + "\04\f4\bf\80\80" ;; "\f4\bf\80\80" + ) + "malformed UTF-8 encoding" +) + +;; first byte after (0xf4) 4-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\05" ;; custom section + "\04\f4\c0\80\80" ;; "\f4\c0\80\80" + ) + "malformed UTF-8 encoding" +) + +;; first byte after (0xf4) 4-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\05" ;; custom section + "\04\f4\fd\80\80" ;; "\f4\fd\80\80" + ) + "malformed UTF-8 encoding" +) + +;; (first) malformed 4-byte prefix +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\05" ;; custom section + "\04\f5\80\80\80" ;; "\f5\80\80\80" + ) + "malformed UTF-8 encoding" +) + +;; (last) malformed 4-byte prefix +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\05" ;; custom section + "\04\f7\80\80\80" ;; "\f7\80\80\80" + ) + "malformed UTF-8 encoding" +) + +;; (last) malformed 4-byte prefix +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\05" ;; custom section + "\04\f7\bf\bf\bf" ;; "\f7\bf\bf\bf" + ) + "malformed UTF-8 encoding" +) + +;;;; 4-byte sequence contents (third byte) + +;; second byte after (0xf0) 4-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\05" ;; custom section + "\04\f0\90\00\90" ;; "\f0\90\00\90" + ) + "malformed UTF-8 encoding" +) + +;; second byte after (0xf0) 4-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\05" ;; custom section + "\04\f0\90\7f\90" ;; "\f0\90\7f\90" + ) + "malformed UTF-8 encoding" +) + +;; second byte after (0xf0) 4-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\05" ;; custom section + "\04\f0\90\c0\90" ;; "\f0\90\c0\90" + ) + "malformed UTF-8 encoding" +) + +;; second byte after (0xf0) 4-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\05" ;; custom section + "\04\f0\90\fd\90" ;; "\f0\90\fd\90" + ) + "malformed UTF-8 encoding" +) + +;; second byte after (first normal) 4-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\05" ;; custom section + "\04\f1\80\00\80" ;; "\f1\80\00\80" + ) + "malformed UTF-8 encoding" +) + +;; second byte after (first normal) 4-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\05" ;; custom section + "\04\f1\80\7f\80" ;; "\f1\80\7f\80" + ) + "malformed UTF-8 encoding" +) + +;; second byte after (first normal) 4-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\05" ;; custom section + "\04\f1\80\c0\80" ;; "\f1\80\c0\80" + ) + "malformed UTF-8 encoding" +) + +;; second byte after (first normal) 4-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\05" ;; custom section + "\04\f1\80\fd\80" ;; "\f1\80\fd\80" + ) + "malformed UTF-8 encoding" +) + +;; second byte after (last normal) 4-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\05" ;; custom section + "\04\f3\80\00\80" ;; "\f3\80\00\80" + ) + "malformed UTF-8 encoding" +) + +;; second byte after (last normal) 4-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\05" ;; custom section + "\04\f3\80\7f\80" ;; "\f3\80\7f\80" + ) + "malformed UTF-8 encoding" +) + +;; second byte after (last normal) 4-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\05" ;; custom section + "\04\f3\80\c0\80" ;; "\f3\80\c0\80" + ) + "malformed UTF-8 encoding" +) + +;; second byte after (last normal) 4-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\05" ;; custom section + "\04\f3\80\fd\80" ;; "\f3\80\fd\80" + ) + "malformed UTF-8 encoding" +) + +;; second byte after (0xf4) 4-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\05" ;; custom section + "\04\f4\80\00\80" ;; "\f4\80\00\80" + ) + "malformed UTF-8 encoding" +) + +;; second byte after (0xf4) 4-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\05" ;; custom section + "\04\f4\80\7f\80" ;; "\f4\80\7f\80" + ) + "malformed UTF-8 encoding" +) + +;; second byte after (0xf4) 4-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\05" ;; custom section + "\04\f4\80\c0\80" ;; "\f4\80\c0\80" + ) + "malformed UTF-8 encoding" +) + +;; second byte after (0xf4) 4-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\05" ;; custom section + "\04\f4\80\fd\80" ;; "\f4\80\fd\80" + ) + "malformed UTF-8 encoding" +) + +;;;; 4-byte sequence contents (fourth byte) + +;; third byte after (0xf0) 4-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\05" ;; custom section + "\04\f0\90\90\00" ;; "\f0\90\90\00" + ) + "malformed UTF-8 encoding" +) + +;; third byte after (0xf0) 4-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\05" ;; custom section + "\04\f0\90\90\7f" ;; "\f0\90\90\7f" + ) + "malformed UTF-8 encoding" +) + +;; third byte after (0xf0) 4-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\05" ;; custom section + "\04\f0\90\90\c0" ;; "\f0\90\90\c0" + ) + "malformed UTF-8 encoding" +) + +;; third byte after (0xf0) 4-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\05" ;; custom section + "\04\f0\90\90\fd" ;; "\f0\90\90\fd" + ) + "malformed UTF-8 encoding" +) + +;; third byte after (first normal) 4-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\05" ;; custom section + "\04\f1\80\80\00" ;; "\f1\80\80\00" + ) + "malformed UTF-8 encoding" +) + +;; third byte after (first normal) 4-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\05" ;; custom section + "\04\f1\80\80\7f" ;; "\f1\80\80\7f" + ) + "malformed UTF-8 encoding" +) + +;; third byte after (first normal) 4-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\05" ;; custom section + "\04\f1\80\80\c0" ;; "\f1\80\80\c0" + ) + "malformed UTF-8 encoding" +) + +;; third byte after (first normal) 4-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\05" ;; custom section + "\04\f1\80\80\fd" ;; "\f1\80\80\fd" + ) + "malformed UTF-8 encoding" +) + +;; third byte after (last normal) 4-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\05" ;; custom section + "\04\f3\80\80\00" ;; "\f3\80\80\00" + ) + "malformed UTF-8 encoding" +) + +;; third byte after (last normal) 4-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\05" ;; custom section + "\04\f3\80\80\7f" ;; "\f3\80\80\7f" + ) + "malformed UTF-8 encoding" +) + +;; third byte after (last normal) 4-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\05" ;; custom section + "\04\f3\80\80\c0" ;; "\f3\80\80\c0" + ) + "malformed UTF-8 encoding" +) + +;; third byte after (last normal) 4-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\05" ;; custom section + "\04\f3\80\80\fd" ;; "\f3\80\80\fd" + ) + "malformed UTF-8 encoding" +) + +;; third byte after (0xf4) 4-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\05" ;; custom section + "\04\f4\80\80\00" ;; "\f4\80\80\00" + ) + "malformed UTF-8 encoding" +) + +;; third byte after (0xf4) 4-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\05" ;; custom section + "\04\f4\80\80\7f" ;; "\f4\80\80\7f" + ) + "malformed UTF-8 encoding" +) + +;; third byte after (0xf4) 4-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\05" ;; custom section + "\04\f4\80\80\c0" ;; "\f4\80\80\c0" + ) + "malformed UTF-8 encoding" +) + +;; third byte after (0xf4) 4-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\05" ;; custom section + "\04\f4\80\80\fd" ;; "\f4\80\80\fd" + ) + "malformed UTF-8 encoding" +) + +;;;; 5-byte sequences + +;; 5-byte sequence contains 6 bytes +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\07" ;; custom section + "\06\f8\80\80\80\80\80" ;; "\f8\80\80\80\80\80" + ) + "malformed UTF-8 encoding" +) + +;; 5-byte sequence contains 4 bytes at end of string +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\05" ;; custom section + "\04\f8\80\80\80" ;; "\f8\80\80\80" + ) + "malformed UTF-8 encoding" +) + +;; 5-byte sequence contains 4 bytes +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\06" ;; custom section + "\05\f8\80\80\80\23" ;; "\f8\80\80\80#" + ) + "malformed UTF-8 encoding" +) + +;; 5-byte sequence contains 3 bytes at end of string +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\04" ;; custom section + "\03\f8\80\80" ;; "\f8\80\80" + ) + "malformed UTF-8 encoding" +) + +;; 5-byte sequence contains 3 bytes +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\05" ;; custom section + "\04\f8\80\80\23" ;; "\f8\80\80#" + ) + "malformed UTF-8 encoding" +) + +;; 5-byte sequence contains 2 bytes at end of string +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\03" ;; custom section + "\02\f8\80" ;; "\f8\80" + ) + "malformed UTF-8 encoding" +) + +;; 5-byte sequence contains 2 bytes +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\04" ;; custom section + "\03\f8\80\23" ;; "\f8\80#" + ) + "malformed UTF-8 encoding" +) + +;; 5-byte sequence contains 1 byte at end of string +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\02" ;; custom section + "\01\f8" ;; "\f8" + ) + "malformed UTF-8 encoding" +) + +;; 5-byte sequence contains 1 byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\03" ;; custom section + "\02\f8\23" ;; "\f8#" + ) + "malformed UTF-8 encoding" +) + +;;;; 5-byte sequence contents + +;; (first) malformed 5-byte prefix +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\06" ;; custom section + "\05\f8\80\80\80\80" ;; "\f8\80\80\80\80" + ) + "malformed UTF-8 encoding" +) + +;; (last) malformed 5-byte prefix +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\06" ;; custom section + "\05\fb\bf\bf\bf\bf" ;; "\fb\bf\bf\bf\bf" + ) + "malformed UTF-8 encoding" +) + +;;;; 6-byte sequences + +;; 6-byte sequence contains 7 bytes +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\08" ;; custom section + "\07\fc\80\80\80\80\80\80" ;; "\fc\80\80\80\80\80\80" + ) + "malformed UTF-8 encoding" +) + +;; 6-byte sequence contains 5 bytes at end of string +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\06" ;; custom section + "\05\fc\80\80\80\80" ;; "\fc\80\80\80\80" + ) + "malformed UTF-8 encoding" +) + +;; 6-byte sequence contains 5 bytes +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\07" ;; custom section + "\06\fc\80\80\80\80\23" ;; "\fc\80\80\80\80#" + ) + "malformed UTF-8 encoding" +) + +;; 6-byte sequence contains 4 bytes at end of string +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\05" ;; custom section + "\04\fc\80\80\80" ;; "\fc\80\80\80" + ) + "malformed UTF-8 encoding" +) + +;; 6-byte sequence contains 4 bytes +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\06" ;; custom section + "\05\fc\80\80\80\23" ;; "\fc\80\80\80#" + ) + "malformed UTF-8 encoding" +) + +;; 6-byte sequence contains 3 bytes at end of string +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\04" ;; custom section + "\03\fc\80\80" ;; "\fc\80\80" + ) + "malformed UTF-8 encoding" +) + +;; 6-byte sequence contains 3 bytes +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\05" ;; custom section + "\04\fc\80\80\23" ;; "\fc\80\80#" + ) + "malformed UTF-8 encoding" +) + +;; 6-byte sequence contains 2 bytes at end of string +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\03" ;; custom section + "\02\fc\80" ;; "\fc\80" + ) + "malformed UTF-8 encoding" +) + +;; 6-byte sequence contains 2 bytes +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\04" ;; custom section + "\03\fc\80\23" ;; "\fc\80#" + ) + "malformed UTF-8 encoding" +) + +;; 6-byte sequence contains 1 byte at end of string +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\02" ;; custom section + "\01\fc" ;; "\fc" + ) + "malformed UTF-8 encoding" +) + +;; 6-byte sequence contains 1 byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\03" ;; custom section + "\02\fc\23" ;; "\fc#" + ) + "malformed UTF-8 encoding" +) + +;;;; 6-byte sequence contents + +;; (first) malformed 6-byte prefix +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\07" ;; custom section + "\06\fc\80\80\80\80\80" ;; "\fc\80\80\80\80\80" + ) + "malformed UTF-8 encoding" +) + +;; (last) malformed 6-byte prefix +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\07" ;; custom section + "\06\fd\bf\bf\bf\bf\bf" ;; "\fd\bf\bf\bf\bf\bf" + ) + "malformed UTF-8 encoding" +) + +;;;; Miscellaneous malformed bytes + +;; malformed byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\02" ;; custom section + "\01\fe" ;; "\fe" + ) + "malformed UTF-8 encoding" +) + +;; malformed byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\02" ;; custom section + "\01\ff" ;; "\ff" + ) + "malformed UTF-8 encoding" +) + +;; UTF-16BE BOM +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\03" ;; custom section + "\02\fe\ff" ;; "\fe\ff" + ) + "malformed UTF-8 encoding" +) + +;; UTF-32BE BOM +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\05" ;; custom section + "\04\00\00\fe\ff" ;; "\00\00\fe\ff" + ) + "malformed UTF-8 encoding" +) + +;; UTF-16LE BOM +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\03" ;; custom section + "\02\ff\fe" ;; "\ff\fe" + ) + "malformed UTF-8 encoding" +) + +;; UTF-32LE BOM +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\00\05" ;; custom section + "\04\ff\fe\00\00" ;; "\ff\fe\00\00" + ) + "malformed UTF-8 encoding" +) + diff --git a/runtime/near-vm/tests/wast/spec/utf8-import-field.wast b/runtime/near-vm/tests/wast/spec/utf8-import-field.wast new file mode 100644 index 00000000000..0d030dabb1f --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/utf8-import-field.wast @@ -0,0 +1,2672 @@ +;;;;;; Invalid UTF-8 import field names + +;;;; Continuation bytes not preceded by prefixes + +;; encoding starts with (first) continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0b" ;; import section + "\01" ;; length 1 + "\01\80" ;; "\80" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; encoding starts with (0x8f) continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0b" ;; import section + "\01" ;; length 1 + "\01\8f" ;; "\8f" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; encoding starts with (0x90) continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0b" ;; import section + "\01" ;; length 1 + "\01\90" ;; "\90" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; encoding starts with (0x9f) continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0b" ;; import section + "\01" ;; length 1 + "\01\9f" ;; "\9f" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; encoding starts with (0xa0) continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0b" ;; import section + "\01" ;; length 1 + "\01\a0" ;; "\a0" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; encoding starts with (last) continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0b" ;; import section + "\01" ;; length 1 + "\01\bf" ;; "\bf" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;;;; 2-byte sequences + +;; 2-byte sequence contains 3 bytes +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0d" ;; import section + "\01" ;; length 1 + "\03\c2\80\80" ;; "\c2\80\80" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; 2-byte sequence contains 1 byte at end of string +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0b" ;; import section + "\01" ;; length 1 + "\01\c2" ;; "\c2" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; 2-byte sequence contains 1 byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0c" ;; import section + "\01" ;; length 1 + "\02\c2\2e" ;; "\c2." + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;;;; 2-byte sequence contents + +;; overlong encoding after 0xc0 prefix +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0c" ;; import section + "\01" ;; length 1 + "\02\c0\80" ;; "\c0\80" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; overlong encoding after 0xc0 prefix +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0c" ;; import section + "\01" ;; length 1 + "\02\c0\bf" ;; "\c0\bf" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; overlong encoding after 0xc1 prefix +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0c" ;; import section + "\01" ;; length 1 + "\02\c1\80" ;; "\c1\80" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; overlong encoding after 0xc1 prefix +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0c" ;; import section + "\01" ;; length 1 + "\02\c1\bf" ;; "\c1\bf" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; byte after (first) 2-byte prefix not a contination byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0c" ;; import section + "\01" ;; length 1 + "\02\c2\00" ;; "\c2\00" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; byte after (first) 2-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0c" ;; import section + "\01" ;; length 1 + "\02\c2\7f" ;; "\c2\7f" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; byte after (first) 2-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0c" ;; import section + "\01" ;; length 1 + "\02\c2\c0" ;; "\c2\c0" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; byte after (first) 2-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0c" ;; import section + "\01" ;; length 1 + "\02\c2\fd" ;; "\c2\fd" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; byte after (last) 2-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0c" ;; import section + "\01" ;; length 1 + "\02\df\00" ;; "\df\00" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; byte after (last) 2-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0c" ;; import section + "\01" ;; length 1 + "\02\df\7f" ;; "\df\7f" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; byte after (last) 2-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0c" ;; import section + "\01" ;; length 1 + "\02\df\c0" ;; "\df\c0" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; byte after (last) 2-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0c" ;; import section + "\01" ;; length 1 + "\02\df\fd" ;; "\df\fd" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;;;; 3-byte sequences + +;; 3-byte sequence contains 4 bytes +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0e" ;; import section + "\01" ;; length 1 + "\04\e1\80\80\80" ;; "\e1\80\80\80" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; 3-byte sequence contains 2 bytes at end of string +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0c" ;; import section + "\01" ;; length 1 + "\02\e1\80" ;; "\e1\80" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; 3-byte sequence contains 2 bytes +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0d" ;; import section + "\01" ;; length 1 + "\03\e1\80\2e" ;; "\e1\80." + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; 3-byte sequence contains 1 byte at end of string +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0b" ;; import section + "\01" ;; length 1 + "\01\e1" ;; "\e1" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; 3-byte sequence contains 1 byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0c" ;; import section + "\01" ;; length 1 + "\02\e1\2e" ;; "\e1." + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;;;; 3-byte sequence contents + +;; first byte after (0xe0) 3-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0d" ;; import section + "\01" ;; length 1 + "\03\e0\00\a0" ;; "\e0\00\a0" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; first byte after (0xe0) 3-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0d" ;; import section + "\01" ;; length 1 + "\03\e0\7f\a0" ;; "\e0\7f\a0" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; overlong encoding after 0xe0 prefix +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0d" ;; import section + "\01" ;; length 1 + "\03\e0\80\80" ;; "\e0\80\80" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; overlong encoding after 0xe0 prefix +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0d" ;; import section + "\01" ;; length 1 + "\03\e0\80\a0" ;; "\e0\80\a0" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; overlong encoding after 0xe0 prefix +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0d" ;; import section + "\01" ;; length 1 + "\03\e0\9f\a0" ;; "\e0\9f\a0" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; overlong encoding after 0xe0 prefix +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0d" ;; import section + "\01" ;; length 1 + "\03\e0\9f\bf" ;; "\e0\9f\bf" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; first byte after (0xe0) 3-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0d" ;; import section + "\01" ;; length 1 + "\03\e0\c0\a0" ;; "\e0\c0\a0" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; first byte after (0xe0) 3-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0d" ;; import section + "\01" ;; length 1 + "\03\e0\fd\a0" ;; "\e0\fd\a0" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; first byte after (first normal) 3-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0d" ;; import section + "\01" ;; length 1 + "\03\e1\00\80" ;; "\e1\00\80" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; first byte after (first normal) 3-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0d" ;; import section + "\01" ;; length 1 + "\03\e1\7f\80" ;; "\e1\7f\80" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; first byte after (first normal) 3-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0d" ;; import section + "\01" ;; length 1 + "\03\e1\c0\80" ;; "\e1\c0\80" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; first byte after (first normal) 3-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0d" ;; import section + "\01" ;; length 1 + "\03\e1\fd\80" ;; "\e1\fd\80" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; first byte after (normal) 3-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0d" ;; import section + "\01" ;; length 1 + "\03\ec\00\80" ;; "\ec\00\80" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; first byte after (normal) 3-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0d" ;; import section + "\01" ;; length 1 + "\03\ec\7f\80" ;; "\ec\7f\80" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; first byte after (normal) 3-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0d" ;; import section + "\01" ;; length 1 + "\03\ec\c0\80" ;; "\ec\c0\80" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; first byte after (normal) 3-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0d" ;; import section + "\01" ;; length 1 + "\03\ec\fd\80" ;; "\ec\fd\80" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; first byte after (0xed) 3-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0d" ;; import section + "\01" ;; length 1 + "\03\ed\00\80" ;; "\ed\00\80" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; first byte after (0xed) 3-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0d" ;; import section + "\01" ;; length 1 + "\03\ed\7f\80" ;; "\ed\7f\80" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; byte sequence reserved for UTF-16 surrogate half +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0d" ;; import section + "\01" ;; length 1 + "\03\ed\a0\80" ;; "\ed\a0\80" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; byte sequence reserved for UTF-16 surrogate half +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0d" ;; import section + "\01" ;; length 1 + "\03\ed\a0\bf" ;; "\ed\a0\bf" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; byte sequence reserved for UTF-16 surrogate half +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0d" ;; import section + "\01" ;; length 1 + "\03\ed\bf\80" ;; "\ed\bf\80" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; byte sequence reserved for UTF-16 surrogate half +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0d" ;; import section + "\01" ;; length 1 + "\03\ed\bf\bf" ;; "\ed\bf\bf" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; first byte after (0xed) 3-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0d" ;; import section + "\01" ;; length 1 + "\03\ed\c0\80" ;; "\ed\c0\80" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; first byte after (0xed) 3-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0d" ;; import section + "\01" ;; length 1 + "\03\ed\fd\80" ;; "\ed\fd\80" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; first byte after (normal) 3-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0d" ;; import section + "\01" ;; length 1 + "\03\ee\00\80" ;; "\ee\00\80" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; first byte after (normal) 3-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0d" ;; import section + "\01" ;; length 1 + "\03\ee\7f\80" ;; "\ee\7f\80" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; first byte after (normal) 3-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0d" ;; import section + "\01" ;; length 1 + "\03\ee\c0\80" ;; "\ee\c0\80" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; first byte after (normal) 3-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0d" ;; import section + "\01" ;; length 1 + "\03\ee\fd\80" ;; "\ee\fd\80" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; first byte after (last normal) 3-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0d" ;; import section + "\01" ;; length 1 + "\03\ef\00\80" ;; "\ef\00\80" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; first byte after (last normal) 3-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0d" ;; import section + "\01" ;; length 1 + "\03\ef\7f\80" ;; "\ef\7f\80" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; first byte after (last normal) 3-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0d" ;; import section + "\01" ;; length 1 + "\03\ef\c0\80" ;; "\ef\c0\80" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; first byte after (last normal) 3-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0d" ;; import section + "\01" ;; length 1 + "\03\ef\fd\80" ;; "\ef\fd\80" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;;;; 3-byte sequence contents (third byte) + +;; second byte after (0xe0) 3-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0d" ;; import section + "\01" ;; length 1 + "\03\e0\a0\00" ;; "\e0\a0\00" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; second byte after (0xe0) 3-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0d" ;; import section + "\01" ;; length 1 + "\03\e0\a0\7f" ;; "\e0\a0\7f" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; second byte after (0xe0) 3-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0d" ;; import section + "\01" ;; length 1 + "\03\e0\a0\c0" ;; "\e0\a0\c0" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; second byte after (0xe0) 3-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0d" ;; import section + "\01" ;; length 1 + "\03\e0\a0\fd" ;; "\e0\a0\fd" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; second byte after (first normal) 3-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0d" ;; import section + "\01" ;; length 1 + "\03\e1\80\00" ;; "\e1\80\00" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; second byte after (first normal) 3-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0d" ;; import section + "\01" ;; length 1 + "\03\e1\80\7f" ;; "\e1\80\7f" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; second byte after (first normal) 3-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0d" ;; import section + "\01" ;; length 1 + "\03\e1\80\c0" ;; "\e1\80\c0" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; second byte after (first normal) 3-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0d" ;; import section + "\01" ;; length 1 + "\03\e1\80\fd" ;; "\e1\80\fd" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; second byte after (normal) 3-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0d" ;; import section + "\01" ;; length 1 + "\03\ec\80\00" ;; "\ec\80\00" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; second byte after (normal) 3-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0d" ;; import section + "\01" ;; length 1 + "\03\ec\80\7f" ;; "\ec\80\7f" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; second byte after (normal) 3-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0d" ;; import section + "\01" ;; length 1 + "\03\ec\80\c0" ;; "\ec\80\c0" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; second byte after (normal) 3-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0d" ;; import section + "\01" ;; length 1 + "\03\ec\80\fd" ;; "\ec\80\fd" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; second byte after (0xed) 3-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0d" ;; import section + "\01" ;; length 1 + "\03\ed\80\00" ;; "\ed\80\00" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; second byte after (0xed) 3-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0d" ;; import section + "\01" ;; length 1 + "\03\ed\80\7f" ;; "\ed\80\7f" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; second byte after (0xed) 3-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0d" ;; import section + "\01" ;; length 1 + "\03\ed\80\c0" ;; "\ed\80\c0" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; second byte after (0xed) 3-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0d" ;; import section + "\01" ;; length 1 + "\03\ed\80\fd" ;; "\ed\80\fd" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; second byte after (normal) 3-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0d" ;; import section + "\01" ;; length 1 + "\03\ee\80\00" ;; "\ee\80\00" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; second byte after (normal) 3-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0d" ;; import section + "\01" ;; length 1 + "\03\ee\80\7f" ;; "\ee\80\7f" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; second byte after (normal) 3-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0d" ;; import section + "\01" ;; length 1 + "\03\ee\80\c0" ;; "\ee\80\c0" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; second byte after (normal) 3-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0d" ;; import section + "\01" ;; length 1 + "\03\ee\80\fd" ;; "\ee\80\fd" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; second byte after (last normal) 3-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0d" ;; import section + "\01" ;; length 1 + "\03\ef\80\00" ;; "\ef\80\00" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; second byte after (last normal) 3-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0d" ;; import section + "\01" ;; length 1 + "\03\ef\80\7f" ;; "\ef\80\7f" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; second byte after (last normal) 3-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0d" ;; import section + "\01" ;; length 1 + "\03\ef\80\c0" ;; "\ef\80\c0" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; second byte after (last normal) 3-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0d" ;; import section + "\01" ;; length 1 + "\03\ef\80\fd" ;; "\ef\80\fd" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;;;; 4-byte sequences + +;; 4-byte sequence contains 5 bytes +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0f" ;; import section + "\01" ;; length 1 + "\05\f1\80\80\80\80" ;; "\f1\80\80\80\80" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; 4-byte sequence contains 3 bytes at end of string +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0d" ;; import section + "\01" ;; length 1 + "\03\f1\80\80" ;; "\f1\80\80" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; 4-byte sequence contains 3 bytes +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0e" ;; import section + "\01" ;; length 1 + "\04\f1\80\80\23" ;; "\f1\80\80#" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; 4-byte sequence contains 2 bytes at end of string +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0c" ;; import section + "\01" ;; length 1 + "\02\f1\80" ;; "\f1\80" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; 4-byte sequence contains 2 bytes +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0d" ;; import section + "\01" ;; length 1 + "\03\f1\80\23" ;; "\f1\80#" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; 4-byte sequence contains 1 byte at end of string +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0b" ;; import section + "\01" ;; length 1 + "\01\f1" ;; "\f1" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; 4-byte sequence contains 1 byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0c" ;; import section + "\01" ;; length 1 + "\02\f1\23" ;; "\f1#" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;;;; 4-byte sequence contents + +;; first byte after (0xf0) 4-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0e" ;; import section + "\01" ;; length 1 + "\04\f0\00\90\90" ;; "\f0\00\90\90" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; first byte after (0xf0) 4-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0e" ;; import section + "\01" ;; length 1 + "\04\f0\7f\90\90" ;; "\f0\7f\90\90" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; overlong encoding after 0xf0 prefix +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0e" ;; import section + "\01" ;; length 1 + "\04\f0\80\80\80" ;; "\f0\80\80\80" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; overlong encoding after 0xf0 prefix +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0e" ;; import section + "\01" ;; length 1 + "\04\f0\80\90\90" ;; "\f0\80\90\90" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; overlong encoding after 0xf0 prefix +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0e" ;; import section + "\01" ;; length 1 + "\04\f0\8f\90\90" ;; "\f0\8f\90\90" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; overlong encoding after 0xf0 prefix +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0e" ;; import section + "\01" ;; length 1 + "\04\f0\8f\bf\bf" ;; "\f0\8f\bf\bf" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; first byte after (0xf0) 4-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0e" ;; import section + "\01" ;; length 1 + "\04\f0\c0\90\90" ;; "\f0\c0\90\90" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; first byte after (0xf0) 4-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0e" ;; import section + "\01" ;; length 1 + "\04\f0\fd\90\90" ;; "\f0\fd\90\90" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; first byte after (first normal) 4-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0e" ;; import section + "\01" ;; length 1 + "\04\f1\00\80\80" ;; "\f1\00\80\80" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; first byte after (first normal) 4-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0e" ;; import section + "\01" ;; length 1 + "\04\f1\7f\80\80" ;; "\f1\7f\80\80" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; first byte after (first normal) 4-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0e" ;; import section + "\01" ;; length 1 + "\04\f1\c0\80\80" ;; "\f1\c0\80\80" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; first byte after (first normal) 4-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0e" ;; import section + "\01" ;; length 1 + "\04\f1\fd\80\80" ;; "\f1\fd\80\80" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; first byte after (last normal) 4-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0e" ;; import section + "\01" ;; length 1 + "\04\f3\00\80\80" ;; "\f3\00\80\80" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; first byte after (last normal) 4-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0e" ;; import section + "\01" ;; length 1 + "\04\f3\7f\80\80" ;; "\f3\7f\80\80" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; first byte after (last normal) 4-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0e" ;; import section + "\01" ;; length 1 + "\04\f3\c0\80\80" ;; "\f3\c0\80\80" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; first byte after (last normal) 4-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0e" ;; import section + "\01" ;; length 1 + "\04\f3\fd\80\80" ;; "\f3\fd\80\80" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; first byte after (0xf4) 4-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0e" ;; import section + "\01" ;; length 1 + "\04\f4\00\80\80" ;; "\f4\00\80\80" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; first byte after (0xf4) 4-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0e" ;; import section + "\01" ;; length 1 + "\04\f4\7f\80\80" ;; "\f4\7f\80\80" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; (first) malformed code point +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0e" ;; import section + "\01" ;; length 1 + "\04\f4\90\80\80" ;; "\f4\90\80\80" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; malformed code point +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0e" ;; import section + "\01" ;; length 1 + "\04\f4\bf\80\80" ;; "\f4\bf\80\80" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; first byte after (0xf4) 4-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0e" ;; import section + "\01" ;; length 1 + "\04\f4\c0\80\80" ;; "\f4\c0\80\80" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; first byte after (0xf4) 4-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0e" ;; import section + "\01" ;; length 1 + "\04\f4\fd\80\80" ;; "\f4\fd\80\80" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; (first) malformed 4-byte prefix +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0e" ;; import section + "\01" ;; length 1 + "\04\f5\80\80\80" ;; "\f5\80\80\80" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; (last) malformed 4-byte prefix +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0e" ;; import section + "\01" ;; length 1 + "\04\f7\80\80\80" ;; "\f7\80\80\80" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; (last) malformed 4-byte prefix +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0e" ;; import section + "\01" ;; length 1 + "\04\f7\bf\bf\bf" ;; "\f7\bf\bf\bf" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;;;; 4-byte sequence contents (third byte) + +;; second byte after (0xf0) 4-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0e" ;; import section + "\01" ;; length 1 + "\04\f0\90\00\90" ;; "\f0\90\00\90" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; second byte after (0xf0) 4-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0e" ;; import section + "\01" ;; length 1 + "\04\f0\90\7f\90" ;; "\f0\90\7f\90" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; second byte after (0xf0) 4-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0e" ;; import section + "\01" ;; length 1 + "\04\f0\90\c0\90" ;; "\f0\90\c0\90" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; second byte after (0xf0) 4-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0e" ;; import section + "\01" ;; length 1 + "\04\f0\90\fd\90" ;; "\f0\90\fd\90" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; second byte after (first normal) 4-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0e" ;; import section + "\01" ;; length 1 + "\04\f1\80\00\80" ;; "\f1\80\00\80" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; second byte after (first normal) 4-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0e" ;; import section + "\01" ;; length 1 + "\04\f1\80\7f\80" ;; "\f1\80\7f\80" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; second byte after (first normal) 4-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0e" ;; import section + "\01" ;; length 1 + "\04\f1\80\c0\80" ;; "\f1\80\c0\80" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; second byte after (first normal) 4-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0e" ;; import section + "\01" ;; length 1 + "\04\f1\80\fd\80" ;; "\f1\80\fd\80" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; second byte after (last normal) 4-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0e" ;; import section + "\01" ;; length 1 + "\04\f3\80\00\80" ;; "\f3\80\00\80" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; second byte after (last normal) 4-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0e" ;; import section + "\01" ;; length 1 + "\04\f3\80\7f\80" ;; "\f3\80\7f\80" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; second byte after (last normal) 4-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0e" ;; import section + "\01" ;; length 1 + "\04\f3\80\c0\80" ;; "\f3\80\c0\80" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; second byte after (last normal) 4-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0e" ;; import section + "\01" ;; length 1 + "\04\f3\80\fd\80" ;; "\f3\80\fd\80" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; second byte after (0xf4) 4-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0e" ;; import section + "\01" ;; length 1 + "\04\f4\80\00\80" ;; "\f4\80\00\80" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; second byte after (0xf4) 4-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0e" ;; import section + "\01" ;; length 1 + "\04\f4\80\7f\80" ;; "\f4\80\7f\80" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; second byte after (0xf4) 4-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0e" ;; import section + "\01" ;; length 1 + "\04\f4\80\c0\80" ;; "\f4\80\c0\80" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; second byte after (0xf4) 4-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0e" ;; import section + "\01" ;; length 1 + "\04\f4\80\fd\80" ;; "\f4\80\fd\80" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;;;; 4-byte sequence contents (fourth byte) + +;; third byte after (0xf0) 4-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0e" ;; import section + "\01" ;; length 1 + "\04\f0\90\90\00" ;; "\f0\90\90\00" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; third byte after (0xf0) 4-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0e" ;; import section + "\01" ;; length 1 + "\04\f0\90\90\7f" ;; "\f0\90\90\7f" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; third byte after (0xf0) 4-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0e" ;; import section + "\01" ;; length 1 + "\04\f0\90\90\c0" ;; "\f0\90\90\c0" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; third byte after (0xf0) 4-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0e" ;; import section + "\01" ;; length 1 + "\04\f0\90\90\fd" ;; "\f0\90\90\fd" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; third byte after (first normal) 4-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0e" ;; import section + "\01" ;; length 1 + "\04\f1\80\80\00" ;; "\f1\80\80\00" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; third byte after (first normal) 4-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0e" ;; import section + "\01" ;; length 1 + "\04\f1\80\80\7f" ;; "\f1\80\80\7f" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; third byte after (first normal) 4-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0e" ;; import section + "\01" ;; length 1 + "\04\f1\80\80\c0" ;; "\f1\80\80\c0" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; third byte after (first normal) 4-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0e" ;; import section + "\01" ;; length 1 + "\04\f1\80\80\fd" ;; "\f1\80\80\fd" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; third byte after (last normal) 4-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0e" ;; import section + "\01" ;; length 1 + "\04\f3\80\80\00" ;; "\f3\80\80\00" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; third byte after (last normal) 4-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0e" ;; import section + "\01" ;; length 1 + "\04\f3\80\80\7f" ;; "\f3\80\80\7f" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; third byte after (last normal) 4-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0e" ;; import section + "\01" ;; length 1 + "\04\f3\80\80\c0" ;; "\f3\80\80\c0" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; third byte after (last normal) 4-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0e" ;; import section + "\01" ;; length 1 + "\04\f3\80\80\fd" ;; "\f3\80\80\fd" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; third byte after (0xf4) 4-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0e" ;; import section + "\01" ;; length 1 + "\04\f4\80\80\00" ;; "\f4\80\80\00" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; third byte after (0xf4) 4-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0e" ;; import section + "\01" ;; length 1 + "\04\f4\80\80\7f" ;; "\f4\80\80\7f" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; third byte after (0xf4) 4-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0e" ;; import section + "\01" ;; length 1 + "\04\f4\80\80\c0" ;; "\f4\80\80\c0" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; third byte after (0xf4) 4-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0e" ;; import section + "\01" ;; length 1 + "\04\f4\80\80\fd" ;; "\f4\80\80\fd" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;;;; 5-byte sequences + +;; 5-byte sequence contains 6 bytes +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\10" ;; import section + "\01" ;; length 1 + "\06\f8\80\80\80\80\80" ;; "\f8\80\80\80\80\80" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; 5-byte sequence contains 4 bytes at end of string +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0e" ;; import section + "\01" ;; length 1 + "\04\f8\80\80\80" ;; "\f8\80\80\80" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; 5-byte sequence contains 4 bytes +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0f" ;; import section + "\01" ;; length 1 + "\05\f8\80\80\80\23" ;; "\f8\80\80\80#" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; 5-byte sequence contains 3 bytes at end of string +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0d" ;; import section + "\01" ;; length 1 + "\03\f8\80\80" ;; "\f8\80\80" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; 5-byte sequence contains 3 bytes +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0e" ;; import section + "\01" ;; length 1 + "\04\f8\80\80\23" ;; "\f8\80\80#" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; 5-byte sequence contains 2 bytes at end of string +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0c" ;; import section + "\01" ;; length 1 + "\02\f8\80" ;; "\f8\80" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; 5-byte sequence contains 2 bytes +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0d" ;; import section + "\01" ;; length 1 + "\03\f8\80\23" ;; "\f8\80#" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; 5-byte sequence contains 1 byte at end of string +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0b" ;; import section + "\01" ;; length 1 + "\01\f8" ;; "\f8" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; 5-byte sequence contains 1 byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0c" ;; import section + "\01" ;; length 1 + "\02\f8\23" ;; "\f8#" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;;;; 5-byte sequence contents + +;; (first) malformed 5-byte prefix +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0f" ;; import section + "\01" ;; length 1 + "\05\f8\80\80\80\80" ;; "\f8\80\80\80\80" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; (last) malformed 5-byte prefix +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0f" ;; import section + "\01" ;; length 1 + "\05\fb\bf\bf\bf\bf" ;; "\fb\bf\bf\bf\bf" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;;;; 6-byte sequences + +;; 6-byte sequence contains 7 bytes +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\11" ;; import section + "\01" ;; length 1 + "\07\fc\80\80\80\80\80\80" ;; "\fc\80\80\80\80\80\80" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; 6-byte sequence contains 5 bytes at end of string +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0f" ;; import section + "\01" ;; length 1 + "\05\fc\80\80\80\80" ;; "\fc\80\80\80\80" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; 6-byte sequence contains 5 bytes +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\10" ;; import section + "\01" ;; length 1 + "\06\fc\80\80\80\80\23" ;; "\fc\80\80\80\80#" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; 6-byte sequence contains 4 bytes at end of string +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0e" ;; import section + "\01" ;; length 1 + "\04\fc\80\80\80" ;; "\fc\80\80\80" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; 6-byte sequence contains 4 bytes +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0f" ;; import section + "\01" ;; length 1 + "\05\fc\80\80\80\23" ;; "\fc\80\80\80#" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; 6-byte sequence contains 3 bytes at end of string +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0d" ;; import section + "\01" ;; length 1 + "\03\fc\80\80" ;; "\fc\80\80" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; 6-byte sequence contains 3 bytes +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0e" ;; import section + "\01" ;; length 1 + "\04\fc\80\80\23" ;; "\fc\80\80#" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; 6-byte sequence contains 2 bytes at end of string +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0c" ;; import section + "\01" ;; length 1 + "\02\fc\80" ;; "\fc\80" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; 6-byte sequence contains 2 bytes +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0d" ;; import section + "\01" ;; length 1 + "\03\fc\80\23" ;; "\fc\80#" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; 6-byte sequence contains 1 byte at end of string +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0b" ;; import section + "\01" ;; length 1 + "\01\fc" ;; "\fc" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; 6-byte sequence contains 1 byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0c" ;; import section + "\01" ;; length 1 + "\02\fc\23" ;; "\fc#" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;;;; 6-byte sequence contents + +;; (first) malformed 6-byte prefix +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\10" ;; import section + "\01" ;; length 1 + "\06\fc\80\80\80\80\80" ;; "\fc\80\80\80\80\80" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; (last) malformed 6-byte prefix +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\10" ;; import section + "\01" ;; length 1 + "\06\fd\bf\bf\bf\bf\bf" ;; "\fd\bf\bf\bf\bf\bf" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;;;; Miscellaneous malformed bytes + +;; malformed byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0b" ;; import section + "\01" ;; length 1 + "\01\fe" ;; "\fe" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; malformed byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0b" ;; import section + "\01" ;; length 1 + "\01\ff" ;; "\ff" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; UTF-16BE BOM +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0c" ;; import section + "\01" ;; length 1 + "\02\fe\ff" ;; "\fe\ff" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; UTF-32BE BOM +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0e" ;; import section + "\01" ;; length 1 + "\04\00\00\fe\ff" ;; "\00\00\fe\ff" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; UTF-16LE BOM +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0c" ;; import section + "\01" ;; length 1 + "\02\ff\fe" ;; "\ff\fe" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; UTF-32LE BOM +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0e" ;; import section + "\01" ;; length 1 + "\04\ff\fe\00\00" ;; "\ff\fe\00\00" + "\04\74\65\73\74" ;; "test" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + diff --git a/runtime/near-vm/tests/wast/spec/utf8-import-module.wast b/runtime/near-vm/tests/wast/spec/utf8-import-module.wast new file mode 100644 index 00000000000..5a092da08ab --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/utf8-import-module.wast @@ -0,0 +1,2672 @@ +;;;;;; Invalid UTF-8 import module names + +;;;; Continuation bytes not preceded by prefixes + +;; encoding starts with (first) continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0b" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\01\80" ;; "\80" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; encoding starts with (0x8f) continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0b" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\01\8f" ;; "\8f" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; encoding starts with (0x90) continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0b" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\01\90" ;; "\90" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; encoding starts with (0x9f) continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0b" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\01\9f" ;; "\9f" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; encoding starts with (0xa0) continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0b" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\01\a0" ;; "\a0" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; encoding starts with (last) continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0b" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\01\bf" ;; "\bf" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;;;; 2-byte sequences + +;; 2-byte sequence contains 3 bytes +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0d" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\03\c2\80\80" ;; "\c2\80\80" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; 2-byte sequence contains 1 byte at end of string +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0b" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\01\c2" ;; "\c2" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; 2-byte sequence contains 1 byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0c" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\02\c2\2e" ;; "\c2." + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;;;; 2-byte sequence contents + +;; overlong encoding after 0xc0 prefix +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0c" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\02\c0\80" ;; "\c0\80" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; overlong encoding after 0xc0 prefix +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0c" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\02\c0\bf" ;; "\c0\bf" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; overlong encoding after 0xc1 prefix +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0c" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\02\c1\80" ;; "\c1\80" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; overlong encoding after 0xc1 prefix +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0c" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\02\c1\bf" ;; "\c1\bf" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; byte after (first) 2-byte prefix not a contination byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0c" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\02\c2\00" ;; "\c2\00" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; byte after (first) 2-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0c" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\02\c2\7f" ;; "\c2\7f" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; byte after (first) 2-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0c" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\02\c2\c0" ;; "\c2\c0" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; byte after (first) 2-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0c" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\02\c2\fd" ;; "\c2\fd" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; byte after (last) 2-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0c" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\02\df\00" ;; "\df\00" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; byte after (last) 2-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0c" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\02\df\7f" ;; "\df\7f" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; byte after (last) 2-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0c" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\02\df\c0" ;; "\df\c0" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; byte after (last) 2-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0c" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\02\df\fd" ;; "\df\fd" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;;;; 3-byte sequences + +;; 3-byte sequence contains 4 bytes +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0e" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\04\e1\80\80\80" ;; "\e1\80\80\80" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; 3-byte sequence contains 2 bytes at end of string +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0c" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\02\e1\80" ;; "\e1\80" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; 3-byte sequence contains 2 bytes +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0d" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\03\e1\80\2e" ;; "\e1\80." + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; 3-byte sequence contains 1 byte at end of string +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0b" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\01\e1" ;; "\e1" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; 3-byte sequence contains 1 byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0c" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\02\e1\2e" ;; "\e1." + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;;;; 3-byte sequence contents + +;; first byte after (0xe0) 3-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0d" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\03\e0\00\a0" ;; "\e0\00\a0" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; first byte after (0xe0) 3-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0d" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\03\e0\7f\a0" ;; "\e0\7f\a0" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; overlong encoding after 0xe0 prefix +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0d" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\03\e0\80\80" ;; "\e0\80\80" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; overlong encoding after 0xe0 prefix +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0d" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\03\e0\80\a0" ;; "\e0\80\a0" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; overlong encoding after 0xe0 prefix +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0d" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\03\e0\9f\a0" ;; "\e0\9f\a0" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; overlong encoding after 0xe0 prefix +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0d" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\03\e0\9f\bf" ;; "\e0\9f\bf" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; first byte after (0xe0) 3-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0d" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\03\e0\c0\a0" ;; "\e0\c0\a0" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; first byte after (0xe0) 3-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0d" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\03\e0\fd\a0" ;; "\e0\fd\a0" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; first byte after (first normal) 3-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0d" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\03\e1\00\80" ;; "\e1\00\80" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; first byte after (first normal) 3-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0d" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\03\e1\7f\80" ;; "\e1\7f\80" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; first byte after (first normal) 3-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0d" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\03\e1\c0\80" ;; "\e1\c0\80" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; first byte after (first normal) 3-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0d" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\03\e1\fd\80" ;; "\e1\fd\80" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; first byte after (normal) 3-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0d" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\03\ec\00\80" ;; "\ec\00\80" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; first byte after (normal) 3-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0d" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\03\ec\7f\80" ;; "\ec\7f\80" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; first byte after (normal) 3-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0d" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\03\ec\c0\80" ;; "\ec\c0\80" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; first byte after (normal) 3-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0d" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\03\ec\fd\80" ;; "\ec\fd\80" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; first byte after (0xed) 3-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0d" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\03\ed\00\80" ;; "\ed\00\80" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; first byte after (0xed) 3-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0d" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\03\ed\7f\80" ;; "\ed\7f\80" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; byte sequence reserved for UTF-16 surrogate half +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0d" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\03\ed\a0\80" ;; "\ed\a0\80" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; byte sequence reserved for UTF-16 surrogate half +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0d" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\03\ed\a0\bf" ;; "\ed\a0\bf" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; byte sequence reserved for UTF-16 surrogate half +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0d" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\03\ed\bf\80" ;; "\ed\bf\80" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; byte sequence reserved for UTF-16 surrogate half +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0d" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\03\ed\bf\bf" ;; "\ed\bf\bf" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; first byte after (0xed) 3-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0d" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\03\ed\c0\80" ;; "\ed\c0\80" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; first byte after (0xed) 3-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0d" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\03\ed\fd\80" ;; "\ed\fd\80" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; first byte after (normal) 3-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0d" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\03\ee\00\80" ;; "\ee\00\80" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; first byte after (normal) 3-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0d" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\03\ee\7f\80" ;; "\ee\7f\80" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; first byte after (normal) 3-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0d" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\03\ee\c0\80" ;; "\ee\c0\80" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; first byte after (normal) 3-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0d" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\03\ee\fd\80" ;; "\ee\fd\80" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; first byte after (last normal) 3-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0d" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\03\ef\00\80" ;; "\ef\00\80" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; first byte after (last normal) 3-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0d" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\03\ef\7f\80" ;; "\ef\7f\80" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; first byte after (last normal) 3-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0d" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\03\ef\c0\80" ;; "\ef\c0\80" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; first byte after (last normal) 3-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0d" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\03\ef\fd\80" ;; "\ef\fd\80" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;;;; 3-byte sequence contents (third byte) + +;; second byte after (0xe0) 3-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0d" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\03\e0\a0\00" ;; "\e0\a0\00" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; second byte after (0xe0) 3-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0d" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\03\e0\a0\7f" ;; "\e0\a0\7f" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; second byte after (0xe0) 3-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0d" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\03\e0\a0\c0" ;; "\e0\a0\c0" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; second byte after (0xe0) 3-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0d" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\03\e0\a0\fd" ;; "\e0\a0\fd" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; second byte after (first normal) 3-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0d" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\03\e1\80\00" ;; "\e1\80\00" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; second byte after (first normal) 3-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0d" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\03\e1\80\7f" ;; "\e1\80\7f" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; second byte after (first normal) 3-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0d" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\03\e1\80\c0" ;; "\e1\80\c0" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; second byte after (first normal) 3-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0d" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\03\e1\80\fd" ;; "\e1\80\fd" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; second byte after (normal) 3-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0d" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\03\ec\80\00" ;; "\ec\80\00" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; second byte after (normal) 3-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0d" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\03\ec\80\7f" ;; "\ec\80\7f" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; second byte after (normal) 3-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0d" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\03\ec\80\c0" ;; "\ec\80\c0" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; second byte after (normal) 3-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0d" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\03\ec\80\fd" ;; "\ec\80\fd" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; second byte after (0xed) 3-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0d" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\03\ed\80\00" ;; "\ed\80\00" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; second byte after (0xed) 3-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0d" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\03\ed\80\7f" ;; "\ed\80\7f" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; second byte after (0xed) 3-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0d" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\03\ed\80\c0" ;; "\ed\80\c0" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; second byte after (0xed) 3-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0d" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\03\ed\80\fd" ;; "\ed\80\fd" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; second byte after (normal) 3-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0d" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\03\ee\80\00" ;; "\ee\80\00" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; second byte after (normal) 3-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0d" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\03\ee\80\7f" ;; "\ee\80\7f" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; second byte after (normal) 3-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0d" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\03\ee\80\c0" ;; "\ee\80\c0" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; second byte after (normal) 3-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0d" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\03\ee\80\fd" ;; "\ee\80\fd" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; second byte after (last normal) 3-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0d" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\03\ef\80\00" ;; "\ef\80\00" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; second byte after (last normal) 3-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0d" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\03\ef\80\7f" ;; "\ef\80\7f" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; second byte after (last normal) 3-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0d" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\03\ef\80\c0" ;; "\ef\80\c0" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; second byte after (last normal) 3-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0d" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\03\ef\80\fd" ;; "\ef\80\fd" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;;;; 4-byte sequences + +;; 4-byte sequence contains 5 bytes +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0f" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\05\f1\80\80\80\80" ;; "\f1\80\80\80\80" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; 4-byte sequence contains 3 bytes at end of string +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0d" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\03\f1\80\80" ;; "\f1\80\80" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; 4-byte sequence contains 3 bytes +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0e" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\04\f1\80\80\23" ;; "\f1\80\80#" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; 4-byte sequence contains 2 bytes at end of string +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0c" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\02\f1\80" ;; "\f1\80" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; 4-byte sequence contains 2 bytes +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0d" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\03\f1\80\23" ;; "\f1\80#" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; 4-byte sequence contains 1 byte at end of string +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0b" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\01\f1" ;; "\f1" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; 4-byte sequence contains 1 byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0c" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\02\f1\23" ;; "\f1#" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;;;; 4-byte sequence contents + +;; first byte after (0xf0) 4-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0e" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\04\f0\00\90\90" ;; "\f0\00\90\90" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; first byte after (0xf0) 4-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0e" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\04\f0\7f\90\90" ;; "\f0\7f\90\90" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; overlong encoding after 0xf0 prefix +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0e" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\04\f0\80\80\80" ;; "\f0\80\80\80" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; overlong encoding after 0xf0 prefix +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0e" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\04\f0\80\90\90" ;; "\f0\80\90\90" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; overlong encoding after 0xf0 prefix +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0e" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\04\f0\8f\90\90" ;; "\f0\8f\90\90" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; overlong encoding after 0xf0 prefix +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0e" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\04\f0\8f\bf\bf" ;; "\f0\8f\bf\bf" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; first byte after (0xf0) 4-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0e" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\04\f0\c0\90\90" ;; "\f0\c0\90\90" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; first byte after (0xf0) 4-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0e" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\04\f0\fd\90\90" ;; "\f0\fd\90\90" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; first byte after (first normal) 4-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0e" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\04\f1\00\80\80" ;; "\f1\00\80\80" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; first byte after (first normal) 4-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0e" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\04\f1\7f\80\80" ;; "\f1\7f\80\80" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; first byte after (first normal) 4-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0e" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\04\f1\c0\80\80" ;; "\f1\c0\80\80" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; first byte after (first normal) 4-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0e" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\04\f1\fd\80\80" ;; "\f1\fd\80\80" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; first byte after (last normal) 4-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0e" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\04\f3\00\80\80" ;; "\f3\00\80\80" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; first byte after (last normal) 4-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0e" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\04\f3\7f\80\80" ;; "\f3\7f\80\80" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; first byte after (last normal) 4-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0e" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\04\f3\c0\80\80" ;; "\f3\c0\80\80" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; first byte after (last normal) 4-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0e" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\04\f3\fd\80\80" ;; "\f3\fd\80\80" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; first byte after (0xf4) 4-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0e" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\04\f4\00\80\80" ;; "\f4\00\80\80" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; first byte after (0xf4) 4-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0e" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\04\f4\7f\80\80" ;; "\f4\7f\80\80" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; (first) malformed code point +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0e" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\04\f4\90\80\80" ;; "\f4\90\80\80" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; malformed code point +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0e" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\04\f4\bf\80\80" ;; "\f4\bf\80\80" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; first byte after (0xf4) 4-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0e" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\04\f4\c0\80\80" ;; "\f4\c0\80\80" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; first byte after (0xf4) 4-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0e" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\04\f4\fd\80\80" ;; "\f4\fd\80\80" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; (first) malformed 4-byte prefix +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0e" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\04\f5\80\80\80" ;; "\f5\80\80\80" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; (last) malformed 4-byte prefix +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0e" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\04\f7\80\80\80" ;; "\f7\80\80\80" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; (last) malformed 4-byte prefix +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0e" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\04\f7\bf\bf\bf" ;; "\f7\bf\bf\bf" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;;;; 4-byte sequence contents (third byte) + +;; second byte after (0xf0) 4-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0e" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\04\f0\90\00\90" ;; "\f0\90\00\90" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; second byte after (0xf0) 4-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0e" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\04\f0\90\7f\90" ;; "\f0\90\7f\90" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; second byte after (0xf0) 4-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0e" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\04\f0\90\c0\90" ;; "\f0\90\c0\90" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; second byte after (0xf0) 4-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0e" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\04\f0\90\fd\90" ;; "\f0\90\fd\90" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; second byte after (first normal) 4-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0e" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\04\f1\80\00\80" ;; "\f1\80\00\80" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; second byte after (first normal) 4-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0e" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\04\f1\80\7f\80" ;; "\f1\80\7f\80" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; second byte after (first normal) 4-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0e" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\04\f1\80\c0\80" ;; "\f1\80\c0\80" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; second byte after (first normal) 4-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0e" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\04\f1\80\fd\80" ;; "\f1\80\fd\80" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; second byte after (last normal) 4-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0e" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\04\f3\80\00\80" ;; "\f3\80\00\80" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; second byte after (last normal) 4-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0e" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\04\f3\80\7f\80" ;; "\f3\80\7f\80" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; second byte after (last normal) 4-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0e" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\04\f3\80\c0\80" ;; "\f3\80\c0\80" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; second byte after (last normal) 4-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0e" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\04\f3\80\fd\80" ;; "\f3\80\fd\80" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; second byte after (0xf4) 4-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0e" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\04\f4\80\00\80" ;; "\f4\80\00\80" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; second byte after (0xf4) 4-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0e" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\04\f4\80\7f\80" ;; "\f4\80\7f\80" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; second byte after (0xf4) 4-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0e" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\04\f4\80\c0\80" ;; "\f4\80\c0\80" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; second byte after (0xf4) 4-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0e" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\04\f4\80\fd\80" ;; "\f4\80\fd\80" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;;;; 4-byte sequence contents (fourth byte) + +;; third byte after (0xf0) 4-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0e" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\04\f0\90\90\00" ;; "\f0\90\90\00" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; third byte after (0xf0) 4-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0e" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\04\f0\90\90\7f" ;; "\f0\90\90\7f" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; third byte after (0xf0) 4-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0e" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\04\f0\90\90\c0" ;; "\f0\90\90\c0" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; third byte after (0xf0) 4-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0e" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\04\f0\90\90\fd" ;; "\f0\90\90\fd" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; third byte after (first normal) 4-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0e" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\04\f1\80\80\00" ;; "\f1\80\80\00" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; third byte after (first normal) 4-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0e" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\04\f1\80\80\7f" ;; "\f1\80\80\7f" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; third byte after (first normal) 4-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0e" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\04\f1\80\80\c0" ;; "\f1\80\80\c0" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; third byte after (first normal) 4-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0e" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\04\f1\80\80\fd" ;; "\f1\80\80\fd" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; third byte after (last normal) 4-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0e" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\04\f3\80\80\00" ;; "\f3\80\80\00" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; third byte after (last normal) 4-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0e" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\04\f3\80\80\7f" ;; "\f3\80\80\7f" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; third byte after (last normal) 4-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0e" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\04\f3\80\80\c0" ;; "\f3\80\80\c0" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; third byte after (last normal) 4-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0e" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\04\f3\80\80\fd" ;; "\f3\80\80\fd" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; third byte after (0xf4) 4-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0e" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\04\f4\80\80\00" ;; "\f4\80\80\00" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; third byte after (0xf4) 4-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0e" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\04\f4\80\80\7f" ;; "\f4\80\80\7f" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; third byte after (0xf4) 4-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0e" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\04\f4\80\80\c0" ;; "\f4\80\80\c0" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; third byte after (0xf4) 4-byte prefix not a continuation byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0e" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\04\f4\80\80\fd" ;; "\f4\80\80\fd" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;;;; 5-byte sequences + +;; 5-byte sequence contains 6 bytes +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\10" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\06\f8\80\80\80\80\80" ;; "\f8\80\80\80\80\80" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; 5-byte sequence contains 4 bytes at end of string +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0e" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\04\f8\80\80\80" ;; "\f8\80\80\80" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; 5-byte sequence contains 4 bytes +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0f" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\05\f8\80\80\80\23" ;; "\f8\80\80\80#" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; 5-byte sequence contains 3 bytes at end of string +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0d" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\03\f8\80\80" ;; "\f8\80\80" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; 5-byte sequence contains 3 bytes +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0e" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\04\f8\80\80\23" ;; "\f8\80\80#" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; 5-byte sequence contains 2 bytes at end of string +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0c" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\02\f8\80" ;; "\f8\80" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; 5-byte sequence contains 2 bytes +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0d" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\03\f8\80\23" ;; "\f8\80#" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; 5-byte sequence contains 1 byte at end of string +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0b" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\01\f8" ;; "\f8" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; 5-byte sequence contains 1 byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0c" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\02\f8\23" ;; "\f8#" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;;;; 5-byte sequence contents + +;; (first) malformed 5-byte prefix +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0f" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\05\f8\80\80\80\80" ;; "\f8\80\80\80\80" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; (last) malformed 5-byte prefix +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0f" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\05\fb\bf\bf\bf\bf" ;; "\fb\bf\bf\bf\bf" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;;;; 6-byte sequences + +;; 6-byte sequence contains 7 bytes +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\11" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\07\fc\80\80\80\80\80\80" ;; "\fc\80\80\80\80\80\80" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; 6-byte sequence contains 5 bytes at end of string +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0f" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\05\fc\80\80\80\80" ;; "\fc\80\80\80\80" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; 6-byte sequence contains 5 bytes +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\10" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\06\fc\80\80\80\80\23" ;; "\fc\80\80\80\80#" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; 6-byte sequence contains 4 bytes at end of string +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0e" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\04\fc\80\80\80" ;; "\fc\80\80\80" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; 6-byte sequence contains 4 bytes +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0f" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\05\fc\80\80\80\23" ;; "\fc\80\80\80#" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; 6-byte sequence contains 3 bytes at end of string +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0d" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\03\fc\80\80" ;; "\fc\80\80" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; 6-byte sequence contains 3 bytes +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0e" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\04\fc\80\80\23" ;; "\fc\80\80#" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; 6-byte sequence contains 2 bytes at end of string +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0c" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\02\fc\80" ;; "\fc\80" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; 6-byte sequence contains 2 bytes +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0d" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\03\fc\80\23" ;; "\fc\80#" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; 6-byte sequence contains 1 byte at end of string +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0b" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\01\fc" ;; "\fc" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; 6-byte sequence contains 1 byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0c" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\02\fc\23" ;; "\fc#" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;;;; 6-byte sequence contents + +;; (first) malformed 6-byte prefix +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\10" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\06\fc\80\80\80\80\80" ;; "\fc\80\80\80\80\80" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; (last) malformed 6-byte prefix +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\10" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\06\fd\bf\bf\bf\bf\bf" ;; "\fd\bf\bf\bf\bf\bf" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;;;; Miscellaneous malformed bytes + +;; malformed byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0b" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\01\fe" ;; "\fe" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; malformed byte +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0b" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\01\ff" ;; "\ff" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; UTF-16BE BOM +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0c" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\02\fe\ff" ;; "\fe\ff" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; UTF-32BE BOM +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0e" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\04\00\00\fe\ff" ;; "\00\00\fe\ff" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; UTF-16LE BOM +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0c" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\02\ff\fe" ;; "\ff\fe" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + +;; UTF-32LE BOM +(assert_malformed + (module binary + "\00asm" "\01\00\00\00" + "\02\0e" ;; import section + "\01" ;; length 1 + "\04\74\65\73\74" ;; "test" + "\04\ff\fe\00\00" ;; "\ff\fe\00\00" + "\03" ;; GlobalImport + "\7f" ;; i32 + "\00" ;; immutable + ) + "malformed UTF-8 encoding" +) + diff --git a/runtime/near-vm/tests/wast/spec/utf8-invalid-encoding.wast b/runtime/near-vm/tests/wast/spec/utf8-invalid-encoding.wast new file mode 100644 index 00000000000..cfd596930c9 --- /dev/null +++ b/runtime/near-vm/tests/wast/spec/utf8-invalid-encoding.wast @@ -0,0 +1,176 @@ +(assert_malformed (module quote "(func (export \"\\00\\00\\fe\\ff\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\80\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\8f\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\90\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\9f\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\a0\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\bf\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\c0\\80\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\c0\\bf\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\c1\\80\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\c1\\bf\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\c2\\00\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\c2\\2e\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\c2\\7f\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\c2\\80\\80\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\c2\\c0\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\c2\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\c2\\fd\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\df\\00\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\df\\7f\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\df\\c0\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\df\\fd\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\e0\\00\\a0\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\e0\\7f\\a0\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\e0\\80\\80\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\e0\\80\\a0\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\e0\\9f\\a0\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\e0\\9f\\bf\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\e0\\a0\\00\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\e0\\a0\\7f\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\e0\\a0\\c0\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\e0\\a0\\fd\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\e0\\c0\\a0\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\e0\\fd\\a0\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\e1\\00\\80\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\e1\\2e\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\e1\\7f\\80\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\e1\\80\\00\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\e1\\80\\2e\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\e1\\80\\7f\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\e1\\80\\80\\80\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\e1\\80\\c0\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\e1\\80\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\e1\\80\\fd\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\e1\\c0\\80\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\e1\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\e1\\fd\\80\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\ec\\00\\80\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\ec\\7f\\80\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\ec\\80\\00\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\ec\\80\\7f\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\ec\\80\\c0\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\ec\\80\\fd\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\ec\\c0\\80\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\ec\\fd\\80\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\ed\\00\\80\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\ed\\7f\\80\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\ed\\80\\00\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\ed\\80\\7f\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\ed\\80\\c0\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\ed\\80\\fd\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\ed\\a0\\80\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\ed\\a0\\bf\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\ed\\bf\\80\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\ed\\bf\\bf\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\ed\\c0\\80\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\ed\\fd\\80\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\ee\\00\\80\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\ee\\7f\\80\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\ee\\80\\00\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\ee\\80\\7f\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\ee\\80\\c0\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\ee\\80\\fd\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\ee\\c0\\80\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\ee\\fd\\80\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\ef\\00\\80\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\ef\\7f\\80\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\ef\\80\\00\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\ef\\80\\7f\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\ef\\80\\c0\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\ef\\80\\fd\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\ef\\c0\\80\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\ef\\fd\\80\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\f0\\00\\90\\90\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\f0\\7f\\90\\90\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\f0\\80\\80\\80\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\f0\\80\\90\\90\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\f0\\8f\\90\\90\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\f0\\8f\\bf\\bf\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\f0\\90\\00\\90\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\f0\\90\\7f\\90\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\f0\\90\\90\\00\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\f0\\90\\90\\7f\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\f0\\90\\90\\c0\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\f0\\90\\90\\fd\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\f0\\90\\c0\\90\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\f0\\90\\fd\\90\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\f0\\c0\\90\\90\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\f0\\fd\\90\\90\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\f1\\00\\80\\80\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\f1\\23\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\f1\\7f\\80\\80\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\f1\\80\\00\\80\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\f1\\80\\23\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\f1\\80\\7f\\80\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\f1\\80\\80\\00\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\f1\\80\\80\\23\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\f1\\80\\80\\7f\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\f1\\80\\80\\80\\80\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\f1\\80\\80\\c0\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\f1\\80\\80\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\f1\\80\\80\\fd\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\f1\\80\\c0\\80\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\f1\\80\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\f1\\80\\fd\\80\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\f1\\c0\\80\\80\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\f1\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\f1\\fd\\80\\80\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\f3\\00\\80\\80\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\f3\\7f\\80\\80\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\f3\\80\\00\\80\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\f3\\80\\7f\\80\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\f3\\80\\80\\00\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\f3\\80\\80\\7f\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\f3\\80\\80\\c0\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\f3\\80\\80\\fd\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\f3\\80\\c0\\80\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\f3\\80\\fd\\80\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\f3\\c0\\80\\80\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\f3\\fd\\80\\80\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\f4\\00\\80\\80\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\f4\\7f\\80\\80\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\f4\\80\\00\\80\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\f4\\80\\7f\\80\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\f4\\80\\80\\00\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\f4\\80\\80\\7f\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\f4\\80\\80\\c0\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\f4\\80\\80\\fd\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\f4\\80\\c0\\80\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\f4\\80\\fd\\80\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\f4\\90\\80\\80\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\f4\\bf\\80\\80\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\f4\\c0\\80\\80\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\f4\\fd\\80\\80\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\f5\\80\\80\\80\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\f7\\80\\80\\80\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\f7\\bf\\bf\\bf\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\f8\\23\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\f8\\80\\23\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\f8\\80\\80\\23\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\f8\\80\\80\\80\\23\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\f8\\80\\80\\80\\80\\80\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\f8\\80\\80\\80\\80\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\f8\\80\\80\\80\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\f8\\80\\80\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\f8\\80\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\f8\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\fb\\bf\\bf\\bf\\bf\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\fc\\23\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\fc\\80\\23\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\fc\\80\\80\\23\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\fc\\80\\80\\80\\23\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\fc\\80\\80\\80\\80\\23\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\fc\\80\\80\\80\\80\\80\\80\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\fc\\80\\80\\80\\80\\80\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\fc\\80\\80\\80\\80\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\fc\\80\\80\\80\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\fc\\80\\80\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\fc\\80\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\fc\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\fd\\bf\\bf\\bf\\bf\\bf\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\fe\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\fe\\ff\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\ff\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\ff\\fe\\00\\00\"))") "malformed UTF-8 encoding") +(assert_malformed (module quote "(func (export \"\\ff\\fe\"))") "malformed UTF-8 encoding") diff --git a/runtime/near-vm/tests/wast/wasmer/README.md b/runtime/near-vm/tests/wast/wasmer/README.md new file mode 100644 index 00000000000..976146c247b --- /dev/null +++ b/runtime/near-vm/tests/wast/wasmer/README.md @@ -0,0 +1,30 @@ +# Custom wast tests + +In this directory we have created wast tests for different cases +where we want to test other scenarios than the ones offered +by the standard WebAssembly spectests. + +## NaN canonicalization: `nan-canonicalization.wast` + +This is an extra set of tests that assure that operations with NaNs +are deterministic regarless of the environment/chipset where it executes in. + +## Call Indirect Spilled Stack: `call-indirect-spilledd-stack.wast` + +We had an issue occuring that was making singlepass not working properly +on the WebAssembly benchmark: https://00f.net/2019/10/22/updated-webassembly-benchmark/. + +This is a test case to ensure it doesn't reproduce again in the future. + +## Multiple Traps: `multiple-traps.wast` + +This is a test assuring functions that trap can be called multiple times. + +## Fac: `fac.wast` + +This is a simple factorial program. + +## Check that struct-return on the stack doesn't overflow: `stack-overflow-sret.wast` + +Stack space for a structure returning function call should be allocated once up +front, not once in each call. diff --git a/runtime/near-vm/tests/wast/wasmer/call-indirect-spilled-stack.wast b/runtime/near-vm/tests/wast/wasmer/call-indirect-spilled-stack.wast new file mode 100644 index 00000000000..95df771f85b --- /dev/null +++ b/runtime/near-vm/tests/wast/wasmer/call-indirect-spilled-stack.wast @@ -0,0 +1,35 @@ +;; Spilled stack tests +;; https://github.com/wasmerio/wasmer/pull/1191 + +(module + ;; Auxiliary definitions + (type $out-i32 (func (result i32))) + + (func $const-i32 (type $out-i32) (i32.const 0x132)) + + (table funcref + (elem + $const-i32 + ) + ) + + (memory 1) + + (func (export "call-indirect-from-spilled-stack") (result i32) + (i64.add (i64.const 0) (i64.const 0)) + (i64.add (i64.const 0) (i64.const 0)) + (i64.add (i64.const 0) (i64.const 0)) + (i64.add (i64.const 0) (i64.const 0)) + (i64.add (i64.const 0) (i64.const 0)) + (i64.add (i64.const 0) (i64.const 0)) + (i64.add (i64.const 0) (i64.const 0)) + (i64.add (i64.const 0) (i64.const 0)) + (i64.add (i64.const 0) (i64.const 0)) + (i64.add (i64.const 0x100000000) (i64.const 0)) + (i32.wrap_i64) + (call_indirect (type $out-i32)) + (return) + ) +) + +(assert_return (invoke "call-indirect-from-spilled-stack") (i32.const 0x132)) diff --git a/runtime/near-vm/tests/wast/wasmer/fac.wast b/runtime/near-vm/tests/wast/wasmer/fac.wast new file mode 100644 index 00000000000..ef10991a82c --- /dev/null +++ b/runtime/near-vm/tests/wast/wasmer/fac.wast @@ -0,0 +1,89 @@ +(module + ;; Recursive factorial + (func (export "fac-rec") (param i64) (result i64) + (if (result i64) (i64.eq (local.get 0) (i64.const 0)) + (then (i64.const 1)) + (else + (i64.mul (local.get 0) (call 0 (i64.sub (local.get 0) (i64.const 1)))) + ) + ) + ) + + ;; Recursive factorial named + (func $fac-rec-named (export "fac-rec-named") (param $n i64) (result i64) + (if (result i64) (i64.eq (local.get $n) (i64.const 0)) + (then (i64.const 1)) + (else + (i64.mul + (local.get $n) + (call $fac-rec-named (i64.sub (local.get $n) (i64.const 1))) + ) + ) + ) + ) + + ;; Iterative factorial + (func (export "fac-iter") (param i64) (result i64) + (local i64 i64) + (local.set 1 (local.get 0)) + (local.set 2 (i64.const 1)) + (block + (loop + (if + (i64.eq (local.get 1) (i64.const 0)) + (then (br 2)) + (else + (local.set 2 (i64.mul (local.get 1) (local.get 2))) + (local.set 1 (i64.sub (local.get 1) (i64.const 1))) + ) + ) + (br 0) + ) + ) + (local.get 2) + ) + + ;; Iterative factorial named + (func (export "fac-iter-named") (param $n i64) (result i64) + (local $i i64) + (local $res i64) + (local.set $i (local.get $n)) + (local.set $res (i64.const 1)) + (block $done + (loop $loop + (if + (i64.eq (local.get $i) (i64.const 0)) + (then (br $done)) + (else + (local.set $res (i64.mul (local.get $i) (local.get $res))) + (local.set $i (i64.sub (local.get $i) (i64.const 1))) + ) + ) + (br $loop) + ) + ) + (local.get $res) + ) + + ;; Optimized factorial. + (func (export "fac-opt") (param i64) (result i64) + (local i64) + (local.set 1 (i64.const 1)) + (block + (br_if 0 (i64.lt_s (local.get 0) (i64.const 2))) + (loop + (local.set 1 (i64.mul (local.get 1) (local.get 0))) + (local.set 0 (i64.add (local.get 0) (i64.const -1))) + (br_if 0 (i64.gt_s (local.get 0) (i64.const 1))) + ) + ) + (local.get 1) + ) +) + +(assert_return (invoke "fac-rec" (i64.const 25)) (i64.const 7034535277573963776)) +(assert_return (invoke "fac-iter" (i64.const 25)) (i64.const 7034535277573963776)) +(assert_return (invoke "fac-rec-named" (i64.const 25)) (i64.const 7034535277573963776)) +(assert_return (invoke "fac-iter-named" (i64.const 25)) (i64.const 7034535277573963776)) +(assert_return (invoke "fac-opt" (i64.const 25)) (i64.const 7034535277573963776)) +(assert_exhaustion (invoke "fac-rec" (i64.const 1073741824)) "call stack exhausted") diff --git a/runtime/near-vm/tests/wast/wasmer/int-extend-garbage.wast b/runtime/near-vm/tests/wast/wasmer/int-extend-garbage.wast new file mode 100644 index 00000000000..9b290d26f38 --- /dev/null +++ b/runtime/near-vm/tests/wast/wasmer/int-extend-garbage.wast @@ -0,0 +1,35 @@ +;; https://github.com/wasmerio/wasmer/pull/1436 +;; +;; When doing an I64ExtendI32U or other integer extension operations, the +;; upper bits in the underlying storage must be cleared. +;; +;; On x86 sign extension is done with its own instruction, `movsx`, so here we only +;; test the unsigned extension case. + +(module + + (func (export "i64-extend-i32-u") (result i64) + ;; fill in stack slots allocated to registers + (i64.add (i64.const 0) (i64.const 0)) + (i64.add (i64.const 0) (i64.const 0)) + (i64.add (i64.const 0) (i64.const 0)) + (i64.add (i64.const 0) (i64.const 0)) + (i64.add (i64.const 0) (i64.const 0)) + (i64.add (i64.const 0) (i64.const 0)) + + ;; push an i64 to produce garbage on the higher 32 bits + (i64.add (i64.const -1) (i64.const 0)) + + ;; pop it + (drop) + + ;; push an i32 + (i32.add (i32.const 0) (i32.const 0)) + + ;; extend + (i64.extend_i32_u) + (return) + ) +) + +(assert_return (invoke "i64-extend-i32-u") (i64.const 0)) diff --git a/runtime/near-vm/tests/wast/wasmer/max_locals.wast b/runtime/near-vm/tests/wast/wasmer/max_locals.wast new file mode 100644 index 00000000000..6fe0355d998 --- /dev/null +++ b/runtime/near-vm/tests/wast/wasmer/max_locals.wast @@ -0,0 +1,37 @@ +;; As per https://www.w3.org/TR/wasm-core-1/#functions%E2%91%A0 functions may not specify more than +;; u32::MAX locals. Make sure this holds and does not break. + + +;; This is a validation failure +(assert_invalid + (module binary + "\00asm\01\00\00\00" ;; the header + "\01\04\01" ;; 4 byte type section with 1 element + "\60\00\00" ;; fn() -> () + "\03\02\01" ;; 2 byte func section with 1 element + "\00" ;; signature 0 + "\0a\0a\01" ;; 11 byte code section with 1 element + "\08" ;; 4 bytes for this function + "\01\ff\ff\ff\ff\0f\7f" ;; 1 local block containing 0xffff_ffff locals of type i32 + "\0b" ;; end + ) + "locals exceed maximum" +) + +;; Ensure that we don't hit any panics with > 0xFFFF_FFFF locals. +(assert_invalid + (module binary + "\00asm\01\00\00\00" ;; the header + "\01\04\01" ;; 4 byte type section with 1 element + "\60\00\00" ;; fn() -> () + "\03\02\01" ;; 2 byte func section with 1 element + "\00" ;; signature 0 + "\0a\0c\01" ;; 11 byte code section with 1 element + "\0a" ;; 11 bytes for this function + "\02" ;; 2 local blocks + "\ff\ff\ff\ff\0f\7f" ;; local block containing 0xffff_ffff locals of type i32 + "\7f\7f" ;; local block containing 0x7f locals of type i32 + "\0b" ;; end + ) + "locals exceed maximum" +) diff --git a/runtime/near-vm/tests/wast/wasmer/max_size_of_memory.wast b/runtime/near-vm/tests/wast/wasmer/max_size_of_memory.wast new file mode 100644 index 00000000000..99116d1e729 --- /dev/null +++ b/runtime/near-vm/tests/wast/wasmer/max_size_of_memory.wast @@ -0,0 +1 @@ +(module (memory 65536)) diff --git a/runtime/near-vm/tests/wast/wasmer/multiple-traps.wast b/runtime/near-vm/tests/wast/wasmer/multiple-traps.wast new file mode 100644 index 00000000000..99b8e7ba2ac --- /dev/null +++ b/runtime/near-vm/tests/wast/wasmer/multiple-traps.wast @@ -0,0 +1,10 @@ +;; We assert that we can call a function that traps repeatedly + +(module + (func (export "throw_trap") + unreachable + )) + +(assert_trap (invoke "throw_trap") "unreachable") +(assert_trap (invoke "throw_trap") "unreachable") +(assert_trap (invoke "throw_trap") "unreachable") diff --git a/runtime/near-vm/tests/wast/wasmer/nan-canonicalization-issue-2159.wast b/runtime/near-vm/tests/wast/wasmer/nan-canonicalization-issue-2159.wast new file mode 100644 index 00000000000..6a1253ce26f --- /dev/null +++ b/runtime/near-vm/tests/wast/wasmer/nan-canonicalization-issue-2159.wast @@ -0,0 +1,10 @@ +;; https://github.com/wasmerio/wasmer/issues/2159 +(module + (func (export "_start") (result f64) + f64.const 0x0p+0 (;=0;) + f64.const 0x0p+0 (;=0;) + f64.const 0x0p+0 (;=0;) + f64.div + f64.copysign + ) +) \ No newline at end of file diff --git a/runtime/near-vm/tests/wast/wasmer/nan-canonicalization-issue-2347.wast b/runtime/near-vm/tests/wast/wasmer/nan-canonicalization-issue-2347.wast new file mode 100644 index 00000000000..575d33c65d7 --- /dev/null +++ b/runtime/near-vm/tests/wast/wasmer/nan-canonicalization-issue-2347.wast @@ -0,0 +1,14 @@ +;; https://github.com/wasmerio/wasmer/issues/2347 +(module + (type (;0;) (func (param f64) (result i32))) + (func (;0;) (type 0) (param f64) (result i32) + unreachable) + (func (;1;) (type 0) (param f64) (result i32) + i32.const -16579585 + f64.convert_i32_s + f64.ceil + f64.ceil + local.get 0 + f64.copysign + unreachable)) + \ No newline at end of file diff --git a/runtime/near-vm/tests/wast/wasmer/nan-canonicalization.wast b/runtime/near-vm/tests/wast/wasmer/nan-canonicalization.wast new file mode 100644 index 00000000000..748029bf5d2 --- /dev/null +++ b/runtime/near-vm/tests/wast/wasmer/nan-canonicalization.wast @@ -0,0 +1,221 @@ +;; NaN canonicalization tests. +;; +;; Things that are covered by spectests canonicalization +;; (`fabs`, `fneg`, `fcopysign`, `reinterpret`, `const`) +;; won't be duplicated here. + +(module + ;; Auxiliary definitions + (type $f32-id (func (param f32) (result f32))) + (type $f64-id (func (param f64) (result f64))) + + (table funcref + (elem + $nan-canonicalization-f32-func-call-target + $nan-canonicalization-f64-func-call-target + ) + ) + + (memory 1) + + (func (export "nan-canonicalization-f32-add") (param i32) (result i32) + (i32.reinterpret_f32 (f32.add (f32.reinterpret_i32 (get_local 0)) (f32.const 0))) + ) + (func (export "nan-canonicalization-f32-sub") (param i32) (result i32) + (i32.reinterpret_f32 (f32.sub (f32.reinterpret_i32 (get_local 0)) (f32.const 0))) + ) + (func (export "nan-canonicalization-f32-mul") (param i32) (result i32) + (i32.reinterpret_f32 (f32.mul (f32.reinterpret_i32 (get_local 0)) (f32.const 0))) + ) + (func (export "nan-canonicalization-f32-div") (param i32) (result i32) + (i32.reinterpret_f32 (f32.div (f32.reinterpret_i32 (get_local 0)) (f32.const 1))) + ) + (func (export "nan-canonicalization-f32-max") (param i32) (result i32) + (i32.reinterpret_f32 (f32.max (f32.reinterpret_i32 (get_local 0)) (f32.const 1))) + ) + (func (export "nan-canonicalization-f32-min") (param i32) (result i32) + (i32.reinterpret_f32 (f32.min (f32.reinterpret_i32 (get_local 0)) (f32.const 1))) + ) + (func (export "nan-canonicalization-f32-nearest") (param i32) (result i32) + (i32.reinterpret_f32 (f32.nearest (f32.reinterpret_i32 (get_local 0)))) + ) + (func (export "nan-canonicalization-f32-floor") (param i32) (result i32) + (i32.reinterpret_f32 (f32.floor (f32.reinterpret_i32 (get_local 0)))) + ) + (func (export "nan-canonicalization-f32-ceil") (param i32) (result i32) + (i32.reinterpret_f32 (f32.ceil (f32.reinterpret_i32 (get_local 0)))) + ) + (func (export "nan-canonicalization-f32-trunc") (param i32) (result i32) + (i32.reinterpret_f32 (f32.trunc (f32.reinterpret_i32 (get_local 0)))) + ) + (func (export "nan-canonicalization-f32-sqrt") (param i32) (result i32) + (i32.reinterpret_f32 (f32.sqrt (f32.reinterpret_i32 (get_local 0)))) + ) + (func (export "nan-canonicalization-f32-mem") (param i32) (result i32) + (f32.store (i32.const 0) (f32.reinterpret_i32 (get_local 0))) + (i32.reinterpret_f32 (f32.load (i32.const 0))) + ) + (func (export "nan-canonicalization-f32-mem-cncl") (param i32) (result i32) + (f32.store (i32.const 0) (f32.add (f32.reinterpret_i32 (get_local 0)) (f32.const 0))) + (i32.reinterpret_f32 (f32.load (i32.const 0))) + ) + (func (export "nan-canonicalization-f32-local") (param i32) (result i32) + (local f32) + (set_local 1 (f32.reinterpret_i32 (get_local 0))) + (i32.reinterpret_f32 (get_local 1)) + ) + (func (export "nan-canonicalization-f32-local-cncl") (param i32) (result i32) + (local f32) + (set_local 1 (f32.add (f32.reinterpret_i32 (get_local 0)) (f32.const 0))) + (i32.reinterpret_f32 (get_local 1)) + ) + (func $nan-canonicalization-f32-func-call-target (param f32) (result f32) + (get_local 0) + ) + (func (export "nan-canonicalization-f32-func-call") (param i32) (result i32) + (i32.reinterpret_f32 (call $nan-canonicalization-f32-func-call-target (f32.reinterpret_i32 (get_local 0)))) + ) + (func (export "nan-canonicalization-f32-func-call-cncl") (param i32) (result i32) + (i32.reinterpret_f32 (call $nan-canonicalization-f32-func-call-target (f32.add (f32.reinterpret_i32 (get_local 0)) (f32.const 0)))) + ) + (func (export "nan-canonicalization-f32-func-call-indirect") (param i32) (result i32) + (i32.reinterpret_f32 (call_indirect (type $f32-id) (f32.reinterpret_i32 (get_local 0)) (i32.const 0))) + ) + (func (export "nan-canonicalization-f32-func-call-indirect-cncl") (param i32) (result i32) + (i32.reinterpret_f32 (call_indirect (type $f32-id) (f32.add (f32.reinterpret_i32 (get_local 0)) (f32.const 0)) (i32.const 0))) + ) + + (func (export "nan-canonicalization-f64-add") (param i64) (result i64) + (i64.reinterpret_f64 (f64.add (f64.reinterpret_i64 (get_local 0)) (f64.const 0))) + ) + (func (export "nan-canonicalization-f64-sub") (param i64) (result i64) + (i64.reinterpret_f64 (f64.sub (f64.reinterpret_i64 (get_local 0)) (f64.const 0))) + ) + (func (export "nan-canonicalization-f64-mul") (param i64) (result i64) + (i64.reinterpret_f64 (f64.mul (f64.reinterpret_i64 (get_local 0)) (f64.const 0))) + ) + (func (export "nan-canonicalization-f64-div") (param i64) (result i64) + (i64.reinterpret_f64 (f64.div (f64.reinterpret_i64 (get_local 0)) (f64.const 1))) + ) + (func (export "nan-canonicalization-f64-max") (param i64) (result i64) + (i64.reinterpret_f64 (f64.max (f64.reinterpret_i64 (get_local 0)) (f64.const 1))) + ) + (func (export "nan-canonicalization-f64-min") (param i64) (result i64) + (i64.reinterpret_f64 (f64.min (f64.reinterpret_i64 (get_local 0)) (f64.const 1))) + ) + (func (export "nan-canonicalization-f64-nearest") (param i64) (result i64) + (i64.reinterpret_f64 (f64.nearest (f64.reinterpret_i64 (get_local 0)))) + ) + (func (export "nan-canonicalization-f64-floor") (param i64) (result i64) + (i64.reinterpret_f64 (f64.floor (f64.reinterpret_i64 (get_local 0)))) + ) + (func (export "nan-canonicalization-f64-ceil") (param i64) (result i64) + (i64.reinterpret_f64 (f64.ceil (f64.reinterpret_i64 (get_local 0)))) + ) + (func (export "nan-canonicalization-f64-trunc") (param i64) (result i64) + (i64.reinterpret_f64 (f64.trunc (f64.reinterpret_i64 (get_local 0)))) + ) + (func (export "nan-canonicalization-f64-sqrt") (param i64) (result i64) + (i64.reinterpret_f64 (f64.sqrt (f64.reinterpret_i64 (get_local 0)))) + ) + (func (export "nan-canonicalization-f64-mem") (param i64) (result i64) + (f64.store (i32.const 0) (f64.reinterpret_i64 (get_local 0))) + (i64.reinterpret_f64 (f64.load (i32.const 0))) + ) + (func (export "nan-canonicalization-f64-mem-cncl") (param i64) (result i64) + (f64.store (i32.const 0) (f64.add (f64.reinterpret_i64 (get_local 0)) (f64.const 0))) + (i64.reinterpret_f64 (f64.load (i32.const 0))) + ) + (func (export "nan-canonicalization-f64-local") (param i64) (result i64) + (local f64) + (set_local 1 (f64.reinterpret_i64 (get_local 0))) + (i64.reinterpret_f64 (get_local 1)) + ) + (func (export "nan-canonicalization-f64-local-cncl") (param i64) (result i64) + (local f64) + (set_local 1 (f64.add (f64.reinterpret_i64 (get_local 0)) (f64.const 0))) + (i64.reinterpret_f64 (get_local 1)) + ) + (func $nan-canonicalization-f64-func-call-target (param f64) (result f64) + (get_local 0) + ) + (func (export "nan-canonicalization-f64-func-call") (param i64) (result i64) + (i64.reinterpret_f64 (call $nan-canonicalization-f64-func-call-target (f64.reinterpret_i64 (get_local 0)))) + ) + (func (export "nan-canonicalization-f64-func-call-cncl") (param i64) (result i64) + (i64.reinterpret_f64 (call $nan-canonicalization-f64-func-call-target (f64.add (f64.reinterpret_i64 (get_local 0)) (f64.const 0)))) + ) + (func (export "nan-canonicalization-f64-func-call-indirect") (param i64) (result i64) + (i64.reinterpret_f64 (call_indirect (type $f64-id) (f64.reinterpret_i64 (get_local 0)) (i32.const 1))) + ) + (func (export "nan-canonicalization-f64-func-call-indirect-cncl") (param i64) (result i64) + (i64.reinterpret_f64 (call_indirect (type $f64-id) (f64.add (f64.reinterpret_i64 (get_local 0)) (f64.const 0)) (i32.const 1))) + ) +) + +(assert_return (invoke "nan-canonicalization-f32-add" (i32.const 0x7fc00001)) (i32.const 0x7fc00000)) +(assert_return (invoke "nan-canonicalization-f32-sub" (i32.const 0x7fc00001)) (i32.const 0x7fc00000)) +(assert_return (invoke "nan-canonicalization-f32-mul" (i32.const 0x7fc00001)) (i32.const 0x7fc00000)) +(assert_return (invoke "nan-canonicalization-f32-div" (i32.const 0x7fc00001)) (i32.const 0x7fc00000)) +(assert_return (invoke "nan-canonicalization-f32-max" (i32.const 0x7fc00001)) (i32.const 0x7fc00000)) +(assert_return (invoke "nan-canonicalization-f32-min" (i32.const 0x7fc00001)) (i32.const 0x7fc00000)) +(assert_return (invoke "nan-canonicalization-f32-nearest" (i32.const 0x7fc00001)) (i32.const 0x7fc00000)) +(assert_return (invoke "nan-canonicalization-f32-floor" (i32.const 0x7fc00001)) (i32.const 0x7fc00000)) +(assert_return (invoke "nan-canonicalization-f32-ceil" (i32.const 0x7fc00001)) (i32.const 0x7fc00000)) +(assert_return (invoke "nan-canonicalization-f32-trunc" (i32.const 0x7fc00001)) (i32.const 0x7fc00000)) +(assert_return (invoke "nan-canonicalization-f32-sqrt" (i32.const 0x7fc00001)) (i32.const 0x7fc00000)) +(assert_return (invoke "nan-canonicalization-f32-mem" (i32.const 0x7fc00001)) (i32.const 0x7fc00001)) +(assert_return (invoke "nan-canonicalization-f32-mem-cncl" (i32.const 0x7fc00001)) (i32.const 0x7fc00000)) +(assert_return (invoke "nan-canonicalization-f32-local" (i32.const 0x7fc00001)) (i32.const 0x7fc00001)) +(assert_return (invoke "nan-canonicalization-f32-local-cncl" (i32.const 0x7fc00001)) (i32.const 0x7fc00000)) +(assert_return (invoke "nan-canonicalization-f32-func-call" (i32.const 0x7fc00001)) (i32.const 0x7fc00001)) +(assert_return (invoke "nan-canonicalization-f32-func-call-cncl" (i32.const 0x7fc00001)) (i32.const 0x7fc00000)) +(assert_return (invoke "nan-canonicalization-f32-func-call-indirect" (i32.const 0x7fc00001)) (i32.const 0x7fc00001)) +(assert_return (invoke "nan-canonicalization-f32-func-call-indirect-cncl" (i32.const 0x7fc00001)) (i32.const 0x7fc00000)) + +(assert_return (invoke "nan-canonicalization-f64-add" (i64.const 0x7ff8000000000001)) (i64.const 0x7ff8000000000000)) +(assert_return (invoke "nan-canonicalization-f64-sub" (i64.const 0x7ff8000000000001)) (i64.const 0x7ff8000000000000)) +(assert_return (invoke "nan-canonicalization-f64-mul" (i64.const 0x7ff8000000000001)) (i64.const 0x7ff8000000000000)) +(assert_return (invoke "nan-canonicalization-f64-div" (i64.const 0x7ff8000000000001)) (i64.const 0x7ff8000000000000)) +(assert_return (invoke "nan-canonicalization-f64-max" (i64.const 0x7ff8000000000001)) (i64.const 0x7ff8000000000000)) +(assert_return (invoke "nan-canonicalization-f64-min" (i64.const 0x7ff8000000000001)) (i64.const 0x7ff8000000000000)) +(assert_return (invoke "nan-canonicalization-f64-nearest" (i64.const 0x7ff8000000000001)) (i64.const 0x7ff8000000000000)) +(assert_return (invoke "nan-canonicalization-f64-floor" (i64.const 0x7ff8000000000001)) (i64.const 0x7ff8000000000000)) +(assert_return (invoke "nan-canonicalization-f64-ceil" (i64.const 0x7ff8000000000001)) (i64.const 0x7ff8000000000000)) +(assert_return (invoke "nan-canonicalization-f64-trunc" (i64.const 0x7ff8000000000001)) (i64.const 0x7ff8000000000000)) +(assert_return (invoke "nan-canonicalization-f64-sqrt" (i64.const 0x7ff8000000000001)) (i64.const 0x7ff8000000000000)) +(assert_return (invoke "nan-canonicalization-f64-mem" (i64.const 0x7ff8000000000001)) (i64.const 0x7ff8000000000001)) +(assert_return (invoke "nan-canonicalization-f64-mem-cncl" (i64.const 0x7ff8000000000001)) (i64.const 0x7ff8000000000000)) +(assert_return (invoke "nan-canonicalization-f64-local" (i64.const 0x7ff8000000000001)) (i64.const 0x7ff8000000000001)) +(assert_return (invoke "nan-canonicalization-f64-local-cncl" (i64.const 0x7ff8000000000001)) (i64.const 0x7ff8000000000000)) +(assert_return (invoke "nan-canonicalization-f64-func-call" (i64.const 0x7ff8000000000001)) (i64.const 0x7ff8000000000001)) +(assert_return (invoke "nan-canonicalization-f64-func-call-cncl" (i64.const 0x7ff8000000000001)) (i64.const 0x7ff8000000000000)) +(assert_return (invoke "nan-canonicalization-f64-func-call-indirect" (i64.const 0x7ff8000000000001)) (i64.const 0x7ff8000000000001)) +(assert_return (invoke "nan-canonicalization-f64-func-call-indirect-cncl" (i64.const 0x7ff8000000000001)) (i64.const 0x7ff8000000000000)) + +;; Test canonicalization is done before branch in `else` operator. +(module + (func (;0;) + (local f64) + i32.const 1 + if (result f64) + local.get 0 + f64.const 0x1p+0 (;=1;) + f64.add + else + f64.const 0x0p+0 (;=0;) + end + return + ) +) + +;; Test canonicalization is done before branch in `return` operator. +(module + (func (;0;) (result f64) + (local f64) + f64.const 0x0p+0 + local.get 0 + f64.mul + return + ) +) diff --git a/runtime/near-vm/tests/wast/wasmer/rotate-shift-overflow.wast b/runtime/near-vm/tests/wast/wasmer/rotate-shift-overflow.wast new file mode 100644 index 00000000000..456ea414fde --- /dev/null +++ b/runtime/near-vm/tests/wast/wasmer/rotate-shift-overflow.wast @@ -0,0 +1,334 @@ +;; Test that constant folding an operation that overflows doesn't produce an +;; undefined value. Changing these tests to move the constants to the +;; assert_return line hides the bug. + +(module + ;; shl i32 + (func (export "shl1_i32") (result i32) + i32.const 235 + i32.const 0 + i32.shl + ) + (func (export "shl2_i32") (result i32) + i32.const 235 + i32.const 32 + i32.shl + ) + (func (export "shl3_i32") (result i32) + i32.const 235 + i32.const 100 + i32.shl + ) + (func (export "shl4_i32") (result i32) + i32.const 235 + i32.const -32 + i32.shl + ) + (func (export "shl5_i32") (result i32) + i32.const 235 + i32.const -100 + i32.shl + ) + ;; shl i64 + (func (export "shl1_i64") (result i64) + i64.const 235 + i64.const 0 + i64.shl + ) + (func (export "shl2_i64") (result i64) + i64.const 235 + i64.const 64 + i64.shl + ) + (func (export "shl3_i64") (result i64) + i64.const 235 + i64.const 100 + i64.shl + ) + (func (export "shl4_i64") (result i64) + i64.const 235 + i64.const -64 + i64.shl + ) + (func (export "shl5_i64") (result i64) + i64.const 235 + i64.const -100 + i64.shl + ) + + ;; shr_u i32 + (func (export "shr_u1_i32") (result i32) + i32.const 235 + i32.const 0 + i32.shr_u + ) + (func (export "shr_u2_i32") (result i32) + i32.const 235 + i32.const 32 + i32.shr_u + ) + (func (export "shr_u3_i32") (result i32) + i32.const 235 + i32.const 100 + i32.shr_u + ) + (func (export "shr_u4_i32") (result i32) + i32.const 235 + i32.const -32 + i32.shr_u + ) + (func (export "shr_u5_i32") (result i32) + i32.const 235 + i32.const -100 + i32.shr_u + ) + + ;; shr_u i64 + (func (export "shr_u1_i64") (result i64) + i64.const 235 + i64.const 0 + i64.shr_u + ) + (func (export "shr_u2_i64") (result i64) + i64.const 235 + i64.const 64 + i64.shr_u + ) + (func (export "shr_u3_i64") (result i64) + i64.const 235 + i64.const 100 + i64.shr_u + ) + (func (export "shr_u4_i64") (result i64) + i64.const 235 + i64.const -64 + i64.shr_u + ) + (func (export "shr_u5_i64") (result i64) + i64.const 235 + i64.const -100 + i64.shr_u + ) + + ;; shr_s i32 + (func (export "shr_s1_i32") (result i32) + i32.const 235 + i32.const 0 + i32.shr_s + ) + (func (export "shr_s2_i32") (result i32) + i32.const 235 + i32.const 32 + i32.shr_s + ) + (func (export "shr_s3_i32") (result i32) + i32.const 235 + i32.const 100 + i32.shr_s + ) + (func (export "shr_s4_i32") (result i32) + i32.const 235 + i32.const -32 + i32.shr_s + ) + (func (export "shr_s5_i32") (result i32) + i32.const 235 + i32.const -100 + i32.shr_s + ) + + ;; shr_s i64 + (func (export "shr_s1_i64") (result i64) + i64.const 235 + i64.const 0 + i64.shr_s + ) + (func (export "shr_s2_i64") (result i64) + i64.const 235 + i64.const 64 + i64.shr_s + ) + (func (export "shr_s3_i64") (result i64) + i64.const 235 + i64.const 100 + i64.shr_s + ) + (func (export "shr_s4_i64") (result i64) + i64.const 235 + i64.const -64 + i64.shr_s + ) + (func (export "shr_s5_i64") (result i64) + i64.const 235 + i64.const -100 + i64.shr_s + ) + + ;; rotl i32 + (func (export "rotl1_i32") (result i32) + i32.const 235 + i32.const 0 + i32.rotl + ) + (func (export "rotl2_i32") (result i32) + i32.const 235 + i32.const 32 + i32.rotl + ) + (func (export "rotl3_i32") (result i32) + i32.const 235 + i32.const 100 + i32.rotl + ) + (func (export "rotl4_i32") (result i32) + i32.const 235 + i32.const -32 + i32.rotl + ) + (func (export "rotl5_i32") (result i32) + i32.const 235 + i32.const -100 + i32.rotl + ) + + ;; rotl i64 + (func (export "rotl1_i64") (result i64) + i64.const 235 + i64.const 0 + i64.rotl + ) + (func (export "rotl2_i64") (result i64) + i64.const 235 + i64.const 64 + i64.rotl + ) + (func (export "rotl3_i64") (result i64) + i64.const 235 + i64.const 100 + i64.rotl + ) + (func (export "rotl4_i64") (result i64) + i64.const 235 + i64.const -64 + i64.rotl + ) + (func (export "rotl5_i64") (result i64) + i64.const 235 + i64.const -100 + i64.rotl + ) + + ;; rotr i32 + (func (export "rotr1_i32") (result i32) + i32.const 235 + i32.const 0 + i32.rotr + ) + (func (export "rotr2_i32") (result i32) + i32.const 235 + i32.const 32 + i32.rotr + ) + (func (export "rotr3_i32") (result i32) + i32.const 235 + i32.const 100 + i32.rotr + ) + (func (export "rotr4_i32") (result i32) + i32.const 235 + i32.const -32 + i32.rotr + ) + (func (export "rotr5_i32") (result i32) + i32.const 235 + i32.const -100 + i32.rotr + ) + + ;; rotr i64 + (func (export "rotr1_i64") (result i64) + i64.const 235 + i64.const 0 + i64.rotr + ) + (func (export "rotr2_i64") (result i64) + i64.const 235 + i64.const 64 + i64.rotr + ) + (func (export "rotr3_i64") (result i64) + i64.const 235 + i64.const 100 + i64.rotr + ) + (func (export "rotr4_i64") (result i64) + i64.const 235 + i64.const -64 + i64.rotr + ) + (func (export "rotr5_i64") (result i64) + i64.const 235 + i64.const -100 + i64.rotr + ) +) + +(assert_return (invoke "shl1_i32") (i32.const 235)) +(assert_return (invoke "shl2_i32") (i32.const 235)) +(assert_return (invoke "shl3_i32") (i32.const 3760)) +(assert_return (invoke "shl4_i32") (i32.const 235)) +(assert_return (invoke "shl5_i32") (i32.const -1342177280)) + +(assert_return (invoke "shl1_i64") (i64.const 235)) +(assert_return (invoke "shl2_i64") (i64.const 235)) +(assert_return (invoke "shl3_i64") (i64.const 16149077032960)) +(assert_return (invoke "shl4_i64") (i64.const 235)) +(assert_return (invoke "shl5_i64") (i64.const 63082332160)) + +(assert_return (invoke "shr_u1_i32") (i32.const 235)) +(assert_return (invoke "shr_u2_i32") (i32.const 235)) +(assert_return (invoke "shr_u3_i32") (i32.const 14)) +(assert_return (invoke "shr_u4_i32") (i32.const 235)) +(assert_return (invoke "shr_u5_i32") (i32.const 0)) + +(assert_return (invoke "shr_u1_i64") (i64.const 235)) +(assert_return (invoke "shr_u2_i64") (i64.const 235)) +(assert_return (invoke "shr_u3_i64") (i64.const 0)) +(assert_return (invoke "shr_u4_i64") (i64.const 235)) +(assert_return (invoke "shr_u5_i64") (i64.const 0)) + +(assert_return (invoke "shr_s1_i32") (i32.const 235)) +(assert_return (invoke "shr_s2_i32") (i32.const 235)) +(assert_return (invoke "shr_s3_i32") (i32.const 14)) +(assert_return (invoke "shr_s4_i32") (i32.const 235)) +(assert_return (invoke "shr_s5_i32") (i32.const 0)) + +(assert_return (invoke "shr_s1_i64") (i64.const 235)) +(assert_return (invoke "shr_s2_i64") (i64.const 235)) +(assert_return (invoke "shr_s3_i64") (i64.const 0)) +(assert_return (invoke "shr_s4_i64") (i64.const 235)) +(assert_return (invoke "shr_s5_i64") (i64.const 0)) + +(assert_return (invoke "rotl1_i32") (i32.const 235)) +(assert_return (invoke "rotl2_i32") (i32.const 235)) +(assert_return (invoke "rotl3_i32") (i32.const 3760)) +(assert_return (invoke "rotl4_i32") (i32.const 235)) +(assert_return (invoke "rotl5_i32") (i32.const -1342177266)) + +(assert_return (invoke "rotl1_i64") (i64.const 235)) +(assert_return (invoke "rotl2_i64") (i64.const 235)) +(assert_return (invoke "rotl3_i64") (i64.const 16149077032960)) +(assert_return (invoke "rotl4_i64") (i64.const 235)) +(assert_return (invoke "rotl5_i64") (i64.const 63082332160)) + +(assert_return (invoke "rotr1_i32") (i32.const 235)) +(assert_return (invoke "rotr2_i32") (i32.const 235)) +(assert_return (invoke "rotr3_i32") (i32.const -1342177266)) +(assert_return (invoke "rotr4_i32") (i32.const 235)) +(assert_return (invoke "rotr5_i32") (i32.const 3760)) + +(assert_return (invoke "rotr1_i64") (i64.const 235)) +(assert_return (invoke "rotr2_i64") (i64.const 235)) +(assert_return (invoke "rotr3_i64") (i64.const 63082332160)) +(assert_return (invoke "rotr4_i64") (i64.const 235)) +(assert_return (invoke "rotr5_i64") (i64.const 16149077032960)) diff --git a/runtime/near-vm/tests/wast/wasmer/stack-overflow-sret.wast b/runtime/near-vm/tests/wast/wasmer/stack-overflow-sret.wast new file mode 100644 index 00000000000..dc75d77eae3 --- /dev/null +++ b/runtime/near-vm/tests/wast/wasmer/stack-overflow-sret.wast @@ -0,0 +1,47 @@ +(module + (func $sret + (result i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 + i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 + i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 + i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64) + i64.const 0 i64.const 0 i64.const 0 i64.const 0 + i64.const 0 i64.const 0 i64.const 0 i64.const 0 + i64.const 0 i64.const 0 i64.const 0 i64.const 0 + i64.const 0 i64.const 0 i64.const 0 i64.const 0 + + i64.const 0 i64.const 0 i64.const 0 i64.const 0 + i64.const 0 i64.const 0 i64.const 0 i64.const 0 + i64.const 0 i64.const 0 i64.const 0 i64.const 0 + i64.const 0 i64.const 0 i64.const 0 i64.const 0 + + i64.const 0 i64.const 0 i64.const 0 i64.const 0 + i64.const 0 i64.const 0 i64.const 0 i64.const 0 + i64.const 0 i64.const 0 i64.const 0 i64.const 0 + i64.const 0 i64.const 0 i64.const 0 i64.const 0 + + i64.const 0 i64.const 0 i64.const 0 i64.const 0 + i64.const 0 i64.const 0 i64.const 0 i64.const 0 + i64.const 0 i64.const 0 i64.const 0 i64.const 0 + i64.const 0 i64.const 0 i64.const 0 i64.const 0 + ) + + (func (export "long-loop") + (local i32) + i32.const 1000000 + local.set 0 + (loop + call $sret + drop drop drop drop drop drop drop drop drop drop drop drop drop drop drop drop + drop drop drop drop drop drop drop drop drop drop drop drop drop drop drop drop + drop drop drop drop drop drop drop drop drop drop drop drop drop drop drop drop + drop drop drop drop drop drop drop drop drop drop drop drop drop drop drop drop + local.get 0 + i32.const -1 + i32.add + local.tee 0 + br_if 0 + ) + ) +) + +(assert_return (invoke "long-loop")) diff --git a/runtime/near-vm/tests/wast/wasmer/stack-overflow.wast b/runtime/near-vm/tests/wast/wasmer/stack-overflow.wast new file mode 100644 index 00000000000..fc11c085b17 --- /dev/null +++ b/runtime/near-vm/tests/wast/wasmer/stack-overflow.wast @@ -0,0 +1,10 @@ +(module + (type (;0;) (func)) + (func (;0;) (type 0) + i32.const 0 + call_indirect (type 0)) + (table (;0;) 1 anyfunc) + (export "stack-overflow" (func 0)) + (elem (;0;) (i32.const 0) 0)) + +(assert_exhaustion (invoke "stack-overflow") "call stack exhausted")